excel_to_code 0.2.15 → 0.2.16

data/src/compile/c/map_formulae_to_c.rb

@@ -36,6 +36,7 @@ class MapFormulaeToC < MapValuesToC
     :'COSH' => 'cosh',
     :'COUNT' => 'count',
     :'COUNTA' => 'counta',
+    :'ENSURE_IS_NUMBER' => 'ensure_is_number',
     :'EXP' => 'excel_exp',
     :'FIND2' => 'find_2',
     :'FIND3' => 'find',
@@ -53,6 +54,7 @@ class MapFormulaeToC < MapValuesToC
     :'LARGE' => 'large',
     :'LEFT1' => 'left_1',
     :'LEFT2' => 'left',
+    :'LEN' => 'len',
     :'LOG1' => 'excel_log',
     :'LOG2' => 'excel_log_2',
     :'MATCH2' => 'excel_match_2',
@@ -67,6 +69,8 @@ class MapFormulaeToC < MapValuesToC
     :'PV5' => 'pv_5',
     :'RANK2' => 'rank_2',
     :'RANK3' => 'rank',
+    :'RIGHT1' => 'right_1',
+    :'RIGHT2' => 'right',
     :'ROUND' => 'excel_round',
     :'ROUNDDOWN' => 'rounddown',
     :'ROUNDUP' => 'roundup',

data/src/compile/c/map_values_to_c.rb

@@ -18,6 +18,10 @@ class MapValuesToC
   def blank
     "BLANK"
   end
+
+  def inlined_blank
+    "ZERO"
+  end
   
   def constant(name)
     name

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -26,6 +26,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'COSH' => 'cosh',
     :'COUNT' => 'count',
     :'COUNTA' => 'counta',
+    :'ENSURE_IS_NUMBER' => 'ensure_is_number',
     :'EXP' => 'exp',
     :'FIND' => 'find',
     :'FORECAST' => 'forecast',
@@ -82,7 +83,12 @@ class MapFormulaeToRuby < MapValuesToRuby
   end
 
   def string_join(*strings)
-    "string_join(#{strings.map {|a| map(a)}.join(',')})"
+    strings = strings.map do |s|
+      s = [:string, ""] if s == [:inlined_blank]
+      s = map(s)
+    end
+
+    "string_join(#{strings.join(',')})"
   end
 
   def comparison(left,operator,right)

data/src/compile/ruby/map_values_to_ruby.rb

@@ -20,6 +20,10 @@ class MapValuesToRuby
   def blank
     "nil"
   end
+
+  def inlined_blank
+    "0.0"
+  end
   
   def constant(constant)
     map(constants[constant])

data/src/excel/area.rb

@@ -14,9 +14,13 @@ class Area < String
   end
   
   attr_reader :excel_start, :excel_finish
+
+  def unfix
+    calculate_excel_variables
+    Area.for("#{@excel_start.unfix}:#{@excel_finish.unfix}").calculate_excel_variables
+  end
   
   def calculate_excel_variables
-    return if @excel_variables_calculated
     if self =~ /([^:]+):(.*)/
       @excel_start = Reference.for($1)
       @excel_finish = Reference.for($2)
@@ -25,6 +29,7 @@ class Area < String
     end      
     @excel_start.calculate_excel_variables
     @excel_finish.calculate_excel_variables
+    self
   end
   
   def offset(row,column)

data/src/excel/excel_functions.rb

@@ -104,3 +104,5 @@ require_relative 'excel_functions/isblank'
 require_relative 'excel_functions/averageifs'
 
 require_relative 'excel_functions/forecast'
+
+require_relative 'excel_functions/ensure_is_number'

data/src/excel/excel_functions/ensure_is_number.rb

@@ -0,0 +1,7 @@
+module ExcelFunctions
+  
+  def ensure_is_number(a)
+    return number_argument(a)
+  end
+  
+end

data/src/excel/excel_functions/excel_if.rb

@@ -2,6 +2,7 @@ module ExcelFunctions
   
   def excel_if(condition,true_value,false_value = false)
     return condition if condition.is_a?(Symbol)
+    return false_value if condition == 0
     condition ? true_value : false_value
   end
   

data/src/excel/excel_functions/left.rb

@@ -4,6 +4,7 @@ module ExcelFunctions
     return string if string.is_a?(Symbol)
     return characters if characters.is_a?(Symbol)
     return nil if string == nil || characters == nil
+    return :value if characters < 0
     string = "TRUE" if string == true
     string = "FALSE" if string == false
     string.to_s.slice(0,characters)

data/src/excel/excel_functions/right.rb

@@ -4,10 +4,11 @@ module ExcelFunctions
     return string if string.is_a?(Symbol)
     return characters if characters.is_a?(Symbol)
     return nil if string == nil || characters == nil
+    return :value if characters < 0
     string = "TRUE" if string == true
     string = "FALSE" if string == false
     string = string.to_s
-    string.slice(string.length-characters,characters)
+    string.slice(string.length-characters,characters) || ""
   end
   
 end

data/src/excel/formula_peg.rb

@@ -67,7 +67,7 @@ class Formula < RubyPeg
   
   def comparison
     node :comparison do
-      (arithmetic || thing) && space && comparator && space && (arithmetic || thing)
+      (arithmetic || string_join || thing) && space && comparator && space && (arithmetic || string_join || thing)
     end
   end
   
@@ -111,7 +111,7 @@ class Formula < RubyPeg
   
   def external_reference
     node :external_reference do
-      terminal(/\[\d+\]!?/) && any_internal_reference
+      terminal(/\[\d+\]!?/) && (any_internal_reference || named_reference)
     end
   end
   

data/src/excel/formula_peg.txt

@@ -9,7 +9,7 @@ row								:= basic_type ( space `',' space basic_type )*
 basic_type						 = string | percentage | number | boolean
 string_join                     := (arithmetic | thing) (space `"&" space (arithmetic | thing))+
 arithmetic                      := thing (space operator space thing)+
-comparison                      := (arithmetic | thing) space comparator space (arithmetic | thing)
+comparison                      := (arithmetic | string_join | thing) space comparator space (arithmetic | string_join | thing)
 comparator                      := '>=' | '<=' | '<>' | '>' | '<' | '='
 string                          := `'"' /(""|[^"])*/ `'"'
 any_reference                    = external_reference | any_internal_reference
@@ -17,7 +17,7 @@ any_internal_reference           = table_reference | local_table_reference | she
 percentage                      := /[-+]?[0-9]+\.?[0-9]*/ `'%'
 number                          := /[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/
 operator                        := '+' | '-' | '/' | '*' | '^'
-external_reference              := /\[\d+\]!?/ any_internal_reference
+external_reference              := /\[\d+\]!?/ (any_internal_reference | named_reference)
 table_reference                 := table_name `'[' (range_structured_reference | short_range_structured_reference | complex_structured_reference | overly_structured_reference | simple_structured_reference) `']'
 local_table_reference           := `'[' (range_structured_reference | short_range_structured_reference | complex_structured_reference | overly_structured_reference | simple_structured_reference) `']'
 table_name                       = /[.\p{Word}_]+/

data/src/excel/reference.rb

@@ -41,6 +41,7 @@ class Reference < String
     @excel_row_number = @excel_row.to_i
     @excel_column_number = @@column_number_for_column[@excel_column]
     @excel_variables_calculated = true
+    self
   end
     
   def offset(rows,columns)

data/src/excel_to_code.rb

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

data/src/extract/extract_data_from_worksheet.rb

@@ -2,6 +2,8 @@ require 'ox'
 
 class ExtractDataFromWorksheet < ::Ox::Sax
 
+  attr_accessor :only_extract_values
+
   attr_accessor :table_rids
   attr_accessor :worksheets_dimensions
   attr_accessor :values
@@ -75,6 +77,8 @@ class ExtractDataFromWorksheet < ::Ox::Sax
       @values[key] = @fp.map(ast)
     when :f
       @current_element.pop
+      return if only_extract_values
+
       unless @formula.empty?
         formula_text = @formula.join.gsub(/[\r\n]+/,'')
         ast = @fp.parse(formula_text)

data/src/simplify/inline_formulae.rb

@@ -1,6 +1,8 @@
+module BlankCell; end
+
 class InlineFormulaeAst
 
-  BLANK = [:blank]
+  BLANK = [:inlined_blank]
   
   attr_accessor :references, :current_sheet_name, :inline_ast
   attr_accessor :count_replaced

data/src/simplify/map_formulae_to_values.rb

@@ -28,7 +28,7 @@ class MapFormulaeToValues
     # FIXME: Remove references to this method
   end
 
-  DO_NOT_MAP = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :sheet_reference => true, :cell => true}
+  DO_NOT_MAP = {:number => true, :string => true, :blank => true, :inlined_blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :sheet_reference => true, :cell => true}
 
   def map(ast)
     ast[1..-1].each do |a| 
@@ -62,14 +62,14 @@ class MapFormulaeToValues
     elsif l == 0
       case operator.last
       when :+ 
-        ast.replace(right)
+        ast.replace(n(right))
       when :*, :/, :^
         ast.replace([:number, 0])
       end
     elsif r == 0
       case operator.last
       when :+, :-
-        ast.replace(left)
+        ast.replace(n(left))
       when :* 
         ast.replace([:number, 0])
       when :/
@@ -80,19 +80,24 @@ class MapFormulaeToValues
     elsif l == 1
       case operator.last
       when :*
-        ast.replace(right)
+        ast.replace(n(right))
       when :^
         ast.replace([:number, 1])
       end
     elsif r == 1
       case operator.last
       when :*, :/, :^
-        ast.replace(left)
+        ast.replace(n(left))
       end
     end
     ast
   end
 
+  def n(ast)
+    return ast if ast[0] == :function && ast[1] == :ENSURE_IS_NUMBER
+    [:function, :ENSURE_IS_NUMBER, ast]
+  end
+
   def comparison(ast)
     left, operator, right = ast[1], ast[2], ast[3]
     l = value(left)
@@ -108,7 +113,9 @@ class MapFormulaeToValues
   
   # [:string_join, stringA, stringB, ...]
   def string_join(ast)
-    values = ast[1..-1].map { |a| value(a) } 
+    values = ast[1..-1].map do |a| 
+        value(a, "")
+    end
     return if values.any? { |a| a == :not_a_value }
     ast.replace(ast_for_value(@calculator.string_join(*values)))
   end
@@ -123,18 +130,45 @@ class MapFormulaeToValues
     if respond_to?("map_#{name.to_s.downcase}")
       send("map_#{name.to_s.downcase}",ast)
     else
-      values = ast[2..-1].map { |a| value(a) }
-      return if values.any? { |a| a == :not_a_value }
-      ast.replace(formula_value(name,*values))
+      normal_function(ast)
     end
   end
 
+  def normal_function(ast, inlined_blank = 0)
+    values = ast[2..-1].map { |a| value(a, inlined_blank) }
+    return if values.any? { |a| a == :not_a_value }
+    ast.replace(formula_value( ast[1],*values))
+  end
+
+  def map_right(ast)
+    normal_function(ast, "")
+  end
+
+  def map_left(ast)
+    normal_function(ast, "")
+  end
+
+  def map_mid(ast)
+    normal_function(ast, "")
+  end
+
+  def map_len(ast)
+    normal_function(ast, "")
+  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))
+  end
+
   # [:function, "COUNT", range]
   def map_count(ast)
-    range = ast[2]
-    return unless [:array, :cell, :sheet_reference].include?(range.first)
-    range = array_as_values(range)
-    ast.replace(ast_for_value(range.size * range.first.size))
+    values = ast[2..-1].map { |a| value(a, nil) }
+    return if values.any? { |a| a == :not_a_value }
+    ast.replace(formula_value( ast[1],*values))
   end
   
   # [:function, "INDEX", array, row_number, column_number]
@@ -249,10 +283,11 @@ class MapFormulaeToValues
     :"#NUM!" => :num
   }
     
-  def value(ast)
-    return extract_values_from_array(ast) if ast.first == :array
+  def value(ast, inlined_blank = 0)
+    return extract_values_from_array(ast, inlined_blank) if ast.first == :array
     case ast.first
     when :blank; nil
+    when :inlined_blank; inlined_blank
     when :null; nil
     when :number; ast[1]
     when :percentage; ast[1]/100.0
@@ -264,10 +299,10 @@ class MapFormulaeToValues
     end
   end
   
-  def extract_values_from_array(ast)
+  def extract_values_from_array(ast, inlined_blank = 0)
     ast[1..-1].map do |row|
       row[1..-1].map do |cell|
-        v = value(cell)
+        v = value(cell, inlined_blank)
         return :not_a_value if v == :not_a_value
         v
       end

data/src/simplify/replace_arithmetic_on_ranges.rb

@@ -2,10 +2,59 @@ class ReplaceArithmeticOnRangesAst
     
   def map(ast)
     return ast unless ast.is_a?(Array)
-    arithmetic(ast) if ast.first == :arithmetic
     ast.each { |a| map(a) }
+    arithmetic(ast) if ast.first == :arithmetic
+    comparison(ast) if ast.first == :comparison
     ast
   end
+
+  # FIXME: DRY THIS UP
+  def comparison(ast)
+    left, operator, right = ast[1], ast[2], ast[3]
+    # 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]
+        end
+      )
+
+    # 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)]
+        end
+      )
+    
+    # now array both sides
+    elsif left.first == :array && right.first == :array 
+      ast.replace(
+        left.map.with_index do |row, i|
+          if row == :array
+            row
+          else
+            row.map.with_index do |cell, j|
+              if cell == :row
+                cell
+              elsif i >= left.length || i >= right.length || j >= left[1].length || j >= right[1].length
+                [:error, "#VALUE!"]
+              else
+                [:comparison, map(left[i][j]), operator, map(right[i][j])]
+              end
+            end
+          end
+        end
+      )
+    else
+      map(left)
+      map(right)
+    end
+  end
+
   
   # Format [:artithmetic, left, operator, right] 
   # should have removed arithmetic with more than one operator
@@ -41,7 +90,7 @@ class ReplaceArithmeticOnRangesAst
             row.map.with_index do |cell, j|
               if cell == :row
                 cell
-              elsif i >= left.length || i >= right.length || j >= left.first.length || j >= right.first.length
+              elsif i >= left.length || i >= right.length || j >= left[1].length || j >= right[1].length
                 [:error, "#VALUE!"]
               else
                 [:arithmetic, map(left[i][j]), operator, map(right[i][j])]

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -12,7 +12,12 @@ class ReplaceArraysWithSingleCellsAst
     return unless ast.is_a?(Array)
     if ast.first == :array
       @need_to_replace = true
-      return try_and_convert_array(ast)
+      new_ast = try_and_convert_array(ast)
+      return ERROR if new_ast.first == :array
+      return new_ast
+    # Special case, only change if at the top level
+    elsif ast[0] == :function && ast[1] == :CHOOSE && check_choose(ast)
+      # Replacement made in check
     else
       do_map(ast)
       ast
@@ -39,11 +44,62 @@ class ReplaceArraysWithSingleCellsAst
       else
         ast[1..-1].each { |a| do_map(a) }
       end
+    when :function
+      if ast[1] == :SUMIF && ast[3].first == :array
+        ast[3] = try_and_convert_array(ast[3])
+      elsif ast[1] == :SUMIFS && check_sumifs(ast)
+        # Replacement madein check_sumif function
+      elsif ast[1] == :MATCH && check_match(ast)
+        # Replacement made in check_match function
+      elsif ast[1] == :INDIRECT && check_indirect(ast)
+        # Replacement made in check function
+      else
+        ast[2..-1].each { |a| do_map(a) }
+      end
     else
       ast[1..-1].each { |a| do_map(a) }
     end
   end
 
+  def check_choose(ast)
+    replacement_made = false
+    i = 2
+    while i < ast.length
+      if ast[i].first == :array
+        replacement_made = true
+        ast[i] = try_and_convert_array(ast[i])
+      end
+      i +=1
+    end
+    replacement_made
+  end
+
+  def check_match(ast)
+    return false unless ast[2].first == :array
+    ast[2] = try_and_convert_array(ast[2])
+    ast[3..-1].each { |a| do_map(a) }
+    true
+  end
+
+  def check_indirect(ast)
+    return false unless ast[2].first == :array
+    ast[2] = try_and_convert_array(ast[2])
+    true
+  end
+
+  def check_sumifs(ast)
+    replacement_made = false
+    i = 4
+    while i < ast.length
+      if ast[i].first == :array
+        replacement_made = true
+        ast[i] = try_and_convert_array(ast[i])
+      end
+      i +=2
+    end
+    replacement_made
+  end
+
   def try_and_convert_array(ast)
     return ast unless ast.first == :array
     return ast unless all_references?(ast)
@@ -53,7 +109,7 @@ class ReplaceArraysWithSingleCellsAst
     elsif ast[1].length == 2
       single_column(ast)
     else
-      ERROR
+      ast
     end
   end
 
@@ -78,7 +134,7 @@ class ReplaceArraysWithSingleCellsAst
       sheet == s && column == c
     end
 
-    match || ERROR
+    match || ast
   end
 
   def single_column(ast)
@@ -94,6 +150,6 @@ class ReplaceArraysWithSingleCellsAst
       sheet == s && row == r
     end
 
-    match || ERROR
+    match || ast
   end
 end