excel_to_code 0.1.23 → 0.2.0

data/src/extract/extract_everything.rb

@@ -0,0 +1,140 @@
+require 'ox'
+
+class ExtractEverythingFromWorkbook < ::Ox::Sax
+
+  attr_accessor :table_rids
+  attr_accessor :worksheets_dimensions
+  attr_accessor :values
+  attr_accessor :formulae_simple
+  attr_accessor :formulae_array
+  attr_accessor :formulae_shared
+  attr_accessor :formulae_shared_targets
+
+  def initialize
+    # State
+    @current_element = []
+
+    # For parsing formulae
+    @fp = CachingFormulaParser.instance
+
+    # Outputs
+    @table_rids ||= {}
+    @worksheets_dimensions ||= {}
+    @values ||= {}
+    @formulae_simple ||= {}
+    @formulae_array ||= {}
+    @formulae_shared ||= {}
+    @formulae_shared_targets ||= {}
+  end
+
+  def extract(sheet_name, input_xml)
+    @sheet_name = sheet_name.to_sym
+    Ox.sax_parse(self, input_xml, :convert_special => true)
+    self
+  end
+    
+  def start_element(name)
+    case name
+    when :v # :v is value
+      @current_element.push(name)
+      @value = []
+    when :f # :f is formula
+      @current_element.push(name)
+      @formula = []
+      @formula_type = 'simple' # Default is a simple formula, alternatives are shared or array
+      @formula_ref = nil # Used to specify range for shared or array formulae
+      @si = nil # Used to specify the index for shared formulae
+    when :c # :c is cell, wraps values and formulas
+      @current_element.push(name)
+      @ref = nil
+      @value_type = 'n' #Default type is number
+    when :dimension, :tablePart
+      @current_element.push(name)
+    end
+  end
+
+  def key
+    [@sheet_name, @ref]
+  end
+
+  def end_element(name)
+    case name
+    when :v
+      @current_element.pop
+      value = @value.join
+      ast = case @value_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 "Value of type #{@value_type} not known #{@sheet_name} #{@ref}"
+        exit
+      end
+      @values[key] = @fp.map(ast)
+    when :f
+      @current_element.pop
+      unless @formula.empty?
+        formula_text = @formula.join.gsub(/[\r\n]+/,'')
+        ast = @fp.parse(formula_text)
+        unless ast
+          $stderr.puts "Could not parse #{@sheet_name} #{@ref} #{formula_text}"
+          exit
+        end
+      end
+      case @formula_type
+      when 'simple'
+        return if @formula.empty?
+        @formulae_simple[key] = ast
+      when 'shared'
+        @formulae_shared_targets[key] = @si
+        if ast
+          @formulae_shared[key] = [@formula_ref, @si, ast]
+        end
+      when 'array'
+        @formulae_array[key] = [@formula_ref, ast]
+      end
+    when :dimension, :tablePart, :c
+      @current_element.pop
+    end
+  end
+
+  def attr(name, value)
+    case @current_element.last
+    when :dimension
+      return unless name == :ref
+      @worksheets_dimensions[@sheet_name] = value
+    when :tablePart
+      return unless name == :'r:id'
+      @table_rids[@sheet_name] ||= []
+      @table_rids[@sheet_name] << value
+    when :c
+      case name
+      when :r
+        @ref = value.to_sym
+      when :t
+        @value_type = value
+      end
+    when :f
+      case name
+      when :t
+        @formula_type = value
+      when :si
+        @si = value
+      when :ref
+        @formula_ref = value
+      end
+    end
+  end
+
+  def text(text)
+    case @current_element.last
+    when :v
+      @value << text
+    when :f
+      @formula << text
+    end
+  end
+
+end

data/src/extract/extract_formulae.rb

@@ -1,36 +1,46 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
+
+class ExtractFormulae < 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
+    Nokogiri::XML::SAX::Parser.new(self).parse(input)
+    @output
+  end
 
-class ExtractFormulae < SimpleExtractFromXML
-  
-  attr_accessor :ref, :formula
-  
   def start_element(name,attributes)
     if name == 'c'
-      @ref = attributes.assoc('r').last
+      @ref = attributes.assoc('r').last.to_sym
     elsif name == "f"
       type = attributes.assoc('t')
       @formula = []
       start_formula( type && type.last, attributes)
     end
   end
-  
-  def start_formula(type,attributes)
-    # Should be overriden in sub classes
-  end
-  
-  def write_formula
-    # Should be overriden in sub classes
-  end
-  
+
   def end_element(name)
-    return unless parsing && name == "f"
-    self.parsing = false
+    return unless @parsing && name == "f"
+    @parsing = false
     write_formula
   end
-  
+
   def characters(string)
-    return unless parsing
+    return unless @parsing
     @formula.push(string)
   end
-  
+
+  def start_formula(type,attributes)
+    # Override
+  end
+
+  def write_formula   
+    # Override
+  end
+
 end

data/src/extract/extract_named_references.rb

@@ -1,38 +1,53 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
+
+class ExtractNamedReferences < Nokogiri::XML::SAX::Document 
+
+  attr_accessor :parsing, :input, :output
+
+  def self.extract(input)
+    self.new.extract(input)
+  end
 
-class ExtractNamedReferences < SimpleExtractFromXML
-  
-  attr_accessor :sheet_names
-  
   def initialize
     super
     @sheet_names = []
   end
-  
+
+  def extract(input)
+    @input, @output = input, {}
+    @sheet = nil
+    @name = nil
+    @reference = nil
+    parser = Nokogiri::XML::SAX::Parser.new(self)
+    parser.parse(@input)
+    @output
+  end
+
   def start_element(name,attributes)
     if name == "sheet"
-      sheet_names << attributes.assoc('name').last
+      @sheet_names << attributes.assoc('name').last
     elsif name == "definedName"
-      @parsing = true    
-      sheet = attributes.assoc('localSheetId')
-      if sheet
-        output.write sheet_names[sheet.last.to_i]
-      end
-      output.write "\t"
-      output.write attributes.assoc('name').last
-      output.write "\t"
+      @sheet = attributes.assoc('localSheetId') && @sheet_names[attributes.assoc('localSheetId').last.to_i].downcase.to_sym
+      @name =  attributes.assoc('name').last.downcase.to_sym
+      @reference = ""
     end
   end
-  
+
   def end_element(name)
     return unless name == "definedName"
-    self.parsing = false
-    output.putc "\n"
+    if @sheet
+      @output[[@sheet, @name]] = @reference.gsub('$', '')
+    else
+      @output[@name] = @reference.gsub('$', '')
+    end
+    @sheet = nil
+    @name = nil
+    @reference = nil
   end
-  
+
   def characters(string)
-    return unless parsing
-    output.write string
+    return unless @reference
+    @reference << string
   end
-  
+
 end

data/src/extract/extract_relationships.rb

@@ -1,10 +1,23 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractRelationships < SimpleExtractFromXML
+class ExtractRelationships < 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 == "Relationship"
-    output.puts "#{attributes.assoc('Id').last}\t#{attributes.assoc('Target').last}"
+    @output[attributes.assoc('Id').last] = attributes.assoc('Target').last
   end
   
 end

data/src/extract/extract_shared_formulae.rb

@@ -2,9 +2,6 @@ require_relative 'extract_formulae'
 
 class ExtractSharedFormulae < ExtractFormulae
   
-  attr_accessor :shared_range
-  attr_accessor :shared_formula_identifier
-  
   def start_formula(type,attributes)
     return unless type == 'shared' && attributes.assoc('ref')
     @shared_range = attributes.assoc('ref').last
@@ -14,14 +11,14 @@ class ExtractSharedFormulae < ExtractFormulae
   
   def write_formula
     return if @formula.empty?
-    output.write @ref
-    output.write "\t"
-    output.write @shared_range
-    output.write "\t"
-    output.write @shared_formula_identifier
-    output.write "\t"
-    output.write @formula.join.gsub(/[\n\r]+/,'')
-    output.write "\n"
+    formula_text = @formula.join.gsub(/[\r\n]+/,'')
+    ast = CachingFormulaParser.parse(formula_text)
+    unless ast
+      $stderr.puts "Could not parse #{@sheet_name} #{@ref} #{formula_text}"
+      exit
+    end
+    # FIXME: Should leave in original form rather than converting to ast?
+    @output[[@sheet_name, @ref]] = [@shared_range, @shared_formula_identifier, ast]
   end
   
 end

data/src/extract/extract_shared_formulae_targets.rb

@@ -2,8 +2,6 @@ require_relative 'extract_formulae'
 
 class ExtractSharedFormulaeTargets < ExtractFormulae
   
-  attr_accessor :shared_formula_identifier
-
   def start_formula(type,attributes)
     return unless type == 'shared'
     @shared_formula_identifier = attributes.assoc('si').last
@@ -11,10 +9,7 @@ class ExtractSharedFormulaeTargets < ExtractFormulae
   end
   
   def write_formula
-    output.write @ref
-    output.write "\t"
-    output.write @shared_formula_identifier
-    output.write "\n"
+    @output[[@sheet_name, @ref]] = @shared_formula_identifier
   end
   
 end

data/src/extract/extract_shared_strings.rb

@@ -1,20 +1,33 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractSharedStrings < SimpleExtractFromXML
+class ExtractSharedStrings < Nokogiri::XML::SAX::Document 
+
+    def self.extract(input)
+      self.new.extract(input)
+    end
+
+    def extract(input)
+      @input, @output = input, []
+      @current = nil
+      parser = Nokogiri::XML::SAX::Parser.new(self)
+      parser.parse(input)
+      @output
+    end
 
   def start_element(name,attributes)
-    self.parsing = true if name == "si"
+    @current = [] if name == "si"
   end
   
   def end_element(name)
     return unless name == "si"
-    self.parsing = false
-    output.putc "\n"
+    @output << [:string, @current.join]
+    @current = nil
   end
   
   def characters(string)
-    return unless parsing
-    output.write string.gsub("\n","")
+    return unless @current
+    # FIXME: SHOULDN'T ELINMATE NEWLINES
+    @current << string.gsub("\n","")
   end
   
-end
+end

data/src/extract/extract_simple_formulae.rb

@@ -1,18 +1,23 @@
 require_relative 'extract_formulae'
 
 class ExtractSimpleFormulae < ExtractFormulae
-  
+
   def start_formula(type,attributes)
+    # Simple formulas don't have a type
     return if type
     @parsing = true
   end
-  
+
   def write_formula   
     return if @formula.empty?
-    output.write @ref
-    output.write "\t"
-    output.write @formula.join.gsub(/[\r\n]+/,'')
-    output.write "\n"
+    formula_text = @formula.join.gsub(/[\r\n]+/,'')
+    ast = CachingFormulaParser.parse(formula_text)
+    unless ast
+      $stderr.puts "Could not parse #{@sheet_name} #{@ref} #{formula_text}"
+      exit
+    end
+    # FIXME: Should leave in original form rather than converting to ast?
+    @output[[@sheet_name, @ref]] = ast
   end
 
 end

data/src/extract/extract_table.rb

@@ -1,24 +1,37 @@
-require_relative 'simple_extract_from_xml'
+require 'nokogiri'
 
-class ExtractTable < SimpleExtractFromXML
-  
-  attr_accessor :worksheet_name
-  
-  def initialize(worksheet_name = nil)
-    super()
-    @worksheet_name = worksheet_name
-  end
-  
+class ExtractTable < Nokogiri::XML::SAX::Document 
+
+    def self.extract(*args)
+      self.new.extract(*args)
+    end
+
+    def extract(sheet_name, input)
+      @sheet_name = sheet_name
+      @output = {} 
+      @table_name = nil
+      @table_ref = nil
+      @table_total_rows = nil
+      @table_columns = nil
+
+      @parsing = false
+      Nokogiri::XML::SAX::Parser.new(self).parse(input)
+      @output
+    end
+    
   def start_element(name,attributes)
     if name == "table"
-      output.write "#{attributes.assoc('displayName').last}\t#{@worksheet_name}\t#{attributes.assoc('ref').last}\t#{attributes.assoc('totalsRowCount').try(:last) || 0}"
+      @table_name = attributes.assoc('displayName').last
+      @table_ref = attributes.assoc('ref').last
+      @table_total_rows = attributes.assoc('totalsRowCount').try(:last) || "0"
+      @table_columns = []
     elsif name == "tableColumn"
-      output.write "\t#{attributes.assoc('name').last}"
+      @table_columns << attributes.assoc('name').last
     end
   end
   
   def end_element(name)
     return unless name == "table"
-    output.putc "\n"
+    @output[@table_name] = [@sheet_name, @table_ref, @table_total_rows, *@table_columns]
   end  
 end