excel_to_code 0.2.18 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 337fc100f3818bf193414bcd8fb3aaec557e1a6b
-  data.tar.gz: 34218ff7c787a63a1e0081b688ff328d1235316e
+  metadata.gz: 74698377e3e89c2dae52564440694e4e2e97f2f1
+  data.tar.gz: 73e3a3af8271ac02a3f68727f43e5874153d2d2f
 SHA512:
-  metadata.gz: 10b5b04a5fe6ae0b5df092a010b5cbf0cad48025db71b99350da7a040e2992c5301c08f23652040b4eb340fcb2f064aa7bae7c02b765c53c8849e11480a66a71
-  data.tar.gz: 3ec3fbfbad7b341990559ae40d121dfdbd46839aa3f92f5a1b41b58ce597e43606d91de146bc940d5976b682320b593925bea0619463f9e183b98800f0b15a5c
+  metadata.gz: f97a19688abe21b1cdbc7755a77158379746f012bda38154b35c7114add213ef4d1cee34f6121ce61d09d3bced7ae5de98f413e297ce5c0beecc9bd586a7177d
+  data.tar.gz: b911c226eed1bd735828b5a80927b8198ea1b226b312032c937c9bb96a98f10ccb3bff9fc13e391c2aef0c3163307e3b1e541e371c74459ae628ac714aa34027

data/src/commands/excel_to_x.rb

@@ -228,10 +228,16 @@ class ExcelToX
 
     # Setting this to false may make it easier to figure out errors
     self.extract_repeated_parts_of_formulae = true if @extract_repeated_parts_of_formulae == nil
+
+    # This setting is used for debugging, and makes the system only do the conversion on a subset of the the
     if self.isolate
-      self.cells_to_keep = { isolate.to_s => :all }
-      self.isolate = self.isolate.to_sym 
-      log.warn "Isolating #{@isolate} worksheet. No other sheets will be converted"
+      self.isolate = [self.isolate] unless self.isolate.is_a?(Array)
+      self.cells_to_keep ||= {}
+      self.isolate.each do |sheet|
+        self.cells_to_keep[sheet.to_s] = :all
+      end
+      self.isolate = self.isolate.map { |s| s.to_sym }
+      log.warn "Isolating #{@isolate} worksheet(s). No other sheets will be converted"
     end
   end
   
@@ -283,6 +289,7 @@ class ExcelToX
     end
     # Then we parse them
     @named_references.each do |name, reference|
+      begin
       parsed = CachingFormulaParser.parse(reference)
       if parsed
         @named_references[name] = parsed
@@ -290,6 +297,10 @@ class ExcelToX
         $stderr.puts "Named reference #{name} #{reference} not parsed"
         exit
       end
+    rescue Exception
+        $stderr.puts "Named reference #{name} #{reference} not parsed"
+        raise
+    end
     end
     # Replace A$1:B2 with [A1, A2, B1, B2]
     @replace_ranges_with_array_literals_replacer ||= ReplaceRangesWithArrayLiteralsAst.new
@@ -456,7 +467,8 @@ class ExcelToX
       # This is used in debugging large worksheets to limit 
       # the optimisation to a particular worksheet
       if isolate
-        extractor.only_extract_values = (isolate != name)
+        log.info "Only extracting values from #{name}: #{!isolate.include?(name)}"
+        extractor.only_extract_values = !isolate.include?(name)
       end
 
       log.info "Extracting data from #{name}"
@@ -648,10 +660,13 @@ class ExcelToX
     # FIXME: THIS IS THE MOST HORRIFIC BODGE. I HATE IT.
     emergency_indirect_replacement_bodge = EmergencyArrayFormulaReplaceIndirectBodge.new
     emergency_indirect_replacement_bodge.references = @values
+    emergency_indirect_replacement_bodge.tables = @tables
+    emergency_indirect_replacement_bodge.named_references = @named_references
     
     @formulae_array.each do |ref, details|
       @shared_string_replacer.map(details.last)
       emergency_indirect_replacement_bodge.current_sheet_name = ref.first
+      emergency_indirect_replacement_bodge.referring_cell = ref.last
       emergency_indirect_replacement_bodge.replace(details.last)
 
       named_reference_replacer.default_sheet_name = ref.first
@@ -930,22 +945,27 @@ class ExcelToX
       references_that_need_updating = {}
 
       @cells_with_formulae.each do |ref, ast|
-        # FIXME: Shouldn't need to wrap ref.fist in an array
-        inline_replacer.current_sheet_name = [ref.first]
-        inline_replacer.map(ast)
-        # If a formula references a cell containing a value, the reference is replaced with the value (e.g., if A1 := 2 and A2 := A1 + 1 then becomes: A2 := 2 + 1)
-        value_replacer.map(ast)
-        column_and_row_function_replacement.current_reference = ref.last
-        if column_and_row_function_replacement.replace(ast)
-          references_that_need_updating[ref] = ast
-        end
-        if offset_replacement.replace(ast)
-          references_that_need_updating[ref] = ast
-        end
-        if indirect_replacement.replace(ast)
-          references_that_need_updating[ref] = ast
+        begin
+          # FIXME: Shouldn't need to wrap ref.fist in an array
+          inline_replacer.current_sheet_name = [ref.first]
+          inline_replacer.map(ast)
+          # If a formula references a cell containing a value, the reference is replaced with the value (e.g., if A1 := 2 and A2 := A1 + 1 then becomes: A2 := 2 + 1)
+          value_replacer.map(ast)
+          column_and_row_function_replacement.current_reference = ref.last
+          if column_and_row_function_replacement.replace(ast)
+            references_that_need_updating[ref] = ast
+          end
+          if offset_replacement.replace(ast)
+            references_that_need_updating[ref] = ast
+          end
+          if indirect_replacement.replace(ast)
+            references_that_need_updating[ref] = ast
+          end
+          @cells_with_formulae.delete(ref) if VALUE_TYPE[ast[0]]
+        rescue  Exception => e
+          log.fatal "Exception when replacing formulae with results in #{ref}: #{ast}"
+          raise
         end
-        @cells_with_formulae.delete(ref) if VALUE_TYPE[ast[0]]
       end
 
       simplify(references_that_need_updating)
@@ -1032,8 +1052,13 @@ class ExcelToX
     r.references = @formulae
     r.inline_ast = inline_ast_decision
     @cells_with_formulae.each do |ref, ast|
-      r.current_sheet_name = [ref.first]
-      r.map(ast)
+      begin
+        r.current_sheet_name = [ref.first]
+        r.map(ast)
+      rescue  Exception => e
+        log.fatal "Exception when inlining formulae only used once in #{ref}: #{ast}"
+        raise
+      end
     end
   end
   

data/src/compile/c/excel_to_c_runtime.c

@@ -308,6 +308,9 @@ static ExcelValue ensure_is_number(ExcelValue maybe_number_v) {
   if(maybe_number_v.type == ExcelNumber) {
     return maybe_number_v;
   }
+  if(maybe_number_v.type == ExcelError) {
+    return maybe_number_v;
+  }
   NUMBER(maybe_number_v, maybe_number)
 	CHECK_FOR_CONVERSION_ERROR
 	return new_excel_number(maybe_number);
@@ -847,7 +850,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 }
 
 static ExcelValue excel_match_2(ExcelValue lookup_value, ExcelValue lookup_array ) {
-	return excel_match(lookup_value, lookup_array, ZERO);
+	return excel_match(lookup_value, lookup_array, ONE);
 }
 
 static ExcelValue find(ExcelValue find_text_v, ExcelValue within_text_v, ExcelValue start_number_v) {
@@ -1615,9 +1618,10 @@ static ExcelValue subtotal(ExcelValue subtotal_type_v, int number_of_arguments,
 }
 
 
+// FIXME: Check if this deals with errors correctly
 static ExcelValue filter_range(ExcelValue original_range_v, int number_of_arguments, ExcelValue *arguments) {
   // First, set up the original_range
-  CHECK_FOR_PASSED_ERROR(original_range_v);
+  //CHECK_FOR_PASSED_ERROR(original_range_v);
 
   // Set up the sum range
   ExcelValue *original_range;

data/src/compile/c/excel_to_c_runtime_test.c

@@ -115,11 +115,9 @@ int test_functions() {
   ExcelValue excel_match_array_5_v = new_excel_range(excel_match_array_5,1,3);
 
   // Two argument version
-  assert(excel_match_2(new_excel_number(10),excel_match_array_1_v).number == 1);
-  assert(excel_match_2(new_excel_number(100),excel_match_array_1_v).number == 2);
-  assert(excel_match_2(new_excel_number(1000),excel_match_array_1_v).type == ExcelError);
-  assert(excel_match_2(new_excel_number(0), excel_match_array_4_v).number == 2);
-  assert(excel_match_2(BLANK, excel_match_array_5_v).number == 2);
+  assert(excel_match_2(new_excel_number(14),excel_match_array_1_v).number == 1);
+  assert(excel_match_2(new_excel_number(110),excel_match_array_1_v).number == 2);
+  assert(excel_match_2(new_excel_number(-10),excel_match_array_1_v).type == ExcelError);
 
   // Three argument version	
   assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, new_excel_number(0) ).number == 1);
@@ -512,7 +510,8 @@ int test_functions() {
   assert(sumifs(new_excel_number(100),2,sumifs_array_14).number == 0);
 
   // ... should return an error if range argument is an error
-  assert(sumifs(REF,2,sumifs_array_13).type == ExcelError);
+  ExcelValue sumifs_array_15[] = {ONE, ONE};
+  assert(sumifs(REF,2,sumifs_array_15).type == ExcelError);
 
 
   // Test SUMIF

data/src/compile/c/map_values_to_c.rb

@@ -20,7 +20,7 @@ class MapValuesToC
   end
 
   def inlined_blank
-    "ZERO"
+    "BLANK"
   end
   
   def constant(name)
@@ -30,16 +30,7 @@ class MapValuesToC
   alias :null :blank
     
   def number(text)
-    n = case text
-    when /\./
-      text.to_f.to_s
-    when /e/i
-      text.to_f.to_s
-    else
-      text.to_i.to_s
-    end
-    
-    case n
+    case text.to_f
     when 0; "ZERO"
     when 1; "ONE"
     when 2; "TWO"
@@ -52,6 +43,14 @@ class MapValuesToC
     when 9; "NINE"
     when 10; "TEN"
     else   
+      n = case text
+      when /\./
+        text.to_f.to_s
+      when /e/i
+        text.to_f.to_s
+      else
+        text.to_i.to_s
+      end
       "new_excel_number(#{n})"
     end
   end

data/src/excel/excel_functions/averageifs.rb

@@ -1,76 +1,10 @@
 module ExcelFunctions
   
-  def averageifs(average_range, *criteria)
-    # First, get rid of the errors
-    return average_range if average_range.is_a?(Symbol)
-    error = criteria.find { |a| a.is_a?(Symbol) }
-    return error if error
-    
-    # Sort out the average range
-    average_range = [average_range] unless average_range.is_a?(Array)
-    average_range = average_range.flatten
-    
-    # Sort out the criteria
-    0.step(criteria.length-1,2).each do |i|
-      if criteria[i].is_a?(Array)
-        criteria[i] = criteria[i].flatten
-      else
-        criteria[i] = [criteria[i]]
-      end
-    end
-      
-    # This will hold the items that pass the test
-    accumulator = []
-    
-    # Work through each part of the average range
-    average_range.each_with_index do |potential_average,index|
-      next unless potential_average.is_a?(Numeric)
-      
-      # If a criteria fails, this is set to false and no further criteria are evaluated
-      pass = true
-      
-      0.step(criteria.length-1,2).each do |i|
-        check_range = criteria[i]
-        required_value = criteria[i+1]
-        return :value if index >= check_range.length
-        check_value = check_range[index]
-        
-        pass = case check_value
-        when String
-          check_value.downcase == required_value.to_s.downcase
-        when true, false
-          check_value == required_value
-        when nil
-          required_value == ""
-        when Numeric
-          case required_value
-          when Numeric
-            check_value == required_value
-          when String
-            required_value =~ /^(<=|>=|<|>)?([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)$/
-            if $1 && $2
-              check_value.send($1,$2.to_f)
-            elsif $2
-              check_value == $2.to_f
-            else
-              false
-            end
-          else
-            check_value == required_value
-          end
-        end # case check_value
-                
-        break unless pass
-      end # criteria loop
-      
-      accumulator << potential_average if pass
-        
-      end
+  # See sumifs.rb for _filtered_range
 
-      accumulator.delete_if { |a| !a.is_a?(Numeric) }
-      return :div0 if accumulator.empty?
-      accumulator.inject(0.0) { |m,i| m + i.to_f } / accumulator.size.to_f
-      
+  def averageifs(average_range, *criteria)
+    filtered = _filtered_range(average_range, *criteria)
+    average(*filtered)
   end
   
 end

data/src/excel/excel_functions/excel_match.rb

@@ -1,6 +1,9 @@
 module ExcelFunctions
   
-  def excel_match(lookup_value,lookup_array,match_type = 0)
+  # FIXME: Excel doesn't use this algorithm for matching. Seems
+  # to do some bisecting. Only matters if doing an ordered search
+  # and the range is not in order
+  def excel_match(lookup_value,lookup_array,match_type = 1)
     return lookup_value if lookup_value.is_a?(Symbol)
     return lookup_array if lookup_array.is_a?(Symbol)
     return match_type if match_type.is_a?(Symbol)

data/src/excel/excel_functions/sumifs.rb

@@ -1,14 +1,9 @@
 module ExcelFunctions
-  
-  def sumifs(sum_range,*criteria)
-    # First, get rid of the errors
-    return sum_range if sum_range.is_a?(Symbol)
-    error = criteria.find { |a| a.is_a?(Symbol) }
-    return error if error
-    
+
+  def _filtered_range(range, *criteria)
     # Sort out the sum range
-    sum_range = [sum_range] unless sum_range.is_a?(Array)
-    sum_range = sum_range.flatten
+    range = [range] unless range.is_a?(Array)
+    range = range.flatten
     
     # Sort out the criteria
     0.step(criteria.length-1,2).each do |i|
@@ -18,13 +13,12 @@ module ExcelFunctions
         criteria[i] = [criteria[i]]
       end
     end
-      
-    # This will be the final answer
-    accumulator = 0
+
+    filtered = []
     
     # Work through each part of the sum range
-    sum_range.each_with_index do |potential_sum,index|
-      next unless potential_sum.is_a?(Numeric)
+    range.each_with_index do |potential,index|
+      #next unless potential.is_a?(Numeric)
       
       # If a criteria fails, this is set to false and no further criteria are evaluated
       pass = true
@@ -58,17 +52,22 @@ module ExcelFunctions
           else
             check_value == required_value
           end
+        when Symbol
+          check_value == required_value
         end # case check_value
                 
         break unless pass
       end # criteria loop
       
-      accumulator += potential_sum if pass
-        
-      end
-      
-      return accumulator
-      
+      filtered << potential if pass
     end
+
+    return filtered
+  end
+  
+  def sumifs(range,*criteria)
+    filtered = _filtered_range(range,*criteria)
+    sum(*filtered)
+  end
   
 end

data/src/excel/formula_peg.rb

@@ -18,7 +18,7 @@ class Formula < RubyPeg
   end
   
   def thing
-    function || array || brackets || any_reference || string || percentage || number || boolean || prefix || error || named_reference
+    percentage || function || array || brackets || any_reference || string || number || boolean || prefix || error || named_reference
   end
   
   def argument
@@ -93,7 +93,7 @@ class Formula < RubyPeg
   
   def percentage
     node :percentage do
-      terminal(/[-+]?[0-9]+\.?[0-9]*/) && ignore { terminal("%") }
+      (terminal(/[-+]?[0-9]+\.?[0-9]*/) || function) && ignore { terminal("%") }
     end
   end
   

data/src/excel/formula_peg.txt

@@ -1,6 +1,6 @@
 formula                         := space? expression+
 expression                       = string_join | comparison | arithmetic | thing
-thing                            = function | array | brackets | any_reference | string | percentage | number | boolean | prefix | error | named_reference 
+thing                            = percentage | function | array | brackets | any_reference | string | number | boolean | prefix | error | named_reference 
 argument                         = expression | null
 function                        := /[A-Z]+/ `'(' space argument? (space `',' space argument)* space `')'
 brackets                        := `'(' space expression+ space `')'
@@ -14,7 +14,7 @@ comparator                      := '>=' | '<=' | '<>' | '>' | '<' | '='
 string                          := `'"' /(""|[^"])*/ `'"'
 any_reference                    = external_reference | any_internal_reference
 any_internal_reference           = table_reference | local_table_reference | sheet_reference | sheetless_reference
-percentage                      := /[-+]?[0-9]+\.?[0-9]*/ `'%'
+percentage                      := (/[-+]?[0-9]+\.?[0-9]*/ | function) `'%'
 number                          := /[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/
 operator                        := '+' | '-' | '/' | '*' | '^'
 external_reference              := /\[\d+\]!?/ (any_internal_reference | named_reference)

data/src/excel/table.rb

@@ -17,14 +17,14 @@ class Table
 
     case structured_reference
     when /\[#Headers\],\[(.*?)\]:\[(.*?)\]/io
-      column_number_start = @column_name_array.find_index($1.strip.downcase)
-      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      column_number_start = column_number_for($1)
+      column_number_finish = column_number_for($2)
       return ref_error unless column_number_start && column_number_finish
       ast_for_area @area.excel_start.offset(0,column_number_start), @area.excel_start.offset(0,column_number_finish)
 
     when /\[#Totals\],\[(.*?)\]:\[(.*?)\]/io
-      column_number_start = @column_name_array.find_index($1.strip.downcase)
-      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      column_number_start = column_number_for($1)
+      column_number_finish = column_number_for($2)
       return ref_error unless column_number_start && column_number_finish
       ast_for_area @area.excel_start.offset(@area.height,column_number_start), @area.excel_start.offset(@area.height,column_number_finish)
 
@@ -32,24 +32,24 @@ class Table
       r = Reference.for(calling_cell)
       r.calculate_excel_variables
       row = r.excel_row_number
-      column_number_start = @column_name_array.find_index($1.strip.downcase)
-      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      column_number_start = column_number_for($1)
+      column_number_finish = column_number_for($2)
       return ref_error unless column_number_start && column_number_finish
       ast_for_area @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number_start), @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number_finish)
 
     when /\[(.*?)\]:\[(.*?)\]/io
-      column_number_start = @column_name_array.find_index($1.strip.downcase)
-      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      column_number_start = column_number_for($1)
+      column_number_finish = column_number_for($2)
       return ref_error unless column_number_start && column_number_finish
       ast_for_area @area.excel_start.offset(1,column_number_start), @area.excel_start.offset(@area.height - @number_of_total_rows,column_number_finish)
 
     when /\[#Headers\],\[(.*?)\]/io
-      column_number = @column_name_array.find_index($1.strip.downcase)
+      column_number = column_number_for($1)
       return ref_error unless column_number      
       ast_for_cell @area.excel_start.offset(0,column_number)
 
     when /\[#Totals\],\[(.*?)\]/io
-      column_number = @column_name_array.find_index($1.strip.downcase)
+      column_number = column_number_for($1)
       return ref_error unless column_number
       ast_for_cell @area.excel_start.offset(@area.height,column_number)
 
@@ -57,7 +57,7 @@ class Table
       r = Reference.for(calling_cell)
       r.calculate_excel_variables
       row = r.excel_row_number
-      column_number = @column_name_array.find_index($1.strip.downcase)
+      column_number = column_number_for($1)
       return ref_error unless column_number
       ast_for_cell @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number)      
 
@@ -96,11 +96,11 @@ class Table
         r = Reference.for(calling_cell)
         r.calculate_excel_variables
         row = r.excel_row_number
-        column_number = @column_name_array.find_index(structured_reference.strip.downcase)
+        column_number = column_number_for(structured_reference)
         return ref_error unless column_number
         ast_for_cell @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number)      
       else        
-        column_number = @column_name_array.find_index(structured_reference.strip.downcase)
+        column_number = column_number_for(structured_reference)
         return ref_error unless column_number
         ast_for_area @area.excel_start.offset(1,column_number), @area.excel_start.offset(@area.height - @number_of_total_rows,column_number)
       end
@@ -118,6 +118,11 @@ class Table
   def ref_error
     [:error,"#REF!"]
   end
+
+  def column_number_for(name)
+    name = name.strip.downcase.gsub("'#","#")
+    @column_name_array.find_index(name)
+  end
   
   def includes?(sheet,reference)
     return false unless @worksheet == sheet

data/src/excel_to_code.rb

@@ -1,5 +1,5 @@
 class ExcelToCode
-  def self.version() "0.2.18" end
+  def self.version() "0.2.19" end
 end
 
 require_relative 'commands'

data/src/rewrite/caching_formula_parser.rb

@@ -90,7 +90,12 @@ class CachingFormulaParser
   end
 
   def percentage(ast)
-    ast[1] = ast[1].to_f
+    if ast[1].is_a?(Array)
+      ast.replace([:arithmetic, map(ast[1]), operator([:operator, :'/']), number([:number, 100])])
+    else
+      ast[1] = ast[1].to_f / 100.0
+      ast[0] = :number
+    end
     @percentage_cache[ast] ||= ast
   end
 

data/src/simplify/emergency_array_formula_replace_indirect_bodge.rb

@@ -4,11 +4,16 @@ class EmergencyArrayFormulaReplaceIndirectBodge
   
   attr_accessor :current_sheet_name
   attr_accessor :references
+  attr_accessor :named_references
+  attr_accessor :tables
+  attr_accessor :referring_cell
 
   def initialize
     @indirect_replacer = ReplaceIndirectsWithReferencesAst.new
     @formulae_to_value_replacer = MapFormulaeToValues.new
     @inline_formulae_replacer = InlineFormulaeAst.new
+    @simplify_arithmetic_replacer ||= SimplifyArithmeticAst.new
+    @replace_ranges_with_array_literals_replacer ||= ReplaceRangesWithArrayLiteralsAst.new
   end
 
   def replace(ast)
@@ -25,17 +30,36 @@ class EmergencyArrayFormulaReplaceIndirectBodge
   
   def function(ast)
     new_ast = deep_copy(ast)
+    @replace_ranges_with_array_literals_replacer.map(new_ast)
     @inline_formulae_replacer.references = @references
     @inline_formulae_replacer.current_sheet_name = [@current_sheet_name]
     @inline_formulae_replacer.map(new_ast)
+    @simplify_arithmetic_replacer.map(new_ast)
+
+    @formulae_to_value_replacer.map(new_ast)
+    
+    @named_reference_replacer ||= ReplaceNamedReferencesAst.new(@named_references)
+    @named_reference_replacer.default_sheet_name = @current_sheet_name
+    @named_reference_replacer.map(new_ast)
+    
+    @table_reference_replacer ||= ReplaceTableReferenceAst.new(@tables)
+    @table_reference_replacer.worksheet = @current_sheet_name
+    @table_reference_replacer.referring_cell = @referring_cell
+    @table_reference_replacer.map(new_ast)
+
+    @replace_ranges_with_array_literals_replacer.map(new_ast)
+    @inline_formulae_replacer.map(new_ast)
     @formulae_to_value_replacer.map(new_ast)
+    
     @indirect_replacer.replace(new_ast)
+    
     ast.replace(new_ast)
     ast
   end
 
   def deep_copy(ast)
     return ast if ast.is_a?(Symbol)
+    return ast if ast.is_a?(Numeric)
     return ast.dup unless ast.is_a?(Array)
     ast.map do |a|
       deep_copy(a)

data/src/simplify/inline_formulae.rb

@@ -1,5 +1,3 @@
-module BlankCell; end
-
 class InlineFormulaeAst
 
   attr_accessor :references, :current_sheet_name, :inline_ast
@@ -40,6 +38,7 @@ class InlineFormulaeAst
   
   # Should be of the form [:sheet_reference, sheet_name, reference]
   # FIXME: Can we rely on reference always being a [:cell, ref] at this stage?
+  # FIXME: NO! Because they won't be when they are used in EmergencyArrayFormulaReplaceIndirectBodge
   def sheet_reference(ast)
     return unless ast[2][0] == :cell
     sheet = ast[1].to_sym

data/src/simplify/map_formulae_to_values.rb

@@ -63,7 +63,7 @@ class MapFormulaeToValues
       case operator.last
       when :+ 
         ast.replace(n(right))
-      when :*, :/, :^
+      when :*
         ast.replace([:number, 0])
       end
     elsif r == 0
@@ -140,6 +140,27 @@ class MapFormulaeToValues
     ast.replace(formula_value( ast[1],*values))
   end
 
+  def map_if(ast)
+    condition_ast = ast[2]
+    true_option_ast = ast[3]
+    false_option_ast = ast[4] || [:boolean_false]
+
+    condition_value = value(condition_ast)
+    return if condition_value == :not_a_value
+
+    case condition_value
+    when Symbol
+      ast.replace(condition_ast)
+    when String
+      ast.replace([:error, :"#VALUE!"])
+    when false, 0
+      ast.replace(false_option_ast)
+    else
+      ast.replace(true_option_ast)
+    end
+    ast
+  end
+
   def map_right(ast)
     normal_function(ast, "")
   end
@@ -161,11 +182,38 @@ class MapFormulaeToValues
   end
 
   def map_sumifs(ast)
-    sum_value = value(ast[2])
     values = ast[3..-1].map.with_index { |a,i| value(a, (i % 2) == 0 ? 0 : nil ) }
-    return if sum_value == :not_a_value
     return if values.any? { |a| a == :not_a_value }
-    ast.replace(formula_value( ast[1], sum_value, *values))
+    return unless [:sheet_reference, :cell, :area, :array, :number, :string, :boolean_true, :boolean_false].include?(ast[2].first)
+    sum_value = value(ast[2])
+    if sum_value == :not_a_value
+      partially_map_sumifs(ast)
+    else
+      ast.replace(formula_value( ast[1], sum_value, *values))
+    end
+  end
+
+  def partially_map_sumifs(ast)
+    values = ast[3..-1].map.with_index { |a,i| value(a, (i % 2) == 0 ? 0 : nil ) }
+    sum_range = []
+    if ast[2].first == :array
+      ast[2].each do |row|
+        next if row.is_a?(Symbol)
+        row.each do |cell|
+          next if cell.is_a?(Symbol)
+          sum_range << cell
+        end
+      end
+    else
+      sum_range = [ast[2]]
+    end
+    sum_range_indexes = 0.upto(sum_range.length-1).to_a
+    filtered_range = @calculator._filtered_range(sum_range_indexes, *values)
+    if filtered_range.is_a?(Symbol)
+      ast.replace(value(filtered_range))
+    else
+      ast.replace([:function, :SUM, *sum_range.values_at(*filtered_range)])
+    end
   end
 
   # [:function, "COUNT", range]
@@ -180,6 +228,7 @@ class MapFormulaeToValues
     return map_index_with_only_two_arguments(ast) if ast.length == 4
 
     array_mapped = ast[2] 
+    return ast.replace(ast[2]) if ast[2].first == :error
     row_as_number = value(ast[3])
     column_as_number = value(ast[4])
 
@@ -198,6 +247,7 @@ class MapFormulaeToValues
   # [:function, "INDEX", array, row_number]
   def map_index_with_only_two_arguments(ast)
     array_mapped = ast[2]
+    return ast.replace(ast[2]) if ast[2].first == :error
     row_as_number = value(ast[3])
     return if row_as_number == :not_a_value
     array_as_values = array_as_values(array_mapped)
@@ -227,9 +277,10 @@ class MapFormulaeToValues
       ast.replace([:number, number_total])
     # FIXME: Will I be haunted by this? What if doing a sum of something that isn't a number
     # and so what is expected is a VALUE error?. YES. This doesn't work well.
-    #elsif number_total == 0 && not_number_array.size == 1
-    #  p not_number_array[0]
-    #  ast.replace(not_number_array[0])
+    elsif ast.length == 3 && [:cell, :sheet_reference].include?(ast[2].first)
+      ast.replace(n(ast[2]))
+    elsif ast.length == 3 && ast[2][0] == :function && ast[2][1] == :ENSURE_IS_NUMBER
+      ast.replace(ast[2])
     else
       new_ast = [:function, :SUM].concat(not_number_array)
       new_ast.push([:number, number_total]) unless number_total == 0
@@ -243,13 +294,30 @@ class MapFormulaeToValues
     not_number_array = []
     case ast.first
     when :array
+      array_total = 0
+      array_not_numbers = []
+      # First we just have a go at splitting the array into a list of numbers
+      # and not numbers.
       array_as_values(ast).each do |row|
         row.each do |c|
           result = filter_numbers_and_not(c)
-          number_total += result.first
-          not_number_array.concat(result.last)
+          array_total += result.first
+          array_not_numbers.concat(result.last)
         end
       end
+      # If there are no not_numbers, or only one, we are good
+      if array_not_numbers.length <= 1
+        number_total += array_total
+        not_number_array.concat(array_not_numbers)
+      # If there are more than on not_numbers we aren't neccessarily good
+      # unless all those not numbers are simple
+      elsif array_not_numbers.all? { |c| [:cell, :area, :sheet_reference].include?(c.first)}
+        number_total += array_total
+        not_number_array.concat(array_not_numbers)
+      # Otherwise, leave that array alone
+      else
+        not_number_array.push(ast)
+      end
     when :blank, :number, :percentage, :string, :boolean_true, :boolean_false
       number = @calculator.number_argument(value(ast))
       if number.is_a?(Symbol)

data/src/simplify/replace_arithmetic_on_ranges.rb

@@ -14,7 +14,6 @@ class ReplaceArithmeticOnRangesAst
     # Three different options, array on the left, array on the right, or both
     # array on the left first
     if left.first == :array && right.first != :array
-      map(right)
       ast.replace(
         array_map(left) do |cell|
           [:comparison, map(cell), operator, right]
@@ -23,7 +22,6 @@ class ReplaceArithmeticOnRangesAst
 
     # array on the right next
     elsif left.first != :array && right.first == :array
-      map(left)
       ast.replace(
         array_map(right) do |cell|
           [:comparison, left, operator, map(cell)]
@@ -49,9 +47,6 @@ class ReplaceArithmeticOnRangesAst
           end
         end
       )
-    else
-      map(left)
-      map(right)
     end
   end
 
@@ -64,7 +59,6 @@ class ReplaceArithmeticOnRangesAst
     # Three different options, array on the left, array on the right, or both
     # array on the left first
     if left.first == :array && right.first != :array
-      map(right)
       ast.replace(
         array_map(left) do |cell|
           [:arithmetic, map(cell), operator, right]
@@ -73,7 +67,6 @@ class ReplaceArithmeticOnRangesAst
 
     # array on the right next
     elsif left.first != :array && right.first == :array
-      map(left)
       ast.replace(
         array_map(right) do |cell|
           [:arithmetic, left, operator, map(cell)]
@@ -99,9 +92,6 @@ class ReplaceArithmeticOnRangesAst
           end
         end
       )
-    else
-      map(left)
-      map(right)
     end
   end
 

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -18,10 +18,13 @@ class ReplaceArraysWithSingleCellsAst
     # Special case, only change if at the top level
     elsif ast[0] == :function && ast[1] == :CHOOSE && check_choose(ast)
       # Replacement made in check
+    # Special case, only change if at the top level
+    elsif ast[0] == :function && ast[1] == :IF && check_if(ast)
+      # Replacement made in check
     else
       do_map(ast)
-      ast
     end
+    ast
   end
 
   def do_map(ast)
@@ -74,6 +77,19 @@ class ReplaceArraysWithSingleCellsAst
     replacement_made
   end
 
+  def check_if(ast)
+    replacement_made = false
+    if ast[3] && ast[3].first == :array
+      replacement_made = true
+      ast[3] = try_and_convert_array(ast[3])
+    end
+    if ast[4] && ast[4].first == :array
+      replacement_made = true
+      ast[4] = try_and_convert_array(ast[3])
+    end
+    replacement_made
+  end
+
   def check_match(ast)
     return false unless ast[2].first == :array
     ast[2] = try_and_convert_array(ast[2])

data/src/simplify/replace_values_with_constants.rb

@@ -10,18 +10,32 @@ class MapValuesToConstants
     end
   end
   
-  POTENTIAL_CONSTANTS = { :number => true, :percentage => true, :string => true}
-
   def map(ast)
     return ast unless ast.is_a?(Array)
     operator = ast[0]
-    if POTENTIAL_CONSTANTS.has_key?(operator)
+    if replace?(ast)
       ast.replace([:constant, constants[ast.dup]])
     else
       ast.each { |a| map(a) }
     end
   end
 
+  def replace?(ast)
+    case ast.first
+    when :string; return true
+    when :percentage, :number
+      n = ast.last.to_f
+      # Don't use constant if an integer less than ten, 
+      # as will use constant predefined in the c runtime
+      return true if n > 10
+      return true if n < 0
+      return false if n % 1 == 0
+      return true
+    else
+      return false
+    end
+  end
+
 end
 
 

data/src/simplify/simplify_arithmetic.rb

@@ -9,7 +9,9 @@ class SimplifyArithmeticAst
 
   def simplify_arithmetic(ast)
     return ast unless ast.is_a?(Array)
-    ast.each { |a| simplify_arithmetic(a) }
+    ast.each do |a| 
+      simplify_arithmetic(a) if a.is_a?(Array)
+    end
     case ast[0]
     when :arithmetic; arithmetic(ast)
     when :brackets; @brackets_to_remove << ast

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.2.19
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-02 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -277,7 +277,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Converts .xlxs files into pure ruby 1.9 code or pure C code so that they