amee-data-abstraction 2.1.1 → 2.2.0

data/CHANGELOG.txt

@@ -1,4 +1,7 @@
 = Changelog
 
+== 1.3.0
+  * Reconfigure storage and API for Calculation Sets
+
 == 1.0.0
   * Initial public release

data/README.txt

@@ -25,9 +25,9 @@ Documentation: http://rubydoc.info/gems/amee-data-abstraction
  All gem requirements should be installed as part of the rubygems installation process 
  above, but are listed here for completeness.
 
- * amee ~> 3.0
+ * amee ~> 4.1
  * uuidtools = 2.1.2
- * quantify = 1.1.0
+ * quantify = 2.0.0
  
 == USAGE
 
@@ -117,16 +117,10 @@ Submit to AMEE for calculation
 
 Typical practice is initialize the calculation prototypes required for an
 application via a configuration file which creates the required calculation
-templates within an instance of CalculationSet. If the calculation set is assigned
-to a global variable or constant, the set of prototypes is available for
-initializing new calculations and templating view structures (e.g. tables, forms)
-from anywhere in the application.
+templates within an instance of CalculationSet. Such a configuration file can
+be structured the follow DSL:
 
-Adding a configuration to /config or /config/initializers may be appropriate
-
-  # e.g. /config/initializers/calculations.rb
-
-   Calculations = AMEE::DataAbstraction::CalculationSet {
+  # e.g. /config/calculations/my_emissions_calculations.rb
 
     calculation {
       label :electricity
@@ -148,17 +142,35 @@ Adding a configuration to /config or /config/initializers may be appropriate
       path "/some/fuel/associated/path/in/amee"
       terms_from_amee
     }
-  }
+
+The default location for such files within Rails applications is under
+/config/calculations. If such an approach is taken, the configuration can be
+read and a calculation set generated by using the filename, thus:
+
+  CalculationSet.find('my_emissions_calculations')
+
+                          #=> <AMEE::DataAbstraction::CalculationSet ... >
+
+Otherwise, the path to the configuration file can be provided:
+
+  CalculationSet.find('some/directory/my_emissions_calculations')
+
+                          #=> <AMEE::DataAbstraction::CalculationSet ... >
+
+The calculation set is accessible as follow using the same argument as used
+by the Find method (filename if conventional Rails location, path otherwise):
+
+  CalculationSet.sets['my_emissions_calculations']
 
                           #=> <AMEE::DataAbstraction::CalculationSet ... >
 
 From this global calculation set, initialize a new calculation
 
-  my_fuel_calculation = Calculations[:fuel].begin_calculation
+  my_fuel_calculation = CalculationSet.sets['my_emissions_calcualtions'][:fuel].begin_calculation
 
                           #=> <AMEE::DataAbstraction::OngoingCalculation ... >
 
-  a_different_transport_calculation = Calculations[:transport].begin_calculation
+  a_different_transport_calculation = CalculationSet.sets['my_emissions_calcualtions'][:transport].begin_calculation
 
                           #=> <AMEE::DataAbstraction::OngoingCalculation ... >
 

data/VERSION

@@ -1 +1 @@
-2.1.1
+2.2.0

data/amee-data-abstraction.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{amee-data-abstraction}
-  s.version = "2.1.1"
+  s.version = "2.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["James Hetherington", "Andrew Berkeley", "James Smith", "George Palmer"]
-  s.date = %q{2011-10-12}
+  s.date = %q{2011-10-18}
   s.description = %q{Part of the AMEEappkit this gem provides a data abstraction layer, decreasing the amount and detail of development required}
   s.email = %q{help@amee.com}
   s.extra_rdoc_files = [
@@ -62,16 +62,17 @@ Gem::Specification.new do |s|
     "spec/core-extensions/hash_spec.rb",
     "spec/core-extensions/ordered_hash_spec.rb",
     "spec/core-extensions/proc_spec.rb",
-    "spec/fixtures/electricity.rb",
-    "spec/fixtures/electricity_and_transport.rb",
-    "spec/fixtures/transport.rb",
+    "spec/fixtures/config/calculations/electricity.rb",
+    "spec/fixtures/config/calculations/electricity_and_transport.rb",
+    "spec/fixtures/config/calculations/transport.rb",
+    "spec/fixtures/config/electricity.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/AMEE/amee-data-abstraction}
   s.licenses = ["BSD 3-Clause"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{1.5.3}
   s.summary = %q{Calculation and form building tool hiding details of AMEEconnect}
 
   if s.respond_to? :specification_version then

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

@@ -132,7 +132,7 @@ module AMEE
       end
 
       def explorer_url
-         ::Rails.logger.info "#explorer_url method deprecated. Use #discover_url" if defined? Rails
+         ::Rails.logger.info "#explorer_url method deprecated. Use #discover_url" if defined?(Rails) && ::Rails.logger.present?
          discover_url
       end
        

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

@@ -36,22 +36,95 @@ module AMEE
     #
     class CalculationSet
 
-      # Initialize a <i>CalculationSet</i> with a "DSL" block, i.e. a block to be
-      # evaluated in the context of the instantiated CalculationSet
+      # Class variable holding all instantiated calculation sets keyed on the set
+      # name.
       #
-      def initialize(options={},&block)
-        @calculations=ActiveSupport::OrderedHash.new
+      @@sets = {}
+      
+      # Convenience method for accessing the @@sets class variable
+      def self.sets
+        @@sets
+      end
+      
+      # 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.
+      #
+      def self.find(name)
+        @@sets[name.to_sym] or load_set(name)
+      end
+      
+      # Regenerate a configuration lock file assocaited with the master
+      # configuration file <tt>name</tt>. Optionally set a custom path for the
+      # lock file as <tt>output_path</tt>, otherwise the lock file path and
+      # filename will be based upon the master file with the extension .lock.rb.
+      #
+      def self.regenerate_lock_file(name,output_path=nil)
+        set = CalculationSet.find(name)
+        set.generate_lock_file(output_path)
+      end
+
+      # Find a specific prototype calculation instance without specifying the set
+      # to which it belongs.
+      #
+      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
+
+      protected
+
+      # Load a calculation set based on a filename or full path.
+      def self.load_set(name)
+        CalculationSet.new(name,:file => name) do
+          instance_eval(File.open(self.config_path).read)
+        end
+      end
+
+      DEFFAULT_RAILS_CONFIG_DIR = "config/calculations"
+
+      # Find the config file assocaited with <tt>name</tt>. The method first checks
+      # the default Rails configuration location (config/calculations) then the
+      # file path described by <tt>name</tt> relative to the Rails root and by
+      # absolute path.
+      def self.find_config_file(name)
+        default_config_dir = defined?(::Rails) ? "#{::Rails.root}/#{DEFFAULT_RAILS_CONFIG_DIR}" : nil
+        if defined?(::Rails) && File.exists?("#{default_config_dir}/#{name.to_s}.rb")
+          "#{default_config_dir}/#{name.to_s}.rb"
+        elsif defined?(::Rails) && File.exists?("#{default_config_dir}/#{name.to_s}")
+          "#{default_config_dir}/#{name.to_s}"
+        elsif defined?(::Rails) && File.exists?("#{::Rails.root}/#{name}")
+          "#{::Rails.root}/#{name}"
+        elsif File.exists?(name)
+          name
+        else
+          raise ArgumentError, "The config file '#{name}' could not be located"
+        end
+      end
+
+      public
+
+      attr_accessor :calculations, :name, :file
+
+      # 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.
+      #
+      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
 
-      # Access the @calculations instance variable ordered hash. Keys are labels
-      # assocaited with each prototype calculation; values are the instantiated
-      # <i>PrototypeCalculation</i> objects
-      #
-      attr_accessor :calculations
-
       # Shorthand method for returning the prototype calculation which is represented
       # by a label matching <tt>sym</tt>
       #
@@ -94,8 +167,77 @@ module AMEE
             instance_exec(usage,&dsl_block)
           }
         end
+      end
+
+      # Returns the path to the configuration file for <tt>self</tt>. If a .lock
+      # file exists, this takes precedence, otherwise the master config file
+      # described by the <tt>#file</tt> attribute is returned.
+      #
+      def config_path
+        lock_file_exists? ? lock_file_path : @file
+      end
 
+      # Returns the path to the configuration lock file
+      def lock_file_path
+        @file.gsub(".rb",".lock.rb") rescue nil
+      end
+
+      # Returns <tt>true</tt> if a configuration lock file exists. Otherwise,
+      # returns <tt>false</tt>.
+      #
+      def lock_file_exists?
+        File.exists?(lock_file_path)
+      end
+
+      # 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 <tt>#lock_file_path</tt> method. If a custom output
+      # location is required, this can be provided optionally as an argument.
+      #
+      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
+      
     end
   end
 end

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

@@ -158,6 +158,16 @@ 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>

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

@@ -258,7 +258,7 @@ module AMEE
       def load_outputs
         outputs.each do |output|
           res=nil
-          if output.path==:default
+          if output.path.to_s=='default'
             res= profile_item.amounts.find{|x| x[:default] == true}
           else
             res= profile_item.amounts.find{|x| x[:type] == output.path}

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
@@ -8,25 +9,260 @@ class CalculationSet
     @@called
   end
 end
+
 describe CalculationSet do
-  it 'can create an instance' do
-    ElectricityAndTransport.should be_a CalculationSet
+
+  before :all do
+    CalculationSet.sets.clear
+    @calc_set = CalculationSet.find("electricity_and_transport")
   end
+
   it 'can create an instance' do
-    ElectricityAndTransport.calculations.should be_a ActiveSupport::OrderedHash
+    @calc_set.calculations.should be_a ActiveSupport::OrderedHash
+    @calc_set.should be_a CalculationSet
+  end
+
+  it 'can create an instance and find calcs' 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
   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}
       }
@@ -37,6 +273,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']).
@@ -44,7 +281,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
@@ -53,4 +290,5 @@ describe CalculationSet do
     cs[:bybob].profiles.labels.should eql [:first,:second]
     cs[:byfrank].profiles.labels.should eql [:third]
   end
+  
 end