excel_to_code 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30a048682c2cf9317de28a612f4394e205d507fb
-  data.tar.gz: 95d2d238aab30a09195a6665f91124e2fa6a4c29
+  metadata.gz: ab3512a980f85d456a108268e78f6d3b77af40d6
+  data.tar.gz: 2e7b0e729694750dcb09b1ea0323ed3e4eef28f7
 SHA512:
-  metadata.gz: 087a77eefc3bcbfc39b330c2bf21c7ca58e9a5dfd529db6e345ec820937a6e1d16a0ccee457f67a2f8fe001a95ba8f3f2dd29a017e462d05f6fb281f37811619
-  data.tar.gz: 4bdda7d4a4db5e06468b16c9ed3f4e544c60757f33bcf705039677174603c8a522d462bb5011d0a470da20d4283a5fff3e018eaa04235c73f6a1b078cd86521a
+  metadata.gz: ba0771a94b0cac9e9de877f9084df30da3c449463b3e0b916ea4834e911d918052d9d40213a5cb3286ae2ce6cff0150bbccb60b97a1171340b00ead323503171
+  data.tar.gz: a4118b8b83c6e0e564d0d76856ad05e170e502ff353f5f95e90486630872fee0ada8bf97ac401ae92d2e79a4f839f3e832149fff2710010e68b9f52f03103f23

data/bin/excel_to_c

@@ -39,10 +39,6 @@ END
     command.actually_run_tests = true
   end
   
-  opts.on('-m','--run-in-memory',"Instead of writing intermediate files to disk, uses memory. Requires a lot of memory") do
-    command.run_in_memory = true
-  end
-
   opts.on('--sloppy-tests',"The generated tests treat blanks and zeros as equivalent and only require numbers to be approximately the same. This is the default.") do
     command.sloppy_tests = true
   end

data/bin/excel_to_ruby

@@ -35,10 +35,6 @@ END
     command.actually_run_tests = true
   end
   
-  opts.on('-m','--run-in-memory',"Instead of writing intermediate files to disk, uses memory. Requires a lot of memory.") do
-    command.run_in_memory = true
-  end
-
   opts.on('--sloppy-tests',"The generated tests treat blanks and zeros as equivalent and only require numbers to be approximately the same. This is the default.") do
     command.sloppy_tests = true
   end

data/src/commands/excel_to_c.rb

@@ -19,11 +19,16 @@ class ExcelToC < ExcelToX
   def write_out_excel_as_code
     log.info "Writing C code"
         
-    number_of_refs = @formulae.size
+    number_of_refs = @formulae.size + @named_references_to_keep.size
         
     # Output the workbook preamble
     o = output("#{output_name.downcase}.c")
     o.puts "// #{excel_file} approximately translated into C"
+    o.puts "// definitions"
+    o.puts "#define NUMBER_OF_REFS #{number_of_refs}"
+    o.puts "#define EXCEL_FILENAME  #{excel_file.inspect}"
+    o.puts "// end of definitions"
+    o.puts
 
     o.puts '// First we have c versions of all the excel functions that we know'
     o.puts IO.readlines(File.join(File.dirname(__FILE__),'..','compile','c','excel_to_c_runtime.c')).join
@@ -32,34 +37,11 @@ class ExcelToC < ExcelToX
     o.puts '// Start of the file specific functions'
     o.puts
     
-    # Now we have to put all the initial definitions out
-    o.puts "// definitions"
-    o.puts "static ExcelValue ORIGINAL_EXCEL_FILENAME = {.type = ExcelString, .string = #{excel_file.inspect} };"
 
     c = CompileToCHeader.new
     c.settable = settable
     c.gettable = gettable
     c.rewrite(@formulae, @worksheet_c_names, o)
-
-    # Need to make sure there are enough refs for named references as well
-    number_of_refs += @named_references_to_keep.size
-
-    o.puts "// end of definitions"
-    o.puts
-    o.puts "// Used to decide whether to recalculate a cell"
-    o.puts "static int variable_set[#{number_of_refs}];"
-    o.puts ""
-    o.puts "// Used to reset all cached values and free up memory"
-    # FIXME: This feels like a bad place for this. Should be in runtime?
-    o.puts "void reset() {"
-    o.puts "  int i;"
-    o.puts "  cell_counter = 0;"
-    o.puts "  free_all_allocated_memory(); "
-    o.puts "  for(i = 0; i < #{number_of_refs}; i++) {"
-    o.puts "    variable_set[i] = 0;"
-    o.puts "  }"
-    o.puts "};"
-    o.puts
     
     # Output the value constants
     o.puts "// starting the value constants"
@@ -320,12 +302,10 @@ END
     o = output("test_#{name}.rb")    
     o.puts "# coding: utf-8"
     o.puts "# Test for #{name}"
-    o.puts "require 'rubygems'"
-    o.puts "gem 'minitest'"
     o.puts  "require 'minitest/autorun'"
     o.puts  "require_relative '#{output_name.downcase}'"
     o.puts
-    o.puts "class Test#{ruby_module_name} < Minitest::Test"
+    o.puts "class Test#{ruby_module_name} < Minitest::Unit::TestCase"
     o.puts "  def self.runnable_methods"
     o.puts "    puts 'Overriding minitest to run tests in a defined order'"
     o.puts "    methods = methods_matching(/^test_/)"

data/src/commands/excel_to_ruby.rb

@@ -60,10 +60,10 @@ class ExcelToRuby < ExcelToX
     
     o.puts "# coding: utf-8"
     o.puts "# All tests for #{excel_file}"
-    o.puts "require 'test/unit'"
+    o.puts "require 'minitest/autorun'"
     o.puts "require_relative '#{output_name.downcase}'"
     o.puts
-    o.puts "class Test#{ruby_module_name} < Test::Unit::TestCase"
+    o.puts "class Test#{ruby_module_name} < Minitest::Unit::TestCase"
     o.puts "  def worksheet; @worksheet ||= #{ruby_module_name}.new; end"
 
     CompileToCUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)

data/src/commands/excel_to_x.rb

@@ -9,7 +9,6 @@ require_relative '../excel_to_code'
 
 # Used to throw normally fatal errors
 class ExcelToCodeException < Exception; end
-class VersionedFileNotFoundException < Exception; end
 class XMLFileNotFoundException < Exception; end
 
 class ExcelToX
@@ -27,10 +26,6 @@ class ExcelToX
   # Optional attribute. The excel file will be translated to xml and stored here.
   # If not specified, will be '#{excel_file_name}/xml'
   attr_accessor :xml_directory
-
-  # Optional attribute. The intermediate workings will be stored here.
-  # If not specified, will be '#{excel_file_name}/intermediate'
-  attr_accessor :intermediate_directory
   
   # Optional attribute. Specifies which cells have setters created in the c code so their values can be altered at runtime.
   # It is a hash. The keys are the sheet names. The values are either the symbol :all to specify that all cells on that sheet 
@@ -89,11 +84,6 @@ class ExcelToX
   #   * false - the generated tests are not run
   attr_accessor :actually_run_tests
   
-  # Optional attribute. Boolean.
-  #   * true - the intermediate files are not written to disk (requires a lot of memory)
-  #   * false - the intermediate files are written to disk (default, easier to debug)
-  attr_accessor :run_in_memory
-  
   # This is the log file, if set it needs to respond to the same methods as the standard logger library
   attr_accessor :log
 
@@ -101,75 +91,31 @@ class ExcelToX
   #   * true - empty cells and zeros are treated as being equivalent in tests. Numbers greater then 1 are only expected to match with assert_in_epsilon, numbers less than 1 are only expected to match with assert_in_delta
   #   * false - empty cells and zeros are treated as being different in tests. Numbers must match to full accuracy.
   attr_accessor :sloppy_tests
-  
-  def set_defaults
-    raise ExcelToCodeException.new("No excel file has been specified") unless excel_file
-    
-    self.output_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),language)
-    self.xml_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),'xml')
-    self.intermediate_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),'intermediate')
-    
-    self.output_name ||= "Excelspreadsheet"
-    
-    self.cells_that_can_be_set_at_runtime ||= {}
-    
-    # Make sure that all the cell names are upcase symbols and don't have any $ in them
-    if cells_that_can_be_set_at_runtime.is_a?(Hash)
-  
-      # Make sure the sheet names are symbols
-      cells_that_can_be_set_at_runtime.keys.each do |sheet|
-        next if sheet.is_a?(Symbol)
-        cells_that_can_be_set_at_runtime[sheet.to_sym] = cells_that_can_be_set_at_runtime.delete(sheet)
-      end
-
-      cells_that_can_be_set_at_runtime.keys.each do |sheet|
-        next unless cells_that_can_be_set_at_runtime[sheet].is_a?(Array)
-        cells_that_can_be_set_at_runtime[sheet] = cells_that_can_be_set_at_runtime[sheet].map { |reference| reference.gsub('$','').upcase.to_sym }
-      end
-    end
-
-    # Make sure that all the cell names are upcase symbols and don't have any $ in them
-    if cells_to_keep
-      cells_to_keep.keys.each do |sheet|
-        next if sheet.is_a?(Symbol)
-        cells_to_keep[sheet.to_sym] = cells_to_keep.delete(sheet)
-      end
-
-      cells_to_keep.keys.each do |sheet|
-        next unless cells_to_keep[sheet].is_a?(Array)
-        cells_to_keep[sheet] = cells_to_keep[sheet].map { |reference| reference.gsub('$','').upcase.to_sym }
-      end
-    end  
-
-    if named_references_to_keep.is_a?(Array)
-      named_references_to_keep.map! { |named_reference| named_reference.downcase.to_sym }
-    end
-
-    if named_references_that_can_be_set_at_runtime.is_a?(Array)
-      named_references_that_can_be_set_at_runtime.map! { |named_reference| named_reference.downcase.to_sym }
-    end
-    
-    # Make sure the relevant directories exist
-    self.excel_file = File.expand_path(excel_file)
-    self.output_directory = File.expand_path(output_directory)
-    
-    # Set up our log file
-    self.log ||= Logger.new(STDOUT)
 
-    # By default, tests allow empty cells and zeros to be treated as equivalent, and numbers only have to match to a 0.001 epsilon (if expected>1) or 0.001 delta (if expected<1)
-    self.sloppy_tests ||= true
-  end
+  # Deprecated
+  def run_in_memory=(boolean)
+    $stderr.puts "The run_in_memory switch is deprecated (it is now always true). Please remove calls to it"
+  end 
   
+  # Deprecated
+  def intermediate_directory=(dirname)
+    $stderr.puts "The intermediate_directory switch is deprecated (nowdays, no intermediate files are written). Please remove calls to it"
+  end
+
+  # This is the main method. Once all the above attributes have been set, it should be called to actually do the work.
   def go!
     # This sorts out the settings
     set_defaults
+    clean_cells_that_can_be_set_at_runtime
+    clean_cells_to_keep
+    clean_named_references_to_keep
+    clean_named_references_that_can_be_set_at_runtime
     
-    # These turn the excel into a more accesible format
+    # These turn the excel into xml on disk
     sort_out_output_directories
     unzip_excel
     
-    # These get all the information out of the excel and put
-    # into a series of plain text files
+    # These get all the information out of the excel and put it in memory
     extract_data_from_workbook
     extract_data_from_worksheets
     
@@ -184,24 +130,33 @@ class ExcelToX
     # * Turning range references (e.g., A1:B2) into array litterals (e.g., {A1,B1;A2,B2})
     # * Turning shared formulae into a series of conventional formulae
     # * Turning array formulae into a series of conventional formulae
-    # * Mergining all the different types of formulae and values into a single file
-    rewrite_worksheets
+    # * Mergining all the different types of formulae and values into a single hash
+    rewrite_values_to_remove_shared_strings
+    rewrite_row_and_column_references
+    rewrite_shared_formulae_into_normal_formulae
+    rewrite_array_formulae
+    combine_formulae_types
     
     # These perform a series of transformations to the information
-    # with the intent of removing any redundant calculations
-    # that are in the excel.
-    simplify # Replacing shared strings and named references with their actual values, tidying arithmetic
-
-    # In case this hasn't been set by the user
-    if @cells_that_can_be_set_at_runtime.empty?
-      log.info "Creating a good set of cells that should be settable"
-      @cells_that_can_be_set_at_runtime = a_good_set_of_cells_that_should_be_settable_at_runtime
-    end
-
-    if named_references_that_can_be_set_at_runtime == :where_possible
-      work_out_which_named_references_can_be_set_at_runtime
-    end
-
+    # with the intent of removing any redundant calculations that are in the excel.
+    # Replacing shared strings and named references with their actual values, tidying arithmetic
+    simplify_arithmetic
+    simplify
+
+    # If nothing has been specified in named_references_that_can_be_set_at_runtime 
+    # or in cells_that_can_be_set_at_runtime, then we assume that
+    # all value cells should be settable if they are referenced by
+    # any other forumla.
+    ensure_there_is_a_good_set_of_cells_that_can_be_set_at_runtime
+
+    # If named_reference_that_have_been_set_at_runtime is given the :where_possible switch
+    # then will take a look at which named_references only refer to cells that have been
+    # specifed or judged as settable
+    work_out_which_named_references_can_be_set_at_runtime
+
+    # Slims down the named references we keep track of to just the ones that should
+    # appear in the generated code: basically those that are specifed as being gettable
+    # or specified or judged to be settable.
     filter_named_references
 
     replace_formulae_with_their_results
@@ -221,11 +176,82 @@ class ExcelToX
     log.info "The generated code is available in #{File.join(output_directory)}"
   end
   
+  # If an attribute hasn't been specified, specifies a good default value here.
+  def set_defaults
+    raise ExcelToCodeException.new("No excel file has been specified") unless excel_file
+    
+    self.output_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),language)
+    self.xml_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),'xml')
+    
+    self.output_name ||= "Excelspreadsheet"
+    
+    self.cells_that_can_be_set_at_runtime ||= {}
+    
+    # Make sure the relevant directories exist
+    self.excel_file = File.expand_path(excel_file)
+    self.output_directory = File.expand_path(output_directory)
+    
+    # Set up our log file
+    self.log ||= Logger.new(STDOUT)
+
+    # By default, tests allow empty cells and zeros to be treated as equivalent, and numbers only have to match to a 0.001 epsilon (if expected>1) or 0.001 delta (if expected<1)
+    self.sloppy_tests ||= true
+  end
+  
+  # Make sure that sheet names are symbols FIXME: Case ?
+  # Make sure that all the cell names are upcase symbols and don't have any $ in them
+  def clean_cells_that_can_be_set_at_runtime
+    return unless cells_that_can_be_set_at_runtime.is_a?(Hash)
+
+    # Make sure sheet names are symbols
+    cells_that_can_be_set_at_runtime.keys.each do |sheet|
+      next if sheet.is_a?(Symbol)
+      cells_that_can_be_set_at_runtime[sheet.to_sym] = cells_that_can_be_set_at_runtime.delete(sheet)
+    end
+
+    # Make sure references are of the form A1, not a1 or A$1
+    cells_that_can_be_set_at_runtime.keys.each do |sheet|
+      next unless cells_that_can_be_set_at_runtime[sheet].is_a?(Array)
+      cells_that_can_be_set_at_runtime[sheet] = cells_that_can_be_set_at_runtime[sheet].map do |reference| 
+        reference.gsub('$','').upcase.to_sym
+      end
+    end
+  end
+
+  # Make sure that sheet names are symbols FIXME: Case ?
+  # Make sure that all the cell names are upcase symbols and don't have any $ in them
+  def clean_cells_to_keep
+    return unless cells_to_keep
+    
+    # Make sure sheet names are symbols
+    cells_to_keep.keys.each do |sheet|
+      next if sheet.is_a?(Symbol)
+      cells_to_keep[sheet.to_sym] = cells_to_keep.delete(sheet)
+    end
+
+    # Make sure references are of the form A1, not a1 or A$1
+    cells_to_keep.keys.each do |sheet|
+      next unless cells_to_keep[sheet].is_a?(Array)
+      cells_to_keep[sheet] = cells_to_keep[sheet].map { |reference| reference.gsub('$','').upcase.to_sym }
+    end
+  end  
+
+  # Make sure named_references_to_keep are lowercase symbols
+  def clean_named_references_to_keep
+    return unless named_references_to_keep.is_a?(Array)
+    named_references_to_keep.map! { |named_reference| named_reference.downcase.to_sym }
+  end
+
+  # Make sure named_references_that_can_be_set_at_runtime are lowercase symbols
+  def clean_named_references_that_can_be_set_at_runtime
+    return unless named_references_that_can_be_set_at_runtime.is_a?(Array)
+    named_references_that_can_be_set_at_runtime.map! { |named_reference| named_reference.downcase.to_sym }
+  end
+
   # Creates any directories that are needed
   def sort_out_output_directories    
     FileUtils.mkdir_p(output_directory)
     FileUtils.mkdir_p(xml_directory)
-    FileUtils.mkdir_p(intermediate_directory) unless run_in_memory
   end
   
   # FIXME: Replace these with pure ruby versions?
@@ -344,13 +370,12 @@ class ExcelToX
     @c_names_assigned[c_name] = name
     c_name
   end
-
   
   # For each worksheet, extract the useful bits from the excel xml
   def extract_data_from_worksheets
     # All are hashes of the format ["SheetName", "A1"] => [:number, "1"]
     # This one has a series of table references
-    extractor = ExtractEverythingFromWorkbook.new
+    extractor = ExtractDataFromWorksheet.new
     
     # Loop through the worksheets
     # FIXME: make xml_filename be the IO object?
@@ -396,13 +421,72 @@ class ExcelToX
     end
   end
   
-  def rewrite_worksheets
-    rewrite_values
-    rewrite_row_and_column_references
-    rewrite_shared_formulae
-    rewrite_array_formulae
-    combine_formulae_files
-    simplify_arithmetic
+  # This makes sure that cells_to_keep includes named_references_to_keep
+  def transfer_named_references_to_keep_into_cells_to_keep
+    log.info "Transfering named references to keep into cells to keep"
+    return unless @named_references_to_keep
+    @named_references_to_keep = @named_references.keys if @named_references_to_keep == :all
+    @cells_to_keep ||= {}
+    @named_references_to_keep.each do |name|
+      ref = @named_references[name]
+      if ref
+        add_ref_to_hash(ref, @cells_to_keep)
+      else
+        log.warn "Named reference \"#{name}\" not found"
+      end
+    end
+  end
+
+  # This makes sure that there are cell setter methods for any named references that can be set
+  def transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
+    log.info "Making sure there are setter methods for named references that can be set"
+    return unless @named_references_that_can_be_set_at_runtime
+    return if @named_references_that_can_be_set_at_runtime == :where_possible # in this case will be done in #work_out_which_named_references_can_be_set_at_runtime
+    @cells_that_can_be_set_at_runtime ||= {}
+    @named_references_that_can_be_set_at_runtime.each do |name|
+      ref = @named_references[name]
+      if ref
+        add_ref_to_hash(ref, @cells_that_can_be_set_at_runtime)
+      else
+        log.warn "Named reference #{name} not found"
+      end
+    end
+  end
+
+  # The reference passed may be a sheet reference or an area reference
+  # in which case we need to expand out the ref so that the hash contains
+  # one reference per cell
+  def add_ref_to_hash(ref, hash)
+    ref = ref.dup
+    if ref.first == :sheet_reference
+      sheet = ref[1]
+      cell = Reference.for(ref[2][1]).unfix.to_sym
+      hash[sheet] ||= []
+      return if hash[sheet] == :all
+      hash[sheet] << cell.to_sym unless hash[sheet].include?(cell.to_sym)
+    elsif ref.first == :array
+      ref.shift
+      ref.each do |row|
+        row = row.dup
+        row.shift
+        row.each do |cell|
+          add_ref_to_hash(cell, hash)
+        end
+      end
+    else
+      log.error "Weird reference in named reference #{ref}"
+    end
+  end
+  
+  # Excel can include references to strings rather than the strings
+  # themselves. This harmonises so the strings themselves are always
+  # used.
+  def rewrite_values_to_remove_shared_strings
+    log.info "Rewriting values"
+    r = ReplaceSharedStringAst.new(@shared_strings)
+    @values.each do |ref, ast|
+      r.map(ast)
+    end
   end
   
   # In Excel we can have references like A:Z and 5:20 which mean all cells in columns 
@@ -435,19 +519,17 @@ class ExcelToX
     # FIXME: Could we now nil off the dimensions? Or do we need for indirects?
   end
   
-  def rewrite_shared_formulae
+  # Excel can share formula definitions across cells. This function unshares
+  # them so every cell has its own definition
+  def rewrite_shared_formulae_into_normal_formulae
     log.info "Rewriting shared formulae"
     @formulae_shared = RewriteSharedFormulae.rewrite( @formulae_shared, @formulae_shared_targets)
-    # FIXME: Could now nil off the @formula_shared_targets ?
+    @shared_formulae_targets = :no_longer_needed # Allow the targets to be garbage collected.
   end
 
-  def simplify_arithmetic
-    simplify_arithmetic_replacer ||= SimplifyArithmeticAst.new
-    @formulae.each do |ref, ast|
-      simplify_arithmetic_replacer.map(ast)
-    end
-  end
-  
+  # Excel has the concept of array formulae: formulae whose answer spans
+  # many cells. They are awkward. We try and replace them with conventional
+  # formulae here.
   def rewrite_array_formulae
     log.info "Rewriting array formulae"
     # FIMXE: Refactor this
@@ -481,16 +563,10 @@ class ExcelToX
     @formulae_array = RewriteArrayFormulae.rewrite(@formulae_array)
   end
 
-  def rewrite_values
-    log.info "Rewriting values"
-    r = ReplaceSharedStringAst.new(@shared_strings)
-    @values.each do |ref, ast|
-      r.map(ast)
-    end
-  end
-  
-  def combine_formulae_files
-    log.info "Combining formula files"
+  # At the end of this function we are left with a single @formulae hash
+  # that contains every cell in the workbook, whatever its original format.
+  def combine_formulae_types
+    log.info "Combining formulae types"
 
     @formulae = required_references
     # We dup this to avoid the values being replaced when manipulating formulae
@@ -504,6 +580,16 @@ class ExcelToX
     log.info "Sheet contains #{@formulae.size} cells"
   end
   
+  # Turns aritmetic with many arguments (1+2+3+4) into arithmetic with only
+  # two arguments (((1+2)+3)+4), taking into account operator precedence.
+  def simplify_arithmetic
+    log.info "Simplifying arithmetic"
+    simplify_arithmetic_replacer ||= SimplifyArithmeticAst.new
+    @formulae.each do |ref, ast|
+      simplify_arithmetic_replacer.map(ast)
+    end
+  end
+  
   # This ensures that all gettable and settable values appear in the output
   # even if they are blank in the underlying excel
   def required_references
@@ -560,71 +646,13 @@ class ExcelToX
     required_refs
   end
 
-  # This makes sure that cells_to_keep includes named_references_to_keep
-  def transfer_named_references_to_keep_into_cells_to_keep
-    log.info "Transfering named references to keep into cells to keep"
-    return unless @named_references_to_keep
-    @named_references_to_keep = @named_references.keys if @named_references_to_keep == :all
-    @cells_to_keep ||= {}
-    @named_references_to_keep.each do |name|
-      ref = @named_references[name]
-      if ref
-        add_ref_to_hash(ref, @cells_to_keep)
-        p @cells_to_keep
-      else
-        log.warn "Named reference \"#{name}\" not found"
-      end
-    end
-  end
-
-  # This makes sure that there are cell setter methods for any named references that can be set
-  def transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
-    log.info "Making sure there are setter methods for named references that can be set"
-    return unless @named_references_that_can_be_set_at_runtime
-    return if @named_references_that_can_be_set_at_runtime == :where_possible # in this case will be done in #work_out_which_named_references_can_be_set_at_runtime
-    @cells_that_can_be_set_at_runtime ||= {}
-    @named_references_that_can_be_set_at_runtime.each do |name|
-      ref = @named_references[name]
-      if ref
-        add_ref_to_hash(ref, @cells_that_can_be_set_at_runtime)
-      else
-        log.warn "Named reference #{name} not found"
-      end
-    end
-  end
-
-  # The reference passed may be a sheet reference or an area reference
-  # in which case we need to expand out the ref so that the hash contains
-  # one reference per cell
-  def add_ref_to_hash(ref, hash)
-    ref = ref.dup
-    if ref.first == :sheet_reference
-      sheet = ref[1]
-      cell = Reference.for(ref[2][1]).unfix.to_sym
-      hash[sheet] ||= []
-      return if hash[sheet] == :all
-      hash[sheet] << cell.to_sym unless hash[sheet].include?(cell.to_sym)
-    elsif ref.first == :array
-      ref.shift
-      ref.each do |row|
-        row = row.dup
-        row.shift
-        row.each do |cell|
-          add_ref_to_hash(cell, hash)
-        end
-      end
-    else
-      log.error "Weird reference in named reference #{ref}"
-    end
-  end
-
   # This just checks which named references refer to cells that we have already declared as settable
   def work_out_which_named_references_can_be_set_at_runtime
     log.info "Working out which named references can be set at runtime"
     return unless @named_references_that_can_be_set_at_runtime
     return unless @named_references_that_can_be_set_at_runtime == :where_possible
     cells_that_can_be_set = @cells_that_can_be_set_at_runtime
-    cells_that_can_be_set = a_good_set_of_cells_that_should_be_settable_at_runtime if cells_that_can_be_set == :named_references_only
+    cells_that_can_be_set = cells_with_settable_values if cells_that_can_be_set == :named_references_only
     cells_that_can_be_set_due_to_named_reference = Hash.new { |h,k| h[k] = Array.new  }
     @named_references_that_can_be_set_at_runtime = []
     all_named_references = @named_references
@@ -979,7 +1007,19 @@ class ExcelToX
   # or in cells_that_can_be_set_at_runtime, then we assume that
   # all value cells should be settable if they are referenced by
   # any other forumla.
-  def a_good_set_of_cells_that_should_be_settable_at_runtime
+  def ensure_there_is_a_good_set_of_cells_that_can_be_set_at_runtime
+    # By this stage, if named_references were set, then cells_that_can_be_set_at_runtime will 
+    # have been set to match
+    return unless @cells_that_can_be_set_at_runtime.empty?
+    @cells_that_can_be_set_at_runtime = cells_with_settable_values
+  end
+
+  # Returns a list of cells that are:
+  # 1. Simple values (e.g., a string or a number)
+  # 2. That are referenced in other formulae
+  # ... these are likely to be cells that the user will want to use as inputs
+  # to their calculation.
+  def cells_with_settable_values
     log.info "Generating a good set of cells that should be settable"
 
     counter = CountFormulaReferences.new