excel_to_code 0.1.23 → 0.2.0

data/src/compile/c/map_values_to_c_structs.rb

@@ -16,7 +16,7 @@ class MapValuesToCStructs
   end
   
   def number(text)
-    n = case text
+    n = case text.to_s
     when /\./
       text.to_f.to_s
     when /e/i

data/src/compile/ruby/compile_to_ruby.rb

@@ -4,29 +4,32 @@ class CompileToRuby
   
   attr_accessor :settable
   attr_accessor :worksheet
+  attr_accessor :defaults
   
   def self.rewrite(*args)
     self.new.rewrite(*args)
   end
   
-  def rewrite(input,sheet_names_file,output,defaults = nil)
+  def rewrite(input, sheet_names, output)
     self.settable ||= lambda { |ref| false }
+    self.defaults ||= []
     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.each_line do |line|
+    mapper.sheet_names = sheet_names
+    input.each do |ref, ast|
       begin
-        ref, formula = line.split("\t")
-        name = c_name ? "#{c_name}_#{ref.downcase}" : ref.downcase
+        worksheet = ref.first.to_s
+        cell = ref.last
+        mapper.worksheet = worksheet
+        worksheet_c_name = mapper.sheet_names[worksheet] || worksheet.to_s
+        name = worksheet_c_name.length > 0 ? "#{worksheet_c_name}_#{cell.downcase}" : cell.downcase
         if settable.call(ref)
-          output.puts "  attr_accessor :#{name} # Default: #{mapper.map(eval(formula))}"
-          defaults.puts "    @#{name} = #{mapper.map(eval(formula))}" if defaults
+          output.puts "  attr_accessor :#{name} # Default: #{mapper.map(ast)}"
+          defaults << "    @#{name} = #{mapper.map(ast)}"
         else
-          output.puts "  def #{name}; @#{name} ||= #{mapper.map(eval(formula))}; end"
+          output.puts "  def #{name}; @#{name} ||= #{mapper.map(ast)}; end"
         end
       rescue Exception => e
-        puts "Exception at line #{line}"
+        puts "Exception at #{ref} => #{ast}"
         raise
       end      
     end

data/src/compile/ruby/compile_to_ruby_unit_test.rb

@@ -7,23 +7,30 @@ class CompileToRubyUnitTest
   attr_accessor :delta
 
   def initialize
-    @epsilon = 0.001
-    @delta = 0.001
+    @epsilon = 0.002
+    @delta = 0.002
   end
 
   def self.rewrite(*args)
     self.new.rewrite(*args)
   end
   
-  def rewrite(input, sloppy, o)
+  def rewrite(input, sloppy, sheet_names, constants,  o)
     mapper = MapValuesToRuby.new
-    input.each_line do |line|
-      c_name, ref, formula = line.split("\t")
-      ast = eval(formula)
+    mapper.constants = constants
+    input.each do |ref, ast|
+      worksheet_c_name = sheet_names[ref.first.to_s] || ref.first.to_s #FIXME: Need to make it the actual c_name
+      cell = ref.last
       value = mapper.map(ast)
-      full_reference = "worksheet.#{c_name}_#{ref.downcase}"
-      test_name = "test_#{c_name}_#{ref.downcase}"
-      case ast.first
+      full_reference = worksheet_c_name.length > 0 ? "worksheet.#{worksheet_c_name}_#{cell.downcase}" : "worksheet.#{cell.downcase}"
+      test_name = "test_#{worksheet_c_name}_#{cell.downcase}"
+      if ast.first == :constant
+        type = constants[ast[1]][0] || :constant
+      else
+        type = ast.first
+      end
+
+      case type
       when :blank
         if sloppy
           o.puts "  def #{test_name}; assert_includes([nil, 0], #{full_reference}); end"
@@ -33,7 +40,7 @@ class CompileToRubyUnitTest
       when :number
         if sloppy
           if value.to_f.abs <= 1
-            if value == "0" 
+            if value.to_f == 0 
               o.puts "  def #{test_name}; assert_in_delta(#{value}, (#{full_reference}||0), #{delta}); end"
             else
               o.puts "  def #{test_name}; assert_in_delta(#{value}, #{full_reference}, #{delta}); end"

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -6,61 +6,61 @@ class MapFormulaeToRuby < MapValuesToRuby
   attr_accessor :worksheet
   
   FUNCTIONS = {
-    '*' => 'multiply',
-    '+' => 'add',
-    '-' => 'subtract',
-    '/' => 'divide',
-    '<' => 'less_than?',
-    '<=' => 'less_than_or_equal?',
-    '<>' => 'not_equal?',
-    '=' => 'excel_equal?',
-    '>' => 'more_than?',
-    '>=' => 'more_than_or_equal?',
-    'ABS' => 'abs',
-    'AND' => 'excel_and',
-    'AVERAGE' => 'average',
-    'CELL' => 'cell',
-    'CHOOSE' => 'choose',
-    'CONCATENATE' => 'string_join',
-    'COSH' => 'cosh',
-    'COUNT' => 'count',
-    'COUNTA' => 'counta',
-    'FIND' => 'find',
-    'HLOOKUP' => 'hlookup',
-    'IF' => 'excel_if',
-    'IFERROR' => 'iferror',
-    'INDEX' => 'index',
-    'INT' => 'int',
-    'ISNUMBER' => 'isnumber',
-    'LARGE' => 'large',
-    'LEFT' => 'left',
-    'LEN' => 'len',
-    'LOG' => 'log',
-    'MATCH' => 'excel_match',
-    'MAX' => 'max',
-    'MID' => 'mid',
-    'MIN' => 'min',
-    'MMULT' => 'mmult',
-    'MOD' => 'mod',
-    'PI' => 'pi',
-    'PMT' => 'pmt',
-    'POWER' => 'power',
-    'PV' => 'pv',
-    'RANK' => 'rank',
-    'RIGHT' => 'right',
-    'ROUND' => 'round',
-    'ROUNDDOWN' => 'rounddown',
-    'ROUNDUP' => 'roundup',
-    'SUBSTITUTE' => 'substitute',
-    'SUBTOTAL' => 'subtotal',
-    'SUM' => 'sum',
-    'SUMIF' => 'sumif',
-    'SUMIFS' => 'sumifs',
-    'SUMPRODUCT' => 'sumproduct',
-    'TEXT' => 'text',
-    'TRIM' => 'trim',
-    'VLOOKUP' => 'vlookup',
-    '^' => 'power'
+    :'*' => 'multiply',
+    :'+' => 'add',
+    :'-' => 'subtract',
+    :'/' => 'divide',
+    :'<' => 'less_than?',
+    :'<=' => 'less_than_or_equal?',
+    :'<>' => 'not_equal?',
+    :'=' => 'excel_equal?',
+    :'>' => 'more_than?',
+    :'>=' => 'more_than_or_equal?',
+    :'ABS' => 'abs',
+    :'AND' => 'excel_and',
+    :'AVERAGE' => 'average',
+    :'CELL' => 'cell',
+    :'CHOOSE' => 'choose',
+    :'CONCATENATE' => 'string_join',
+    :'COSH' => 'cosh',
+    :'COUNT' => 'count',
+    :'COUNTA' => 'counta',
+    :'FIND' => 'find',
+    :'HLOOKUP' => 'hlookup',
+    :'IF' => 'excel_if',
+    :'IFERROR' => 'iferror',
+    :'INDEX' => 'index',
+    :'INT' => 'int',
+    :'ISNUMBER' => 'isnumber',
+    :'LARGE' => 'large',
+    :'LEFT' => 'left',
+    :'LEN' => 'len',
+    :'LOG' => 'log',
+    :'MATCH' => 'excel_match',
+    :'MAX' => 'max',
+    :'MID' => 'mid',
+    :'MIN' => 'min',
+    :'MMULT' => 'mmult',
+    :'MOD' => 'mod',
+    :'PI' => 'pi',
+    :'PMT' => 'pmt',
+    :'POWER' => 'power',
+    :'PV' => 'pv',
+    :'RANK' => 'rank',
+    :'RIGHT' => 'right',
+    :'ROUND' => 'round',
+    :'ROUNDDOWN' => 'rounddown',
+    :'ROUNDUP' => 'roundup',
+    :'SUBSTITUTE' => 'substitute',
+    :'SUBTOTAL' => 'subtotal',
+    :'SUM' => 'sum',
+    :'SUMIF' => 'sumif',
+    :'SUMIFS' => 'sumifs',
+    :'SUMPRODUCT' => 'sumproduct',
+    :'TEXT' => 'text',
+    :'TRIM' => 'trim',
+    :'VLOOKUP' => 'vlookup',
+    :'^' => 'power'
   }
   
   def prefix(symbol,ast)
@@ -93,7 +93,7 @@ class MapFormulaeToRuby < MapValuesToRuby
   end
   
   def cell(reference)
-    reference.downcase.gsub('$','')
+    reference.to_s.downcase.gsub('$','')
   end
   
   def sheet_reference(sheet,reference)

data/src/compile/ruby/map_values_to_ruby.rb

@@ -2,6 +2,8 @@ require_relative '../../util/not_supported_exception'
 
 class MapValuesToRuby
 
+  attr_accessor :constants
+
   def map(ast)
     if ast.is_a?(Array)
       operator = ast[0]
@@ -19,10 +21,14 @@ class MapValuesToRuby
     "nil"
   end
   
+  def constant(constant)
+    map(constants[constant])
+  end
+  
   alias :null :blank
     
   def number(text)
-    case text
+    case text.to_s
     when /\./
       text.to_f.to_s
     when /e/i
@@ -46,7 +52,13 @@ class MapValuesToRuby
     "#DIV/0!" => ":div0",
     "#REF!" => ":ref",
     "#N/A" => ":na",
-    "#NUM!" => ":num"
+    "#NUM!" => ":num",
+    :"#NAME?" => ":name",
+    :"#VALUE!" => ":value",
+    :"#DIV/0!" => ":div0",
+    :"#REF!" => ":ref",
+    :"#N/A" => ":na",
+    :"#NUM!" => ":num"
   }
   
   REVERSE_ERRORS = ERRORS.invert

data/src/excel/area.rb

@@ -10,7 +10,7 @@ class Area < String
     
   # This is so that we only have one instance of a given reference specified by its variables
   def Area.for(text)
-     @@areas_for_text[text]
+     @@areas_for_text[text.to_s]
   end
   
   attr_reader :excel_start, :excel_finish
@@ -59,17 +59,15 @@ class Area < String
   def to_array_literal(sheet = nil)
     calculate_excel_variables
     unfixed_start = @excel_start.unfix
+    fc = CachingFormulaParser.instance
     [:array,
       *(0.upto(height).map do |row|
         [:row,
           *(0.upto(width).map do |column|
             if sheet
-              [:sheet_reference, 
-                sheet,
-                [:cell,
-                  unfixed_start.offset(row,column)
-                ]
-              ]
+              fc.sheet_reference(
+                [:sheet_reference, sheet, [:cell, unfixed_start.offset(row,column)]]
+              )
             else
               [:cell,
                 unfixed_start.offset(row,column)
@@ -90,4 +88,4 @@ class Area < String
     true
   end
   
-end
+end

data/src/excel/excel_functions/hlookup.rb

@@ -23,7 +23,7 @@ module ExcelFunctions
       next if lookup_value.is_a?(String) && !possible_match.is_a?(String)
       next if lookup_value.is_a?(Numeric) && !possible_match.is_a?(Numeric)
       
-      possible_match.downcase! if lookup_value.is_a?(String)
+      possible_match = possible_match.downcase if lookup_value.is_a?(String)
 
       if lookup_value == possible_match
         return lookup_table[row_number-1][column_number]

data/src/excel/excel_functions/vlookup.rb

@@ -21,7 +21,7 @@ module ExcelFunctions
       next if lookup_value.is_a?(String) && !possible_match.is_a?(String)
       next if lookup_value.is_a?(Numeric) && !possible_match.is_a?(Numeric)
       
-      possible_match.downcase! if lookup_value.is_a?(String)
+      possible_match = possible_match.downcase if lookup_value.is_a?(String)
 
       if lookup_value == possible_match
         return :value unless column_number <= row.length

data/src/excel/formula_peg.rb

@@ -204,7 +204,7 @@ class Formula < RubyPeg
   end
   
   def reference
-    terminal(/\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_])/)
+    terminal(/\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_.])/)
   end
   
   def boolean

data/src/excel/formula_peg.txt

@@ -36,7 +36,7 @@ area                            := reference `':' reference
 cell                            := reference
 row_number                       = /\$?\d+/
 column                           = /\$?[A-Za-z]{1,3}/
-reference                        = /\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_])/
+reference                        = /\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_.])/
 boolean                          = boolean_true | boolean_false
 boolean_true                    := `'TRUE'
 boolean_false                   := `'FALSE'

data/src/excel/reference.rb

@@ -1,3 +1,4 @@
+# FIXME Make this a subclass of symbol
 class Reference < String
   
   # This is so that we only have one instance for a given reference
@@ -8,7 +9,7 @@ class Reference < String
     
   # This is so that we only have one instance of a given reference specified by its variables
   def Reference.for(text)
-     @@references_for_text[text]
+     @@references_for_text[text.to_s]
   end
     
   # This caches the calculation for turning column letters (e.g., AAB) into column numbers (e.g., 127)
@@ -46,11 +47,11 @@ class Reference < String
     calculate_excel_variables
     new_column = @excel_fixed_column ? @excel_column :  @@column_letters_for_column_number[@excel_column_number + columns]
     new_row = @excel_fixed_row ? @excel_row : @excel_row_number + rows
-    Reference.new([@excel_fixed_column,new_column,@excel_fixed_row,new_row].join)
+    [@excel_fixed_column,new_column,@excel_fixed_row,new_row].join.to_sym
   end
   
   def unfix
     gsub("$","")
   end
   
-end
+end

data/src/excel/table.rb

@@ -6,7 +6,7 @@ class Table
   attr_accessor :name
   
   def initialize(name,worksheet,reference,number_of_total_rows,*column_name_array)
-    @name, @worksheet, @area, @number_of_total_rows, @column_name_array = name, worksheet, Area.for(reference), number_of_total_rows.to_i, column_name_array.map { |c| c.strip.downcase }
+    @name, @worksheet, @area, @number_of_total_rows, @column_name_array = name, worksheet.to_sym, Area.for(reference), number_of_total_rows.to_i, column_name_array.map { |c| c.strip.downcase }
     @area.calculate_excel_variables    
     @data_area = Area.for("#{@area.excel_start.offset(1,0)}:#{@area.excel_finish.offset(-@number_of_total_rows,0)}")
     @data_area.calculate_excel_variables
@@ -82,7 +82,7 @@ class Table
     when /#Data/io, ""
       ast_for_area @data_area.excel_start, @data_area.excel_finish
 
-    when /#All/io, ""
+    when /#All/io
       ast_for_area @area.excel_start, @area.excel_finish
 
     when /#This Row/io
@@ -108,11 +108,11 @@ class Table
   end
   
   def ast_for_area(start,finish)
-    [:sheet_reference,@worksheet,[:area,start,finish]]
+    [:sheet_reference,@worksheet,[:area,start.to_sym,finish.to_sym]]
   end
   
   def ast_for_cell(ref)
-    [:sheet_reference,@worksheet,[:cell,ref]]
+    [:sheet_reference,@worksheet,[:cell,ref.to_sym]]
   end
   
   def ref_error

data/src/extract.rb

@@ -12,3 +12,4 @@ require_relative "extract/extract_worksheet_names"
 require_relative "extract/extract_named_references"
 require_relative "extract/extract_worksheet_table_relationships"
 require_relative "extract/extract_table"
+require_relative "extract/extract_everything"

data/src/extract/check_for_unknown_functions.rb

@@ -11,8 +11,8 @@ class CheckForUnknownFunctions
   def check(input,output)
     self.settable ||= lambda { |ref| false }
     input.each_line do |line|
-      line.scan(/\[:function, "(.*?)"/).each do |match|
-        output.puts $1 unless MapFormulaeToRuby::FUNCTIONS.has_key?($1)
+      line.scan(/\[:function, :["']?([A-Z ]+)['"]?/).each do |match|
+        output.puts $1 unless MapFormulaeToRuby::FUNCTIONS.has_key?($1.to_sym)
       end
     end
   end

data/src/extract/extract_array_formulae.rb

@@ -2,8 +2,6 @@ require_relative 'extract_formulae'
 
 class ExtractArrayFormulae < ExtractFormulae
   
-  attr_accessor :array_range
-  
   def start_formula(type,attributes)
     return unless type == 'array' && attributes.assoc('ref')
     @array_range = attributes.assoc('ref').last
@@ -11,13 +9,15 @@ class ExtractArrayFormulae < ExtractFormulae
   end
   
   def write_formula
-    return false if @formula.empty?
-    output.write @ref
-    output.write "\t"
-    output.write @array_range
-    output.write "\t"
-    output.write @formula.join.gsub(/[\n\r]+/,'')
-    output.write "\n"
+    return if @formula.empty?
+    formula_text = @formula.join.gsub(/[\r\n]+/,'')
+    ast = CachingFormulaParser.parse(formula_text)
+    unless ast
+      $stderr.puts "Could not parse #{@sheet_name} #{@ref} #{formula_text}"
+      exit
+    end
+    # FIXME: Should leave in original form rather than converting to ast?
+    @output[[@sheet_name, @ref]] = [@array_range, ast]
   end
 
 end