amee-data-abstraction 1.3.1 → 2.0.0

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

@@ -35,29 +35,6 @@ module AMEE
         choice_validation_message
       end
 
-      # Returns the list of available choices for <tt>self</tt>. A custom list of
-      # choices can be provided as an argument, in which case these will override
-      # the list provided by the AMEE platform
-      #
-      def choices(*args)
-        if args.empty?
-          if @choices.blank?
-            drill_down = parent.amee_drill(:before=>label)
-            if single_choice = drill_down.selections[path]
-              disable!
-              [single_choice]
-            else
-              enable!
-              drill_down.choices
-            end
-          else
-            @choices
-          end
-        else
-          @choices = [args].flatten
-        end
-      end
-
       private
 
       # Returns <tt>true</tt> if the value set for <tt>self</tt> is one of the
@@ -67,6 +44,12 @@ module AMEE
         super && (choices.include? value)
       end
 
+      # Returns the list of available choices for <tt>self</tt>.
+      def choices
+        c=parent.amee_drill(:before=>label).choices
+        c.length==1 ? [value] : c #Intention is to get autodrilled, drill will result in a UID
+      end
+
       # Returns <tt>true</tt> if <tt>self</tt> is the "first unset" drill, i.e.
       # the one which should be set next
       #

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

@@ -11,8 +11,6 @@ module AMEE
     #
     class Input < Term
 
-      attr_accessor :dirty
-
       # Returns the valid choices for this input
       # (Abstract, implemented only for subclasses of input.)
       def choices
@@ -31,7 +29,6 @@ module AMEE
         @validation = nil
         validation_message {"#{name} is invalid."}
         super
-        @dirty = false
       end
 
       # Configures the value of <tt>self</tt> to be fixed to <tt>val</tt>, i.e.
@@ -70,7 +67,6 @@ module AMEE
           if args.first.to_s != @value.to_s
             raise Exceptions::FixedValueInterference if fixed?
             parent.dirty! if parent and parent.is_a? OngoingCalculation
-            mark_as_dirty
           end
         end
         super
@@ -159,16 +155,6 @@ module AMEE
         !optional?(usage)
       end
 
-      # Manually set the term as optional
-      def optional!
-        @optional=true
-      end
-
-      # Manually set the term as compuslory
-      def compulsory!
-        @optional=false
-      end
-
       # Check that the value of <tt>self</tt> is valid. If invalid, and is defined
       # as part of a calculation, add the invalidity message to the parent
       # calculation's error list. Otherwise, raise a <i>ChoiceValidation</i>
@@ -199,10 +185,6 @@ module AMEE
         super || fixed?
       end
 
-      def dirty?
-        @dirty
-      end
-
       protected
       # Returns <tt>true</tt> if the value set for <tt>self</tt> is either blank
       # or passes custom validation criteria. Otherwise, returns <tt>false</tt>.
@@ -210,12 +192,6 @@ module AMEE
       def valid?
         validation.blank? || validation === @value_before_cast
       end
-
-      def mark_as_dirty
-        @dirty = true
-        parent.dirty! if parent and parent.is_a? OngoingCalculation
-      end
-      
     end
   end
 end

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

@@ -235,10 +235,6 @@ module AMEE
         reset_invalidity_messages
       end
 
-      def clear_outputs
-        outputs.each {|output| output.value nil }
-      end
-
       def ==(other_calc)
         !terms.inject(false) do |boolean,term|
           boolean || term != other_calc[term.label]
@@ -258,7 +254,7 @@ module AMEE
       def load_outputs
         outputs.each do |output|
           res=nil
-          if output.path.to_s=='default'
+          if output.path==:default
             res= profile_item.amounts.find{|x| x[:default] == true}
           else
             res= profile_item.amounts.find{|x| x[:type] == output.path}
@@ -287,7 +283,7 @@ module AMEE
       # and units for any unset <i>Profile</i> terms (profile item values) from
       # the AMEE platform
       #
-      def load_profile_item_values
+      def load_profile_item_values  
         return unless profile_item
         profiles.unset.each do |term|
           ameeval=profile_item.values.find { |value| value[:path] == term.path }
@@ -309,7 +305,6 @@ module AMEE
       def load_drills
         return unless profile_item
         drills.each do |term|
-          next unless term.value.nil? || term.dirty?
           ameeval=data_item.value(term.path)
           raise Exceptions::Syncronization if term.set? && ameeval!=term.value
           term.value ameeval
@@ -330,7 +325,6 @@ module AMEE
           load_drills
         rescue Exceptions::Syncronization
           delete_profile_item
-          clear_outputs
         end
         load_metadata
         # We could create an unsatisfied PI, and just check drilled? here
@@ -457,8 +451,10 @@ module AMEE
       # <i>Profile</i> term values and attributes
       #
       def set_profile_item_values
-        @profile_item = AMEE::Profile::Item.update(connection,profile_item_path, 
-          profile_options.merge(:get_item=>true))
+        AMEE::Profile::Item.update(connection,profile_item_path, 
+          profile_options.merge(:get_item=>false))
+        #Clear the memoised profile item, to reload with updated values
+        @profile_item=nil
       end
 
       # Delete the profile item which is associated with <tt>self</tt> from the
@@ -467,7 +463,7 @@ module AMEE
       #
       def delete_profile_item
         AMEE::Profile::Item.delete(connection,profile_item_path)
-        self.profile_item_uid=nil
+        self.profile_item_uid=false
         @profile_item=nil
       end
 
@@ -513,8 +509,6 @@ module AMEE
         @profile_category||=AMEE::Profile::Category.get(connection, profile_category_path)
       end
 
-      public
-      
       # Automatically set the value of a drill term if there is only one choice
       def autodrill
         
@@ -535,6 +529,8 @@ module AMEE
         end
       end
 
+      public
+
       # Instantiate an <tt>AMEE::Data::DrillDown</tt> object representing the
       # drill down sequence defined by the drill terms associated with
       # <tt>self</tt>. As with <tt>#drill_options</tt>, An optional hash argument

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

@@ -84,6 +84,16 @@ 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.,
@@ -201,19 +211,6 @@ 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.
@@ -267,33 +264,19 @@ 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)
-            default = send("default_#{field}".to_sym)
-            return instance_variable_set(ivar, (default.alternatives)) if default
+            return instance_variable_set(ivar, (default.alternatives << default)) 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.
@@ -520,7 +503,6 @@ module AMEE
           else value
         end
       end
-      
     end
   end
 end

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

@@ -1,264 +1,32 @@
-require 'spec_helper'
-
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
 class CalculationSet
   def call_me
     #stub, because flexmock doesn't work for new instances during constructor
     @@called=true
   end
-  cattr_accessor :called
+  def self.called
+    @@called
+  end
 end
 describe CalculationSet do
-  
-  before :all do
-    CalculationSet.sets.clear
-    @calc_set = CalculationSet.find("electricity_and_transport")
-  end
-  
   it 'can create an instance' do
-    @calc_set.should be_a CalculationSet
+    ElectricityAndTransport.should be_a CalculationSet
   end
-
   it 'can create an instance' do
-    @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
+    ElectricityAndTransport.calculations.should be_a ActiveSupport::OrderedHash
   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
-    @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
+    ElectricityAndTransport[:transport].should be_a PrototypeCalculation
   end
-
   it 'can construct a calculation' do
-    CalculationSet.new('my_set') {calculation {label :mycalc}}[:mycalc].should be_a PrototypeCalculation
+    CalculationSet.new {calculation {label :mycalc}}[:mycalc].should be_a PrototypeCalculation
   end
-
   it 'can be initialized with a DSL block' do
-    CalculationSet.new('my_set') {call_me}
+    CalculationSet.new {call_me}
     CalculationSet.called.should be_true
   end
-
   it 'can have terms added to all calculations' do
-    cs=CalculationSet.new('my_set') {
+    cs=CalculationSet.new {
       all_calculations {
         drill {label :energetic}
       }
@@ -269,7 +37,6 @@ 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']).
@@ -277,7 +44,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('my_set') {
+    cs=CalculationSet.new {
       calculations_all_usages('/something') { |usage|
         label usage.to_sym
         profiles_from_usage usage
@@ -286,5 +53,4 @@ describe CalculationSet do
     cs[:bybob].profiles.labels.should eql [:first,:second]
     cs[:byfrank].profiles.labels.should eql [:third]
   end
-  
 end