excel_to_code 0.2.14 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5462c5420b1ec9bd0cb8fc6c2a6641475348f7b1
-  data.tar.gz: e5bd8eb39e00007be6ac7b847d7b3fabd3260dcf
+  metadata.gz: f02167c81fefd0532b50c1fc9c9014a4398306f5
+  data.tar.gz: ec0ce7e9de3c7ed214052a9a45bad36c02e1c763
 SHA512:
-  metadata.gz: 49e9dde17bb074100d96a2868a79f95bf1ec111dfe0bf6675759a272407980cd830110a7eda9db3c5257d2bb2ead0d889798b564fe0a82fcddc87d757298d6e3
-  data.tar.gz: 2e4da6cd7577fc93718190048457e08fcd0067a66d69ac45fdfff46b99622b58c20ae22591d0e76d99e40670cd8f2ded881f7dc6b544fcd447abb9e61c64357e
+  metadata.gz: 52fd6998dddf65a826c6bb3a014d5b915342845ab5a1801dfc3c4fc7572f446aedd2f8662c92aa186be8c0b5dd9719ffcc2f90f1b71842df6cb5c97e886cbc8f
+  data.tar.gz: 7725a362a6049b3533e1db2c1be5c256581fb915519d274b89d3c9790f83e654d9470deb6c9148549fe905cf51e3ff6ee35794f6d4026feb357d23e2c07a1d74

data/src/commands/excel_to_x.rb

@@ -98,6 +98,11 @@ class ExcelToX
   #   * false - empty cells and zeros are treated as being different in tests. Numbers must match to full accuracy.
   attr_accessor :sloppy_tests
 
+  # Optional attribute, Boolean. Default true
+  #   * true - the compiler attempts to extract bits of calculation that appear in more than one formula into separate methods. This should increase performance
+  #   * false - the compiler leaves calculations fully expanded. This may make debugging easier
+  attr_accessor :extract_repeated_parts_of_formulae
+
   # Deprecated
   def run_in_memory=(boolean)
     $stderr.puts "The run_in_memory switch is deprecated (it is now always true). Please remove calls to it"
@@ -179,7 +184,7 @@ class ExcelToX
     replace_formulae_with_their_results
     inline_formulae_that_are_only_used_once
     remove_any_cells_not_needed_for_outputs
-    separate_formulae_elements
+    separate_formulae_elements if extract_repeated_parts_of_formulae
     replace_values_with_constants
     create_sorted_references_to_test
 
@@ -213,6 +218,9 @@ class ExcelToX
 
     # By default, tests allow empty cells and zeros to be treated as equivalent, and numbers only have to match to a 0.001 epsilon (if expected>1) or 0.001 delta (if expected<1)
     self.sloppy_tests ||= true
+
+    # 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
   end
   
 
@@ -811,21 +819,31 @@ class ExcelToX
     @sheetless_cell_reference_replacer ||= RewriteCellReferencesToIncludeSheetAst.new
 
     cells.each do |ref, ast|
-      @sheetless_cell_reference_replacer.worksheet = ref.first
-      @sheetless_cell_reference_replacer.map(ast)
-      @shared_string_replacer.map(ast)
-      @named_reference_replacer.default_sheet_name = ref.first
-      @named_reference_replacer.map(ast)
-      @table_reference_replacer.worksheet = ref.first
-      @table_reference_replacer.referring_cell = ref.last
-      @table_reference_replacer.map(ast)
-      @replace_ranges_with_array_literals_replacer.map(ast)
-      @replace_arithmetic_on_ranges_replacer.map(ast)
-      @replace_arrays_with_single_cells_replacer.map(ast)
-      @replace_string_joins_on_ranges_replacer.map(ast)
-      @wrap_formulae_that_return_arrays_replacer.map(ast)
-    end
+      begin
+        @sheetless_cell_reference_replacer.worksheet = ref.first
+        @sheetless_cell_reference_replacer.map(ast)
+        @shared_string_replacer.map(ast)
+        @named_reference_replacer.default_sheet_name = ref.first
+        @named_reference_replacer.map(ast)
+        @table_reference_replacer.worksheet = ref.first
+        @table_reference_replacer.referring_cell = ref.last
+        @table_reference_replacer.map(ast)
+        @replace_ranges_with_array_literals_replacer.map(ast)
+        #@replace_arithmetic_on_ranges_replacer.map(ast)
+
+        @replace_arrays_with_single_cells_replacer.ref = ref
+        a = @replace_arrays_with_single_cells_replacer.map(ast)
+        if @replace_arrays_with_single_cells_replacer.need_to_replace
+          cells[ref] = a
+        end
 
+        #@replace_string_joins_on_ranges_replacer.map(ast)
+        @wrap_formulae_that_return_arrays_replacer.map(ast)
+      rescue  Exception => e
+        log.fatal "Exception when simplifying #{ref}: #{ast}"
+        raise
+      end
+    end
   end
 
   # These types of cells don't conatain formulae and can therefore be skipped

data/src/compile/c/map_formulae_to_c.rb

@@ -148,6 +148,45 @@ class MapFormulaeToC < MapValuesToC
     "#{FUNCTIONS[:AVERAGEIFS]}(#{map(average_range)}, #{map_arguments_to_array(criteria)})"
   end
 
+  def function_if(condition, true_case, false_case = [:boolean_false])
+    true_code = map(true_case)
+    false_code = map(false_case)
+
+    condition_name = "condition#{@counter}"
+    result_name = "ifresult#{@counter}"
+    @counter += 1
+
+    initializers << "ExcelValue #{condition_name} = #{map(condition)};"
+    initializers << "ExcelValue #{result_name};"
+    initializers << "switch(#{condition_name}.type) {"
+    initializers << "case ExcelBoolean:"
+  	initializers << "  if(#{condition_name}.number == true) {"
+    initializers << "    #{result_name} = #{true_code};"
+    initializers << "  } else {"
+    initializers << "    #{result_name} = #{false_code};"
+    initializers << "  }"
+    initializers << "  break;"
+  	initializers << "case ExcelNumber:"
+    initializers << "  if(#{condition_name}.number == 0) {"
+    initializers << "    #{result_name} = #{false_code};"
+    initializers << "  } else {"
+    initializers << "    #{result_name} = #{true_code};"
+    initializers << "  }"
+    initializers << "  break;"
+	  initializers << "case ExcelEmpty: "
+    initializers << "  #{result_name} = #{false_code};"
+    initializers << "  break;"
+	  initializers << "case ExcelString:"
+    initializers << "case ExcelRange:"
+    initializers << "  #{result_name} = VALUE;"
+    initializers << "  break;"
+  	initializers << "case ExcelError:"
+    initializers << "  #{result_name} = #{condition_name};"
+    initializers << "  break;"
+    initializers << "}"
+
+    return result_name
+  end
   
   def any_number_of_argument_function(function_name,arguments)    
     "#{FUNCTIONS[function_name.to_sym]}(#{map_arguments_to_array(arguments)})"

data/src/excel_to_code.rb

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

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -2,32 +2,98 @@ require_relative '../excel'
 
 class ReplaceArraysWithSingleCellsAst
 
+  attr_accessor :ref
+  attr_accessor :need_to_replace
+
+  ERROR = [:error, :"#VALUE!"]
+
   def map(ast)
-    return ast unless ast.first == :array
-    ast[1][1]
+    @need_to_replace = false
+    return unless ast.is_a?(Array)
+    if ast.first == :array
+      @need_to_replace = true
+      return try_and_convert_array(ast)
+    else
+      do_map(ast)
+      ast
+    end
   end
-end
 
+  def do_map(ast)
+    return ast unless ast.is_a?(Array)
+    case ast.first
+    when :arithmetic
+      left, op, right = ast[1], ast[2], ast[3]
+      if left.first == :array || right.first == :array
+        left = try_and_convert_array(left)
+        right = try_and_convert_array(right)
+        ast.replace([:arithmetic, left, op, right])
+      else
+        ast[1..-1].each { |a| do_map(a) }
+      end
+    when :string_join
+      strings = ast[1..-1]
+      if strings.any? { |s| s.first == :array }
+        strings = strings.map { |s| try_and_convert_array(s) }
+        ast.replace([:string_join, *strings])
+      else
+        ast[1..-1].each { |a| do_map(a) }
+      end
+    else
+      ast[1..-1].each { |a| do_map(a) }
+    end
+  end
 
-class ReplaceArraysWithSingleCells
-  
-  def self.replace(*args)
-    self.new.replace(*args)
+  def try_and_convert_array(ast)
+    return ast unless ast.first == :array
+    return ast unless all_references?(ast)
+    #return ast unless ast[1..-1].all? { |c| c.first == :sheet_reference }
+    if ast.length == 2
+      single_row(ast)
+    elsif ast[1].length == 2
+      single_column(ast)
+    else
+      ERROR
+    end
   end
-  
-  def replace(input,output)
-  
-    replacer = ReplaceArraysWithSingleCellsAst.new
-    input.each_line do |line|
-      # Looks to match shared string lines
-      if line =~ /\[:array/
-        content = line.split("\t")
-        ast = eval(content.pop)
-        output.puts "#{content.join("\t")}\t#{replacer.map(ast).inspect}"          
-      else
-        output.puts line
+
+  def all_references?(ast)
+    ast[1..-1].all? do |row|
+      row[1..-1].all? do |cell|
+        cell.first == :sheet_reference
       end
     end
   end
-  
+
+  def single_row(ast)
+    r = Reference.for(ref.last)
+    r.calculate_excel_variables
+    column = r.excel_column
+    sheet = ref.first
+
+    cells = ast[1][1..-1]
+    match = cells.find do |cell|
+      s = cell[1]
+      c = cell[2][1][/([A-Za-z]{1,3})/,1]
+      sheet == s && column == c
+    end
+
+    match || ERROR
+  end
+
+  def single_column(ast)
+    r = Reference.for(ref.last)
+    r.calculate_excel_variables
+    row = r.excel_row
+    sheet = ref.first
+
+    cells = ast[1..-1].map { |row| row.last }
+    match = cells.find do |cell|
+      s = cell[1]
+      r = cell[2][1][/([A-Za-z]{1,3})(\d+)/,2]
+      sheet == s && row == r
+    end
+
+    match || ERROR
+  end
 end

data/src/simplify/replace_offsets_with_references.rb

@@ -29,6 +29,11 @@ class ReplaceOffsetsWithReferencesAst
     column_offset = ast[4]
     height = ast[5] || [:number, 1]
     width = ast[6] || [:number, 1]
+    [row_offset, column_offset, height, width].each do |arg|
+       next unless arg.first == :error
+       ast.replace(arg) 
+       return
+    end
     return unless [row_offset, column_offset, height, width].all? { |a| a.first == :number }
     if reference.first == :cell
       ast.replace(offset_cell(reference, row_offset, column_offset, height, width))

data/src/simplify/replace_ranges_with_array_literals.rb

@@ -16,19 +16,69 @@ class ReplaceRangesWithArrayLiteralsAst
     case ast[0]
     when :sheet_reference; return sheet_reference(ast)
     when :area; return area(ast)
+    when :function;
+      if ast[1] == :SUMIF
+        return sumif(ast)
+      else
+        map_args(ast)
+      end
     else
-      ast.each.with_index do |a,i|
-        next unless a.is_a?(Array)
-        case a[0]
-        when :sheet_reference; ast[i] = sheet_reference(a)
-        when :area; ast[i] = area(a)
-        else do_map(a)
+      map_args(ast)
+    end
+    ast
+  end
+
+  def map_args(ast)
+    ast.each.with_index do |a,i|
+      next unless a.is_a?(Array)
+      case a[0]
+      when :sheet_reference; ast[i] = sheet_reference(a)
+      when :area; ast[i] = area(a)
+      when :function
+        if ast[1] == :sumif
+          ast[i] = sumif(a)
+        else
+          do_map(a) 
         end
+      else 
+        do_map(a)
       end
     end
-    ast
   end
-  
+
+  # ARGH: SUMIF(A1:A10, 10, B5:B6) is interpreted by Excel as SUMIF(A1:A10, 10, B5:B15)
+  def sumif(ast)
+    # If only two arguments to SUMIF, won't be a problem
+    return map_args(ast) unless ast.length == 5
+    check_range, criteria, sum_range = ast[2], ast[3], ast[4]
+    return map_args(ast) unless [:area, :sheet_reference, :cell].include?(check_range.first)
+    return map_args(ast) unless [:area, :sheet_reference, :cell].include?(sum_range.first)
+    check_area = area_for(check_range)
+    sum_area = area_for(sum_range)
+
+    check_area.calculate_excel_variables
+    sum_area.calculate_excel_variables
+
+    return map_args(ast) if check_area.height  == sum_area.height && check_area.width == sum_area.width
+
+    new_sum_area = [:area, sum_area.excel_start.to_sym, sum_area.excel_start.offset(check_area.height, check_area.width).to_sym]
+
+    if sum_range.first == :sheet_reference
+      ast[4][2] = new_sum_area
+    else
+      ast[4] = new_sum_area
+    end
+    map_args(ast)
+  end
+
+  def area_for(ast)
+    case ast.first
+    when :cell then Area.for(ast[1])
+    when :area then Area.for("#{ast[1]}:#{ast[2]}")
+    when :sheet_reference then area_for(ast[2])
+    end
+  end
+
   # Of the form [:sheet_reference, sheet, reference]
   def sheet_reference(ast)
     @cache[ast] || calculate_expansion_for(ast)
@@ -40,16 +90,16 @@ class ReplaceRangesWithArrayLiteralsAst
     return ast unless reference.first == :area
     area = Area.for("#{reference[1]}:#{reference[2]}")
     a = area.to_array_literal(sheet)
-    
+
     # Don't convert single cell ranges
     result = if a.size == 2 && a[1].size == 2
-      a[1][1]
-    else
-      a
-    end
+               a[1][1]
+             else
+               a
+             end
     @cache[ast.dup] = result
   end
-  
+
   # Of the form [:area, start, finish]
   def area(ast)
     start = ast[1]
@@ -64,18 +114,18 @@ class ReplaceRangesWithArrayLiteralsAst
       a
     end
   end
-  
+
 end
 
 class ReplaceRangesWithArrayLiterals
-  
+
   def self.replace(*args)
     self.new.replace(*args)
   end
-  
+
   def replace(input,output)
     rewriter = ReplaceRangesWithArrayLiteralsAst.new
-  
+
     input.each_line do |line|
       # Looks to match shared string lines
       if line =~ /\[:area/
@@ -87,5 +137,5 @@ class ReplaceRangesWithArrayLiterals
       end
     end
   end
-  
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.15
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg