excel_to_code 0.0.1

data/src/excel/formula_peg.txt

@@ -0,0 +1,45 @@
+formula                         := space? expression+
+expression                       = string_join | comparison | arithmetic | thing
+thing                            = function | array | brackets | any_reference | string | percentage | number | boolean | prefix | named_reference 
+argument                         = expression | null
+function                        := /[A-Z]+/ `'(' space argument? (space `',' space argument)* space `')'
+brackets                        := `'(' space expression+ space `')'
+array							:= `'{' space  row ( space `';' space row )* space `'}'
+row								:= basic_type ( space `',' space basic_type )*
+basic_type						 = string | percentage | number | boolean
+string_join                     := (arithmetic | thing) (space `"&" space (arithmetic | thing))+
+arithmetic                      := thing (space operator space thing)+
+comparison                      := (arithmetic | thing) space comparator space (arithmetic | thing)
+comparator                      := '>=' | '<=' | '<>' | '>' | '<' | '='
+string                          := `'"' /(""|[^"])*/ `'"'
+any_reference                    = external_reference | any_internal_reference
+any_internal_reference           = table_reference | local_table_reference | sheet_reference | sheetless_reference
+percentage                      := /[-+]?[0-9]+\.?[0-9]*/ `'%'
+number                          := /[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/
+operator                        := '+' | '-' | '/' | '*' | '^'
+external_reference              := /\[\d+\]!?/ any_internal_reference
+table_reference                 := table_name `'[' (range_structured_reference | complex_structured_reference | simple_structured_reference) `']'
+local_table_reference           := `'[' (range_structured_reference | complex_structured_reference | overly_structured_reference | simple_structured_reference) `']'
+table_name                       = /[.a-zA-Z0-9_]+/
+range_structured_reference       = /\[[^\u005d]*\],\[[^\u005d]*\]:\[[^\u005d]*\]/
+complex_structured_reference     = /\[[^\u005d]*\],\[[^\u005d]*\]/
+overly_structured_reference      = `'[' simple_structured_reference `']'
+simple_structured_reference      = /[^\u005d]*/
+named_reference                 := /[#a-zA-Z][\w_.!]+/
+sheet_reference                 := (single_quoted_string | /[a-zA-Z0-9][\w_.]+/) `'!' (sheetless_reference | named_reference)
+single_quoted_string             = `"'" /[^']*/ `"'"
+sheetless_reference              = column_range | row_range | area | cell
+column_range                    := column `':' column
+row_range                       := row_number `':' row_number
+area                            := reference `':' reference
+cell                            := reference
+row_number                       = /\$?\d+/
+column                           = /\$?[A-Za-z]{1,3}/
+reference                        = /\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_])/
+boolean                          = boolean_true | boolean_false
+boolean_true                    := `'TRUE'
+boolean_false                   := `'FALSE'
+prefix                          := /[-+]/ thing
+space                            = `/[ \n]*/
+null                            := &','
+

data/src/excel/reference.rb

@@ -0,0 +1,56 @@
+class Reference < String
+  
+  # This is so that we only have one instance for a given reference
+  @@references_for_text ||= Hash.new do |hash,text|
+    hash[text] = reference = Reference.new(text)
+    reference
+  end
+    
+  # This is so that we only have one instance of a given reference specified by its variables
+  def Reference.for(text)
+     @@references_for_text[text]
+  end
+    
+  # This caches the calculation for turning column letters (e.g., AAB) into column numbers (e.g., 127)
+  @@column_number_for_column ||= Hash.new do |hash,letters|
+    number = letters.downcase.each_byte.to_a.reverse.each.with_index.inject(0) do |memo,byte_with_index,c|
+      memo + ((byte_with_index.first - 96) * (26**byte_with_index.last))
+    end
+    hash[letters] = number
+    @@column_letters_for_column_number[number] = letters.upcase
+    number
+  end
+  
+  # This caches the calculation for turning column numbers (e.g., 127) into column letters (e.g., AAB)
+  @@column_letters_for_column_number ||= Hash.new do |hash,number|
+    letters = (number-1).to_i.to_s(26)
+    letters = (letters[0...-1].tr('1-9a-z','abcdefghijklmnopqrstuvwxyz') + letters[-1,1].tr('0-9a-z','abcdefghijklmnopqrstuvwxyz')).gsub('a0','z').gsub(/([b-z])0/) { $1.tr('b-z','a-y')+"z" }
+    letters.upcase!
+    hash[number] = letters
+    @@column_number_for_column[letters] = number
+    letters
+  end
+  
+  attr_reader :excel_row_number, :excel_column_number, :excel_column, :excel_row
+  
+  def calculate_excel_variables
+    return if @excel_variables_calculated
+    self =~ /(\$)?([A-Za-z]{1,3})(\$)?([0-9]+)/
+    @excel_fixed_column, @excel_column, @excel_fixed_row, @excel_row = $1, $2, $3, $4
+    @excel_row_number = @excel_row.to_i
+    @excel_column_number = @@column_number_for_column[@excel_column]
+    @excel_variables_calculated = true
+  end
+    
+  def offset(rows,columns)
+    calculate_excel_variables
+    new_column = @excel_fixed_column ? @excel_column :  @@column_letters_for_column_number[@excel_column_number + columns]
+    new_row = @excel_fixed_row ? @excel_row : @excel_row_number + rows
+    Reference.new([@excel_fixed_column,new_column,@excel_fixed_row,new_row].join)
+  end
+  
+  def unfix
+    gsub("$","")
+  end
+  
+end

data/src/excel/table.rb

@@ -0,0 +1,108 @@
+require_relative '../excel'
+require_relative '../util'
+
+class Table
+  
+  attr_accessor :name
+  
+  def initialize(name,worksheet,reference,number_of_total_rows,*column_name_array)
+    @name, @worksheet, @area, @number_of_total_rows, @column_name_array = name, worksheet, Area.for(reference), number_of_total_rows.to_i, column_name_array.map { |c| c.strip.downcase }
+    @area.calculate_excel_variables    
+    @data_area = Area.for("#{@area.excel_start.offset(1,0)}:#{@area.excel_finish.offset(-@number_of_total_rows,0)}")
+  end
+  
+  def reference_for(table_name,structured_reference,calling_worksheet,calling_cell)
+    raise NotSupportedException.new("Local table reference not supported in #{structured_reference.inspect}") unless table_name
+    case structured_reference
+    when /\[#Headers\],\[(.*?)\]:\[(.*?)\]/io
+      column_number_start = @column_name_array.find_index($1.strip.downcase)
+      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      return ref_error unless column_number_start && column_number_finish
+      ast_for_area @area.excel_start.offset(0,column_number_start), @area.excel_start.offset(0,column_number_finish)
+    when /\[#Totals\],\[(.*?)\]:\[(.*?)\]/io
+      column_number_start = @column_name_array.find_index($1.strip.downcase)
+      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      return ref_error unless column_number_start && column_number_finish
+      ast_for_area @area.excel_start.offset(@area.height,column_number_start), @area.excel_start.offset(@area.height,column_number_finish)
+    when /\[#This Row\],\[(.*?)\]:\[(.*?)\]/io
+      r = Reference.for(calling_cell)
+      r.calculate_excel_variables
+      row = r.excel_row_number
+      column_number_start = @column_name_array.find_index($1.strip.downcase)
+      column_number_finish = @column_name_array.find_index($2.strip.downcase)
+      return ref_error unless column_number_start && column_number_finish
+      ast_for_area @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number_start), @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number_finish)      
+    when /\[#Headers\],\[(.*?)\]/io
+      column_number = @column_name_array.find_index($1.strip.downcase)
+      return ref_error unless column_number      
+      ast_for_cell @area.excel_start.offset(0,column_number)
+    when /\[#Totals\],\[(.*?)\]/io
+      column_number = @column_name_array.find_index($1.strip.downcase)
+      return ref_error unless column_number
+      ast_for_cell @area.excel_start.offset(@area.height,column_number)
+    when /\[#This Row\],\[(.*?)\]/io
+      r = Reference.for(calling_cell)
+      r.calculate_excel_variables
+      row = r.excel_row_number
+      column_number = @column_name_array.find_index($1.strip.downcase)
+      return ref_error unless column_number
+      ast_for_cell @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number)      
+    when /#Headers/io
+      if calling_worksheet == @worksheet && @data_area.includes?(calling_cell)
+        r = Reference.for(calling_cell)
+        r.calculate_excel_variables
+        ast_for_cell "#{r.excel_column}#{@area.excel_start.excel_row_number}"
+      else
+        ast_for_area @area.excel_start.offset(0,0), @area.excel_start.offset(0,@area.width)
+      end
+    when /#Totals/io
+      if calling_worksheet == @worksheet && @data_area.includes?(calling_cell)
+        r = Reference.for(calling_cell)
+        r.calculate_excel_variables
+        ast_for_cell "#{r.excel_column}#{@area.excel_finish.excel_row_number}"
+      else
+        ast_for_area @area.excel_start.offset(@area.height,0), @area.excel_start.offset(@area.height,@area.width)
+      end
+    when /#Data/io, ""
+      ast_for_area @data_area.excel_start, @data_area.excel_finish
+    when /#All/io, ""
+      ast_for_area @area.excel_start, @area.excel_finish
+    when /#This Row/io
+      r = Reference.for(calling_cell)
+      r.calculate_excel_variables
+      row = r.excel_row_number
+      ast_for_area "#{@area.excel_start.excel_column}#{row}", "#{@area.excel_finish.excel_column}#{row}"
+    else
+      if calling_worksheet == @worksheet && @data_area.includes?(calling_cell)
+        r = Reference.for(calling_cell)
+        r.calculate_excel_variables
+        row = r.excel_row_number
+        column_number = @column_name_array.find_index(structured_reference.strip.downcase)
+        return ref_error unless column_number
+        ast_for_cell @area.excel_start.offset(row - @area.excel_start.excel_row_number,column_number)      
+      else        
+        column_number = @column_name_array.find_index(structured_reference.strip.downcase)
+        return ref_error unless column_number
+        ast_for_area @area.excel_start.offset(1,column_number), @area.excel_start.offset(@area.height - @number_of_total_rows,column_number)
+      end
+    end
+  end
+  
+  def ast_for_area(start,finish)
+    [:sheet_reference,@worksheet,[:area,start,finish]]
+  end
+  
+  def ast_for_cell(ref)
+    [:sheet_reference,@worksheet,[:cell,ref]]
+  end
+  
+  def ref_error
+    [:error,"#REF!"]
+  end
+  
+  def includes?(sheet,reference)
+    return false unless @worksheet == sheet
+    @area.includes?(reference)
+  end
+  
+end

data/src/excel_to_code.rb

@@ -0,0 +1,7 @@
+require_relative 'commands'
+require_relative 'compile'
+require_relative 'excel'
+require_relative 'extract'
+require_relative 'rewrite'
+require_relative 'simplify'
+require_relative 'util'

data/src/extract.rb

@@ -0,0 +1,13 @@
+require_relative 'extract/check_for_unknown_functions'
+require_relative "extract/extract_array_formulae"
+require_relative "extract/extract_formulae"
+require_relative "extract/extract_relationships"
+require_relative "extract/extract_shared_formulae"
+require_relative "extract/extract_shared_strings"
+require_relative "extract/extract_simple_formulae"
+require_relative "extract/extract_values"
+require_relative "extract/extract_worksheet_dimensions"
+require_relative "extract/extract_worksheet_names"
+require_relative "extract/extract_named_references"
+require_relative "extract/extract_worksheet_table_relationships"
+require_relative "extract/extract_table"

data/src/extract/check_for_unknown_functions.rb

@@ -0,0 +1,20 @@
+require_relative '../compile/ruby/map_formulae_to_ruby'
+
+class CheckForUnknownFunctions
+  
+  attr_accessor :settable
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def check(input,output)
+    self.settable ||= lambda { |ref| false }
+    input.lines do |line|
+      line.scan(/\[:function, "(.*?)"/).each do |match|
+        output.puts $1 unless MapFormulaeToRuby::FUNCTIONS.has_key?($1)
+      end
+    end
+  end
+  
+end

data/src/extract/extract_array_formulae.rb

@@ -0,0 +1,23 @@
+require_relative 'extract_formulae'
+
+class ExtractArrayFormulae < ExtractFormulae
+  
+  attr_accessor :array_range
+  
+  def start_formula(type,attributes)
+    return unless type == 'array' && attributes.assoc('ref')
+    @array_range = attributes.assoc('ref').last
+    @parsing = true
+  end
+  
+  def write_formula
+    return false if @formula.empty?
+    output.write @ref
+    output.write "\t"
+    output.write @array_range
+    output.write "\t"
+    output.write @formula.join
+    output.write "\n"
+  end
+
+end

data/src/extract/extract_formulae.rb

@@ -0,0 +1,36 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractFormulae < SimpleExtractFromXML
+  
+  attr_accessor :ref, :formula
+  
+  def start_element(name,attributes)
+    if name == 'c'
+      @ref = attributes.assoc('r').last
+    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
+    write_formula
+  end
+  
+  def characters(string)
+    return unless parsing
+    @formula.push(string)
+  end
+  
+end

data/src/extract/extract_named_references.rb

@@ -0,0 +1,38 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractNamedReferences < SimpleExtractFromXML
+  
+  attr_accessor :sheet_names
+  
+  def initialize
+    super
+    @sheet_names = []
+  end
+  
+  def start_element(name,attributes)
+    if name == "sheet"
+      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"
+    end
+  end
+  
+  def end_element(name)
+    return unless name == "definedName"
+    self.parsing = false
+    output.putc "\n"
+  end
+  
+  def characters(string)
+    return unless parsing
+    output.write string
+  end
+  
+end

data/src/extract/extract_relationships.rb

@@ -0,0 +1,10 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractRelationships < SimpleExtractFromXML
+  
+  def start_element(name,attributes)
+    return false unless name == "Relationship"
+    output.puts "#{attributes.assoc('Id').last}\t#{attributes.assoc('Target').last}"
+  end
+  
+end

data/src/extract/extract_shared_formulae.rb

@@ -0,0 +1,23 @@
+require_relative 'extract_formulae'
+
+class ExtractSharedFormulae < ExtractFormulae
+  
+  attr_accessor :shared_range
+  
+  def start_formula(type,attributes)
+    return unless type == 'shared' && attributes.assoc('ref')
+    @shared_range = attributes.assoc('ref').last
+    @parsing = true
+  end
+  
+  def write_formula
+    return if @formula.empty?
+    output.write @ref
+    output.write "\t"
+    output.write @shared_range
+    output.write "\t"
+    output.write @formula.join
+    output.write "\n"
+  end
+  
+end

data/src/extract/extract_shared_strings.rb

@@ -0,0 +1,20 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractSharedStrings < SimpleExtractFromXML
+
+  def start_element(name,attributes)
+    self.parsing = true if name == "si"
+  end
+  
+  def end_element(name)
+    return unless name == "si"
+    self.parsing = false
+    output.putc "\n"
+  end
+  
+  def characters(string)
+    return unless parsing
+    output.write string.gsub("\n","")
+  end
+  
+end

data/src/extract/extract_simple_formulae.rb

@@ -0,0 +1,18 @@
+require_relative 'extract_formulae'
+
+class ExtractSimpleFormulae < ExtractFormulae
+  
+  def start_formula(type,attributes)
+    return if type
+    @parsing = true
+  end
+  
+  def write_formula   
+    return if @formula.empty?
+    output.write @ref
+    output.write "\t"
+    output.write @formula.join
+    output.write "\n"
+  end
+
+end

data/src/extract/extract_table.rb

@@ -0,0 +1,24 @@
+require_relative 'simple_extract_from_xml'
+
+class ExtractTable < SimpleExtractFromXML
+  
+  attr_accessor :worksheet_name
+  
+  def initialize(worksheet_name = nil)
+    super()
+    @worksheet_name = worksheet_name
+  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}"
+    elsif name == "tableColumn"
+      output.write "\t#{attributes.assoc('name').last}"
+    end
+  end
+  
+  def end_element(name)
+    return unless name == "table"
+    output.putc "\n"
+  end  
+end