Class: AMEE::DataAbstraction::CalculationSet

Inherits:
Object
  • Object
show all
Defined in:
lib/amee-data-abstraction/calculation_set.rb

Overview

The CalculationSet class represents a collection of prototype calculations (of the class ProtptypeCalculation.

Prototype calculations are contained within the @calculations instance variable ordered hash. Calculations can be added manually to the @calculations hash or initialized in place using the #calculation method which takes an options hash or block for specifying the prototype calculation properties.

Typical usage is to initialize the CalculationSet and its daughter prototype calculations together using block syntax, thus:

Calculations = CalculationSet.new {

  calculation {
    label :electricity
    path "/some/path/for/electricity"
    ...
  }

  calculation {
    label :transport
    path "a/transport/path"
    ...
  }

  ...
}

Constant Summary collapse

@@sets =

Class variable holding all instantiated calculation sets keyed on the set name.

{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, options = {}, &block) ⇒ CalculationSet

Initialise a new Calculation set. Specify the name of the calculation set as the first argument. This name is used as the set key within the class variable @@sets hash.

Raises:

  • (ArgumentError) 


117
118
119
120
121
122
123
124
125
126
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 117

def initialize(name,options={},&block)
  raise ArgumentError, "Calculation set must have a name" unless name
  @name = name
  @file = CalculationSet.find_config_file(options[:file]) if options[:file]
  @calculations = ActiveSupport::OrderedHash.new
  @all_blocks=[]
  @all_options={}
  instance_eval(&block) if block
  @@sets[@name.to_sym] = self
end

Instance Attribute Details

#calculations ⇒ Object

Returns the value of attribute calculations.



111
112
113
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 111

def calculations
  @calculations
end

#file ⇒ Object

Returns the value of attribute file.



111
112
113
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 111

def file
  @file
end

#name ⇒ Object

Returns the value of attribute name.



111
112
113
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 111

def name
  @name
end

Class Method Details

.find(name) ⇒ Object

Retrieve a calculation set on the basis of a configuration file name or relatiev/absolute file path. If configuration files are location within the default Rails location under ‘/config/calculations’ then the path and the .rb extenstion can be omitted from the name.



54
55
56
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 54

def self.find(name)
  @@sets[name.to_sym] or load_set(name)
end

.find_prototype_calculation(label) ⇒ Object

Find a specific prototype calculation instance without specifying the set to which it belongs.



71
72
73
74
75
76
77
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 71

def self.find_prototype_calculation(label)
  @@sets.each_pair do |name,set|
    set = find(name)
    return set[label] if set[label]
  end
  return nil
end

.regenerate_lock_file(name, output_path = nil) ⇒ Object

Regenerate a configuration lock file assocaited with the master configuration file name. Optionally set a custom path for the lock file as output_path, otherwise the lock file path and filename will be based upon the master file with the extension .lock.rb.



63
64
65
66
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 63

def self.regenerate_lock_file(name,output_path=nil)
  set = CalculationSet.find(name)
  set.generate_lock_file(output_path)
end

.sets ⇒ Object

Convenience method for accessing the @@sets class variable



45
46
47
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 45

def self.sets
  @@sets
end

Instance Method Details

#[](sym) ⇒ Object

Shorthand method for returning the prototype calculation which is represented by a label matching sym



131
132
133
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 131

def [](sym)
  @calculations[sym.to_sym]
end

#all_calculations(options = {}, &dsl_block) ⇒ Object

Append the supplied block to the DSL block of ALL calculations in this calculation set. This is useful for configuration which is required across all calculations (e.g. overriding human readable names or adding globally applicable metadatum)



151
152
153
154
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 151

def all_calculations(options={},&dsl_block)
  @all_blocks.push dsl_block
  @all_options.merge(options)
end

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

Instantiate a PrototypeCalculation within this calculation set, initializing with the supplied DSL block to be evaluated in the context of the newly created calculation



139
140
141
142
143
144
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 139

def calculation(options={},&block)
  new_content=PrototypeCalculation.new(options.merge(@all_options),&block)
  @all_blocks.each {|all_block| new_content.instance_eval(&all_block) }
  new_content.name new_content.label.to_s.humanize unless new_content.name
  @calculations[new_content.label]=new_content
end

#calculations_all_usages(apath, options = {}, &dsl_block) ⇒ Object

Instantiate several prototype calculations, by loading each possible usage for the category with path given in apath.

Each instantiated calculation is customised on the basis of the supplied DSL block. The usage is given as a parameter to the DSL block



162
163
164
165
166
167
168
169
170
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 162

def calculations_all_usages(apath,options={},&dsl_block)
  dummycalc=PrototypeCalculation.new{path apath}
  dummycalc.amee_usages.each do |usage|
    calculation(options){
      path apath
      instance_exec(usage,&dsl_block)
    }
  end
end

#config_path ⇒ Object

Returns the path to the configuration file for self. If a .lock file exists, this takes precedence, otherwise the master config file described by the #file attribute is returned.



176
177
178
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 176

def config_path
  lock_file_exists? ? lock_file_path : @file
end

#generate_lock_file(output_path = nil) ⇒ Object

Generates a lock file for the calcuation set configuration. If no argument is provided the, the lock file is generated using the filename and path described by the #lock_file_path method. If a custom output location is required, this can be provided optionally as an argument.



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 197

def generate_lock_file(output_path=nil)
  file = output_path || lock_file_path or raise ArgumentError,
    "No path for lock file known. Either set path for the master config file using the #file accessor method or provide as an argument"
  string = ""
  @calculations.values.each do |prototype_calculation|
    string += "calculation {\n\n"
    string += "  name \"#{prototype_calculation.name}\"\n"
    string += "  label :#{prototype_calculation.label}\n"
    string += "  path \"#{prototype_calculation.path}\"\n\n"
    prototype_calculation.terms.each do |term|
      string += "  #{term.class.to_s.split("::").last.downcase} {\n"
      string += "    name \"#{term.name}\"\n" unless term.name.blank?
      string += "    label :#{term.label}\n" unless term.label.blank?
      string += "    path \"#{term.path}\"\n" unless term.path.blank?
      string += "    value \"#{term.value}\"\n" unless term.value.blank?

      if term.is_a?(AMEE::DataAbstraction::Input)
        string += "    fixed \"#{term.value}\"\n" if term.fixed? && !term.value.blank?
        if term.is_a?(AMEE::DataAbstraction::Drill)
          string += "    choices \"#{term.choices.join('","')}\"\n" if term.instance_variable_defined?("@choices")  && !term.choices.blank?
        elsif term.is_a?(AMEE::DataAbstraction::Profile)
          string += "    choices [\"#{term.choices.join('","')}\"]\n" if term.instance_variable_defined?("@choices")  && !term.choices.blank?
        end
        string += "    optional!\n" if term.optional?
      end

      string += "    default_unit :#{term.default_unit.label}\n" unless term.default_unit.blank?
      string += "    default_per_unit :#{term.default_per_unit.label}\n" unless term.default_per_unit.blank?
      string += "    alternative_units :#{term.alternative_units.map(&:label).join(', :')}\n" unless term.alternative_units.blank?
      string += "    alternative_per_units :#{term.alternative_per_units.map(&:label).join(', :')}\n" unless term.alternative_per_units.blank?
      string += "    unit :#{term.unit.label}\n" unless term.unit.blank?
      string += "    per_unit :#{term.per_unit.label}\n" unless term.per_unit.blank?
      string += "    type :#{term.type}\n" unless term.type.blank?
      string += "    interface :#{term.interface}\n" unless term.interface.blank?
      string += "    note \"#{term.note}\"\n" unless term.note.blank?
      string += "    disable!\n" if !term.is_a?(AMEE::DataAbstraction::Drill) && term.disabled?
      string += "    hide!\n" if term.hidden?
      string += "  }\n\n"
    end
    string += "}\n\n"
  end
  File.open(file,'w') { |f| f.write string }
end

#lock_file_exists? ⇒ Boolean

Returns true if a configuration lock file exists. Otherwise, returns false.

Returns:

  • (Boolean) 


188
189
190
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 188

def lock_file_exists?
  File.exists?(lock_file_path)
end

#lock_file_path ⇒ Object

Returns the path to the configuration lock file



181
182
183
 
# File 'lib/amee-data-abstraction/calculation_set.rb', line 181

def lock_file_path
  @file.gsub(".rb",".lock.rb") rescue nil
end