class Build::Rulebook

Attributes

rules[R]

Public Class Methods

for(environment) click to toggle source
# File lib/build/rulebook.rb, line 84
def self.for(environment)
        rulebook = self.new(environment.name)
        
        environment.defined.each do |name, define|
                rulebook << define.klass.build(name, &define.block)
        end
        
        return rulebook
end
new(name = nil) click to toggle source
# File lib/build/rulebook.rb, line 25
def initialize(name = nil)
        @name = name
        @rules = {}
        @processes = {}
end

Public Instance Methods

<<(rule) click to toggle source
# File lib/build/rulebook.rb, line 33
def << rule
        @rules[rule.name] = rule

        # A cache for fast process/file-type lookup:
        processes = @processes[rule.process_name] ||= []
        processes << rule
end
[](name) click to toggle source
# File lib/build/rulebook.rb, line 41
def [] name
        @rules[name]
end
with(superclass, **state) click to toggle source
# File lib/build/rulebook.rb, line 45
def with(superclass, **state)
        task_class = Class.new(superclass)
        
        # name = @name
        # task_class.send(:define_method, :to_s) do
        #    "name"
        # end
        
        # Define methods for all processes, e.g. task_class#compile
        @processes.each do |key, rules|
                # Define general rules, which use rule applicability for disambiguation:
                task_class.send(:define_method, key) do |arguments, &block|
                        rule = rules.find{|rule| rule.applicable? arguments }
                        
                        if rule
                                invoke_rule(rule, arguments, &block)
                        else
                                raise NoApplicableRule.new(key, arguments)
                        end
                end
        end
        
        # Define methods for all rules, e.g. task_class#compile_cpp
        @rules.each do |key, rule|
                task_class.send(:define_method, rule.full_name) do |arguments, &block|
                        invoke_rule(rule, arguments, &block)
                end
        end
        
        # Typically, this defines methods like #environment and #target which can be accessed in the build rule.
        state.each do |key, value|
                task_class.send(:define_method, key) do
                        value
                end
        end
        
        return task_class
end