excel_to_code 0.0.1

data/src/extract/extract_values.rb

@@ -0,0 +1,29 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractValues < SimpleExtractFromXML
+  
+  attr_accessor :ref, :type
+  
+  def start_element(name,attributes)
+    if name == "v"
+      self.parsing = true 
+      output.write "#{@ref}\t#{@type}\t"
+    elsif name == "c"
+      @ref = attributes.assoc('r').last
+      type = attributes.assoc('t')
+      @type = type ? type.last : "n"
+    end
+  end
+  
+  def end_element(name)
+    return unless name == "v"
+    self.parsing = false
+    output.putc "\n"
+  end
+  
+  def characters(string)
+    return unless parsing
+    output.write string
+  end
+  
+end

data/src/extract/extract_worksheet_dimensions.rb

@@ -0,0 +1,11 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractWorksheetDimensions < SimpleExtractFromXML
+  
+  # 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}"
+  end
+  
+end

data/src/extract/extract_worksheet_names.rb

@@ -0,0 +1,10 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractWorksheetNames < SimpleExtractFromXML
+  
+  def start_element(name,attributes)
+    return false unless name == "sheet"
+    output.puts "#{attributes.assoc('r:id').last}\t#{attributes.assoc('name').last}"
+  end
+  
+end

data/src/extract/extract_worksheet_table_relationships.rb

@@ -0,0 +1,10 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractWorksheetTableRelationships < SimpleExtractFromXML
+
+  def start_element(name,attributes)
+    return false unless name == "tablePart"
+    output.puts "#{attributes.assoc('r:id').last}"
+  end
+
+end

data/src/extract/simple_extract_from_xml.rb

@@ -0,0 +1,19 @@
+require 'nokogiri'
+
+class SimpleExtractFromXML < Nokogiri::XML::SAX::Document 
+
+    attr_accessor :parsing, :input, :output
+  
+    def self.extract(input,output)
+      self.new.extract(input,output)
+    end
+
+    def extract(input,output)
+      @input, @output = input, output
+      parsing = false
+      parser = Nokogiri::XML::SAX::Parser.new(self)
+      parser.parse(input)
+      output
+    end
+    
+end

data/src/rewrite.rb

@@ -0,0 +1,10 @@
+require_relative "rewrite/rewrite_formulae_to_ast"
+require_relative "rewrite/rewrite_worksheet_names"
+require_relative "rewrite/rewrite_whole_row_column_references_to_areas"
+require_relative "rewrite/rewrite_shared_formulae"
+require_relative "rewrite/rewrite_array_formulae_to_arrays"
+require_relative "rewrite/rewrite_array_formulae"
+require_relative "rewrite/rewrite_values_to_ast"
+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"

data/src/rewrite/ast_copy_formula.rb

@@ -0,0 +1,42 @@
+require_relative '../excel'
+require_relative '../util/not_supported_exception'
+
+class AstCopyFormula
+  attr_accessor :rows_to_move
+  attr_accessor :columns_to_move
+  
+  def initialize
+    self.rows_to_move = 0
+    self.columns_to_move = 0
+  end
+  
+  def copy(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| copy(a) }]
+    end
+  end
+  
+  def cell(reference)
+    r = Reference.for(reference)
+    [:cell,r.offset(rows_to_move,columns_to_move)]
+  end
+  
+  def area(start,finish)
+    s = Reference.for(start).offset(rows_to_move,columns_to_move)
+    f = Reference.for(finish).offset(rows_to_move,columns_to_move)
+    [:area,s,f]
+  end
+    
+  def column_range(reference)
+    raise NotSupportedException.new("Column ranges not suported in AstCopyFormula")
+  end
+
+  def row_range(reference)
+    raise NotSupportedException.new("Row ranges not suported in AstCopyFormula")
+  end  
+  
+end

data/src/rewrite/ast_expand_array_formulae.rb

@@ -0,0 +1,180 @@
+require_relative '../excel'
+
+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
+  end
+
+  def arithmetic(left,operator,right)
+    left = map(left)
+    right = map(right)
+    return [:arithmetic, left, operator, right] unless array?(left,right)
+    
+    map_arrays([left,right]) do |arrayed|
+      [:arithmetic,arrayed[0],operator,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
+  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
+  end
+  
+  def map_arrays(arrays, &block)
+    # Turn them into ruby arrays
+    arrays = arrays.map { |a| array_ast_to_ruby_array(a) }
+
+    # Find the largest one
+    max_rows = arrays.max { |a,b| a.length <=> b.length }.length
+    max_columns = arrays.max { |a,b| a.first.length <=> b.first.length }.first.length
+    
+    # Convert any single rows into an array of the right size
+    arrays = arrays.map { |a| a.length == 1 ? Array.new(max_rows,a.first) : a }
+    
+    # Convert any single columns into an array of the right size
+    arrays = arrays.map { |a| a.first.length == 1 ? Array.new(max_columns,a.flatten(1)).transpose : a }
+    
+    # Now iterate through
+    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"]
+        end)
+      end]
+    end]
+  end
+  
+  FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS = %w{AVERAGE COUNT COUNTA MAX MIN SUM SUMPRODUCT}
+  
+  def function(name,*arguments)
+    if FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS.include?(name)
+      [:function, name, *arguments.map { |a| map(a) }]
+    elsif respond_to?("map_#{name.downcase}")
+      send("map_#{name.downcase}",*arguments)
+    else
+      function_that_does_not_accept_ranges(name,arguments)
+    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)
+  end
+  
+  def map_match(*args)
+    $DEBUGN = true
+    a = array_map args, 'MATCH', false, true, false
+    $DEBUGN = false
+    a
+  end
+  
+  def map_subtotal(*args)
+    array_map args, 'SUBTOTAL', false, *Array.new(args.length-1,true)
+  end
+  
+  def map_index(*args)
+    array_map args, 'INDEX', true, false, false
+  end
+  
+  def map_sumif(*args)
+    array_map args, 'SUMIF', 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))
+    else
+      array_map args, 'SUMIFS', true, true, false
+    end
+  end
+  
+  def map_vlookup(*args)
+    array_map args, "VLOOKUP", false, true, false, false
+  end
+  
+  private
+  
+  def no_need_to_array?(args,ok_to_be_an_array)
+    ok_to_be_an_array.each_with_index do |array_ok,i|
+      unless array_ok
+        if args[i].first == :array
+          return false
+        end
+      end
+    end
+    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)
+
+    # 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| 
+      unless ok_to_be_an_array[i]
+        a = array_ast_to_ruby_array(a)
+        r = a.length
+        c = a.first.length
+        max_rows = r if r > max_rows
+        max_columns = c if c > max_columns
+      end
+      a
+    end
+        
+    # Convert any single rows into an array of the right size
+    args = args.map.with_index { |a,i| (!ok_to_be_an_array[i] && a.length == 1) ? Array.new(max_rows,a.first) : a }
+    
+    # Convert any single columns into an array of the right size
+    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|
+      [:row, *max_columns.times.map do |column| 
+        [:function, function, *args.map.with_index do |a,i|
+          if ok_to_be_an_array[i]
+            a
+          else
+            a[row][column] || [:error, "#N/A"]
+          end
+        end]
+      end]
+    end]
+  end
+  
+  def array?(*args)
+    args.any? { |a| a.first == :array }
+  end
+  
+  def array_ast_to_ruby_array(array_ast)
+    return [[array_ast]] unless array_ast.first == :array
+    array_ast[1..-1].map do |row_ast|
+      row_ast[1..-1].map do |cell|
+        cell
+      end
+    end
+  end
+  
+end

data/src/rewrite/rewrite_array_formulae.rb

@@ -0,0 +1,71 @@
+class ExtractArrayFormulaForCell
+  
+  attr_accessor :row_offset, :column_offset
+  
+  def map(ast)
+    case ast.first
+    when :array; map_array(ast)
+    when :function; map_function(ast)
+    else return ast
+    end
+  end
+  
+  def map_array(ast)
+    if (@row_offset + 1) >= ast.length 
+      if ast.length == 2
+        @row_offset = 0
+      else
+        return [:error, "#N/A"]
+      end
+    end
+
+    if (@column_offset + 1) >= ast[1].length
+      if ast[1].length == 2
+        @column_offset = 0
+      else
+        return [: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}
+  
+  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]]
+  end
+  
+end
+
+class RewriteArrayFormulae
+  def self.rewrite(input,output)
+    new.rewrite(input,output)
+  end
+  
+  def rewrite(input,output)
+    input.lines do |line|
+      ref, array_range, formula = line.split("\t")
+      array_formula(formula,array_range,output)
+    end
+  end
+  
+  def array_formula(formula,array_range,output)
+    array_ast = eval(formula)
+    array_range = "#{array_range}:#{array_range}" unless array_range.include?(':')
+    array_range = Area.for(array_range)
+    array_range.calculate_excel_variables
+    start_reference = array_range.excel_start
+    mapper = ExtractArrayFormulaForCell.new
+    
+    # Then we rewrite each of the subsidiaries
+    array_range.offsets.each do |row,column|
+      mapper.row_offset = row
+      mapper.column_offset = column
+      ref = start_reference.offset(row,column)
+      output.puts "#{ref}\t#{mapper.map(array_ast).inspect}"
+    end
+  end
+  
+end

data/src/rewrite/rewrite_array_formulae_to_arrays.rb

@@ -0,0 +1,18 @@
+require_relative "ast_expand_array_formulae"
+
+class RewriteArrayFormulaeToArrays
+  
+  def self.rewrite(*args)
+    new.rewrite(*args)
+  end
+  
+  def rewrite(input,output)
+    mapper = AstExpandArrayFormulae.new
+    input.lines do |line|
+      content = line.split("\t")
+      ast = eval(content.pop)
+      output.puts "#{content.join("\t")}\t#{mapper.map(ast).inspect}"
+    end
+  end
+  
+end

data/src/rewrite/rewrite_cell_references_to_include_sheet.rb

@@ -0,0 +1,56 @@
+require_relative '../excel'
+
+class RewriteCellReferencesToIncludeSheetAst 
+  
+  attr_accessor :worksheet
+    
+  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 cell(ref)
+    [:sheet_reference, worksheet, [:cell, ref]]
+  end
+  
+  def area(start,finish)
+    [:sheet_reference, worksheet, [:area, start, finish]]    
+  end
+  
+  def sheet_reference(sheet_name,reference)
+    [:sheet_reference, sheet_name, reference]
+  end
+
+end
+
+class RewriteCellReferencesToIncludeSheet
+  
+  def self.rewrite(*args)
+    new.rewrite(*args)
+  end
+  
+  attr_accessor :worksheet
+  
+  def rewrite(input,output)
+    mapper = RewriteCellReferencesToIncludeSheetAst.new
+    mapper.worksheet = worksheet
+    input.lines do |line|
+      if line =~ /(:area|:cell)/
+        content = line.split("\t")
+        ast = eval(content.pop)
+        output.puts "#{content.join("\t")}\t#{mapper.map(ast).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+  
+end