excel_to_code 0.0.2 → 0.0.4

data/{README → README.md}

@@ -3,7 +3,7 @@
 Converts some excel spreadsheets (.xlsx, not .xls) into some other programming languages (currently ruby or c).
 This allows the excel spreadsheets to be run programatically, without excel.
 
-Its cannonical source is at http://github.com/tamc/excel2code
+Its cannonical source is at http://github.com/tamc/excel_to_code
 
 # Running excel_to_code
 

data/TODO

@@ -0,0 +1,34 @@
+# TODO
+
+## Parsing bugs
+
+See doc/How_to_fix_parsing_bugs.md for help
+
+* Whitespace handling in table references
+* Whitespace handling between arguments in a list
+* Doesn't do range unions (e.g., 10:10 C:C == C:10)
+* Doesn't do manually entered arrays {1,2,3;4,5,6}
+
+## Missing functions
+
+See doc/Which_functions_are_implemented.md
+
+See doc/How_to_add_a_missing_function.md
+
+## Simplification & optimisation bugs
+
+* Optimize IF, CHOOSE, MATCH, VLOOKUP and similar functions so that they don't have to calculate all their arguments
+* Fix it so that cells that are being reported as empty, that excel would give a numeric value of zero, are fixed
+
+## Things that are badly written
+
+* Rewrite the excel_to_ruby command to use command line options
+* Refactor the common elements of src/commands/excel_to_c.rb and src/commands/excel_to_ruby.rb
+* Refactor excel_to_c_runtime - split the functions? split the tests?
+* Figure out a common test framework for different code output
+* Tool for turning spreadsheets into tests
+* Option to reorder test output to make it easier to localise errors
+* Tool to create minimal failing example out of test run
+
+
+

data/bin/excel_to_c

@@ -13,7 +13,7 @@ Usage: excel_to_c [options] input_excel_file <output_directory>
   input_excel_file    the name of a .xlsx excel file (i.e., produced by Excel 2007+, not a .xls file) 
   output_directory    the name of a folder in which to place the generated code. If not specified will have the same name as the input_excel_file, without the .xlsx
   
-Support: http://github.com/tamc/excel2code
+Support: http://github.com/tamc/excel_to_code
 END
   
   opts.separator ""

data/bin/excel_to_ruby

@@ -1,9 +1,63 @@
 #!/usr/bin/env ruby
-require_relative '../src/commands/excel_to_ruby'
+require 'optparse'
+require_relative '../src/excel_to_code'
+
 command = ExcelToRuby.new
+
+opts = OptionParser.new do |opts|
+  opts.banner = <<-END
+
+A command to approximately translate excel files into c code.
+
+Usage: excel_to_ruby [options] input_excel_file <output_directory>
+  input_excel_file    the name of a .xlsx excel file (i.e., produced by Excel 2007+, not a .xls file) 
+  output_directory    the name of a folder in which to place the generated code. If not specified will have the same name as the input_excel_file, without the .xlsx
+  
+Support: http://github.com/tamc/excel_to_code
+END
+  
+  opts.separator ""
+  opts.separator "Specific options:"
+  
+  opts.on('-s','--settable WORKSHEET','Make it possible to set the values of cells in this worksheet at runtime. By default no values are settable.') do |sheet|
+    command.cells_that_can_be_set_at_runtime = { sheet => :all }
+  end
+
+  opts.on('-o','--output-name NAME','Filename to give to ruby version of code. Defaults to a folder with the same name as the excel file.') do |name|
+    command.output_name = name
+  end
+  
+  opts.on('-p','--prune-except WORKSHEET',"Remove all cells except those on this worksheet, or that are required to calculate values on that worksheet. By default keeps all cells.") do |sheet|
+    command.cells_to_keep = { sheet => :all }
+  end
+    
+  opts.on('-r','--run-tests',"Run the generated tests") do
+    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("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+begin
+  opts.parse!(ARGV)
+rescue OptionParser::ParseError => e 
+  STDERR.puts e.message, "\n", opts 
+  exit(-1)
+end
+
+unless ARGV.size > 0
+  puts opts
+  exit(-1)
+end
+
 command.excel_file = ARGV[0]
-command.compiled_module_name = "ExcelSpreadsheet"
-command.output_directory = ARGV[1]
-command.values_that_can_be_set_at_runtime = { ARGV[2] => :all } if ARGV[2]
-command.outputs_to_keep = { ARGV[3] => :all } if ARGV[3]
-command.go!
+command.output_directory = ARGV[1] if ARGV[1]
+
+command.go!

data/src/commands/excel_to_c.rb

@@ -3,6 +3,10 @@ require_relative 'excel_to_x'
 
 class ExcelToC < ExcelToX
   
+  def language
+    "c"
+  end
+  
   # These actually create the code version of the excel
   def write_code
     write_out_excel_as_code
@@ -18,13 +22,18 @@ class ExcelToC < ExcelToX
     number_of_refs = 0
     
     # Probably a better way of getting the runtime file to be compiled with the created file
-    puts `cp #{File.join(File.dirname(__FILE__),'..','compile','c','excel_to_c_runtime.c')} #{File.join(output_directory,'excel_to_c_runtime.c')}`
+    puts `cp #} #{File.join(output_directory,'excel_to_c_runtime.c')}`
     
     # Output the workbook preamble
     w = input("worksheet_c_names")
     o = output("#{output_name.downcase}.c")
     o.puts "// #{excel_file} approximately translated into C"
-    o.puts '#include "excel_to_c_runtime.c"'
+
+    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
+    o.puts '// End of the generic c functions'
+    o.puts 
+    o.puts '// Start of the file specific functions'
     o.puts
     
     # Now we have to put all the initial definitions out
@@ -109,7 +118,6 @@ class ExcelToC < ExcelToX
       c.worksheet = name
 
       i = input(name,"formulae_inlined_pruned_replaced.ast")
-      ruby_name = c_name_for_worksheet_name(name)
       o.puts "// start #{name}"
       c.rewrite(i,w,o)
       o.puts "// end #{name}"
@@ -145,12 +153,13 @@ class ExcelToC < ExcelToX
     all_formulae = all_formulae('formulae_inlined_pruned_replaced.ast')
     name = output_name.downcase
     o = output("#{name}.rb")
+      
     code = <<END
 require 'ffi'
 
-module #{name.capitalize}
+module #{ruby_module_name}
   extend FFI::Library
-  ffi_lib  File.join(File.dirname(__FILE__),'lib#{name}.dylib')
+  ffi_lib  File.join(File.dirname(__FILE__),FFI.map_library_name('#{name}'))
   ExcelType = enum :ExcelEmpty, :ExcelNumber, :ExcelString, :ExcelBoolean, :ExcelError, :ExcelRange
                 
   class ExcelValue < FFI::Struct
@@ -202,7 +211,7 @@ END
   
   def write_tests
     name = output_name.downcase
-    o = output("#{name}_test.rb")    
+    o = output("test_#{name}.rb")    
     o.puts "# coding: utf-8"
     o.puts "# Test for #{name}"
     o.puts "require 'rubygems'"
@@ -212,7 +221,7 @@ END
     o.puts
     o.puts "class Test#{name.capitalize} < Test::Unit::TestCase"
     o.puts "  def spreadsheet; @spreadsheet ||= init_spreadsheet; end"
-    o.puts "  def init_spreadsheet; #{name.capitalize} end"
+    o.puts "  def init_spreadsheet; #{ruby_module_name} end"
     
     all_formulae = all_formulae('formulae_inlined_pruned_replaced.ast')
     
@@ -227,6 +236,7 @@ END
         refs_to_test = cells_to_keep[name]
       end
       if refs_to_test && !refs_to_test.empty?
+        refs_to_test = refs_to_test.map(&:upcase)
         CompileToCUnitTest.rewrite(i, c_name, refs_to_test, o)
       end
       close(i)
@@ -244,7 +254,7 @@ END
   def run_tests
     return unless actually_run_tests
     puts "Running the resulting tests"
-    puts `cd #{File.join(output_directory)}; ruby "#{output_name.downcase}_test.rb"`
+    puts `cd #{File.join(output_directory)}; ruby "test_#{output_name.downcase}.rb"`
   end
   
 end

data/src/commands/excel_to_ruby.rb

@@ -3,118 +3,133 @@
 require_relative 'excel_to_x'
 
 class ExcelToRuby < ExcelToX
+  
+  def language
+    "ruby"
+  end  
+  
+  # Skip this
+  def replace_values_with_constants
     
+    worksheets("Skipping replacing values with constants") do |name,xml_filename|    
+      i = File.join(intermediate_directory, name, "formulae_inlined_pruned_replaced-1.ast")
+      o = File.join(intermediate_directory, name, "formulae_inlined_pruned_replaced.ast")
+      if run_in_memory
+        @files[o] = @files[i]
+      else
+        `cp '#{i}' '#{o}'`
+      end
+    end
+
+    i = File.join(intermediate_directory,"common-elements-1.ast")
+    o = File.join(intermediate_directory,"common-elements.ast")
+    if run_in_memory
+      @files[o] = @files[i]
+    else
+      `cp '#{i}' '#{o}'`
+    end
+  end
+  
   # These actually create the code version of the excel
   def write_code
-    write_out_excel_workbook_as_code
-    write_out_excel_workbook_test_as_code
-    worksheets("Compiling worksheet") do |name,xml_filename|
-      #fork do 
-        compile_worksheet_code(name,xml_filename)
-        compile_worksheet_test(name,xml_filename)
-      #end
-    end    
+    write_out_excel_as_code
+    write_out_test_as_code
   end
     
-  def write_out_excel_workbook_as_code
-    w = input("worksheet_ruby_names")
-    o = ruby("#{compiled_module_name.downcase}.rb")
+  def write_out_excel_as_code
+    w = input("worksheet_c_names")
+    o = output("#{output_name.downcase}.rb")
+    o.puts "# coding: utf-8"
     o.puts "# Compiled version of #{excel_file}"
     o.puts "require '#{File.expand_path(File.join(File.dirname(__FILE__),'../excel/excel_functions'))}'"
     o.puts ""
-    o.puts "module #{compiled_module_name}"
-    o.puts "class Spreadsheet"
+    o.puts "class #{ruby_module_name}"
     o.puts "  include ExcelFunctions"
-    w.lines do |line|
-      name, ruby_name = line.strip.split("\t")
-      o.puts "  def #{ruby_name}; @#{ruby_name} ||= #{ruby_name.capitalize}.new; end"
-    end
     
+    o.puts  
+    o.puts "  # Starting common elements"
     c = CompileToRuby.new
     i = input("common-elements.ast")
-    w.rewind
+    w.rewind    
     c.rewrite(i,w,o)
-          
-    o.puts "end"
-    o.puts 'Dir[File.join(File.dirname(__FILE__),"worksheets/","*.rb")].each {|f| autoload(File.basename(f,".rb").capitalize,f)}'
-    o.puts "end"
-    close(i,w,o)
-  end
-
-  def write_out_excel_workbook_test_as_code
-    w = input("worksheet_ruby_names")
-    o = ruby("test_#{compiled_module_name.downcase}.rb")
-    o.puts "# All tests for #{excel_file}"
-    o.puts  "require 'test/unit'"
-    w.lines do |line|
-      name, ruby_name = line.strip.split("\t")
-      o.puts "require_relative 'tests/test_#{ruby_name.downcase}'"
-    end
-    close(w,o)
-  end
-    
-  def compile_worksheet_code(name,xml_filename)
-    settable_refs = @values_that_can_be_set_at_runtime[name]    
-    c = CompileToRuby.new
-    c.settable =lambda { |ref| (settable_refs == :all) ? true : settable_refs.include?(ref) } if settable_refs
-    c.worksheet = name
-    i = input(name,"formulae_inlined_pruned_replaced.ast")
-    w = input("worksheet_ruby_names")
-    ruby_name = ruby_name_for_worksheet_name(name)
-    o = ruby('worksheets',"#{ruby_name.downcase}.rb")
-    d = output(name,'defaults')
-    o.puts "# coding: utf-8"
-    o.puts "# #{name}"
+    o.puts "  # Ending common elements"
     o.puts
-    o.puts "require_relative '../#{compiled_module_name.downcase}'"
+    close(i)
+    
+    d = intermediate('defaults')
+    
+    worksheets("Turning worksheet into code") do |name,xml_filename|
+      c.settable = settable(name)
+      c.worksheet = name
+      i = input(name,"formulae_inlined_pruned_replaced.ast")
+      w.rewind
+      o.puts "  # Start of #{name}"
+      c.rewrite(i,w,o,d)
+      o.puts "  # End of #{name}"
+      o.puts ""
+      close(i)
+    end   
+     
+    close(d)
+    
     o.puts
-    o.puts "module #{compiled_module_name}"
-    o.puts "class #{ruby_name.capitalize} < Spreadsheet"
-    c.rewrite(i,w,o,d)
+    o.puts "  # starting initializer"
+    o.puts "  def initialize"
+    d = input('defaults')
+    d.lines do |line|
+      o.puts line
+    end
+    o.puts "  end"
     o.puts ""
     close(d)
-    if settable_refs
-      o.puts "  def initialize"
-      d = input(name,'defaults')
-      d.lines do |line|
-        o.puts line
-      end
-      o.puts "  end"
-      o.puts ""
-      close(d)
-    end
-    o.puts "end"
+              
     o.puts "end"
-    close(i,o)
+    close(w,o)
   end
 
-  def compile_worksheet_test(name,xml_filename)
-    i = input(name,"values_pruned2.ast")
-    ruby_name = ruby_name_for_worksheet_name(name)
-    o = ruby('tests',"test_#{ruby_name.downcase}.rb")
+  def write_out_test_as_code
+    o = output("test_#{output_name.downcase}.rb")
+    
     o.puts "# coding: utf-8"
-    o.puts "# Test for #{name}"
-    o.puts  "require 'test/unit'"
-    o.puts  "require_relative '../#{compiled_module_name.downcase}'"
+    o.puts "# All tests for #{excel_file}"
+    o.puts "require 'test/unit'"
+    o.puts "require_relative '#{output_name.downcase}'"
     o.puts
-    o.puts "module #{compiled_module_name}"
-    o.puts "class Test#{ruby_name.capitalize} < Test::Unit::TestCase"
-    o.puts "  def spreadsheet; $spreadsheet ||= Spreadsheet.new; end"
-    o.puts "  def worksheet; @worksheet ||= spreadsheet.#{ruby_name}; end"
-    CompileToRubyUnitTest.rewrite(i, o)
-    o.puts "end"
-    o.puts "end"
-    close(i,o)
+    o.puts "class Test#{output_name.capitalize} < Test::Unit::TestCase"
+    o.puts "  def worksheet; @worksheet ||= #{ruby_module_name}.new; end"
+    
+    c = CompileToRubyUnitTest.new
+    all_formulae = all_formulae('formulae_inlined_pruned_replaced.ast')
+    
+    worksheets("Compiling worksheet") do |name,xml_filename|
+      i = input(name,"values_pruned2.ast")
+      o.puts "  # Start of #{name}"
+      c_name = c_name_for_worksheet_name(name)
+      if !cells_to_keep || cells_to_keep.empty? || cells_to_keep[name] == :all
+        refs_to_test = all_formulae[name].keys
+      else
+        refs_to_test = cells_to_keep[name]
+      end
+      if refs_to_test && !refs_to_test.empty?
+        refs_to_test = refs_to_test.map(&:upcase)
+        c.rewrite(i, c_name, refs_to_test, o)
+      end
+      o.puts "  # End of #{name}"
+      o.puts ""
+      close(i)
+    end 
+    o.puts "end"   
+    close(o)
   end
   
-  def ruby_name_for_worksheet_name(name)
-    unless @worksheet_names
-      w = input("worksheet_ruby_names")
-      @worksheet_names = Hash[w.readlines.map { |line| line.split("\t").map { |a| a.strip }}]
-      close(w)
-    end
-    @worksheet_names[name]
+  def compile_code
+    # Not needed
+  end
+  
+  def run_tests
+    return unless actually_run_tests
+    puts "Running the resulting tests"
+    puts `cd #{File.join(output_directory)}; ruby "test_#{output_name.downcase}.rb"`
   end
-
   
 end

data/src/commands/excel_to_x.rb

@@ -14,7 +14,7 @@ class ExcelToX
   #  If not specified, will be '#{excel_file_name}/c'
   attr_accessor :output_directory
   
-  # Optional attribute. The name of the resulting c file (and associated ruby ffi module). Defaults to excelspreadsheet
+  # Optional attribute. The name of the resulting ruby or c file and ruby or ruby ffi module name. Defaults to excelspreadsheet
   attr_accessor :output_name
 
   # Optional attribute. The excel file will be translated to xml and stored here.
@@ -61,7 +61,7 @@ class ExcelToX
   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,".*"),'c')
+    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')
     
@@ -72,14 +72,14 @@ class ExcelToX
     # Make sure that all the cell names are downcase and don't have any $ in them
     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('$','').downcase }
+      cells_that_can_be_set_at_runtime[sheet] = cells_that_can_be_set_at_runtime[sheet].map { |reference| reference.gsub('$','').upcase }
     end
 
     # Make sure that all the cell names are downcase and don't have any $ in them
     if cells_to_keep
       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('$','').downcase }
+        cells_to_keep[sheet] = cells_to_keep[sheet].map { |reference| reference.gsub('$','').upcase }
       end
     end  
     
@@ -113,6 +113,7 @@ class ExcelToX
     remove_any_cells_not_needed_for_outputs
     inline_formulae_that_are_only_used_once
     separate_formulae_elements
+    replace_values_with_constants
     
     # This actually creates the code (implemented in subclasses)
     write_code
@@ -272,7 +273,21 @@ class ExcelToX
     array_formulae = File.join(name,"array_formulae-expanded.ast")
     simple_formulae = File.join(name,"simple_formulae.ast-nocols")
     output = File.join(name,'formulae.ast')
-    rewrite RewriteMergeFormulaeAndValues, values, shared_formulae, array_formulae, simple_formulae, output
+    
+    # This ensures that all gettable and settable values appear in the output
+    # even if they are blank in the underlying excel
+    required_refs = []
+    if @cells_that_can_be_set_at_runtime && @cells_that_can_be_set_at_runtime[name] && @cells_that_can_be_set_at_runtime[name] != :all
+      required_refs.concat(@cells_that_can_be_set_at_runtime[name])
+    end
+    if @cells_to_keep && @cells_to_keep[name] && @cells_to_keep[name] != :all
+      required_refs.concat(@cells_to_keep[name])
+    end
+    
+    r = RewriteMergeFormulaeAndValues.new
+    r.references_to_add_if_they_are_not_already_present = required_refs
+    
+    rewrite r, values, shared_formulae, array_formulae, simple_formulae, output
   end
   
   def merge_table_files
@@ -516,7 +531,9 @@ class ExcelToX
     worksheets("Replacing repeated elements") do |name,xml_filename|
       replace ReplaceCommonElementsInFormulae, File.join(name,"formulae_inlined_pruned_with_sheets.ast"), "common-elements-1.ast", File.join(name,"formulae_inlined_pruned_replaced-1.ast")
     end
-
+  end
+  
+  def replace_values_with_constants
     r = ReplaceValuesWithConstants.new  
     worksheets("Replacing values with constants") do |name,xml_filename|
       i = input(name,"formulae_inlined_pruned_replaced-1.ast")
@@ -544,7 +561,7 @@ class ExcelToX
   def settable(name)
     settable_refs = @cells_that_can_be_set_at_runtime[name]    
     if settable_refs
-      lambda { |ref| (settable_refs == :all) ? true : settable_refs.include?(ref) } 
+      lambda { |ref| (settable_refs == :all) ? true : settable_refs.include?(ref.upcase) } 
     else
       lambda { |ref| false }
     end
@@ -554,7 +571,7 @@ class ExcelToX
     if @cells_to_keep
       gettable_refs = @cells_to_keep[name]
       if gettable_refs
-        lambda { |ref| (gettable_refs == :all) ? true : gettable_refs.include?(ref) }
+        lambda { |ref| (gettable_refs == :all) ? true : gettable_refs.include?(ref.upcase) }
       else
         lambda { |ref| false }
       end
@@ -657,4 +674,12 @@ class ExcelToX
     end
   end
   
+  def ruby_module_name
+    puts output_name
+    @ruby_module_name = output_name.sub(/^[a-z\d]*/) { $&.capitalize }
+    @ruby_module_name = @ruby_module_name.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    puts @ruby_module_name
+    @ruby_module_name
+  end
+  
 end

data/src/compile/c/compile_to_c.rb

@@ -43,7 +43,6 @@ class CompileToC
           mapper.initializers.each do |i|
             output.puts "  #{i}"
           end
-          #output.puts "  return #{calculation};"
           output.puts "  result = #{calculation};"
           output.puts "  variable_set[#{@variable_set_counter}] = 1;"
           output.puts "  return result;"

data/src/compile/c/compile_to_c_unit_test.rb

@@ -8,7 +8,7 @@ class CompileToCUnitTest
     input.lines do |line|
       begin
         ref, formula = line.split("\t")
-        next unless refs_to_test.include?(ref)
+        next unless refs_to_test.include?(ref.upcase)
         output.puts "def test_#{c_name}_#{ref.downcase}"
         output.puts "  r = spreadsheet.#{c_name}_#{ref.downcase}"
         ast = eval(formula)

data/src/compile/ruby/compile_to_ruby.rb

@@ -14,14 +14,16 @@ class CompileToRuby
     mapper = MapFormulaeToRuby.new
     mapper.worksheet = worksheet
     mapper.sheet_names = Hash[sheet_names_file.readlines.map { |line| line.strip.split("\t")}]
+    c_name = mapper.sheet_names[worksheet]
     input.lines do |line|
       begin
         ref, formula = line.split("\t")
+        name = c_name ? "#{c_name}_#{ref.downcase}" : ref.downcase
         if settable.call(ref)
-          output.puts "  attr_accessor :#{ref.downcase} # Default: #{mapper.map(eval(formula))}"
-          defaults.puts "    @#{ref.downcase} = #{mapper.map(eval(formula))}" if defaults
+          output.puts "  attr_accessor :#{name} # Default: #{mapper.map(eval(formula))}"
+          defaults.puts "    @#{name} = #{mapper.map(eval(formula))}" if defaults
         else
-          output.puts "  def #{ref.downcase}; @#{ref.downcase} ||= #{mapper.map(eval(formula))}; end"
+          output.puts "  def #{name}; @#{name} ||= #{mapper.map(eval(formula))}; end"
         end
       rescue Exception => e
         puts "Exception at line #{line}"

data/src/compile/ruby/compile_to_ruby_unit_test.rb

@@ -6,21 +6,22 @@ class CompileToRubyUnitTest
     self.new.rewrite(*args)
   end
   
-  def rewrite(input,output)
+  def rewrite(input, c_name, refs_to_test, output)
     mapper = MapValuesToRuby.new
     input.lines do |line|
       ref, formula = line.split("\t")
+      next unless refs_to_test.include?(ref.upcase)
       ast = eval(formula)
       value = mapper.map(ast)
-      full_reference = "worksheet.#{ref.downcase}"
+      full_reference = "worksheet.#{c_name}_#{ref.downcase}"
       if ast.first == :number
         if value == "0" # Need to do a slightly different test, because needs to pass if nil returned, as well as zero
-          output.puts "  def test_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference} || 0); end"      
+          output.puts "  def test_#{c_name}_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference} || 0); end"      
         else
-          output.puts "  def test_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference}); end"      
+          output.puts "  def test_#{c_name}_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference}); end"      
         end
       else
-        output.puts "  def test_#{ref.downcase}; assert_equal(#{value},#{full_reference}); end"
+        output.puts "  def test_#{c_name}_#{ref.downcase}; assert_equal(#{value},#{full_reference}); end"
       end
     end
   end

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -80,8 +80,7 @@ class MapFormulaeToRuby < MapValuesToRuby
   end
   
   def sheet_reference(sheet,reference)
-    return map(reference) if worksheet && worksheet == sheet
-    "#{sheet_names[sheet]}.#{map(reference)}"
+    "#{sheet_names[sheet]}_#{map(reference)}"
   end
   
   def array(*rows)

data/src/rewrite/rewrite_merge_formulae_and_values.rb

@@ -3,15 +3,23 @@ class RewriteMergeFormulaeAndValues
     new.rewrite(*args)
   end
   
+  attr_accessor :references_to_add_if_they_are_not_already_present
+  
   def rewrite(values,shared_formulae,array_formula,simple_formulae,output)
+    @references_to_add_if_they_are_not_already_present ||= []
+    
     shared_formulae = Hash[shared_formulae.readlines.map { |line| [line[/(.*?)\t/,1],line]}]
     array_formula = Hash[array_formula.readlines.map { |line| [line[/(.*?)\t/,1],line]}]
     simple_formulae = Hash[simple_formulae.readlines.map { |line| [line[/(.*?)\t/,1],line]}]
 
     values.lines do |line|
       ref = line[/(.*?)\t/,1]
+      @references_to_add_if_they_are_not_already_present.delete(ref)
       output.puts simple_formulae[ref] || array_formula[ref] || shared_formulae[ref] || line
     end
+    @references_to_add_if_they_are_not_already_present.each do |r|
+      output.puts "#{r}\t[:blank]"
+    end
   end
   
 end

data/src/simplify/replace_common_elements_in_formulae.rb

@@ -4,16 +4,31 @@ class ReplaceCommonElementsInFormulae
     self.new.replace(*args)
   end
   
+  attr_accessor :common_elements
+  
   def replace(input,common,output)
-    common = common.readlines.map do |a| 
+    @common_elements ||= {}
+    common.readlines.map do |a|
       ref, element = a.split("\t")
-      [element.strip,"[:cell, \"#{ref}\"]",ref]
-    end.sort
+      @common_elements[element.strip] = [:cell, ref]
+    end
     input.lines do |line|
-      common.each do |element,cell,ref|
-        line.gsub!(element,cell)
-      end
-      output.puts line
+      ref, formula = line.split("\t")
+      output.puts "#{ref}\t#{replace_repeated_formulae(eval(formula)).inspect}"
     end
   end
+  
+  def replace_repeated_formulae(ast)
+    return ast unless ast.is_a?(Array)
+    return ast if [:number,:string,:blank,:null,:error,:boolean_true,:boolean_false,:sheet_reference,:cell, :row].include?(ast.first)    
+    string = ast.inspect
+    return ast if string.length < 20
+    if @common_elements.has_key?(string)
+      return @common_elements[string]
+    end
+    ast.map do |a|
+      replace_repeated_formulae(a)
+    end
+  end   
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-17 00:00:00.000000000 Z
+date: 2012-04-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubypeg
+  requirement: &70157840000000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70157840000000
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70281994911220 !ruby/object:Gem::Requirement
+  requirement: &70157839999500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +32,10 @@ dependencies:
         version: 1.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70281994911220
+  version_requirements: *70157839999500
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70281994926800 !ruby/object:Gem::Requirement
+  requirement: &70157839999000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,13 +43,24 @@ dependencies:
         version: 2.7.0
   type: :runtime
   prerelease: false
-  version_requirements: *70281994926800
+  version_requirements: *70157839999000
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &70157839998540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: *70157839998540
 description: ! "# excel_to_code\n\nConverts some excel spreadsheets (.xlsx, not .xls)
   into some other programming languages (currently ruby or c).\nThis allows the excel
   spreadsheets to be run programatically, without excel.\n\nIts cannonical source
-  is at http://github.com/tamc/excel2code\n\n# Running excel_to_code\n\nTo just have
-  a go:\n\n\t./bin/excel_to_c <excel_file_name>\n\t\nNB:For small spreadsheets this
-  will take a minute or so. For large spreadsheets it is best to run it overnight.\n\t\nfor
+  is at http://github.com/tamc/excel_to_code\n\n# Running excel_to_code\n\nTo just
+  have a go:\n\n\t./bin/excel_to_c <excel_file_name>\n\t\nNB:For small spreadsheets
+  this will take a minute or so. For large spreadsheets it is best to run it overnight.\n\t\nfor
   more detail:\n\t\n\t./bin/excel_to_c --compile --run-tests --settable <name of input
   worksheet> --prune-except <name of output worksheet> <excel file name> \n\t\nthis
   should work:\n\n\t./bin/excel_to_c --help\n\n# Testing excel_to_code\n\n1. Make
@@ -56,7 +78,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- README
+- README.md
+- TODO
 - src/commands/excel_to_c.rb
 - src/commands/excel_to_ruby.rb
 - src/commands/excel_to_x.rb