excel_to_code 0.1.23 → 0.2.0

data/src/simplify/remove_cells.rb

@@ -7,12 +7,19 @@ class RemoveCells
     self.new.rewrite(*args)
   end
   
-  def rewrite(input,output)
-    input.each_line do |line|
-      ref = line[/^(.*?)\t/,1]
-      if cells_to_keep.has_key?(ref)
-        output.puts line
-      end
+  def rewrite(formulae)
+    formulae.delete_if do |ref, ast|
+      delete_ref?(ref)
     end
+    formulae
+  end
+
+  def delete_ref?(ref)
+    sheet = ref.first
+    cell = ref.last
+    cells_to_keep_in_sheet = cells_to_keep[sheet]
+    return true unless cells_to_keep_in_sheet
+    return false if cells_to_keep_in_sheet.has_key?(cell)
+    true
   end
 end

data/src/simplify/replace_arithmetic_on_ranges.rb

@@ -2,43 +2,57 @@ class ReplaceArithmeticOnRangesAst
     
   def map(ast)
     return ast unless ast.is_a?(Array)
-    operator = ast[0]
-    if respond_to?(operator)
-      send(operator,*ast[1..-1])
-    else
-      [operator,*ast[1..-1].map {|a| map(a) }]
-    end
+    arithmetic(ast) if ast.first == :arithmetic
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def arithmetic(left, operator, right)
+  # Format [:artithmetic, left, operator, right] 
+  # should have removed arithmetic with more than one operator
+  # in an earlier transformation
+  def arithmetic(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
-      mapped_right = map(right)
-      array_map(left) do |cell|
-        [:arithmetic, map(cell), operator, mapped_right]
-      end
+      map(right)
+      ast.replace(
+        array_map(left) do |cell|
+          [:arithmetic, map(cell), operator, right]
+        end
+      )
+
+    # array on the right next
     elsif left.first != :array && right.first == :array
-      mapped_left = map(left)
-      array_map(right) do |cell|
-        [:arithmetic, mapped_left, operator, map(cell)]
-      end
+      map(left)
+      ast.replace(
+        array_map(right) do |cell|
+          [:arithmetic, left, operator, map(cell)]
+        end
+      )
+    
+    # now array both sides
     elsif left.first == :array && right.first == :array 
-      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.first.length || j >= right.first.length
-              [:error, "#VALUE!"]
-            else
-              [:arithmetic, map(left[i][j]), operator, map(right[i][j])]
+      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.first.length || j >= right.first.length
+                [:error, "#VALUE!"]
+              else
+                [:arithmetic, map(left[i][j]), operator, map(right[i][j])]
+              end
             end
           end
         end
-      end
+      )
     else
-      [:arithmetic, map(left), operator, map(right)]
+      map(left)
+      map(right)
     end
   end
 

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -1,5 +1,14 @@
 require_relative '../excel'
 
+class ReplaceArraysWithSingleCellsAst
+
+  def map(ast)
+    return ast unless ast.first == :array
+    ast[1][1]
+  end
+end
+
+
 class ReplaceArraysWithSingleCells
   
   def self.replace(*args)
@@ -8,16 +17,13 @@ class ReplaceArraysWithSingleCells
   
   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)
-        if ast.first == :array
-          output.puts "#{content.join("\t")}\t#{ast[1][1].inspect}"          
-        else
-          output.puts line
-        end
+        output.puts "#{content.join("\t")}\t#{replacer.map(ast).inspect}"          
       else
         output.puts line
       end

data/src/simplify/replace_column_with_column_number.rb

@@ -1,34 +1,42 @@
 class ReplaceColumnWithColumnNumberAST
     
-  attr_accessor :replacements_made_in_the_last_pass
+  attr_accessor :count_replaced
+  attr_accessor :replacement_made
 
   def initialize
-    @replacements_made_in_the_last_pass = 0
+    @count_replaced = 0
+  end
+
+  def replace(ast)
+    @replacement_made = false
+    map(ast)
+    @replacement_made
   end
    
   def map(ast)
     return ast unless ast.is_a?(Array)
-    operator = ast[0]
-    if respond_to?(operator)
-      send(operator,*ast[1..-1])
-    else
-      [operator,*ast[1..-1].map {|a| map(a) }]
-    end
+    function(ast) if ast[0] == :function
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def function(name,*args)
-    if name == "COLUMN" && args.size == 1 && [:cell, :sheet_reference].include?(args[0][0])
-      if args[0][0] == :cell
-        reference = Reference.for(args[0][1])
-      elsif args[0][0] == :sheet_reference
-        reference = Reference.for(args[0][2][1])
-      end
-      reference.calculate_excel_variables
-      @replacements_made_in_the_last_pass += 1
-      [:number, reference.excel_column_number.to_s]
-    else
-      [:function,name,*args.map { |a| map(a) }]
+  # Should be of the form [:function, "COLUMN", [:sheet_reference, sheet, ref]] 
+  
+  REF_TYPES = {:cell => true, :sheet_reference => true}
+
+  def function(ast)
+    return unless ast[1] == :COLUMN
+    return unless ast.size == 3
+    return unless REF_TYPES.has_key?(ast[2][0])
+    if ast[2][0] == :cell
+      reference = Reference.for(ast[2][1])
+    elsif ast[2][0] == :sheet_reference
+      reference = Reference.for(ast[2][2][1])
     end
+    reference.calculate_excel_variables
+    @count_replaced += 1
+    @replacement_made = true
+    ast.replace( CachingFormulaParser.map([:number, reference.excel_column_number]))
   end
 
 end
@@ -40,19 +48,19 @@ class ReplaceColumnWithColumnNumber
     self.new.replace(*args)
   end
 
-  attr_accessor :replacements_made_in_the_last_pass
+  attr_accessor :count_replaced
   
   def replace(input,output)
     rewriter = ReplaceColumnWithColumnNumberAST.new
     input.each_line do |line|
       # Looks to match lines with references
-      if line =~ /"COLUMN"/
+      if line =~ /:COLUMN/
         ref, ast = line.split("\t")
         output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
       else
         output.puts line
       end
     end
-    @replacements_made_in_the_last_pass = rewriter.replacements_made_in_the_last_pass
+    @count_replaced = rewriter.count_replaced
   end
 end

data/src/simplify/replace_common_elements_in_formulae.rb

@@ -5,29 +5,28 @@ class ReplaceCommonElementsInFormulae
   end
   
   attr_accessor :common_elements
+  attr_accessor :common_elements_used
   
-  def replace(input,common,output)
-    @common_elements ||= {}
-    common.readlines.map do |a|
-      ref, element = a.split("\t")
-      @common_elements[element.strip] = [:cell, ref]
-    end
-    input.each_line do |line|
-      ref, formula = line.split("\t")
-      output.puts "#{ref}\t#{replace_repeated_formulae(eval(formula)).inspect}"
+  def replace(input, common_elements)
+    @common_elements_used ||= Hash.new { |h, k| h[k] = 0 }
+    @common_elements = common_elements
+    input.each do |ref, ast|
+      replace_repeated_formulae(ast)
     end
+    input
   end
+
+  VALUES = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :sheet_reference => true, :cell => true, :row => true}
   
   def replace_repeated_formulae(ast)
     return ast unless ast.is_a?(Array)
-    return ast if [:number,:string,:blank,:null,:error,:boolean_true,:boolean_false,:sheet_reference,:cell, :row].include?(ast.first)    
-    string = ast.inspect
-    return ast if string.length < 20
-    if @common_elements.has_key?(string)
-      return @common_elements[string]
-    end
-    ast.map do |a|
-      replace_repeated_formulae(a)
+    return ast if VALUES.has_key?(ast.first)    
+    replacement = @common_elements[ast]
+    if replacement
+      @common_elements_used[replacement] += 1
+      ast.replace(replacement)
+    else
+      ast.each { |a| replace_repeated_formulae(a) }
     end
   end   
 

data/src/simplify/replace_indirects_with_references.rb

@@ -2,32 +2,37 @@ require_relative '../excel/formula_peg'
 
 class ReplaceIndirectsWithReferencesAst
   
-  attr_accessor :replacements_made_in_the_last_pass
+  attr_accessor :count_replaced
+  attr_accessor :replacement_made
 
   def initialize
-    @replacements_made_in_the_last_pass = 0
+    @count_replaced = 0
+  end
+
+  def replace(ast)
+    @replacement_made = false
+    map(ast)
+    @replacement_made
   end
    
   def map(ast)
     return ast unless ast.is_a?(Array)
-    operator = ast[0]
-    if respond_to?(operator)
-      send(operator,*ast[1..-1])
-    else
-      [operator,*ast[1..-1].map {|a| map(a) }]
-    end
+    function(ast) if ast[0] == :function
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def function(name,*args)
-    if name == "INDIRECT" && args[0][0] == :string
-      @replacements_made_in_the_last_pass += 1
-      Formula.parse(args[0][1]).to_ast[1]
-    elsif name == "INDIRECT" && args[0][0] == :error
-      @replacements_made_in_the_last_pass += 1
-      args[0]
-    else
-      puts "indirect #{[:function,name,*args.map { |a| map(a) }].inspect} not replaced" if name == "INDIRECT"
-      [:function,name,*args.map { |a| map(a) }]
+  def function(ast)
+    return unless ast[1] == :INDIRECT
+    args = ast[2..-1]
+    if args[0][0] == :string
+      @count_replaced += 1
+      @replacement_made = true
+      ast.replace(CachingFormulaParser.parse(args[0][1]))
+    elsif args[0][0] == :error
+      @count_replaced += 1
+      @replacement_made = true
+      ast.replace(args[0])
     end
   end
 end
@@ -39,19 +44,19 @@ class ReplaceIndirectsWithReferences
     self.new.replace(*args)
   end
 
-  attr_accessor :replacements_made_in_the_last_pass
+  attr_accessor :count_replaced
   
   def replace(input,output)
     rewriter = ReplaceIndirectsWithReferencesAst.new
     input.each_line do |line|
       # Looks to match lines with references
-      if line =~ /"INDIRECT"/
+      if line =~ /:INDIRECT/
         ref, ast = line.split("\t")
         output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
       else
         output.puts line
       end
     end
-    @replacements_made_in_the_last_pass = rewriter.replacements_made_in_the_last_pass
+    @count_replaced = rewriter.count_replaced
   end
 end

data/src/simplify/replace_named_references.rb

@@ -3,22 +3,15 @@ class NamedReferences
   attr_accessor :named_references
   
   def initialize(refs)
-    @named_references = {}
-    refs.each do |line|
-      sheet, name, reference = line.split("\t")
-      @named_references[sheet.downcase] ||= {}
-      @named_references[sheet.downcase][name.downcase] = eval(reference)
-    end
+    @named_references = refs
   end
   
   def reference_for(sheet,named_reference)
     sheet = sheet.downcase
-    named_reference = named_reference.downcase
-    if @named_references.has_key?(sheet)
-      @named_references[sheet][named_reference] || @named_references[""][named_reference] || [:error, "#NAME?"]
-    else
-      @named_references[""][named_reference] || [:error, "#NAME?"]
-    end
+    named_reference = named_reference.downcase.to_sym
+    @named_references[[sheet, named_reference]] ||
+    @named_references[named_reference] ||
+    [:error, :"#NAME?"]
   end
   
 end
@@ -27,30 +20,32 @@ class ReplaceNamedReferencesAst
   
   attr_accessor :named_references, :default_sheet_name
   
-  def initialize(named_references, default_sheet_name)
+  def initialize(named_references, default_sheet_name = nil)
     @named_references, @default_sheet_name = named_references, default_sheet_name
+    @named_references = NamedReferences.new(@named_references) unless @named_references.is_a?(NamedReferences)
   end
   
   def map(ast)
     return ast unless ast.is_a?(Array)
-    operator = ast[0]
-    if respond_to?(operator)
-      send(operator,*ast[1..-1])
-    else
-      [operator,*ast[1..-1].map {|a| map(a) }]
+    case ast[0]
+    when :sheet_reference; sheet_reference(ast)
+    when :named_reference; named_reference(ast)
     end
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def sheet_reference(sheet,reference)
-    if reference.first == :named_reference
-      named_references.reference_for(sheet,reference.last)
-    else
-      [:sheet_reference,sheet,reference]
-    end    
+  # Format [:sheet_reference, sheet,  reference]
+  def sheet_reference(ast)
+    reference = ast[2]
+    return unless reference.first == :named_reference
+    sheet = ast[1]
+    ast.replace(named_references.reference_for(sheet, reference.last))
   end
   
-  def named_reference(name)
-    named_references.reference_for(default_sheet_name,name)
+  # Format [:named_reference, name]
+  def named_reference(ast)
+    ast.replace(named_references.reference_for(default_sheet_name, ast[1]))
   end
   
 end
@@ -58,15 +53,15 @@ end
 
 class ReplaceNamedReferences
   
-  attr_accessor :sheet_name
+  attr_accessor :sheet_name, :named_references
   
-  def self.replace(values,sheet_name,named_references,output)
-    self.new.replace(values,sheet_name,named_references,output)
+  def self.replace(*args)
+    self.new.replace(*args)
   end
   
   # Rewrites ast with named references
-  def replace(values,named_references,output)
-    named_references = NamedReferences.new(named_references.readlines)
+  def replace(values,output)
+    named_references = NamedReferences.new(@named_references)
     rewriter = ReplaceNamedReferencesAst.new(named_references,sheet_name)
     values.each_line do |line|
       # Looks to match shared string lines