excel_to_code 0.1.23 → 0.2.0

data/src/simplify/replace_offsets_with_references.rb

@@ -1,42 +1,39 @@
 class ReplaceOffsetsWithReferencesAst
 
-  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 == "OFFSET"
-      try_to_replace_offset(*args)
-    else
-      [:function,name,*args.map { |a| map(a) }]
-    end
-  end
-
-  def try_to_replace_offset(reference, row_offset, column_offset, height = [:number, 1], width = [:number, 1])
-    if [row_offset, column_offset, height, width].all? { |a| a.first == :number }
-      if reference.first == :cell
-        offset_cell(reference, row_offset, column_offset, height, width)
-      elsif reference.first == :sheet_reference && reference[2].first == :cell
-        [:sheet_reference, reference[1], offset_cell(reference[2], row_offset, column_offset, height, width)]
-      else
-        puts "#{[:function, "OFFSET", reference, row_offset, column_offset, height, width]} not replaced"
-        [:function, "OFFSET", reference, row_offset, column_offset, height, width]
-      end
-    else
-        puts "#{[:function, "OFFSET", reference, row_offset, column_offset, height, width]} not replaced"
-        [:function, "OFFSET", reference, row_offset, column_offset, height, width]
+  def function(ast)
+    name = ast[1]
+    args = ast[2..-1]
+    return unless ast[1] == :OFFSET
+    reference = ast[2]
+    row_offset = ast[3]
+    column_offset = ast[4]
+    height = ast[5] || [:number, 1]
+    width = ast[6] || [:number, 1]
+    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))
+    elsif reference.first == :sheet_reference && reference[2].first == :cell
+      ast.replace([:sheet_reference, reference[1], offset_cell(reference[2], row_offset, column_offset, height, width)])
     end
   end
 
@@ -48,8 +45,10 @@ class ReplaceOffsetsWithReferencesAst
     height = height[1].to_i
     width = width[1].to_i
 
-    @replacements_made_in_the_last_pass += 1
-    reference = Reference.for(reference.gsub("$",""))
+    @count_replaced += 1
+    @replacement_made = true
+
+    reference = Reference.for(reference).unfix
     start_reference = reference.offset(row_offset.to_i, column_offset.to_i)
     end_reference = reference.offset(row_offset.to_i + height.to_i - 1, column_offset.to_i + width.to_i - 1)
     if start_reference == end_reference
@@ -68,19 +67,19 @@ class ReplaceOffsetsWithReferences
     self.new.replace(*args)
   end
   
-  attr_accessor :replacements_made_in_the_last_pass
+  attr_accessor :count_replaced
   
   def replace(input,output)
     rewriter = ReplaceOffsetsWithReferencesAst.new
     input.each_line do |line|
       # Looks to match lines with references
-      if line =~ /"OFFSET"/
+      if line =~ /:OFFSET/
         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_ranges_with_array_literals.rb

@@ -1,40 +1,68 @@
 require_relative '../excel'
 
 class ReplaceRangesWithArrayLiteralsAst
+  def initialize
+    @cache = {}
+  end
+
   def map(ast)
-    if ast.is_a?(Array)
-      operator = ast.shift
-      if respond_to?(operator)
-        send(operator,*ast)
-      else
-        [operator,*ast.map {|a| map(a) }]
-      end
+    r = do_map(ast)
+    ast.replace(r) unless r.object_id == ast.object_id
+    ast
+  end
+
+  def do_map(ast)
+    return ast unless ast.is_a?(Array)
+    case ast[0]
+    when :sheet_reference; return sheet_reference(ast)
+    when :area; return area(ast)
     else
-      return 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)
+        else do_map(a)
+        end
+      end
     end
+    ast
   end
   
-  def sheet_reference(sheet,reference)
-    if reference.first == :area
-      area = Area.for("#{reference[1]}:#{reference[2]}")
-      a = area.to_array_literal(sheet)
-      
-      # Don't convert single cell ranges
-      return a[1][1] if a.size == 2 && a[1].size == 2
-      a
+  # Of the form [:sheet_reference, sheet, reference]
+  def sheet_reference(ast)
+    @cache[ast] || calculate_expansion_for(ast)
+  end
 
+  def calculate_expansion_for(ast)
+    sheet = ast[1]
+    reference = ast[2]
+    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
-      [:sheet_reference,sheet,reference]
+      a
     end
+    @cache[ast.dup] = result
   end
   
-  def area(start,finish)
+  # Of the form [:area, start, finish]
+  def area(ast)
+    start = ast[1]
+    finish = ast[2]
     area = Area.for("#{start}:#{finish}")
     a = area.to_array_literal
 
     # Don't convert single cell ranges
-    return a[1][1] if a.size == 2 && a[1].size == 2
-    a
+    if a.size == 2 && a[1].size == 2
+      a[1][1]
+    else
+      a
+    end
   end
   
 end

data/src/simplify/replace_shared_strings.rb

@@ -3,26 +3,28 @@ class ReplaceSharedStringAst
   attr_accessor :shared_strings
   
   def initialize(shared_strings)
-    @shared_strings = shared_strings.map do |s|
-      s[/^(.*?)\n$/,1]
-    end
+    @shared_strings = shared_strings
   end
   
+  # This is convoluted so as to always
+  # return the same shared string
   def map(ast)
-    if ast.is_a?(Array)
-      operator = ast.shift
-      if respond_to?(operator)
-        send(operator,*ast)
+    return ast unless ast.is_a?(Array)
+    return shared_string(ast) if ast[0] == :shared_string
+    ast.each.with_index do |a, i|
+      next unless a.is_a?(Array)
+      if a[0] == :shared_string
+        ast[i] = shared_string(a)
       else
-        [operator,*ast.map {|a| map(a) }]
+        map(a)
       end
-    else
-      return ast
     end
+    ast
   end
   
-  def shared_string(string_id)
-    [:string,shared_strings[string_id.to_i]]
+  # Format [:shared_string, string_id]
+  def shared_string(ast)
+    ast.replace(shared_strings[ast[1].to_i])
   end
 end
   
@@ -35,7 +37,7 @@ class ReplaceSharedStrings
   
   # Rewrites ast with shared strings to strings
   def replace(values,shared_strings,output)
-    rewriter = ReplaceSharedStringAst.new(shared_strings.readlines)
+    rewriter = ReplaceSharedStringAst.new(shared_strings)
     values.each_line do |line|
       # Looks to match shared string lines
       if line =~ /\[:shared_string/

data/src/simplify/replace_string_join_on_ranges.rb

@@ -2,17 +2,15 @@ class ReplaceStringJoinOnRangesAST
     
   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
+    string_join(ast) if ast[0] == :string_join
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def string_join(*strings)
+  def string_join(ast)
+    strings = ast[1..-1]
     # Make sure there is actually a conversion to do
-    return [:string_join, *strings] unless strings.any? { |s| s.first == :array }
+    return unless strings.any? { |s| s.first == :array }
     # Now work out the largest dimensions
     # Arrays look like this [:array, [:row, 1, 2, 3], [:row, 4, 5, 6]]
     max_rows = 0
@@ -37,7 +35,7 @@ class ReplaceStringJoinOnRangesAST
       end
       result << row
     end
-    result       
+    ast.replace(result)
   end
 
   def select_from(maybe_array, row_index, column_index)

data/src/simplify/replace_table_references.rb

@@ -8,25 +8,30 @@ class ReplaceTableReferenceAst
   
   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 :table_reference; table_reference(ast)
+    when :local_table_reference; local_table_reference(ast)
     end
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def table_reference(table_name,table_reference)
-    return [:error,"#REF!"] unless tables.has_key?(table_name.downcase)
-    tables[table_name.downcase].reference_for(table_name,table_reference,worksheet,referring_cell)
+  # Of the format [:table_reference, table_name, table_reference]
+  def table_reference(ast)
+    table_name = ast[1]
+    table_reference = ast[2]
+    return ast.replace([:error, :"#REF!"]) unless tables.has_key?(table_name.downcase)
+    ast.replace(tables[table_name.downcase].reference_for(table_name,table_reference,worksheet,referring_cell))
   end
   
-  def local_table_reference(table_reference)
+  # Of the format [:local_table_reference, table_reference]
+  def local_table_reference(ast)
+    table_reference = ast[1]
     table = tables.values.find do |table|
       table.includes?(worksheet,referring_cell)
     end
-    return [:error,"#REF!"] unless table
-    table.reference_for(table.name,table_reference,worksheet,referring_cell)
+    return ast.replace([:error, :"#REF!"]) unless table
+    ast.replace(table.reference_for(table.name,table_reference,worksheet,referring_cell))
   end
   
 end

data/src/simplify/replace_values_with_constants.rb

@@ -6,17 +6,19 @@ class MapValuesToConstants
     count = 0
     @constants = Hash.new do |hash,key|
       count += 1
-      hash[key] = "C#{count}"
+      hash[key] = "constant#{count}"
     end
   end
   
+  POTENTIAL_CONSTANTS = { :number => true, :percentage => true, :string => true}
+
   def map(ast)
     return ast unless ast.is_a?(Array)
     operator = ast[0]
-    if [:number,:percentage,:string].include?(operator)
-      [:constant, constants[ast]]
+    if POTENTIAL_CONSTANTS.has_key?(operator)
+      ast.replace([:constant, constants[ast.dup]])
     else
-      [operator,*ast[1..-1].map {|a| map(a) }]
+      ast.each { |a| map(a) }
     end
   end
 

data/src/simplify/simplify_arithmetic.rb

@@ -2,31 +2,45 @@ class SimplifyArithmeticAst
     
   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 :brackets; brackets(ast)
+    when :arithmetic; arithmetic(ast)
     end
+    ast.each { |a| map(a) }
+    ast
   end
   
-  def brackets(*args)
-    raise NotSupportedException.new("Multiple arguments not supported in brackets #{args.inspect}") if args.size > 1
-    map(args.first)
+  def brackets(ast)
+    raise NotSupportedException.new("Multiple arguments not supported in brackets #{args.inspect}") if ast.size > 2
+    ast.replace(map(ast[1]))
   end
   
-  def arithmetic(*args)
-    return map(args.first) if args.size == 1
-    return [:arithmetic,*args.map {|a| map(a) }] if args.size == 3
-    [['^'],['*','/'],['+','-']].each do |op|
-      i = args.find_index { |a| a[0] == :operator && op.include?(a[1])}
-      next unless i
-      pre_operation = i == 1 ? [] : args[0..(i-2)]
-      operation = args[(i-1)..(i+1)]
-      post_operation = (i + 2) > args.size ? [] : args[(i+2)..-1]
-      return arithmetic(*pre_operation.map {|a| map(a) },[:arithmetic,*operation],*post_operation.map {|a| map(a) })
+  def arithmetic(ast)
+    case ast.size
+    when 2; return map(ast[1]) # Not really arithmetic
+    when 4; # Normal arithmetic that doesn't need re-arranging
+      ast.each { |a| map(a) }
+    else
+      # This sets the operator precedence
+      i = nil
+      [{:'^' => 1},{:'*' => 2,:'/' => 2},{:'+' => 3,:'-' => 3}].each do |op|
+        i = ast.find_index { |a| a[0] == :operator && op.has_key?(a[1])}
+        break if i
+      end
+      if i
+        # Now we need to wrap that operation in its own arithmetic clause
+        old_clause = ast[(i-1)..(i+1)]
+        # Make sure we do any mapping
+        old_clause.each { |a| map(a) }
+        # Now create a new clause
+        new_clause = [:arithmetic, *old_clause]
+        # And insert it back into the ast
+        ast[(i-1)..(i+1)]  = [new_clause]
+        # Redo the mapping
+        map(ast)
+      end
     end
-    return [:arithmetic,*args.map {|a| map(a) }]
+    ast.each { |a| map(a) }
   end
     
 end

data/src/simplify/sort_into_calculation_order.rb

@@ -9,21 +9,20 @@ class SortIntoCalculationOrder
   def sort(references)
     @current_sheet = []
     @ordered_references = []
+    @counted = {}
     @references = references
 
     # First we find the references that are at the top of the tree
     references_with_counts = CountFormulaReferences.new.count(references)
     tops = []
-    references_with_counts.each do |sheet, references|
-      references.each do |cell, count|
-        next unless count == 0
-        tops << [sheet, cell]
-      end
+    references_with_counts.each do |reference, count|
+      next unless count == 0
+      tops << reference
     end
     # Then we have to work through those tops
     # recursively adding the cells that they depend on
-    tops.each do |ref|
-      add_ordered_references_for ref
+    tops.each do |reference|
+      add_ordered_references_for reference
     end
     @ordered_references
   end
@@ -32,10 +31,11 @@ class SortIntoCalculationOrder
     sheet = ref.first
     cell = ref.last
     current_sheet.push(sheet)
-    ast = @references[sheet][cell]
+    ast = @references[ref]
     map(ast)
     current_sheet.pop
-    ordered_references << ref
+    @ordered_references << ref
+    @counted[ref] = true
   end  
 
   def map(ast)
@@ -51,14 +51,14 @@ class SortIntoCalculationOrder
   end
   
   def sheet_reference(sheet,reference)
-    ref = [sheet, reference.last.gsub('$','')]
-    return if @ordered_references.include?(ref)
+    ref = [sheet, reference.last.to_s.gsub('$','').to_sym]
+    return if @counted.has_key?(ref)
     add_ordered_references_for(ref)
   end
   
   def cell(reference)
-    ref = [current_sheet.last, reference.gsub('$','')]
-    return if @ordered_references.include?(ref)
+    ref = [current_sheet.last, reference.to_s.gsub('$','').to_sym]
+    return if @counted.has_key?(ref)
     add_ordered_references_for(ref)
   end