excel_to_code 0.1.23 → 0.2.0

data/src/rewrite/rewrite_array_formulae.rb

@@ -2,6 +2,10 @@ class ExtractArrayFormulaForCell
   
   attr_accessor :row_offset, :column_offset
   
+  def initialize
+    @fc = CachingFormulaParser.instance
+  end
+
   def map(ast)
     case ast.first
     when :array; map_array(ast)
@@ -15,7 +19,7 @@ class ExtractArrayFormulaForCell
       if ast.length == 2
         @row_offset = 0
       else
-        return [:error, "#N/A"]
+        return @fc.map([:error, :"#N/A"])
       end
     end
 
@@ -23,36 +27,39 @@ class ExtractArrayFormulaForCell
       if ast[1].length == 2
         @column_offset = 0
       else
-        return [:error, "#N/A"]
+        return @fc.map([:error, :"#N/A"])
       end
     end
     
     ast[@row_offset+1][@column_offset+1] # plus ones to skip tthe [:array,[:row,"cell"]] symbols
   end
   
-  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = %w{INDEX MMULT}
+  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = { INDEX: true,  MMULT: true}
   
   def map_function(ast)
-    return ast unless FUNCTIONS_THAT_CAN_RETURN_ARRAYS.include?(ast[1])
-    [:function, "INDEX", ast, [:number, (@row_offset+1).to_s], [:number, (column_offset+1).to_s]]
+    return ast unless FUNCTIONS_THAT_CAN_RETURN_ARRAYS.has_key?(ast[1])
+    [:function, :INDEX, ast, @fc.map([:number, (@row_offset+1)]), @fc.map([:number, (column_offset+1)])]
   end
   
 end
 
 class RewriteArrayFormulae
-  def self.rewrite(input,output)
-    new.rewrite(input,output)
+  def self.rewrite(*args)
+    new.rewrite(*args)
   end
   
-  def rewrite(input,output)
-    input.each_line do |line|
-      ref, array_range, formula = line.split("\t")
-      array_formula(formula,array_range,output)
+  def rewrite(input)
+    @output = {}
+    input.each do |ref, details|
+      sheet = ref[0]
+      array_range = details[0]
+      ast = details[1]
+      array_formula(sheet, array_range, ast)
     end
+    @output
   end
   
-  def array_formula(formula,array_range,output)
-    array_ast = eval(formula)
+  def array_formula(sheet, array_range, array_ast)
     array_range = "#{array_range}:#{array_range}" unless array_range.include?(':')
     array_range = Area.for(array_range)
     array_range.calculate_excel_variables
@@ -64,7 +71,7 @@ class RewriteArrayFormulae
       mapper.row_offset = row
       mapper.column_offset = column
       ref = start_reference.offset(row,column)
-      output.puts "#{ref}\t#{mapper.map(array_ast).inspect}"
+      @output[[sheet.to_sym, ref.to_sym]] = mapper.map(array_ast)
     end
   end
   

data/src/rewrite/rewrite_cell_references_to_include_sheet.rb

@@ -3,30 +3,58 @@ require_relative '../excel'
 class RewriteCellReferencesToIncludeSheetAst 
   
   attr_accessor :worksheet
+
+  def initialize
+    @fp = CachingFormulaParser.instance
+  end
     
+  # FIXME: UGh.
   def map(ast)
-    if ast.is_a?(Array)
-      operator = ast.shift
-      if respond_to?(operator)
-        send(operator,*ast)
+    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)
+    return cell(ast) if ast[0] == :cell
+    return area(ast) if ast[0] == :area
+    return sheet_reference(ast) if ast[0] == :sheet_reference
+    ast.each.with_index do |a,i|
+      next unless a.is_a?(Array)
+      case a[0]
+      when :cell
+        ast[i] = cell(a)
+      when :area
+        ast[i] = area(a)
+      when :sheet_reference
+        ast[i] = sheet_reference(a)
       else
-        [operator,*ast.map {|a| map(a) }]
+        do_map(a)
       end
-    else
-      return ast
     end
+    ast
   end
   
-  def cell(ref)
-    [:sheet_reference, worksheet, [:cell, ref]]
+  def cell(ast)
+    ast[1] = ast[1].to_s.gsub('$','').to_sym
+    @fp.map([:sheet_reference, worksheet, ast.dup])
   end
   
-  def area(start,finish)
-    [:sheet_reference, worksheet, [:area, start, finish]]    
+  def area(ast)
+    ast[1] = ast[1].to_s.gsub('$','').to_sym
+    ast[2] = ast[2].to_s.gsub('$','').to_sym
+    @fp.map([:sheet_reference, worksheet, ast.dup])
   end
   
-  def sheet_reference(sheet_name,reference)
-    [:sheet_reference, sheet_name, reference]
+  def sheet_reference(ast)
+    if ast[2][0] == :cell
+      ast[2][1] = ast[2][1].to_s.gsub('$','').to_sym
+    elsif ast[2][1] == :area
+      ast[2][1] = ast[2][1].to_s.gsub('$','').to_sym
+      ast[2][2] = ast[2][2].to_s.gsub('$','').to_sym
+    end
+    @fp.map(ast)
   end
 
 end

data/src/rewrite/rewrite_shared_formulae.rb

@@ -1,45 +1,44 @@
 require_relative 'ast_copy_formula'
 
 class RewriteSharedFormulae
-  def self.rewrite(input, shared_targets, output)
-    new.rewrite(input, shared_targets, output)
+  def self.rewrite(*args)
+    new.rewrite(*args)
   end
   
-  def rewrite(input, shared_target_file, output)
-    shared_targets = Hash.new
-    shared_target_file.each_line do |l| 
-      ref, number = *l.split("\t")
-      shared_targets[ref.strip] = number.strip
-    end
+  def rewrite(formula_shared, formula_shared_targets)
+    @output = {}
+    @formula_shared_targets = formula_shared_targets
 
-    input.each_line do |line|
-      ref, copy_range,  shared_formula_identifier, formula = line.split("\t")
-      share_formula(ref, formula, copy_range, shared_formula_identifier, shared_targets, output)
+    formula_shared.each do |ref, a|
+      copy_range = a[0]
+      shared_formula_identifier = a[1]
+      shared_ast = a[2]
+      share_formula(ref, shared_ast, copy_range, shared_formula_identifier)
     end
+    @output
   end
   
-  def share_formula(ref, formula, copy_range, shared_formula_identifier, shared_targets, output)
-    shared_ast = eval(formula)
+  def share_formula(ref, shared_ast, copy_range, shared_formula_identifier)
     copier = AstCopyFormula.new
     copy_range = Area.for(copy_range)
     copy_range.calculate_excel_variables
     
     start_reference = copy_range.excel_start
     
-    r = Reference.for(ref)
+    r = Reference.for(ref.last)
     r.calculate_excel_variables
     
     offset_from_formula_to_start_rows = start_reference.excel_row_number - r.excel_row_number
     offset_from_formula_to_start_columns = start_reference.excel_column_number - r.excel_column_number
     
     copy_range.offsets.each do |row,column|
-      new_ref = start_reference.offset(row,column)
-      next unless shared_targets.include?(new_ref)
-      next unless shared_formula_identifier == shared_targets[new_ref]
+      new_ref = [ref.first.to_sym, start_reference.offset(row,column).to_sym]
+      next unless @formula_shared_targets.include?(new_ref)
+      next unless shared_formula_identifier == @formula_shared_targets[new_ref]
       copier.rows_to_move = row + offset_from_formula_to_start_rows
       copier.columns_to_move = column + offset_from_formula_to_start_columns
       ast = copier.copy(shared_ast)
-      output.puts "#{new_ref}\t#{ast.inspect}"
+      @output[new_ref] = ast
     end
   end
   

data/src/rewrite/rewrite_values_to_ast.rb

@@ -1,5 +1,7 @@
 require_relative '../excel/formula_peg'
 
+#FIXME: NOT NEEDED
+
 class RewriteValuesToAst
   
   def self.rewrite(input,output)

data/src/rewrite/rewrite_whole_row_column_references_to_areas.rb

@@ -20,6 +20,10 @@ class WorksheetDimension
   def map_column(start,finish)
     ["#{start}#{first_row}","#{finish}#{last_row}"]
   end
+
+  def inspect
+    area.inspect
+  end
   
 end
 
@@ -29,37 +33,36 @@ class MapColumnAndRowRangeAst
   
   def initialize(default_worksheet_name,worksheet_dimensions)
     @default_worksheet_name, @worksheet_dimensions = default_worksheet_name, worksheet_dimensions
+    @worksheet_names = []
   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
-    else
-      return ast
+    return ast unless ast.is_a?(Array)
+    case ast[0]
+    when :sheet_reference; sheet_reference(ast)
+    when :row_range; row_range(ast)
+    when :column_range; column_range(ast)
     end
+    ast.each {|e| map(e)}
   end
   
-  def sheet_reference(sheet_name,reference)
-    if reference.first == :row_range
-      [:sheet_reference,sheet_name,[:area,*worksheet_dimensions[sheet_name].map_row(reference[1],reference[2])]]
-    elsif reference.first == :column_range
-      [:sheet_reference,sheet_name,[:area,*worksheet_dimensions[sheet_name].map_column(reference[1],reference[2])]]
-    else
-      [:sheet_reference,sheet_name,reference]
-    end
+  # Of the form [:sheet_reference, sheet_name, reference]
+  def sheet_reference(ast)
+    @worksheet_names.push(ast[1].to_sym) #FIXME: Remove once all symbols
+    map(ast[2])
+    @worksheet_names.pop
   end
   
-  def row_range(start,finish)
-    [:area,*worksheet_dimensions[default_worksheet_name].map_row(start,finish)]
+  # Of the form [:row_range, start, finish]
+  def row_range(ast)
+    worksheet = @worksheet_names.last || @default_worksheet_name
+    ast.replace([:area,*worksheet_dimensions[worksheet].map_row(ast[1],ast[2])])
   end
   
-  def column_range(start,finish)
-    [:area,*worksheet_dimensions[default_worksheet_name].map_column(start,finish)]
+  # Of the form [:column_range, start, finish]
+  def column_range(ast)
+    worksheet = @worksheet_names.last || @default_worksheet_name
+    ast.replace([:area,*worksheet_dimensions[worksheet].map_column(ast[1],ast[2])])
   end
   
 end
@@ -86,10 +89,10 @@ class RewriteWholeRowColumnReferencesToAreas
   end
   
   def worksheet_dimensions=(worksheet_dimensions)
-    @dimensions =  Hash[worksheet_dimensions.readlines.map do |line| 
-      worksheet_name, area = line.split("\t")
-      [worksheet_name,WorksheetDimension.new(area)]
-    end]
+    @dimensions = {}
+    worksheet_dimensions.each do |name, area|
+      @dimensions[name] = WorksheetDimension.new(area)
+    end
     @mapper = nil
   end
   

data/src/simplify.rb

@@ -19,3 +19,4 @@ require_relative "simplify/sort_into_calculation_order"
 require_relative "simplify/replace_arithmetic_on_ranges"
 require_relative "simplify/wrap_formulae_that_return_arrays_and_are_not_in_arrays"
 require_relative "simplify/replace_string_join_on_ranges"
+require_relative "simplify/emergency_array_formula_replace_indirect_bodge.rb"

data/src/simplify/count_formula_references.rb

@@ -1,5 +1,6 @@
 class CountFormulaReferences
   
+  # FIXME: Do we need these accessors
   attr_accessor :references
   attr_accessor :dependencies
   attr_accessor :current_sheet
@@ -8,25 +9,22 @@ class CountFormulaReferences
     @references = references
     @dependencies = dependencies
     dependencies.default_proc = lambda do |hash,key|
-      hash[key] = {}
+      hash[key] = 0
     end
     @current_sheet = []
   end
   
   def count(references)
+    # FIXME: Why do we have this references instance variable?
     @references = references
-    references.each do |sheet,cells|
-      current_sheet << sheet
-      cells.each do |ref,ast|
-        count_dependencies_for(sheet,ref,ast)
-      end
-      current_sheet.pop
+    references.each do |full_ref,ast|
+      @dependencies[full_ref] ||= 0
+      count_dependencies_for(full_ref.first,full_ref.last,ast)
     end
     return dependencies
   end
     
   def count_dependencies_for(sheet,ref,ast)
-    @dependencies[sheet][ref] ||= 0
     current_sheet.push(sheet)
     map(ast)
     current_sheet.pop
@@ -34,26 +32,27 @@ class CountFormulaReferences
   
   def map(ast)
     return ast unless ast.is_a?(Array)
-    operator = ast[0]
-    if respond_to?(operator)
-      send(operator,*ast[1..-1])
-    else
-      ast[1..-1].each do |a|
-        map(a)
-      end
+    case ast[0]
+    when :sheet_reference; sheet_reference(ast)
+    when :cell; cell(ast)
+    else; ast.each { |a| map(a) }
     end
+    ast
   end
   
-  def sheet_reference(sheet,reference)
-    ref = reference.last.gsub('$','')
-    @dependencies[sheet][ref] ||= 0
-    @dependencies[sheet][ref] += 1
+  # Format [:sheet_reference, sheet, reference]
+  def sheet_reference(ast)
+    sheet = ast[1]
+    reference = ast[2]
+    ref = reference.last.to_s.gsub('$','').to_sym
+    @dependencies[[sheet, ref]] += 1
   end
   
-  def cell(reference)
-    ref = reference.gsub('$','')
-    @dependencies[current_sheet.last][ref] ||= 0
-    @dependencies[current_sheet.last][ref] += 1
+  # Format [:cell, reference]
+  def cell(ast)
+    reference = ast[1]
+    ref = reference.to_s.gsub('$','').to_sym
+    @dependencies[[current_sheet.last, ref]] += 1
   end
    
 end

data/src/simplify/emergency_array_formula_replace_indirect_bodge.rb

@@ -0,0 +1,44 @@
+require_relative '../excel/formula_peg'
+
+class EmergencyArrayFormulaReplaceIndirectBodge
+  
+  attr_accessor :current_sheet_name
+  attr_accessor :references
+
+  def initialize
+    @indirect_replacer = ReplaceIndirectsWithReferencesAst.new
+    @formulae_to_value_replacer = MapFormulaeToValues.new
+    @inline_formulae_replacer = InlineFormulaeAst.new
+  end
+
+  def replace(ast)
+    map(ast)
+    ast
+  end
+   
+  def map(ast)
+    return ast unless ast.is_a?(Array)
+    function(ast) if ast[0] == :function && ast[1] == :INDIRECT
+    ast.each { |a| map(a) }
+    ast
+  end
+  
+  def function(ast)
+    new_ast = deep_copy(ast)
+    @inline_formulae_replacer.references = @references
+    @inline_formulae_replacer.current_sheet_name = [@current_sheet_name]
+    @inline_formulae_replacer.map(new_ast)
+    @formulae_to_value_replacer.map(new_ast)
+    @indirect_replacer.replace(new_ast)
+    ast.replace(new_ast)
+    ast
+  end
+
+  def deep_copy(ast)
+    return ast if ast.is_a?(Symbol)
+    return ast.dup unless ast.is_a?(Array)
+    ast.map do |a|
+      deep_copy(a)
+    end
+  end
+end

data/src/simplify/identify_dependencies.rb

@@ -15,9 +15,9 @@ class IdentifyDependencies
   
   def add_depedencies_for(sheet,cell = :all)
     if cell == :all
-      return unless references.has_key?(sheet)
-      references[sheet].each do |ref,ast|
-        recursively_add_dependencies_for(sheet,ref)
+      references.each do |ref,ast|
+        next unless ref.first == sheet
+        recursively_add_dependencies_for(sheet,ref.last)
       end
     else
       recursively_add_dependencies_for(sheet,cell)
@@ -27,8 +27,7 @@ class IdentifyDependencies
   def recursively_add_dependencies_for(sheet,cell)
     return if dependencies[sheet].has_key?(cell)
     dependencies[sheet][cell] = true
-    return unless references.has_key?(sheet)
-    ast = references[sheet][cell]
+    ast = references[[sheet,cell]]
     return unless ast
     current_sheet.push(sheet)
     map(ast)
@@ -41,16 +40,16 @@ class IdentifyDependencies
     if respond_to?(operator)
       send(operator,*ast[1..-1])
     else
-      [operator,*ast[1..-1].map {|a| map(a) }]
+      ast.each {|a| map(a) }
     end
   end
   
   def sheet_reference(sheet,reference)
-    recursively_add_dependencies_for(sheet,reference.last.gsub('$',''))
+    recursively_add_dependencies_for(sheet,Reference.for(reference.last).unfix.to_sym)
   end
   
   def cell(reference)
-    recursively_add_dependencies_for(current_sheet.last,reference.gsub('$',''))
+    recursively_add_dependencies_for(current_sheet.last,Reference.for(reference).unfix.to_sym)
   end
    
 end