Class: Build::Rule

Inherits:
Object
  • Object
show all
Defined in:
lib/build/rule.rb

Overview

A rule is a function with a specific set of input and output parameters, which can match against a given set of specific arguments. For example, there might be several rules for compiling, but the specific rules depend on the language being compiled.

Defined Under Namespace

Classes: Parameter

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(process_name, type) ⇒ Rule

Returns a new instance of Rule.



104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/build/rule.rb', line 104

def initialize(process_name, type)
  @name = process_name + "." + type
  @full_name = @name.gsub(/[^\w]/, '_')
  
  @process_name = process_name.gsub('-', '_').to_sym
  @type = type
  
  @apply = nil
  
  @parameters = []
  @primary_output = nil
end

Instance Attribute Details

#full_name ⇒ Object (readonly)

compile_cpp



126
127
128
 
# File 'lib/build/rule.rb', line 126

def full_name
  @full_name
end

#name ⇒ Object (readonly)

compile.cpp



118
119
120
 
# File 'lib/build/rule.rb', line 118

def name
  @name
end

#parameters ⇒ Object (readonly)

Returns the value of attribute parameters.



120
121
122
 
# File 'lib/build/rule.rb', line 120

def parameters
  @parameters
end

#primary_output ⇒ Object (readonly)

Returns the value of attribute primary_output.



128
129
130
 
# File 'lib/build/rule.rb', line 128

def primary_output
  @primary_output
end

#process_name ⇒ Object (readonly)

compile



123
124
125
 
# File 'lib/build/rule.rb', line 123

def process_name
  @process_name
end

Class Method Details

.build(name, &block) ⇒ Object 



24
25
26
27
28
29
30
 
# File 'lib/build/rule.rb', line 24

def self.build(name, &block)
  rule = self.new(*name.split('.', 2))
  
  rule.instance_eval(&block)
  
  return rule.freeze
end

Instance Method Details

#<<(parameter) ⇒ Object 



157
158
159
160
161
162
163
 
# File 'lib/build/rule.rb', line 157

def << parameter
  @parameters << parameter
  
  if parameter.output?
    @primary_output ||= parameter
  end
end

#==(other) ⇒ Object 



220
221
222
 
# File 'lib/build/rule.rb', line 220

def ==(other)
  other.kind_of?(self.class) and @name == other.name and @parameters == other.parameters
end

#applicable?(arguments) ⇒ Boolean

Check if this rule can process these parameters

Returns:

  • (Boolean) 


166
167
168
169
170
171
172
173
174
 
# File 'lib/build/rule.rb', line 166

def applicable?(arguments)
  @parameters.each do |parameter|
    next if parameter.implicit?
    
    return false unless parameter.applicable?(arguments)
  end
  
  return true
end

#apply(&block) ⇒ Object 



206
207
208
 
# File 'lib/build/rule.rb', line 206

def apply(&block)
  @apply = Proc.new(&block)
end

#apply!(scope, arguments) ⇒ Object 



210
211
212
 
# File 'lib/build/rule.rb', line 210

def apply!(scope, arguments)
  scope.instance_exec(arguments, &@apply) if @apply
end

#files(arguments) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/build/rule.rb', line 185

def files(arguments)
  input_files = []
  output_files = []
  
  @parameters.each do |parameter|
    # This could probably be improved a bit, we are assuming all parameters are file based:
    value = arguments[parameter.name]
    
    next unless value
    
    case parameter.direction
    when :input
      input_files << value
    when :output
      output_files << value
    end
  end
  
  return Build::Files::Composite.new(input_files), Build::Files::Composite.new(output_files)
end

#freeze ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/build/rule.rb', line 130

def freeze
  return self if frozen?
  
  @name.freeze
  @full_name.freeze
  @process_name.freeze
  @type.freeze
  
  @apply.freeze
  @parameters.freeze
  @primary_output.freeze
  
  super
end

#input(name, options = {}, &block) ⇒ Object 



145
146
147
 
# File 'lib/build/rule.rb', line 145

def input(name, options = {}, &block)
  self << Parameter.new(:input, name, options, &block)
end

#normalize(arguments, scope) ⇒ Object

The scope is the context in which the dynamic rule computation is done, usually an instance of Task.



177
178
179
180
181
182
183
 
# File 'lib/build/rule.rb', line 177

def normalize(arguments, scope)
  Hash[
    @parameters.collect do |parameter|
      [parameter.name, parameter.compute(arguments, scope)]
    end
  ]
end

#output(name, options = {}, &block) ⇒ Object 



153
154
155
 
# File 'lib/build/rule.rb', line 153

def output(name, options = {}, &block)
  self << Parameter.new(:output, name, options, &block)
end

#parameter(name, options = {}, &block) ⇒ Object 



149
150
151
 
# File 'lib/build/rule.rb', line 149

def parameter(name, options = {}, &block)
  self << Parameter.new(:argument, name, options, &block)
end

#result(arguments) ⇒ Object 



214
215
216
217
218
 
# File 'lib/build/rule.rb', line 214

def result(arguments)
  if @primary_output
    arguments[@primary_output.name]
  end
end

#to_s ⇒ Object 



224
225
226
 
# File 'lib/build/rule.rb', line 224

def to_s
  "#<#{self.class} #{@name.dump}>"
end