excel_to_code 0.1.23 → 0.2.0

data/src/extract/extract_values.rb

@@ -1,15 +1,28 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractValues < SimpleExtractFromXML
-  
-  attr_accessor :ref, :type
+class ExtractValues < Nokogiri::XML::SAX::Document 
+
+  def self.extract(*args)
+    self.new.extract(*args)
+  end
+
+  def extract(sheet_name, input)
+    @sheet_name = sheet_name.to_sym
+    @output = {}
+    @parsing = false
+    @fp = CachingFormulaParser.instance
+    Nokogiri::XML::SAX::Parser.new(self).parse(input)
+    @output
+  end
+    
+  attr_accessor :ref, :type, :value
   
   def start_element(name,attributes)
     if name == "v"
-      self.parsing = true 
-      output.write "#{@ref}\t#{@type}\t"
+      @parsing = true 
+      @value = []
     elsif name == "c"
-      @ref = attributes.assoc('r').last
+      @ref = attributes.assoc('r').last.to_sym
       type = attributes.assoc('t')
       @type = type ? type.last : "n"
     end
@@ -17,13 +30,24 @@ class ExtractValues < SimpleExtractFromXML
   
   def end_element(name)
     return unless name == "v"
-    self.parsing = false
-    output.putc "\n"
+    @parsing = false
+    value = @value.join
+    ast = case @type
+    when 'b'; value == "1" ? [:boolean_true] : [:boolean_false]
+    when 's'; [:shared_string,value.to_i]
+    when 'n'; [:number,value.to_f]
+    when 'e'; [:error,value.to_sym]
+    when 'str'; [:string,value.gsub(/_x[0-9A-F]{4}_/,'').freeze]
+    else
+      $stderr.puts "Type #{type} not known #{@sheet_name} #{@ref}"
+      exit
+    end
+    @output[[@sheet_name, @ref]] = @fp.map(ast)
   end
   
   def characters(string)
-    return unless parsing
-    output.write string
+    return unless @parsing
+    @value << string
   end
   
 end

data/src/extract/extract_worksheet_dimensions.rb

@@ -1,11 +1,21 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractWorksheetDimensions < SimpleExtractFromXML
+class ExtractWorksheetDimensions < Nokogiri::XML::SAX::Document 
+
+    def self.extract(*args)
+      self.new.extract(*args)
+    end
+
+    def extract(input)
+      parser = Nokogiri::XML::SAX::Parser.new(self)
+      parser.parse(input)
+      @output
+    end
   
   # FIXME: Is there an elegant way to abort once we have found the dimension tag?
   def start_element(name,attributes)
     return false unless name == "dimension"
-    output.puts "#{attributes.assoc('ref').last}"
+    @output = attributes.assoc('ref').last
   end
   
 end

data/src/extract/extract_worksheet_names.rb

@@ -1,10 +1,23 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractWorksheetNames < SimpleExtractFromXML
+class ExtractWorksheetNames < Nokogiri::XML::SAX::Document 
+
+    attr_accessor :input, :output
+  
+    def self.extract(*args)
+      self.new.extract(*args)
+    end
+
+    def extract(input)
+      @input, @output = input, {}
+      parser = Nokogiri::XML::SAX::Parser.new(self)
+      parser.parse(input)
+      output
+    end
   
   def start_element(name,attributes)
     return false unless name == "sheet"
-    output.puts "#{attributes.assoc('r:id').last}\t#{attributes.assoc('name').last}"
+    output[attributes.assoc('name').last] = attributes.assoc('r:id').last
   end
   
 end

data/src/extract/extract_worksheet_table_relationships.rb

@@ -1,10 +1,22 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractWorksheetTableRelationships < SimpleExtractFromXML
+
+class ExtractWorksheetTableRelationships < Nokogiri::XML::SAX::Document 
+
+    def self.extract(*args)
+      self.new.extract(*args)
+    end
+
+    def extract(input)
+      @output = [] 
+      @parsing = false
+      Nokogiri::XML::SAX::Parser.new(self).parse(input)
+      @output
+    end
 
   def start_element(name,attributes)
     return false unless name == "tablePart"
-    output.puts "#{attributes.assoc('r:id').last}"
+    @output << "#{attributes.assoc('r:id').last}"
   end
 
-end
+end

data/src/extract/simple_extract_from_xml.rb

@@ -2,18 +2,16 @@ require 'nokogiri'
 
 class SimpleExtractFromXML < Nokogiri::XML::SAX::Document 
 
-    attr_accessor :parsing, :input, :output
-  
-    def self.extract(input,output)
-      self.new.extract(input,output)
+    def self.extract(*args)
+      self.new.extract(*args)
     end
 
-    def extract(input,output)
-      @input, @output = input, output
-      parsing = false
-      parser = Nokogiri::XML::SAX::Parser.new(self)
-      parser.parse(input)
-      output
+    def extract(sheet_name, input)
+      @sheet_name = sheet_name
+      @output = {} 
+      @parsing = false
+      Nokogiri::XML::SAX::Parser.new(self).parse(input)
+      @output
     end
     
-end
+end

data/src/rewrite.rb

@@ -1,3 +1,4 @@
+require_relative "excel/formula_peg"
 require_relative "rewrite/rewrite_formulae_to_ast"
 require_relative "rewrite/rewrite_worksheet_names"
 require_relative "rewrite/rewrite_whole_row_column_references_to_areas"
@@ -9,3 +10,5 @@ require_relative "rewrite/rewrite_relationship_id_to_filename"
 require_relative "rewrite/rewrite_merge_formulae_and_values"
 require_relative "rewrite/rewrite_cell_references_to_include_sheet"
 require_relative "rewrite/rewrite_named_reference_names"
+require_relative "rewrite/caching_formula_parser"
+

data/src/rewrite/ast_copy_formula.rb

@@ -10,11 +10,15 @@ class AstCopyFormula
     self.columns_to_move = 0
   end
   
+  DO_NOT_MAP = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :operator => true, :comparator => true}
+
   def copy(ast)
     return ast unless ast.is_a?(Array)
     operator = ast[0]
     if respond_to?(operator)
       send(operator,*ast[1..-1])
+    elsif DO_NOT_MAP[operator]
+      return ast
     else
       [operator,*ast[1..-1].map {|a| copy(a) }]
     end
@@ -39,4 +43,4 @@ class AstCopyFormula
     raise NotSupportedException.new("Row ranges not suported in AstCopyFormula")
   end  
   
-end
+end

data/src/rewrite/ast_expand_array_formulae.rb

@@ -5,39 +5,44 @@ class AstExpandArrayFormulae
   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
+    send(operator, ast) if respond_to?(operator)
+    ast.each {|a| map(a) }
+    ast
   end
 
-  def arithmetic(left,operator,right)
-    left = map(left)
-    right = map(right)
-    return [:arithmetic, left, operator, right] unless array?(left,right)
+  # Format [:arithmetic, left, operator, right]
+  def arithmetic(ast)
+    ast.each {|a| map(a) }
+    return unless array?(ast[1], ast[3])
     
-    map_arrays([left,right]) do |arrayed|
-      [:arithmetic,arrayed[0],operator,arrayed[1]]
-    end
+    ast.replace(
+      map_arrays([ast[1],ast[3]]) do |arrayed|
+        [:arithmetic,arrayed[0],ast[2],arrayed[1]]
+      end
+    )
   end
 
-  def comparison(left,operator,right)
-    left = map(left)
-    right = map(right)
-    return [:comparison, left, operator, right] unless array?(left,right)
-
-    map_arrays([left,right]) do |arrayed|
-      [:comparison,arrayed[0],operator,arrayed[1]]
-    end
+  # Format [:comparison, left, operator, right]
+  def comparison(ast)
+    ast.each {|a| map(a) }
+    return unless array?(ast[1], ast[3])
+    
+    ast.replace(
+      map_arrays([ast[1],ast[3]]) do |arrayed|
+        [:comparison,arrayed[0],ast[2],arrayed[1]]
+      end
+    )
   end
   
-  def string_join(*strings)
-    strings = strings.map { |s| map(s) }
-    return [:string_join, *strings] unless array?(*strings)
-    map_arrays(strings) do |arrayed_strings|
-      [:string_join, *arrayed_strings]
-    end
+  # Format [:string_join, stringA, stringB, ...]
+  def string_join(ast)
+    ast.each {|a| map(a) }
+    return unless array?(*ast[1..-1])
+    ast.replace(
+      map_arrays(ast[1..-1]) do |arrayed_strings|
+        [:string_join, *arrayed_strings]
+      end
+    )
   end
   
   def map_arrays(arrays, &block)
@@ -58,56 +63,62 @@ class AstExpandArrayFormulae
     return [:array, *max_rows.times.map do |row|
       [:row, *max_columns.times.map do |column| 
         block.call(arrays.map do |a|
-          a[row][column] || [:error, "#N/A"]
+          (a[row] && a[row][column]) || CachingFormulaParser.map([:error, :"#N/A"])
         end)
       end]
     end]
   end
   
-  FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS = %w{AVERAGE COUNT COUNTA MAX MIN SUM SUMPRODUCT MMULT}
+  FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS = {AVERAGE: true, COUNT: true, COUNTA: true, MAX: true, MIN: true, SUM: true, SUMPRODUCT: true, MMULT: true}
   
-  def function(name,*arguments)
-    if FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS.include?(name)
-      [:function, name, *arguments.map { |a| map(a) }]
+  # Format [:function, function_name, arg1, arg2, ...]
+  def function(ast)
+    name = ast[1]
+    arguments = ast[2..-1]
+    if FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS.has_key?(name)
+      ast.each { |a| map(a) }
+      return # No need to alter anything
     elsif respond_to?("map_#{name.downcase}")
-      send("map_#{name.downcase}",*arguments)
+      # These typically have some arguments that accept ranges, but not all
+      send("map_#{name.downcase}",ast)
     else
-      function_that_does_not_accept_ranges(name,arguments)
+      function_that_does_not_accept_ranges(ast)
     end
   end
   
-  def function_that_does_not_accept_ranges(name,arguments)
-    return [:function, name] if arguments.empty?
-    array_map arguments, name, *Array.new(arguments.length,false)
+  def function_that_does_not_accept_ranges(ast)
+    return if ast.length == 2
+    name = ast[1]
+    arguments = ast[2..-1]
+    array_map(ast, *Array.new(arguments.length,false))
   end
   
-  def map_match(*args)
-    a = array_map args, 'MATCH', false, true, false
-    a
+  def map_match(ast)
+    array_map(ast, false, true, false)
   end
   
-  def map_subtotal(*args)
-    array_map args, 'SUBTOTAL', false, *Array.new(args.length-1,true)
+  def map_subtotal(ast)
+    array_map ast, false, *Array.new(ast.length-3,true)
   end
   
-  def map_index(*args)
-    array_map args, 'INDEX', true, false, false
+  def map_index(ast)
+    array_map ast, true, false, false
   end
   
-  def map_sumif(*args)
-    array_map args, 'SUMIF', true, false, true
+  def map_sumif(ast)
+    array_map ast, true, false, true
   end
   
-  def map_sumifs(*args)
-    if args.length > 3
-      array_map args, 'SUMIFS', true, true, false, *([true,false]*((args.length-3)/2))
+  def map_sumifs(ast)
+    if ast.length > 5
+      array_map ast, true, true, false, *([true,false]*((ast.length-5)/2))
     else
-      array_map args, 'SUMIFS', true, true, false
+      array_map ast, true, true, false
     end
   end
   
-  def map_vlookup(*args)
-    array_map args, "VLOOKUP", false, true, false, false
+  def map_vlookup(ast)
+    array_map ast, false, true, false, false
   end
   
   private
@@ -121,15 +132,16 @@ class AstExpandArrayFormulae
     true
   end
   
-  def array_map(args,function,*ok_to_be_an_array)
-    args = args.map { |a| map(a) }
-    return [:function, function, *args ] if no_need_to_array?(args,ok_to_be_an_array)
+  def array_map(ast,*ok_to_be_an_array)
+    ast.each { |a| map(a) }
+
+    return if no_need_to_array?(ast[2..-1],ok_to_be_an_array)
 
     # Turn the relevant arguments into ruby arrays and store the dimensions
     # Enumerable#max and Enumerable#min don't return Enumerators, so can't do it using those methods
     max_rows = 1
     max_columns = 1
-    args = args.map.with_index do |a,i| 
+    args = ast[2..-1].map.with_index do |a,i| 
       unless ok_to_be_an_array[i]
         a = array_ast_to_ruby_array(a)
         r = a.length
@@ -147,17 +159,17 @@ class AstExpandArrayFormulae
     args = args.map.with_index { |a,i| (!ok_to_be_an_array[i] && a.first.length == 1) ? Array.new(max_columns,a.flatten(1)).transpose : a }
     
     # Now iterate through
-    return [:array, *max_rows.times.map do |row|
+    ast.replace( [:array, *max_rows.times.map do |row|
       [:row, *max_columns.times.map do |column| 
-        [:function, function, *args.map.with_index do |a,i|
+        [:function, ast[1], *args.map.with_index do |a,i|
           if ok_to_be_an_array[i]
             a
           else
-            a[row][column] || [:error, "#N/A"]
+            a[row][column] || [:error, :"#N/A"]
           end
         end]
       end]
-    end]
+    end])
   end
   
   def array?(*args)

data/src/rewrite/caching_formula_parser.rb

@@ -0,0 +1,110 @@
+require 'singleton'
+
+class CachingFormulaParser
+  include Singleton
+
+  def self.parse(*args)
+    instance.parse(*args)
+  end
+
+  def self.map(*args)
+    instance.map(*args)
+  end
+
+  def initialize
+    @number_cache = {}
+    @string_cache = {}
+    @percentage_cache = {}
+    @error_cache = {}
+    @operator_cache = {}
+    @comparator_cache = {}
+    @sheet_reference_cache = {}
+  end
+
+  def parse(text)
+    ast = Formula.parse(text)
+    if ast
+      map(ast.to_ast[1])
+    else
+      nil
+    end
+  end
+
+  def map(ast)
+    return ast unless ast.is_a?(Array)
+    ast[1] = ast[1].to_sym if ast[0] == :function
+    if respond_to?(ast[0])
+      ast = send(ast[0], ast) 
+    else
+      ast.each.with_index do |a,i| 
+        next unless a.is_a?(Array)
+        a[1] = a[1].to_sym if a[0] == :function
+        ast[i] = map(a)
+      end
+    end
+    ast
+  end
+
+  def sheet_reference(ast)
+    ast[1] = ast[1].to_sym
+    ast[2] = map(ast[2])
+    @sheet_reference_cache[ast] ||= ast
+  end
+
+  def cell(ast)
+    ast[1] = ast[1].to_sym
+    ast
+  end
+
+  def area(ast)
+    ast[1] = ast[1].to_sym
+    ast[2] = ast[2].to_sym
+    ast
+  end
+
+  def number(ast)
+    ast[1] = ast[1].to_f
+    @number_cache[ast] ||= ast
+  end
+
+  def percentage(ast)
+    ast[1] = ast[1].to_f
+    @percentage_cache[ast] ||= ast
+  end
+
+  def string(ast)
+    return @string_cache[ast] ||= ast
+  end
+
+  TRUE = [:boolean_true]
+  FALSE = [:boolean_false]
+  BLANK = [:blank]
+
+  def boolean_true(ast)
+    TRUE
+  end
+
+  def boolean_false(ast)
+    FALSE
+  end
+
+  def error(ast)
+    ast[1] = ast[1].to_sym
+    @error_cache[ast] ||= ast
+  end
+
+  def blank(ast)
+    BLANK
+  end
+
+  def operator(ast)
+    ast[1] = ast[1].to_sym
+    @operator_cache[ast] ||= ast
+  end
+
+  def comparator(ast)
+    ast[1] = ast[1].to_sym
+    @comparator_cache[ast] ||= ast
+  end
+
+end