amee-data-abstraction 1.2.0 → 1.3.0

data/lib/amee-data-abstraction/term.rb

@@ -84,16 +84,6 @@ module AMEE
       #
       attr_property :path
 
-      # String representing an annotation for <tt>self</tt>. Set a value by
-      # passing an argument. Retrieve a value by calling without an argument,
-      # e.g.,
-      #
-      #  my_term.note 'Enter the mass of cement produced in the reporting period'
-      #
-      #  my_term.note                       #=> 'Enter the mass of cement ...'
-      #
-      attr_property :note
-
       # Symbol representing the owning parent calculation of <tt>self</tt>. Set
       # the owning calculation object by passing as an argument. Retrieve it by
       # calling without an argument, e.g.,
@@ -211,6 +201,19 @@ module AMEE
         end
         @value
       end
+
+      # String representing an annotation for <tt>self</tt>. Set a value by
+      # passing an argument. Retrieve a value by calling without an argument,
+      # e.g.,
+      #
+      #  my_term.note 'Enter the mass of cement produced in the reporting period'
+      #
+      #  my_term.note                       #=> 'Enter the mass of cement ...'
+      #
+      def note(string=nil)
+        instance_variable_set("@note",string.gsub('"',"'")) unless string.nil?
+        instance_variable_get("@note")
+      end
       
       # Symbols representing the attributes of <tt>self</tt> which are concerned
       # with quantity units.
@@ -264,19 +267,33 @@ module AMEE
       end
 
       [:unit,:per_unit].each do |field|
+
+        # If no argument provided, returns the alternative units which are valid
+        # for <tt>self</tt>. If a list of units are provided as an argument, these
+        # override the dynamically assigned alternative units for <tt>self</tt>.
+        #
         define_method("alternative_#{field}s") do |*args|
           ivar = "@alternative_#{field}s"
-          default = send("default_#{field}".to_sym)
           unless args.empty?
-            args << default if default
             units = args.map {|arg| Unit.for(arg) }
             Term.validate_dimensional_equivalence?(*units)
             instance_variable_set(ivar, units)
           else
             return instance_variable_get(ivar) if instance_variable_get(ivar)
-            return instance_variable_set(ivar, (default.alternatives << default)) if default
+            default = send("default_#{field}".to_sym)
+            return instance_variable_set(ivar, (default.alternatives)) if default
           end
         end
+
+        # Returns the list of unit choices for <tt>self</tt>, including both the
+        # default unit and all alternative units.
+        #
+        define_method("#{field}_choices") do |*args|
+          choices = send("alternative_#{field}s".to_sym)
+          default = send("default_#{field}".to_sym)
+          choices = [default] + choices if default
+          return choices
+        end
       end
 
       # Returns <tt>true</tt> if <tt>self</tt> has a populated value attribute.
@@ -503,6 +520,7 @@ module AMEE
           else value
         end
       end
+      
     end
   end
 end

data/spec/amee-data-abstraction/calculation_set_spec.rb

@@ -1,4 +1,5 @@
-require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+require 'spec_helper'
+
 class CalculationSet
   def call_me
     #stub, because flexmock doesn't work for new instances during constructor
@@ -7,24 +8,257 @@ class CalculationSet
   cattr_accessor :called
 end
 describe CalculationSet do
+  
+  before :all do
+    CalculationSet.sets.clear
+    @calc_set = CalculationSet.find("electricity_and_transport")
+  end
+  
   it 'can create an instance' do
-    ElectricityAndTransport.should be_a CalculationSet
+    @calc_set.should be_a CalculationSet
   end
+
   it 'can create an instance' do
-    ElectricityAndTransport.calculations.should be_a ActiveSupport::OrderedHash
+    @calc_set.calculations.should be_a ActiveSupport::OrderedHash
+  end
+
+  it "can access class sets hash" do
+    CalculationSet.sets[:electricity_and_transport].should be_a CalculationSet
+  end
+  
+  it "is included in class sets hash if initialised by find method" do
+    CalculationSet.sets[:electricity_and_transport].should be_a CalculationSet
+  end
+
+  it "has file attribute if initialised by find method" do
+    CalculationSet.sets[:electricity_and_transport].file.should eql "#{Rails.root}/config/calculations/electricity_and_transport.rb"
+  end
+
+  it "has name attribute if initialised by find method" do
+    CalculationSet.sets[:electricity_and_transport].name.should eql "electricity_and_transport"
+  end
+  
+  it "is included in class sets hash if initialised manually" do
+    CalculationSet.new('my_set') {calculation {label :mycalc}}
+    CalculationSet.sets[:my_set].should be_a CalculationSet
   end
+
+  it "has name" do
+    CalculationSet.new('my_set') {calculation {label :mycalc}}.name.should eql "my_set"
+  end
+
   it 'can access a calculation by key' do
-    ElectricityAndTransport[:transport].should be_a PrototypeCalculation
+    @calc_set[:transport].should be_a PrototypeCalculation
+  end
+
+  describe "initialising from file" do
+
+    after(:each) do
+      CalculationSet.sets.clear
+      delete_lock_files
+    end
+
+    it "should find config file in default Rails location using just file name" do
+      CalculationSet.find_config_file("electricity").should eql "#{Rails.root}/config/calculations/electricity.rb"
+    end
+
+    it "should find config file in default Rails location using file name and extension" do
+      CalculationSet.find_config_file("electricity.rb").should eql "#{Rails.root}/config/calculations/electricity.rb"
+    end
+
+    it "should find config file in other Rails location using relative path" do
+      CalculationSet.find_config_file("config/electricity.rb").should eql "#{Rails.root}/config/electricity.rb"
+    end
+
+    it "should raise error if config file not found" do
+      lambda{CalculationSet.find_config_file("fuel")}.should raise_error
+    end
+
+    it "should call load_set if no set exists in class hash" do
+      CalculationSet.sets[:transport].should be_nil
+      flexmock(AMEE::DataAbstraction::CalculationSet) do |mock|
+        mock.should_receive(:load_set).once
+      end
+      set = CalculationSet.find('transport')
+    end
+
+    it "should not call load_set if set exists in class hash" do
+      CalculationSet.sets[:transport].should be_nil
+      set = CalculationSet.find('transport')
+      CalculationSet.sets[:transport].should be_a CalculationSet
+      flexmock(AMEE::DataAbstraction::CalculationSet) do |mock|
+        mock.should_receive(:load_set).never
+      end
+      set = CalculationSet.find('transport')
+    end
+
+    it "should generate set from file name using find method" do
+      CalculationSet.sets[:transport].should be_nil
+      set = CalculationSet.find('transport')
+      set.should be_a CalculationSet
+      CalculationSet.sets[:transport].should be_a CalculationSet
+      set.name.should eql 'transport'
+      set.file.should eql "#{Rails.root}/config/calculations/transport.rb"
+    end
+
+    it "should regenerate lock file at default location" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+      CalculationSet.sets[:transport].should be_nil
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      CalculationSet.sets[:transport].should be_a CalculationSet
+
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+
+      # lock file content
+      content = File.open(lock_file).read
+
+      # clear lock file to test for regenerated data
+      File.open(lock_file,'w') {|file| file.write "overwrite content"}
+      File.open(lock_file).read.should eql "overwrite content"
+      File.exist?(lock_file).should be_true
+
+      # regenerate and test content matches original
+      CalculationSet.regenerate_lock_file('transport')
+      File.exist?(lock_file).should be_true
+      File.open(lock_file).read.should eql content
+    end
+
+    it "should regenerate lock file at custom location" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+      CalculationSet.sets[:transport].should be_nil
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      CalculationSet.sets[:transport].should be_a CalculationSet
+
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+
+      content = File.open(lock_file).read
+      File.open(lock_file,'w') {|file| file.write "overwrite content"}
+      File.open(lock_file).read.should eql "overwrite content"
+      File.exist?(lock_file).should be_true
+
+      CalculationSet.regenerate_lock_file('transport', "#{Rails.root}/transport.lock.rb")
+      File.exist?(lock_file).should be_true
+      File.exist?("#{Rails.root}/transport.lock.rb").should be_true
+      File.open(lock_file).read.should eql "overwrite content"
+      File.open("#{Rails.root}/transport.lock.rb").read.should eql content
+
+      File.delete("#{Rails.root}/transport.lock.rb")
+    end
+
+    it "should return a lock file path based on master config file" do
+      set = CalculationSet.find('transport')
+      set.lock_file_path.should eql "#{Rails.root}/config/calculations/transport.lock.rb"
+    end
+
+    it "should return lock file path if lock file exists" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+      set.config_path.should eql lock_file
+    end
+
+    it "should return master file path if lock file does not exist" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      set.config_path.should eql "#{Rails.root}/config/calculations/transport.rb"
+    end
+
+    it "should know if lock file exists" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+      set.lock_file_exists?.should be_true
+      File.delete(lock_file)
+      File.exist?(lock_file).should be_false
+      set.lock_file_exists?.should be_false
+    end
+    
+    it "should generate lock file" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      set.lock_file_exists?.should be_false
+
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+      set.lock_file_exists?.should be_true
+      
+      content = File.open(lock_file).read
+
+      File.delete(lock_file)
+      File.exist?(lock_file).should be_false
+      set.lock_file_exists?.should be_false
+
+      set.generate_lock_file
+      File.exist?(lock_file).should be_true
+      set.lock_file_exists?.should be_true
+      File.open(lock_file).read.should eql content
+    end
+
+    it "should generate lock file at custom location" do
+      lock_file = "#{Rails.root}/config/calculations/transport.lock.rb"
+      File.exist?(lock_file).should be_false
+
+      set = CalculationSet.find('transport')
+      File.exist?(lock_file).should be_false
+      set.lock_file_exists?.should be_false
+
+      set.generate_lock_file("#{Rails.root}/transport.lock.rb")
+      File.exist?(lock_file).should be_false
+      set.lock_file_exists?.should be_false
+
+      File.exist?("#{Rails.root}/transport.lock.rb").should be_true
+
+      File.delete("#{Rails.root}/transport.lock.rb")
+    end
+
+  end
+
+  it "can find a prototype calc without calc set" do
+    CalculationSet.new('my_set') {
+      calculation {label :my_calc}
+      calculation {label :my_other_calc}
+    }
+    CalculationSet.new('your_set') {
+      calculation {label :your_calc}
+      calculation {label :your_other_calc}
+    }
+    CalculationSet.find_prototype_calculation(:transport).should be_a PrototypeCalculation
+    CalculationSet.find_prototype_calculation(:your_calc).should be_a PrototypeCalculation
+    CalculationSet.find_prototype_calculation(:my_other_calc).should be_a PrototypeCalculation
+  end
+
+  it "returns nil where no prototype calcualtion is found" do
+    CalculationSet.find_prototype_calculation(:fuel).should be_nil
   end
+
   it 'can construct a calculation' do
-    CalculationSet.new {calculation {label :mycalc}}[:mycalc].should be_a PrototypeCalculation
+    CalculationSet.new('my_set') {calculation {label :mycalc}}[:mycalc].should be_a PrototypeCalculation
   end
+
   it 'can be initialized with a DSL block' do
-    CalculationSet.new {call_me}
+    CalculationSet.new('my_set') {call_me}
     CalculationSet.called.should be_true
   end
+
   it 'can have terms added to all calculations' do
-    cs=CalculationSet.new {
+    cs=CalculationSet.new('my_set') {
       all_calculations {
         drill {label :energetic}
       }
@@ -35,6 +269,7 @@ describe CalculationSet do
     }
     cs[:mycalc].drills.labels.should eql [:remarkably,:energetic]
   end
+
   it 'can make multiple calculations quickly, one for each usage' do
     mocker=AMEEMocker.new(self,:path=>'something')
     mocker.item_value_definitions.usages(['bybob','byfrank']).
@@ -42,7 +277,7 @@ describe CalculationSet do
       item_value_definition('first',['bybob'],[],'byfrank',[],nil,nil,true,false,nil,"TEXT").
       item_value_definition('second',['bybob'],[],'byfrank',[],nil,nil,true,false,nil,"TEXT").
       item_value_definition('third',['byfrank'],[],['bybob'],[],nil,nil,true,false,nil,"TEXT")
-    cs=CalculationSet.new {
+    cs=CalculationSet.new('my_set') {
       calculations_all_usages('/something') { |usage|
         label usage.to_sym
         profiles_from_usage usage
@@ -51,4 +286,5 @@ describe CalculationSet do
     cs[:bybob].profiles.labels.should eql [:first,:second]
     cs[:byfrank].profiles.labels.should eql [:third]
   end
+  
 end

data/spec/amee-data-abstraction/calculation_spec.rb

@@ -1,53 +1,58 @@
-require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+require 'spec_helper'
+
 describe Calculation do
   
+  before :all do
+    @calc = CalculationSet.find("transport")[:transport]
+  end
+  
   it 'can create an instance' do
-    Transport.should be_a Calculation
+    @calc.should be_a Calculation
   end
   it 'should have ordered terms, with labels' do
-    Transport.terms.labels.should eql [:fuel,:size,:distance,:co2]
+    @calc.terms.labels.should eql [:fuel,:size,:distance,:co2]
   end
   it 'should have amee paths for the terms' do
-    Transport.terms.paths.should eql ['fuel','size','distance',:default]
+    @calc.terms.paths.should eql ['fuel','size','distance','default']
   end
   it 'should have human names for the terms' do
-    Transport.terms.names.
+    @calc.terms.names.
       should eql ['Fuel Type','Vehicle Size','Distance Driven','Carbon Dioxide']
   end
   it 'should return the inputs' do
-    Transport.inputs.labels.should  eql [:fuel,:size,:distance]
+    @calc.inputs.labels.should  eql [:fuel,:size,:distance]
   end
   it 'should return the outputs' do
-    Transport.outputs.labels.should  eql [:co2]
+    @calc.outputs.labels.should  eql [:co2]
   end
   it 'should generate an discover URL' do
-    Transport.discover_url.should eql 'http://discover.amee.com/categories/transport/car/generic'
+    @calc.discover_url.should eql 'http://discover.amee.com/categories/transport/car/generic'
   end
   it 'should redirect to discover URL' do
-    Transport.explorer_url.should eql 'http://discover.amee.com/categories/transport/car/generic'
+    @calc.explorer_url.should eql 'http://discover.amee.com/categories/transport/car/generic'
   end
   it 'can return a term via []' do
-    Transport[:co2].label.should eql :co2
+    @calc[:co2].label.should eql :co2
   end
   it 'when copied, should deep copy the values' do
-    x=Transport.clone
+    x=@calc.clone
     x[:co2].value :somevalue
     x[:co2].value.should eql :somevalue
-    Transport[:co2].value.should be_nil
+    @calc[:co2].value.should be_nil
   end
   it 'knows to get terms that come before or after others' do
-    t=Transport.clone
+    t=@calc.clone
     t.before(:distance).labels.
       should eql [:fuel,:size]
     t.after(:distance).map(&:label).
       should eql [:co2]
   end
   it 'delegates selectors to terms list' do
-    t=Transport.clone
+    t=@calc.clone
     t.drills.labels.should eql [:fuel,:size]
   end
   it 'can find its amee data category' do
-    t=Transport.clone
+    t=@calc.clone
     mocker=AMEEMocker.new self,:path=>'transport/car/generic'
     mocker.data_category
     t.send(:amee_data_category).path.should eql '/data/transport/car/generic'
@@ -55,18 +60,18 @@ describe Calculation do
   it 'can find its amee item definition' do
     mocker=AMEEMocker.new self,:path=>'transport/car/generic'
     mocker.item_definition(:my_itemdef_name).data_category
-    t=Transport.clone
+    t=@calc.clone
     t.send(:amee_item_definition).name.should eql :my_itemdef_name
   end
   it 'can give item value definition list' do
     mocker=AMEEMocker.new self,:path=>'transport/car/generic'
     mocker.item_value_definition('distance').item_value_definitions.
       item_definition.data_category
-    t=Transport.clone
+    t=@calc.clone
     t.send(:amee_ivds).first.path.should eql 'distance'
   end
   it 'can memoise access to  AMEE' do
-    t=Transport.clone
+    t=@calc.clone
     #AMEE::Data::Category.get(connection, "/data#{path}")
     flexmock(AMEE::Data::Category).should_receive(:get).
       with(AMEE::DataAbstraction.connection,'/data/transport/car/generic').