rubyfromexcel 0.0.4

data/lib/excelfile/workbook.rb

@@ -0,0 +1,108 @@
+module RubyFromExcel
+  class Workbook
+  
+    attr_reader   :relationships
+    attr_reader   :worksheets
+    attr_reader   :worksheet_array
+    attr_reader   :named_references
+    attr_accessor :indirects_used
+  
+    def initialize(filename)
+      @worksheets = {}
+      @worksheet_array = []
+      @named_references = {}
+      @indirects_used = false
+      @relationships = Relationships.for_file(filename)
+      xml = File.open(filename) { |f| Nokogiri::XML(f) }.root
+      load_shared_strings
+      puts "\nLoaded shared strings"
+      load_worksheets_from xml
+      puts "Loaded #{worksheets.size} worksheets with #{total_cells} cells in total."
+      work_out_named_references_from(xml)
+      puts "Loaded named references"
+      GC.start
+    end
+  
+    def load_shared_strings
+      return unless relationships.shared_strings
+      SharedStrings.instance.load_strings_from_xml(File.open(relationships.shared_strings) { |f| Nokogiri::XML(f) }.root)    
+    end
+  
+    def load_worksheets_from(xml)
+      xml.css("sheet").each do |s|
+        worksheet_filename = relationships[s['id']]
+        worksheet = Worksheet.from_file(worksheet_filename)
+        worksheet.name = File.basename(worksheet_filename,'.xml')
+        worksheet.workbook = self
+        worksheets[worksheet.name] = worksheet
+        SheetNames.instance[s['name']] = worksheet.name
+        worksheet_array << worksheet
+        puts "Loaded #{worksheet.name} with #{worksheet.cells.size} cells"
+      end
+    end
+  
+    def work_out_named_references_from(xml)
+      xml.css('definedName').each do |defined_name_xml|
+        reference_name = defined_name_xml['name'].gsub(/([a-z])([A-Z])/,'\1_\2').downcase.gsub(/[^a-z0-9_]/,'_')
+        reference = Formula.parse(defined_name_xml.content).visit(FormulaBuilder.new)
+        if defined_name_xml["localSheetId"]
+          worksheet_array[defined_name_xml["localSheetId"].to_i].named_references[reference_name] = reference
+        else
+          named_references[reference_name] = reference
+        end
+      end
+    end
+  
+    def work_out_dependencies
+      puts "Working out dependencies..."
+      worksheets.each do |name,worksheet|
+        puts "Working out dependencies for #{name}"
+        worksheet.work_out_dependencies
+      end
+      puts "Finished working out dependencies"
+    end
+  
+    def workbook_pruner
+      @workbook_pruner ||= WorkbookPruner.new(self)
+    end
+  
+    def prune_cells_not_needed_for_output_sheets(*output_sheets)
+      workbook_pruner.prune_cells_not_needed_for_output_sheets(*output_sheets)
+    end
+  
+    def convert_cells_to_values_when_independent_of_input_sheets(*input_sheets)
+      workbook_pruner.convert_cells_to_values_when_independent_of_input_sheets(*input_sheets)
+    end
+  
+    def cell(reference)
+      reference =~ /^(sheet\d+)\.([a-z]+\d+)$/
+      worksheets[$1].cell($2)
+    end
+  
+    def to_ruby(r = RubyScriptWriter.new)
+      r.put_coding
+      r.puts "require 'rubyfromexcel'"
+      r.puts
+      r.put_class 'Spreadsheet' do
+        r.puts 'include RubyFromExcel::ExcelFunctions'
+        r.puts
+        if indirects_used
+          r.put_method "initialize" do
+            r.puts "@worksheet_names = #{Hash[SheetNames.instance.sort]}"
+            r.puts "@workbook_tables = #{Hash[Table.tables.sort]}"
+          end
+          named_references.each do |name,reference|
+            r.put_simple_method name, reference
+          end
+        end
+      end
+      r.puts 'Dir[File.join(File.dirname(__FILE__),"sheets/","sheet*.rb")].each {|f| Spreadsheet.autoload(File.basename(f,".rb").capitalize,f)}'
+      r.to_s
+    end
+  
+    def total_cells
+      worksheets.inject(0) { |total,a| a.last.cells.size + total }
+    end
+  
+  end
+end

data/lib/excelfile/worksheet.rb

@@ -0,0 +1,122 @@
+module RubyFromExcel
+  class Worksheet
+  
+    def self.from_file(filename)
+      xml = File.open(filename) { |f| Nokogiri::XML(f).root }
+      worksheet = Worksheet.new(xml)
+      relationships = Relationships.for_file(filename)
+      xml.css('tablePart').each do |table_reference_xml|
+        table_xml = File.open(relationships[table_reference_xml['id']]) {|f| Nokogiri::XML(f).root }
+        Table.from_xml(worksheet,table_xml)
+      end
+      worksheet
+    end
+  
+    attr_accessor :cells
+    attr_accessor :name
+    attr_reader   :named_references
+    attr_accessor :workbook
+  
+    def initialize(xml)
+      self.cells = {}
+      @named_references = {}
+      load_cells_from xml
+      GC.start
+    end
+
+    def load_cells_from(xml)
+      xml.css("c").each do |cell_xml|
+         new_cell = create_cell_from cell_xml
+         next unless new_cell
+         self.cells[new_cell.reference.to_s] = new_cell
+      end
+      xml = nil
+      let_cells_alter_other_cells_if_required
+    end
+  
+    def create_cell_from(xml)
+      formula = xml.at_css("f")
+      if formula
+        formula_type = formula['t']
+        ref = formula['ref']
+        return SimpleFormulaCell.new(self,xml) unless formula_type
+        return SharingFormulaCell.new(self,xml) if formula_type == 'shared' && ref
+        return SharedFormulaCell.new(self,xml) if formula_type == 'shared'
+        return ArrayingFormulaCell.new(self,xml) if formula_type == 'array' && ref =~ /:/
+        return SingleCellArrayFormulaCell.new(self,xml) if formula_type == 'array'
+      end
+      return ValueCell.new(self,xml) if xml.at_css("v")
+      nil
+    end
+  
+    def let_cells_alter_other_cells_if_required
+      cells.each do |reference,cell|
+        cell.alter_other_cells_if_required
+      end
+    end
+  
+    def work_out_dependencies
+      cells.each do |reference,cell|
+        cell.work_out_dependencies
+      end
+    end
+  
+    def cell(reference)
+      cells[reference]
+    end
+  
+    def replace_cell(reference,new_cell)
+      cells[reference] = new_cell
+    end
+  
+    def to_ruby(r = RubyScriptWriter.new)
+      r.put_coding
+      r.comment SheetNames.instance.key(variable_name)
+      r.put_class class_name, 'Spreadsheet' do
+        cells.each do |reference,cell|
+          begin
+            cell.to_ruby(r)
+          rescue Exception => e
+            puts "Error in #{cell.inspect}"
+            raise
+          end
+        end
+        if workbook.indirects_used
+          named_references.each do |name,reference|
+            r.put_simple_method name, reference
+          end
+        end
+      end
+      r.to_s
+    end
+  
+    def to_test(r = RubySpecWriter.new)
+      r.put_coding
+      r.puts "require_relative '../spreadsheet'"
+      r.comment SheetNames.instance.key(variable_name)
+      r.put_description "'#{class_name}'" do
+        r.put_simple_method variable_name, "$spreadsheet ||= Spreadsheet.new; $spreadsheet.#{variable_name}"
+        r.puts
+        cells.each do |reference,cell|
+          cell.to_test(r)
+        end
+      end
+      r.to_s
+    end
+  
+    def class_name
+      name.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  
+    def variable_name
+      name.gsub(/([a-z])([A-Z])/,'\1_\2').downcase.gsub(/[^a-z0-9_]/,'_')
+    end
+  
+    alias to_s variable_name
+  
+    def worksheet_file_name
+      variable_name
+    end
+  
+  end
+end

data/lib/formulae/compile/formula_builder.rb

@@ -0,0 +1,316 @@
+module TerminalNode
+  def to_method_name
+    self.gsub(/([a-z])([A-Z])/,'\1_\2').downcase.gsub(/[^a-z0-9_]/,'_')
+  end  
+end
+
+module RubyFromExcel
+  class ExcelFunctionNotImplementedError < Exception
+  end
+
+  class DependsOnCalculatedFormulaError < Exception
+  end
+
+  class FunctionCompiler
+    include RubyFromExcel::ExcelFunctions
+    attr_accessor :worksheet
+  
+    def initialize(worksheet)
+      self.worksheet = worksheet
+    end
+  
+    def method_missing(method,*arguments, &block)
+      return super unless arguments.empty?
+      return super unless block == nil
+      return find_or_create_worksheet(method.to_s) if method.to_s =~ /sheet\d+/
+      return super unless method.to_s =~ /[a-z]+\d+/
+      cell = worksheet.cell(method.to_s)
+      return 0.0.extend(Empty) unless cell
+      raise DependsOnCalculatedFormulaError.new unless cell.can_be_replaced_with_value?
+      cell.value_for_including
+    end
+  
+    def find_or_create_worksheet(worksheet_name)
+      @worksheets ||= {}
+      return @worksheets[worksheet_name] if @worksheets.has_key?(worksheet_name)
+      new_worksheet = FunctionCompiler.new(worksheet.workbooks.worksheets[worksheet_name])
+      @worksheets[worksheet_name] = new_worksheet
+      new_worksheet
+    end
+  
+    def to_s
+      worksheet.to_s
+    end
+  
+  end
+
+  class FormulaBuilder
+  
+    attr_accessor :formula_cell
+  
+    def initialize(formula_cell = nil)
+      self.formula_cell = formula_cell
+    end
+  
+    def formula(*expressions)
+      expressions.map { |e| e.visit(self) }.join
+    end
+  
+    def number(number_as_text)
+      number_as_text.to_f
+    end
+  
+    def percentage(percentage_as_text)
+      (percentage_as_text.to_f/100).to_s
+    end
+  
+    def brackets(*expression)
+      "(#{expression.map{ |e| e.visit(self)}.join})"
+    end
+  
+    def named_reference(name, worksheet = formula_cell.worksheet)
+      worksheet.named_references[name.to_method_name] || 
+      worksheet.workbook.named_references[name.to_method_name] ||
+      ":name"
+    end
+  
+    def cell(reference)
+      Reference.new(reference).to_ruby
+    end
+  
+    def area(start_area,end_area)
+      "a('#{cell(start_area)}','#{cell(end_area)}')"
+    end
+
+    def column_range(start_area,end_area)
+      "c('#{cell(start_area)}','#{cell(end_area)}')"
+    end
+
+    def row_range(start_area,end_area)
+      "r(#{cell(start_area)},#{cell(end_area)})"
+    end
+  
+    def sheet_reference(sheet_name,reference)
+      sheet_name = $1 if sheet_name.to_s =~ /^(\d+)\.0+$/
+      if reference.type == :named_reference
+        worksheet = formula_cell.worksheet.workbook.worksheets[SheetNames.instance[sheet_name]]
+        raise Exception.new("#{sheet_name.inspect} not found in #{SheetNames.instance} and therefore in #{formula_cell.worksheet.workbook.worksheets.keys}") unless worksheet
+        named_reference(reference.first,worksheet)
+      else
+        "#{SheetNames.instance[sheet_name]}.#{reference.visit(self)}"
+      end
+    end
+  
+    def table_reference(table_name,structured_reference)
+      Table.reference_for(table_name,structured_reference,formula_cell && formula_cell.reference).to_s
+    end
+  
+    def local_table_reference(structured_reference)
+      Table.reference_for_local_reference(formula_cell,structured_reference).to_s
+    end
+  
+    alias :quoted_sheet_reference :sheet_reference
+  
+    OPERATOR_CONVERSIONS = { '^' => '**' }
+  
+    def operator(excel_operator)
+      OPERATOR_CONVERSIONS[excel_operator] || excel_operator
+    end
+  
+    def string_join(*strings)
+      strings.map { |s| s.type == :string ? s.visit(self) : "#{s.visit(self)}.to_s"}.join('+')
+    end
+  
+    def string(string_text)
+      string_text.inspect
+    end
+    
+    def function(name,*args)
+      raise ExcelFunctionNotImplementedError.new("#{name}(#{args})") unless self.respond_to?("#{name.downcase}_function")
+      self.send("#{name.downcase}_function",*args)
+    end
+  
+    def self.excel_function(name,name_to_use_in_ruby = name)
+      define_method("#{name}_function") do |*args|
+        standard_function name_to_use_in_ruby, args
+      end
+    end
+  
+    excel_function :and, :excel_and
+    excel_function :average
+    excel_function :count
+    excel_function :counta
+    excel_function :choose
+    excel_function :abs
+    excel_function :find
+    excel_function :if, :excel_if
+    excel_function :iferror
+    excel_function :iserr
+    excel_function :left
+    excel_function :max
+    excel_function :min
+    excel_function :na
+    excel_function :not, '!'
+    excel_function :or, :excel_or
+    excel_function :sum
+    excel_function :sumif
+    excel_function :sumifs
+    excel_function :subtotal
+    excel_function :sumproduct
+  
+    def standard_function(name_to_use_in_ruby,args)
+      "#{name_to_use_in_ruby}(#{args.map {|a| a.visit(self) }.join(',')})"
+    end
+  
+    def index_function(*args)
+      attempt_to_caclulate_index(*args) ||
+      standard_function("index",args)
+    end
+  
+    def match_function(*args)
+      attempt_to_caclulate_match(*args) ||
+      standard_function("match",args)
+    end
+  
+    def attempt_to_caclulate_index(lookup_array,row_number,column_number = :ignore)
+      lookup_array = range_for(lookup_array)
+      row_number = single_value_for(row_number)
+      column_number = single_value_for(column_number) unless column_number == :ignore
+      return nil unless lookup_array
+      return nil unless row_number
+      return nil unless column_number
+      if column_number == :ignore
+        ref = FunctionCompiler.new(formula_cell.worksheet).calculate_index_formula(lookup_array,row_number,nil,:index_reference)
+      else
+        ref = FunctionCompiler.new(formula_cell.worksheet).calculate_index_formula(lookup_array,row_number,column_number,:index_reference)
+      end
+      return nil unless ref
+      return nil if ref.is_a?(Symbol)
+      return ref.to_ruby(true)
+    rescue DependsOnCalculatedFormulaError
+      return nil
+    end
+  
+    def attempt_to_caclulate_match(lookup_value,lookup_array,match_type = :ignore)
+        lookup_value = single_value_for(lookup_value)
+        lookup_array = range_for(lookup_array)
+        match_type = single_value_for(match_type) unless match_type == :ignore
+        return nil unless lookup_value
+        return nil unless lookup_array
+        return nil unless match_type
+        result = nil
+        if match_type == :ignore
+          result = FunctionCompiler.new(formula_cell.worksheet).match(lookup_value,lookup_array).to_f
+        else
+          result = FunctionCompiler.new(formula_cell.worksheet).match(lookup_value,lookup_array,match_type)
+        end
+        result.respond_to?(:to_f) ? result.to_f : result
+      rescue DependsOnCalculatedFormulaError
+        return nil
+    end
+  
+    def single_value_for(ast)
+      return nil unless ast.respond_to?(:visit)
+      ast = ast.visit(self)
+      return ast if ast == "true"
+      return ast if ast == "false"
+      return ast if ast.is_a?(Numeric)
+      return ast if ast =~ /^[0-9.]+$/
+      return $1 if ast =~ /^"([^"]*)"$/
+      return nil unless formula_cell
+      return nil unless formula_cell.worksheet
+      return nil unless ast =~ /^(sheet\d+)?\.?([a-z]+\d+)$/
+      cell = $1 ? formula_cell.worksheet.workbook.worksheets[$1].cell($2) : formula_cell.worksheet.cell($2)
+      return nil unless cell
+      return nil unless cell.can_be_replaced_with_value?
+      cell.value_for_including
+    end
+  
+    def range_for(ast)
+      return nil unless ast.respond_to?(:visit)
+      return nil unless formula_cell
+      return nil unless formula_cell.worksheet
+      ast = ast.visit(self)
+      return nil unless ast =~ /^(sheet\d+)?\.?a\('([a-z]+\d+)','([a-z]+\d+)'\)$/
+      worksheet = $1 ? formula_cell.worksheet.workbook.worksheets[$1] : formula_cell.worksheet
+      FunctionCompiler.new(worksheet).a($2,$3)
+    end
+  
+    def indirect_function(text_formula)
+      attempt_to_parse_indirect(text_formula) || (formula_cell.worksheet.workbook.indirects_used = true; "indirect(#{text_formula.visit(self)},'#{formula_cell && formula_cell.reference}')")
+    end
+  
+    def attempt_to_parse_indirect(text_formula)
+      return parse_and_visit(text_formula.first) if text_formula.type == :string
+      return nil unless text_formula.type == :string_join
+      reformated_indirect = text_formula.map do |non_terminal|
+        if non_terminal.respond_to?(:type)
+          case non_terminal.type
+          when :string, :number
+            non_terminal
+          when :cell
+            cell = formula_cell.worksheet.cell(non_terminal.visit(self))
+            if cell
+              return nil unless cell.can_be_replaced_with_value?
+              cell.value_for_including
+            else
+              ""
+            end
+          when :sheet_reference, :named_reference, :table_reference, :local_table_reference
+            reference = non_terminal.visit(self)
+            return nil unless reference =~ /^(sheet\d+)\.([a-z]+\d+)$/
+            cell = formula_cell.worksheet.workbook.worksheets[$1].cell($2)
+            if cell
+              return nil unless cell.can_be_replaced_with_value?
+              cell.value_for_including
+            else
+              ""
+            end
+          else
+            return nil
+          end
+        else
+          non_terminal
+        end
+      end
+      parse_and_visit(reformated_indirect.join)
+    end
+  
+    def parse_and_visit(text)
+      ast = Formula.parse(text)
+      return ":name" unless ast
+      ast.visit(self.class.new(formula_cell))
+    end
+  
+    def comparison(*strings)
+      strings.map { |s| s.visit(self) }.join
+    end
+  
+    def arithmetic(*strings)
+      strings.map { |s| s.visit(self) }.join
+    end
+  
+    def prefix(prefix,thing)
+     "#{prefix.visit(self)}#{thing.visit(self)}"
+    end
+  
+    COMPARATOR_CONVERSIONS = {'=' => '==' }
+  
+    def comparator(string)
+      COMPARATOR_CONVERSIONS[string] || string
+    end
+  
+    def boolean_true
+      "true"
+    end
+  
+    def boolean_false
+      "false"
+    end
+  
+    def null
+      0.0
+    end
+
+  end
+end

data/lib/formulae/formulae.rb

@@ -0,0 +1,6 @@
+require_relative 'run/reference'
+require_relative 'run/excel_range'
+require_relative 'run/excel_matrix'
+require_relative 'run/excel_functions'
+require_relative 'compile/formula_builder'
+require_relative 'parse/formula_peg'