Configurability module

# File lib/configurability.rb, line 61
def self::after_configure( &block )
        raise LocalJumpError, "no block given" unless block
        self.after_configure_hooks << block

        # Call the block immediately if the hooks have already been called or are in
        # the process of being called.
        block.call if self.after_configure_hooks_run?
end

# File lib/configurability.rb, line 55
def self::after_configure_hooks_run=( new_value )
        @after_configure_hooks_run = new_value ? true : false
end

# File lib/configurability.rb, line 48
def self::after_configure_hooks_run?
        return @after_configure_hooks_run ? true : false
end

# File lib/configurability.rb, line 73
def self::call_after_configure_hooks
        self.log.debug "  calling %d post-config hooks" % [ self.after_configure_hooks.length ]
        @after_configure_hooks_run = true

        self.after_configure_hooks.to_a.each do |hook|
                # self.log.debug "    %s line %s..." % hook.source_location
                hook.call
        end
end

# File lib/configurability.rb, line 135
def self::configure_objects( config )
        self.log.debug "Splitting up config %p between %d objects with configurability." %
                [ config, self.configurable_objects.length ]

        self.reset
        self.loaded_config = config

        self.configurable_objects.each do |obj|
                self.install_config( config, obj )
        end

        self.call_after_configure_hooks
end

# File lib/configurability.rb, line 244
def self::default_config
        return self.gather_defaults( Configurability::Config.new )
end

# File lib/configurability.rb, line 204
def self::expand_config_hash( key, hash )
        return key.to_s.split( '__' ).reverse.inject( hash ) do |inner_hash, subkey|
                { subkey.to_sym => inner_hash }
        end
end

# File lib/configurability.rb, line 94
def self::extend_object( object )
        self.log.debug "Adding Configurability to %p" % [ object ]
        super
        self.configurable_objects << object

        # If the config has already been propagated, add deferred configuration to the extending
        # object in case it overrides #configure later.
        if (( config = self.loaded_config ))
                self.install_config( config, object )
                object.extend( Configurability::DeferredConfig )
        end
end

# File lib/configurability.rb, line 172
def self::find_config_section( config, key )
        return key.to_s.split( '__' ).inject( config ) do |section, subkey|
                next nil if section.nil?
                self.get_config_subsection( section, subkey.to_sym )
        end
end

# File lib/configurability.rb, line 217
def self::gather_defaults( collection={} )
        mergefunc = Configurability::Config.method( :merge_complex_hashes )

        self.configurable_objects.each do |obj|
                next unless obj.respond_to?( :defaults )
                if defaults_hash = obj.defaults
                        nested_hash = self.expand_config_hash( obj.config_key, defaults_hash )
                        Configurability.log.debug "Defaults for %p (%p): %p" %
                                [ obj, obj.config_key, nested_hash ]

                        collection.merge!( nested_hash, &mergefunc )
                else
                        Configurability.log.warn "No defaults for %p; skipping" % [ obj ]
                end
        end

        return collection
end

# File lib/configurability.rb, line 182
def self::get_config_subsection( config, key )
        if config.respond_to?( key )
                self.log.debug "  config has a #%s method; using that" % [ key ]
                return config.send( key )
        elsif config.respond_to?( :[] ) && config.respond_to?( :key? )
                self.log.debug "  config has a hash-ish interface..."
                if config.key?( key.to_sym ) || config.key?( key.to_s )
                        self.log.debug "    and has a %s member; using that" % [ key ]
                        return config[ key.to_sym ] || config[ key.to_s ]
                else
                        self.log.debug "    but no `%s` member." % [ key ]
                        return nil
                end
        else
                self.log.debug "  no %p section in %p; configuring with nil" % [ key, config ]
                return nil
        end
end

# File lib/configurability.rb, line 109
def self::included( mod )
        mod.extend( self )
end

# File lib/configurability.rb, line 158
def self::install_config( config, object )
        self.log.debug "Configuring %p with the %s section of the config." %
                [ object, object.config_key ]

        section = self.find_config_section( config, object.config_key )
        configure_method = object.method( :configure )

        self.log.debug "  calling %p" % [ configure_method ]
        configure_method.call( section )
end

# File lib/configurability.rb, line 117
def self::make_key_from_object( object )
        if object.respond_to?( :name )
                name = object.name
                name = 'anonymous' if name.nil? || name.empty?
                return name.sub( /.*::/, '' ).gsub( /\W+/, '_' ).downcase.to_sym
        elsif object.class.name && !object.class.name.empty?
                return object.class.name.sub( /.*::/, '' ).gsub( /\W+/, '_' ).downcase.to_sym
        else
                return :anonymous
        end
end

# File lib/configurability.rb, line 238
def self::normalize_config_key( key )
        return key.to_s.gsub( /\./, '__' ).to_sym
end

# File lib/configurability.rb, line 151
def self::reset
        self.loaded_config = nil
        self.after_configure_hooks_run = false
end

# File lib/configurability.rb, line 86
def self::version_string( include_buildnum=false )
        vstring = "%s %s" % [ self.name, VERSION ]
        vstring << " (build %s)" % [ REVISION[/: ([[:xdigit:]]+)/, 1] || '0' ] if include_buildnum
        return vstring
end