class Teapot::Configuration

A configuration represents a mapping between package/dependency names and actual source locations. Usually, there is only one configuration, but in some cases it is useful to have more than one, e.g. one for local development using local source code, one for continuous integration, and one for deployment.

Constants

DEFAULT_OPTIONS
Import

Attributes

imports[R]

A list of other configurations to include when materialising the list of packages.

options[R]

Options used to bind packages to this configuration.

packages[R]

A list of packages which are required by this configuration.

targets[R]

A table of named targets for specific purposes.

visibility[R]

Controls how the configuration is exposed in the context.

Public Class Methods

new(context, package, name, packages = [], **options) click to toggle source
Calls superclass method
# File lib/teapot/configuration.rb, line 38
def initialize(context, package, name, packages = [], **options)
        super context, package, name

        @options = DEFAULT_OPTIONS.merge(options)

        @packages = Build::Dependency::Set.new(packages)
        @imports = Build::Dependency::Set.new

        @visibility = :private

        # A list of named targets for specific purposes:
        @targets = Hash.new{|hash,key| hash[key] = Array.new}
end

Public Instance Methods

[](key) click to toggle source

Get a configuration option.

# File lib/teapot/configuration.rb, line 131
def [] key
        @options[key]
end
[]=(key, value) click to toggle source

Set a configuration option.

# File lib/teapot/configuration.rb, line 126
def []= key, value
        @options[key] = value
end
build_path() click to toggle source

The path where built products will be placed.

# File lib/teapot/configuration.rb, line 141
def build_path
        context.root + "teapot/build/#{name}"
end
Also aliased as: platforms_path
environment() click to toggle source
# File lib/teapot/configuration.rb, line 66
def environment
        configuration = self
        
        Build::Environment.new(name: self.name) do
                default build_path configuration.build_path
                default platforms_path configuration.build_path
        end
end
freeze() click to toggle source
Calls superclass method
# File lib/teapot/configuration.rb, line 52
def freeze
        return self if frozen?
        
        @options.freeze
        @packages.freeze
        @imports.freeze
        @visibility.freeze
        
        @targets.default = [].freeze
        @targets.freeze
        
        super
end
group() { || ... } click to toggle source

Create a group for configuration options which will be only be active within the group block.

# File lib/teapot/configuration.rb, line 117
def group
        options = @options.dup
        
        yield
        
        @options = options
end
import(name, explicit = true) click to toggle source

Specifies that this package will import additional configuration records from another definition.

# File lib/teapot/configuration.rb, line 112
def import(name, explicit = true)
        @imports << Import.new(name, explicit, @options.dup)
end
lock_path() click to toggle source
# File lib/teapot/configuration.rb, line 147
def lock_path
        context.root + "#{@name}-lock.yml"
end
lock_store() click to toggle source
# File lib/teapot/configuration.rb, line 151
def lock_store
        YAML::Store.new(lock_path.to_s)
end
merge(configuration) { |package| ... } click to toggle source

Merge an external configuration into this configuration. We won't override already defined packages.

# File lib/teapot/configuration.rb, line 178
def merge(configuration)
        configuration.packages.each do |package|
                # The top level configuration will override packages that are defined by imported configurations. This is desirable behaviour, as it allows us to flatten the configuration but provide overrides if required.
                unless @packages.include? package
                        package = Package.new(packages_path + package.name, package.name, @options.merge(package.options))
                        
                        @packages << package
                        
                        yield package
                end
        end
        
        configuration.imports.each do |import|
                unless @imports.include? import
                        @imports << Import.new(import.name, import.explicit, @options.merge(import.options))
                end
        end
        
        configuration.targets.each do |key, value|
                @targets[key] += value
        end
        
        return self
end
packages_path() click to toggle source

The path where packages will be located when fetched.

# File lib/teapot/configuration.rb, line 136
def packages_path
        context.root + "teapot/packages/#{name}"
end
platforms_path()
Alias for: build_path
public!() click to toggle source
# File lib/teapot/configuration.rb, line 82
def public!
        @visibility = :public
end
public?() click to toggle source
# File lib/teapot/configuration.rb, line 78
def public?
        @visibility == :public
end
require(name, **options) click to toggle source

Specifies that this configuration depends on an external package of some sort.

# File lib/teapot/configuration.rb, line 99
def require(name, **options)
        options = @options.merge(options)
        
        @packages << Package.new(packages_path + name.to_s, name, options)
        
        if options[:import] == true
                import(name, false)
        elsif String === options[:import]
                import(options[:import])
        end
end
to_s() click to toggle source
# File lib/teapot/configuration.rb, line 155
def to_s
        "#<#{self.class} #{@name.dump} visibility=#{@visibility}>"
end
traverse(configurations, imported = Build::Dependency::Set.new) { |self| ... } click to toggle source

Process all import directives and return a new configuration based on the current configuration. Import directives bring packages and other import directives from the specififed configuration definition.

# File lib/teapot/configuration.rb, line 160
def traverse(configurations, imported = Build::Dependency::Set.new, &block)
        yield self # Whatever happens here, should ensure that...
        
        @imports.each do |import|
                # So we don't get into some crazy cycle:
                next if imported.include?(import)
                
                # Mark it as being imported:
                imported << import
                
                # ... by here, the configuration is available:
                if configuration = configurations[import.name]
                        configuration.traverse(configurations, imported, &block)
                end
        end
end