excel_to_code 0.2.19 → 0.2.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74698377e3e89c2dae52564440694e4e2e97f2f1
-  data.tar.gz: 73e3a3af8271ac02a3f68727f43e5874153d2d2f
+  metadata.gz: 8683fda68a9053d3873f3ae6612dc61af4ad4393
+  data.tar.gz: 5ce67a7a836a8931a2b41f7f790ca07b9c565960
 SHA512:
-  metadata.gz: f97a19688abe21b1cdbc7755a77158379746f012bda38154b35c7114add213ef4d1cee34f6121ce61d09d3bced7ae5de98f413e297ce5c0beecc9bd586a7177d
-  data.tar.gz: b911c226eed1bd735828b5a80927b8198ea1b226b312032c937c9bb96a98f10ccb3bff9fc13e391c2aef0c3163307e3b1e541e371c74459ae628ac714aa34027
+  metadata.gz: abef9a443559d67c2dd453d6c386febc7516c2fa88b13c2a0a8e43e932809d90d51e400e637bf4845d85bd6296136805c42e762b1d7dc563192ba0b32841f93d
+  data.tar.gz: 6d74e0cfe7dcdad64037700c137066f21afddc10f2acafb2df63c8348e26ea0618e1b321697af7b1024853949bbc71ef1bfd87edb0839e7c75e039ae5d7d36d3

data/src/commands.rb

@@ -1,3 +1,4 @@
 require_relative "commands/excel_to_x"
 require_relative "commands/excel_to_ruby"
-require_relative "commands/excel_to_c"
+require_relative "commands/excel_to_c"
+require_relative "commands/excel_to_test"

data/src/commands/excel_to_test.rb

@@ -0,0 +1,137 @@
+# coding: utf-8
+require_relative 'excel_to_x'
+require 'ffi'
+
+class ExcelToTest < ExcelToX
+ 
+  attr_accessor :test_name
+
+  def language
+    "C"
+  end
+
+  def go!
+    # This sorts out the settings
+    set_defaults
+
+    log.info "Excel to Code version #{ExcelToCode.version}\n\n"
+    
+    # These turn the excel into xml on disk
+    sort_out_output_directories
+    unzip_excel
+    
+    # These gets the named references, worksheet names and shared strings out of the excel
+    extract_data_from_workbook
+    
+    # This checks that the user inputs of which cells to keep are in the right
+    # format and refer to sheets and references that actually exist
+    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
+    
+    # This turns named references that are specified as getters and setters
+    # into a series of required cell references
+    transfer_named_references_to_keep_into_cells_to_keep
+    transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
+
+    # This makes sure we only extract values from the worksheets we actuall care about
+    extractor = ExtractDataFromWorksheet.new
+    extractor.only_extract_values = true
+
+    cells_to_keep.each do |name, refs|
+      xml_filename = @worksheet_xmls[name]
+
+      log.info "Extracting data from #{name}"
+      xml(xml_filename) do |input|
+        extractor.extract(name, input)
+      end
+    end
+    @values = extractor.values
+
+    
+    # These perform some translations to tsimplify the excel
+    # Including:
+    # * Turning row and column references (e.g., A:A) to areas, based on the size of the worksheet
+    # * 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 hash
+    rewrite_values_to_remove_shared_strings
+    
+    # FIXME: Bodge for the moment
+    @formulae = @values 
+    create_sorted_references_to_test
+
+    # This actually creates the code (implemented in subclasses)
+    write_code
+    
+    # These compile and run the code version of the excel (implemented in subclasses)
+    run_tests
+    
+    log.info "The generated code is available in #{File.join(output_directory)}"
+  end
+  
+  # These actually create the code version of the excel
+  def write_code
+    write_tests
+  end
+    
+  def write_code_to_set_values
+    log.info "Writing code to set values to match those in the worksheet"
+  end
+  
+  # FIXME: Should make a Rakefile, especially in order to make sure the dynamic library name
+  
+  def write_tests
+    log.info "Writing tests" 
+
+    name = output_name.downcase
+    @test_name = "test_#{name}_#{Time.now.to_i}.rb"
+    o = output(@test_name)    
+    o.puts "# coding: utf-8"
+    o.puts "# Test for #{name}"
+    o.puts  "require 'minitest/autorun'"
+    o.puts  "require_relative '#{output_name.downcase}'"
+    o.puts
+    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_/)"
+    o.puts "  end" 
+    o.puts "  def worksheet; @worksheet ||= init_spreadsheet; end"
+
+    # We need to set up the worksheet with the correct starting values
+    o.puts "  def init_spreadsheet"
+    o.puts "    s = #{ruby_module_name}Shim.new"
+
+    mapper = MapValuesToRuby.new
+
+    cells_that_can_be_set_at_runtime.each do |sheet, cells|
+      worksheet_c_name = c_name_for_worksheet_name(sheet)
+      cells.each do |cell|
+        ast = @values[[sheet.to_sym, cell.to_sym]]
+        next unless ast
+        value = mapper.map(ast)
+
+        full_reference = worksheet_c_name.length > 0 ? "#{worksheet_c_name}_#{cell.downcase}" : "#{cell.downcase}"
+        o.puts "    s.#{full_reference} = #{value}"
+      end
+    end
+
+    o.puts "    return s"
+    o.puts "  end"
+    
+    CompileToCUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
+    o.puts "end"
+    close(o)
+    puts "New test is in #{File.join(output_directory, @test_name)}"
+  end
+
+  def run_tests
+    return unless actually_run_tests
+    puts "Running the resulting tests"
+    puts `cd #{File.join(output_directory)}; ruby "#{@test_name}"`
+  end
+  
+end

data/src/compile/c/excel_to_c_runtime.c

@@ -1066,113 +1066,174 @@ static ExcelValue iferror(ExcelValue value, ExcelValue value_if_error) {
 	return value;
 }
 
+// Order is TRUE, FALSE, String, Number; Blank is zero
 static ExcelValue more_than(ExcelValue a_v, ExcelValue b_v) {
-	CHECK_FOR_PASSED_ERROR(a_v)
-	CHECK_FOR_PASSED_ERROR(b_v)
+  CHECK_FOR_PASSED_ERROR(a_v)
+  CHECK_FOR_PASSED_ERROR(b_v)
 
-	switch (a_v.type) {
-  	  case ExcelNumber:
-	  case ExcelBoolean: 
-	  case ExcelEmpty:
-		if((b_v.type == ExcelNumber) || (b_v.type == ExcelBoolean) || (b_v.type == ExcelEmpty)) {
-			if(a_v.number <= b_v.number) return FALSE;
-			return TRUE;
-		} 
-		return FALSE;
-	  case ExcelString:
-	  	if(b_v.type == ExcelString) {
-		  	if(strcasecmp(a_v.string,b_v.string) <= 0 ) return FALSE;
-			return TRUE;	  		
-		}
-		return FALSE;
-  	  case ExcelError:
-		return a_v;
-  	  case ExcelRange:
-  		return NA;
-  }
-  return FALSE;
+  if(a_v.type == ExcelEmpty) { a_v = ZERO; }
+  if(b_v.type == ExcelEmpty) { b_v = ZERO; }
+
+  switch (a_v.type) {
+    case ExcelString:
+      switch (b_v.type) {
+        case ExcelString:
+          if(strcasecmp(a_v.string,b_v.string) <= 0 ) {return FALSE;} else {return TRUE;} 
+        case ExcelNumber: 
+          return TRUE;
+        case ExcelBoolean:
+          return FALSE;
+        // Following shouldn't happen
+        case ExcelEmpty: 
+        case ExcelError: 
+        case ExcelRange:
+          return NA;
+      }
+    case ExcelBoolean: 
+      switch (b_v.type) {
+        case ExcelBoolean:
+          if(a_v.number == true) {
+            if (b_v.number == true) { return FALSE; } else { return TRUE; }
+          } else { // a_v == FALSE
+            return FALSE;
+          }
+        case ExcelString:
+        case ExcelNumber: 
+          return TRUE;
+        // Following shouldn't happen
+        case ExcelEmpty: 
+        case ExcelError: 
+        case ExcelRange:
+          return NA;
+      }
+    case ExcelNumber:
+      switch (b_v.type) {
+        case ExcelNumber:
+          if(a_v.number > b_v.number) { return TRUE; } else { return FALSE; }
+        case ExcelString:
+        case ExcelBoolean:
+          return FALSE;
+        // Following shouldn't happen
+        case ExcelEmpty: 
+        case ExcelError: 
+        case ExcelRange:
+          return NA;
+      }
+    // Following shouldn't happen
+    case ExcelEmpty: 
+    case ExcelError: 
+    case ExcelRange:
+      return NA;
+  } 
+  // Shouldn't reach here
+  return NA;
 }
 
 static ExcelValue more_than_or_equal(ExcelValue a_v, ExcelValue b_v) {
-	CHECK_FOR_PASSED_ERROR(a_v)
-	CHECK_FOR_PASSED_ERROR(b_v)
-
-	switch (a_v.type) {
-  	  case ExcelNumber:
-	  case ExcelBoolean: 
-	  case ExcelEmpty:
-		if((b_v.type == ExcelNumber) || (b_v.type == ExcelBoolean) || (b_v.type == ExcelEmpty)) {
-			if(a_v.number < b_v.number) return FALSE;
-			return TRUE;
-		} 
-		return FALSE;
-	  case ExcelString:
-	  	if(b_v.type == ExcelString) {
-		  	if(strcasecmp(a_v.string,b_v.string) < 0 ) return FALSE;
-			return TRUE;	  		
-		}
-		return FALSE;
-  	  case ExcelError:
-		return a_v;
-  	  case ExcelRange:
-  		return NA;
+  ExcelValue opposite = less_than(a_v, b_v);
+  switch (opposite.type) {
+    case ExcelBoolean:
+      if(opposite.number == true) { return FALSE; } else { return TRUE; }
+    case ExcelError:
+      return opposite;
+    // Shouldn't reach below
+    case ExcelNumber:
+    case ExcelString:
+    case ExcelEmpty:
+    case ExcelRange:
+      return NA;
   }
-  return FALSE;
 }
 
-
+// Order is TRUE, FALSE, String, Number; Blank is zero
 static ExcelValue less_than(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	CHECK_FOR_PASSED_ERROR(b_v)
 
+  if(a_v.type == ExcelEmpty) { a_v = ZERO; }
+  if(b_v.type == ExcelEmpty) { b_v = ZERO; }
+
 	switch (a_v.type) {
-  	  case ExcelNumber:
-	  case ExcelBoolean: 
-	  case ExcelEmpty:
-		if((b_v.type == ExcelNumber) || (b_v.type == ExcelBoolean) || (b_v.type == ExcelEmpty)) {
-			if(a_v.number >= b_v.number) return FALSE;
-			return TRUE;
-		} 
-		return FALSE;
-	  case ExcelString:
-	  	if(b_v.type == ExcelString) {
-		  	if(strcasecmp(a_v.string,b_v.string) >= 0 ) return FALSE;
-			return TRUE;	  		
-		}
-		return FALSE;
-  	  case ExcelError:
-		return a_v;
-  	  case ExcelRange:
-  		return NA;
+    case ExcelString:
+      switch (b_v.type) {
+        case ExcelString:
+          if(strcasecmp(a_v.string, b_v.string) >= 0 )  {
+            return FALSE;
+          } else {
+            return TRUE;
+          }
+        case ExcelNumber:
+          return FALSE;
+        case ExcelBoolean:
+          return TRUE;
+        // The following shouldn't happen
+        // FIXME: Should abort if it does
+        case ExcelError:
+        case ExcelRange:
+        case ExcelEmpty:
+          return NA;
+      }
+  	case ExcelNumber:
+      switch(b_v.type) {
+        case ExcelNumber:
+          if(a_v.number < b_v.number) {
+            return TRUE;
+          } else {
+            return FALSE;
+          }
+        case ExcelBoolean:
+        case ExcelString:
+          return TRUE;
+        // The following shouldn't happen
+        // FIXME: Should abort if it does
+        case ExcelError:
+        case ExcelRange:
+        case ExcelEmpty:
+          return NA;
+      }
+    case ExcelBoolean:
+      switch(b_v.type) {
+        case ExcelBoolean: 
+          if(a_v.number == true) {
+            return FALSE;
+          } else { // a_v.number == false
+            if(b_v.number == true) {return TRUE;} else {return FALSE;}
+          }
+        case ExcelString:
+        case ExcelNumber:
+          return FALSE;
+        // The following shouldn't happen
+        // FIXME: Should abort if it does
+        case ExcelError:
+        case ExcelRange:
+        case ExcelEmpty:
+          return NA;
+      }
+    // The following shouldn't happen
+    // FIXME: Should abort if it does
+    case ExcelError:
+    case ExcelRange:
+    case ExcelEmpty:
+      return VALUE;
   }
-  return FALSE;
+  // Shouldn't reach here
+  return NA;
 }
 
 static ExcelValue less_than_or_equal(ExcelValue a_v, ExcelValue b_v) {
-	CHECK_FOR_PASSED_ERROR(a_v)
-	CHECK_FOR_PASSED_ERROR(b_v)
-
-	switch (a_v.type) {
-  	  case ExcelNumber:
-	  case ExcelBoolean: 
-	  case ExcelEmpty:
-		if((b_v.type == ExcelNumber) || (b_v.type == ExcelBoolean) || (b_v.type == ExcelEmpty)) {
-			if(a_v.number > b_v.number) return FALSE;
-			return TRUE;
-		} 
-		return FALSE;
-	  case ExcelString:
-	  	if(b_v.type == ExcelString) {
-		  	if(strcasecmp(a_v.string,b_v.string) > 0 ) return FALSE;
-			return TRUE;	  		
-		}
-		return FALSE;
-  	  case ExcelError:
-		return a_v;
-  	  case ExcelRange:
-  		return NA;
+  ExcelValue opposite = more_than(a_v, b_v);
+  switch (opposite.type) {
+    case ExcelBoolean:
+      if(opposite.number == true) { return FALSE; } else { return TRUE; }
+    case ExcelError:
+      return opposite;
+    // Shouldn't reach below
+    case ExcelNumber:
+    case ExcelString:
+    case ExcelEmpty:
+    case ExcelRange:
+      return VALUE;
   }
-  return FALSE;
 }
 
 static ExcelValue subtract(ExcelValue a_v, ExcelValue b_v) {

data/src/compile/c/excel_to_c_runtime_test.c

@@ -154,6 +154,13 @@ int test_functions() {
   assert(more_than(BLANK,new_excel_number(-1)).number == true);
   assert(more_than(ONE,BLANK).number == true);
   assert(more_than(new_excel_number(-1),BLANK).number == false);
+  // .. of different types
+  assert(more_than(TRUE,new_excel_string("Hello")).number == true);
+  assert(more_than(FALSE,new_excel_string("Hello")).number == true);
+  assert(more_than(new_excel_string("Hello"), ONE).number == true);
+  assert(more_than(ONE,new_excel_string("Hello")).number == false);
+  assert(more_than(new_excel_string("Hello"), TRUE).number == false);
+  assert(more_than(new_excel_string("Hello"), FALSE).number == false);
 
   // Test less than on
   // .. numbers
@@ -174,6 +181,13 @@ int test_functions() {
   assert(less_than(BLANK,new_excel_number(-1)).number == false);
   assert(less_than(ONE,BLANK).number == false);
   assert(less_than(new_excel_number(-1),BLANK).number == true);
+  // .. of different types
+  assert(less_than(TRUE,new_excel_string("Hello")).number == false);
+  assert(less_than(FALSE,new_excel_string("Hello")).number == false);
+  assert(less_than(new_excel_string("Hello"), ONE).number == false);
+  assert(less_than(ONE,new_excel_string("Hello")).number == true);
+  assert(less_than(new_excel_string("Hello"), TRUE).number == true);
+  assert(less_than(new_excel_string("Hello"), FALSE).number == true);
 
   // Test FIND function
   // ... should find the first occurrence of one string in another, returning :value if the string doesn't match

data/src/excel/excel_functions/less_than.rb

@@ -13,13 +13,27 @@ module ExcelFunctions
     
     case a
     when String
-      a.downcase < b.downcase
-    when TrueClass, FalseClass
-      a = a ? 1 : 0
-      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
-      a < b
-    else
-      a < b
+      case b
+      when String
+        a.downcase < b.downcase
+      when Numeric
+        false
+      when TrueClass, FalseClass
+        true
+      end
+    when TrueClass
+      false
+    when FalseClass
+      b.is_a?(TrueClass)
+    when Numeric
+      case b
+      when Numeric
+        a < b
+      when String
+        true
+      when TrueClass, FalseClass
+        true
+      end
     end
   end
   

data/src/excel/excel_functions/less_than_or_equal.rb

@@ -3,24 +3,9 @@ require_relative 'apply_to_range'
 module ExcelFunctions
   
   def less_than_or_equal?(a,b)
-    # return apply_to_range(a,b) { |a,b| less_than_or_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
-
-    return a if a.is_a?(Symbol)
-    return b if b.is_a?(Symbol)
-    
-    a = 0 if a == nil
-    b = 0 if b == nil
-    
-    case a
-    when String
-      a.downcase <= b.downcase
-    when TrueClass, FalseClass
-      a = a ? 1 : 0
-      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
-      a <= b
-    else
-      a <= b
-    end
+    opposite = more_than?(a,b)
+    return opposite if opposite.is_a?(Symbol)
+    !opposite
   end
   
 end

data/src/excel/excel_functions/more_than.rb

@@ -10,16 +10,33 @@ module ExcelFunctions
     
     a = 0 if a == nil
     b = 0 if b == nil
-    
+
     case a
     when String
-      a.downcase > b.downcase
-    when TrueClass, FalseClass
-      a = a ? 1 : 0
-      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
-      a > b
-    else
-      a > b
+      case b
+      when String
+        a.downcase > b.downcase
+      when Numeric
+        true
+      when TrueClass, FalseClass
+        false
+      end
+    when TrueClass
+      !b.is_a?(TrueClass)
+    when FalseClass
+      case b
+      when TrueClass, FalseClass
+        false
+      else
+        true
+      end
+    when Numeric
+      case b
+      when Numeric
+        a > b
+      else 
+        false
+      end
     end
   end
   

data/src/excel/excel_functions/more_than_or_equal.rb

@@ -3,24 +3,9 @@ require_relative 'apply_to_range'
 module ExcelFunctions
   
   def more_than_or_equal?(a,b)
-    # return apply_to_range(a,b) { |a,b| more_than_or_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
-    
-    return a if a.is_a?(Symbol)
-    return b if b.is_a?(Symbol)
-    
-    a = 0 if a == nil
-    b = 0 if b == nil
-    
-    case a
-    when String
-      a.downcase >= b.downcase
-    when TrueClass, FalseClass
-      a = a ? 1 : 0
-      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
-      a >= b
-    else
-      a >= b
-    end
+    opposite = less_than?(a,b)
+    return opposite if opposite.is_a?(Symbol)
+    !opposite
   end
   
 end

data/src/excel/excel_functions/sumifs.rb

@@ -5,6 +5,12 @@ module ExcelFunctions
     range = [range] unless range.is_a?(Array)
     range = range.flatten
     
+    indexes = _filtered_range_indexes(range, *criteria)
+    return indexes if indexes.is_a?(Symbol)
+    range.values_at(*indexes)
+  end
+
+  def _filtered_range_indexes(range, *criteria)
     # Sort out the criteria
     0.step(criteria.length-1,2).each do |i|
       if criteria[i].is_a?(Array)
@@ -59,7 +65,7 @@ module ExcelFunctions
         break unless pass
       end # criteria loop
       
-      filtered << potential if pass
+      filtered << index if pass
     end
 
     return filtered

data/src/excel_to_code.rb

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

data/src/simplify.rb

@@ -3,7 +3,7 @@ require_relative "simplify/replace_named_references"
 require_relative "simplify/replace_table_references"
 require_relative "simplify/replace_ranges_with_array_literals"
 require_relative "simplify/inline_formulae"
-require_relative "simplify/replace_formulae_with_calculated_values"
+require_relative "simplify/map_formulae_to_values"
 require_relative "simplify/replace_indirects_with_references"
 require_relative "simplify/replace_offsets_with_references"
 require_relative "simplify/replace_column_with_column_number"

data/src/simplify/map_formulae_to_values.rb

@@ -181,12 +181,15 @@ class MapFormulaeToValues
     normal_function(ast,nil)
   end
 
+  OK_CHECK_RANGE_TYPES = [:sheet_reference, :cell, :area, :array, :number, :string, :boolean_true, :boolean_false]
+
   def map_sumifs(ast)
     values = ast[3..-1].map.with_index { |a,i| value(a, (i % 2) == 0 ? 0 : nil ) }
-    return if values.any? { |a| a == :not_a_value }
-    return unless [:sheet_reference, :cell, :area, :array, :number, :string, :boolean_true, :boolean_false].include?(ast[2].first)
+    return if values.all? { |a| a == :not_a_value } # Nothing to be done
+    return attempt_to_reduce_sumifs(ast) if values.any? { |a| a == :not_a_value } # Maybe a reduction to be done
+    return unless OK_CHECK_RANGE_TYPES.include?(ast[2].first)
     sum_value = value(ast[2])
-    if sum_value == :not_a_value
+    if sum_value == :not_a_value # i.e., a sheet_reference, :cell or :area
       partially_map_sumifs(ast)
     else
       ast.replace(formula_value( ast[1], sum_value, *values))
@@ -195,27 +198,58 @@ class MapFormulaeToValues
 
   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
+    sum_range = array_as_values(ast[2]).flatten(1)
+    indexes = @calculator._filtered_range_indexes(sum_range, *values)
+    if indexes.is_a?(Symbol)
+      new_ast = value(filtered_range)
     else
-      sum_range = [ast[2]]
+      new_ast = [:function, :SUM, *sum_range.values_at(*indexes)]
+    end
+    if new_ast != ast
+      @replacements_made_in_the_last_pass += 1
+      ast.replace(new_ast)
+    end
+  end
+
+  # FIXME: Ends up making everything single column. Is that ok?!
+  def attempt_to_reduce_sumifs(ast)
+    return unless OK_CHECK_RANGE_TYPES.include?(ast[2].first)
+    # First combine into a series of checks
+    criteria_that_can_be_resolved = []
+    criteria_that_cant_be_resolved = []
+    ast[3..-1].each_slice(2) do |check|
+      # Give up unless we have something that can actually be used
+      return unless OK_CHECK_RANGE_TYPES.include?(check[0].first)
+      check_range_value = value(check[0])
+      check_criteria_value = value(check[1])
+      if check_range_value == :not_a_value || check_criteria_value == :not_a_value
+        criteria_that_cant_be_resolved << check
+      else
+        criteria_that_can_be_resolved << [check_range_value, check_criteria_value]
+      end
     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))
+    return if criteria_that_can_be_resolved.empty?
+    sum_range = array_as_values(ast[2]).flatten(1)
+    indexes = @calculator._filtered_range_indexes(sum_range, *criteria_that_can_be_resolved.flatten(1))
+    if indexes.is_a?(Symbol)
+      return
+    elsif indexes.empty?
+      new_ast = [:number, 0]
     else
-      ast.replace([:function, :SUM, *sum_range.values_at(*filtered_range)])
+      new_ast = [:function, :SUMIFS]
+      new_ast << ast_for_array(sum_range.values_at(*indexes))
+      criteria_that_cant_be_resolved.each do |check|
+        new_ast << ast_for_array(array_as_values(check.first).flatten(1).values_at(*indexes))
+        new_ast << check.last
+      end
+    end
+    if new_ast != ast
+      @replacements_made_in_the_last_pass += 1
+      ast.replace(new_ast)
     end
   end
 
+
   # [:function, "COUNT", range]
   def map_count(ast)
     values = ast[2..-1].map { |a| value(a, nil) }
@@ -274,17 +308,32 @@ class MapFormulaeToValues
       not_number_array.concat(result.last)
     end
     if number_total == 0 && not_number_array.empty?
-      ast.replace([:number, number_total])
+      new_ast = [:number, number_total]
+      if new_ast != ast
+        @replacements_made_in_the_last_pass += 1
+        ast.replace(new_ast)
+      end
     # 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 ast.length == 3 && [:cell, :sheet_reference].include?(ast[2].first)
-      ast.replace(n(ast[2]))
+      new_ast = n(ast[2])
+      if new_ast != ast
+        @replacements_made_in_the_last_pass += 1
+        ast.replace(new_ast)
+      end
     elsif ast.length == 3 && ast[2][0] == :function && ast[2][1] == :ENSURE_IS_NUMBER
-      ast.replace(ast[2])
+      new_ast = ast[2]
+      if new_ast != ast
+        @replacements_made_in_the_last_pass += 1
+        ast.replace(new_ast)
+      end
     else
       new_ast = [:function, :SUM].concat(not_number_array)
       new_ast.push([:number, number_total]) unless number_total == 0
-      ast.replace(new_ast)
+      if new_ast != ast
+        @replacements_made_in_the_last_pass += 1
+        ast.replace(new_ast)
+      end
     end
     ast
   end
@@ -346,6 +395,11 @@ class MapFormulaeToValues
     end
   end
 
+  # FIXME: Assumes single column. Not wise?
+  def ast_for_array(array)
+    [:array,*array.map { |row| [:row, row ]}]
+  end
+
   ERRORS = {
     :"#NAME?" => :name,
     :"#VALUE!" => :value,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.20
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-18 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -113,6 +113,7 @@ files:
 - src/commands.rb
 - src/commands/excel_to_c.rb
 - src/commands/excel_to_ruby.rb
+- src/commands/excel_to_test.rb
 - src/commands/excel_to_x.rb
 - src/compile.rb
 - src/compile/c.rb
@@ -240,7 +241,6 @@ files:
 - src/simplify/replace_arrays_with_single_cells.rb
 - src/simplify/replace_column_with_column_number.rb
 - src/simplify/replace_common_elements_in_formulae.rb
-- src/simplify/replace_formulae_with_calculated_values.rb
 - src/simplify/replace_indirects_with_references.rb
 - src/simplify/replace_named_references.rb
 - src/simplify/replace_offsets_with_references.rb

data/src/simplify/replace_formulae_with_calculated_values.rb

@@ -1,28 +0,0 @@
-require_relative 'map_formulae_to_values'
-
-class ReplaceFormulaeWithCalculatedValues
-    
-  attr_accessor :excel_file
-
-  def self.replace(*args)
-    self.new.replace(*args)
-  end
-
-  attr_accessor :replacements_made_in_the_last_pass
-  
-  def replace(input,output)
-    rewriter = MapFormulaeToValues.new
-    rewriter.original_excel_filename = excel_file
-    input.each_line do |line|
-      begin
-        ref, ast = line.split("\t")
-        output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
-        rewriter.reset
-      rescue Exception => e
-        puts "Exception at line #{line}"
-        raise
-      end
-    end
-    @replacements_made_in_the_last_pass = rewriter.replacements_made_in_the_last_pass
-  end
-end