excel_to_code 0.0.1

data/src/simplify/map_formulae_to_values.rb

@@ -0,0 +1,157 @@
+require_relative '../compile'
+require_relative '../excel/excel_functions'
+require_relative '../util'
+
+class FormulaeCalculator
+  include ExcelFunctions
+end
+
+class MapFormulaeToValues
+  
+  def initialize
+    @value_for_ast = MapValuesToRuby.new
+    @calculator = FormulaeCalculator.new
+  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
+  end
+  
+  def prefix(operator,argument)
+    argument_value = value(map(argument))
+    return [:prefix, operator, map(argument)] if argument_value == :not_a_value
+    return ast_for_value(argument_value || 0) if operator == "+"
+    ast_for_value(@calculator.negative(argument_value))
+  end
+  
+  def arithmetic(left,operator,right)
+    l = value(map(left))
+    r = value(map(right))
+    if (l != :not_a_value) && (r != :not_a_value)
+      formula_value(operator.last,l,r)
+    else
+      [:arithmetic,map(left),operator,map(right)]
+    end
+  end
+  
+  alias :comparison :arithmetic
+  
+  def percentage(number)
+    ast_for_value(value([:percentage, number]))
+  end
+  
+  def string_join(*args)
+    values = args.map { |a| value(map(a)) } # FIXME: These eval statements are really bugging me. Must find a better solution
+    if values.any? { |a| a == :not_a_value }
+      [:string_join,*args.map { |a| map(a) }]
+    else
+      ast_for_value(@calculator.string_join(*values))
+    end
+  end
+  
+  FUNCTIONS_THAT_SHOULD_NOT_BE_CONVERTED = %w{TODAY RAND RANDBETWEEN INDIRECT}
+  
+  def function(name,*args)
+    if FUNCTIONS_THAT_SHOULD_NOT_BE_CONVERTED.include?(name)
+      [:function,name,*args.map { |a| map(a) }]
+    elsif respond_to?("map_#{name.downcase}")
+      send("map_#{name.downcase}",*args)
+    else
+      values = args.map { |a| value(map(a)) }
+      if values.any? { |a| a == :not_a_value }
+        [:function,name,*args.map { |a| map(a) }]
+      else
+        formula_value(name,*values)
+      end
+    end
+  end
+  
+  def map_index(array,row_number,column_number = :not_specified)
+    return map_index_with_only_two_arguments(array,row_number) if column_number == :not_specified
+
+    array_mapped = map(array)
+    row_as_number = value(map(row_number))
+    column_as_number = value(map(column_number))
+
+    return [:function, "INDEX", array_mapped, map(row_number), map(column_number)] if row_as_number == :not_a_value || column_as_number == :not_a_value
+
+    array_as_values = array_as_values(array)
+    return  [:function, "INDEX", array_mapped, map(row_number), map(column_number)] unless array_as_values
+
+    result = @calculator.send(MapFormulaeToRuby::FUNCTIONS["INDEX"],array_as_values,row_as_number,column_as_number)
+    result = ast_for_value(result) unless result.is_a?(Array)
+    result    
+  end
+  
+  def map_index_with_only_two_arguments(array,row_number)
+    array_mapped = map(array)
+    row_as_number = value(map(row_number))
+    return [:function, "INDEX", array_mapped, map(row_number)] if row_as_number == :not_a_value
+    array_as_values = array_as_values(array)
+    return  [:function, "INDEX", array_mapped, map(row_number)] unless array_as_values
+    result = @calculator.send(MapFormulaeToRuby::FUNCTIONS["INDEX"],array_as_values,row_as_number)
+    result = ast_for_value(result) unless result.is_a?(Array)
+    result
+  end
+  
+  def array_as_values(array_mapped)
+    case array_mapped.first
+    when :array
+      array_mapped[1..-1].map do |row|
+        row[1..-1].map do |cell|
+          cell
+        end
+      end 
+    when :cell, :sheet_reference, :blank, :number, :percentage, :string, :error, :boolean_true, :boolean_false
+      [[array_mapped]]
+    else
+      nil
+    end
+  end
+  
+
+    
+  def value(ast)
+    return extract_values_from_array(ast) if ast.first == :array
+    return :not_a_value unless @value_for_ast.respond_to?(ast.first)
+    eval(@value_for_ast.send(*ast))
+  end
+  
+  def extract_values_from_array(ast)
+    ast[1..-1].map do |row|
+      row[1..-1].map do |cell|
+        v = value(cell)
+        return :not_a_value if v == :not_a_value
+        v
+      end
+    end 
+  end
+  
+  def formula_value(ast_name,*arguments)
+    raise NotSupportedException.new("#{ast_name.inspect} function not recognised in #{MapFormulaeToRuby::FUNCTIONS.inspect}") unless MapFormulaeToRuby::FUNCTIONS.has_key?(ast_name)
+    ast_for_value(@calculator.send(MapFormulaeToRuby::FUNCTIONS[ast_name],*arguments))
+  end
+  
+  def ast_for_value(value)
+    case value
+    when Numeric; [:number,value.inspect]
+    when true; [:boolean_true]
+    when false; [:boolean_false]
+    when Symbol; 
+      raise NotSupportedException.new("Error #{value.inspect} not recognised") unless MapFormulaeToRuby::REVERSE_ERRORS[value.inspect]
+      [:error,MapFormulaeToRuby::REVERSE_ERRORS[value.inspect]]
+    when String; [:string,value]
+    when Array; [:array,*value.map { |row| [:row, *row.map { |c| ast_for_value(c) }]}]
+    when nil; [:blank]
+    else
+      raise NotSupportedException.new("Ast for #{value.inspect} of class #{value.class} not recognised")
+    end
+  end
+  
+end

data/src/simplify/remove_cells.rb

@@ -0,0 +1,18 @@
+
+class RemoveCells
+  
+  attr_accessor :cells_to_keep
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input,output)
+    input.lines do |line|
+      ref = line[/^(.*?)\t/,1]
+      if cells_to_keep.has_key?(ref)
+        output.puts line
+      end
+    end
+  end
+end

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -0,0 +1,27 @@
+require_relative '../excel'
+
+class ReplaceArraysWithSingleCells
+  
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+  
+    input.lines 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
+      else
+        output.puts line
+      end
+    end
+  end
+  
+end

data/src/simplify/replace_blanks.rb

@@ -0,0 +1,58 @@
+class ReplaceBlanksAst
+  
+  attr_accessor :references, :default_sheet_name
+  
+  def initialize(references, default_sheet_name)
+    @references, @default_sheet_name = references, default_sheet_name
+  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
+  end
+  
+  def sheet_reference(sheet,reference)
+    if references[sheet].has_key?(reference.last.gsub('$',''))
+      [:sheet_reference,sheet,reference]
+    else
+      [:blank]
+    end
+  end
+  
+  def cell(reference)
+    if references[default_sheet_name].has_key?(reference.gsub('$',''))
+      [:cell,reference]
+    else
+      [:blank]
+    end
+  end
+  
+end
+  
+
+class ReplaceBlanks
+  
+  attr_accessor :references, :default_sheet_name
+  
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+    rewriter = ReplaceBlanksAst.new(references,default_sheet_name)
+    input.lines do |line|
+      # Looks to match lines with references
+      if line =~ /\[:cell/
+        ref, ast = line.split("\t")
+        output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+end

data/src/simplify/replace_common_elements_in_formulae.rb

@@ -0,0 +1,19 @@
+class ReplaceCommonElementsInFormulae
+    
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,common,output)
+    common = common.readlines.map do |a| 
+      ref, element = a.split("\t")
+      [element.strip,"[:cell, \"#{ref}\"]",ref]
+    end.sort
+    input.lines do |line|
+      common.each do |element,cell,ref|
+        line.gsub!(element,cell)
+      end
+      output.puts line
+    end
+  end
+end

data/src/simplify/replace_formulae_with_calculated_values.rb

@@ -0,0 +1,21 @@
+require_relative 'map_formulae_to_values'
+
+class ReplaceFormulaeWithCalculatedValues
+    
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+    rewriter = MapFormulaeToValues.new
+    input.lines do |line|
+      begin
+        ref, ast = line.split("\t")
+        output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
+      rescue Exception => e
+        puts "Exception at line #{line}"
+        raise
+      end
+    end
+  end
+end

data/src/simplify/replace_indirects_with_references.rb

@@ -0,0 +1,44 @@
+require_relative '../excel/formula_peg'
+
+class ReplaceIndirectsWithReferencesAst
+    
+  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
+  end
+  
+  def function(name,*args)
+    if name == "INDIRECT" && args.size == 1 && args[0][0] == :string
+      Formula.parse(args[0][1]).to_ast[1]
+    else
+      puts "indirect #{[:function,name,*args.map { |a| map(a) }].inspect} not replaced" if name == "INDIRECT"
+      [:function,name,*args.map { |a| map(a) }]
+    end
+  end
+end
+  
+
+class ReplaceIndirectsWithReferences
+    
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+    rewriter = ReplaceIndirectsWithReferencesAst.new
+    input.lines do |line|
+      # Looks to match lines with references
+      if line =~ /"INDIRECT"/
+        ref, ast = line.split("\t")
+        output.puts "#{ref}\t#{rewriter.map(eval(ast)).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+end

data/src/simplify/replace_named_references.rb

@@ -0,0 +1,82 @@
+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
+  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
+  end
+  
+end
+
+class ReplaceNamedReferencesAst
+  
+  attr_accessor :named_references, :default_sheet_name
+  
+  def initialize(named_references, default_sheet_name)
+    @named_references, @default_sheet_name = named_references, default_sheet_name
+  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
+  end
+  
+  def sheet_reference(sheet,reference)
+    if reference.first == :named_reference
+      named_references.reference_for(sheet,reference.last)
+    else
+      [:sheet_reference,sheet,reference]
+    end    
+  end
+  
+  def named_reference(name)
+    named_references.reference_for(default_sheet_name,name)
+  end
+  
+end
+  
+
+class ReplaceNamedReferences
+  
+  attr_accessor :sheet_name
+  
+  def self.replace(values,sheet_name,named_references,output)
+    self.new.replace(values,sheet_name,named_references,output)
+  end
+  
+  # Rewrites ast with named references
+  def replace(values,named_references,output)
+    named_references = NamedReferences.new(named_references.readlines)
+    rewriter = ReplaceNamedReferencesAst.new(named_references,sheet_name)
+    values.lines do |line|
+      # Looks to match shared string lines
+      if line =~ /\[:named_reference/
+        cols = line.split("\t")
+        ast = cols.pop
+        output.puts "#{cols.join("\t")}\t#{rewriter.map(eval(ast)).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+end

data/src/simplify/replace_ranges_with_array_literals.rb

@@ -0,0 +1,54 @@
+require_relative '../excel'
+
+class ReplaceRangesWithArrayLiteralsAst
+  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
+    end
+  end
+  
+  def sheet_reference(sheet,reference)
+    if reference.first == :area
+      area = Area.for("#{reference[1]}:#{reference[2]}")
+      area.to_array_literal(sheet)
+    else
+      [:sheet_reference,sheet,reference]
+    end
+  end
+  
+  def area(start,finish)
+    area = Area.for("#{start}:#{finish}")
+    area.to_array_literal
+  end
+  
+end
+
+class ReplaceRangesWithArrayLiterals
+  
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+    rewriter = ReplaceRangesWithArrayLiteralsAst.new
+  
+    input.lines do |line|
+      # Looks to match shared string lines
+      if line =~ /\[:area/
+        content = line.split("\t")
+        ast = eval(content.pop)
+        output.puts "#{content.join("\t")}\t#{rewriter.map(ast).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+  
+end