rubyfromexcel 0.0.4

data/lib/formulae/run/excel_matrix.rb

@@ -0,0 +1,114 @@
+module RubyFromExcel
+  class ExcelMatrixCollection
+    include Enumerable
+  
+    attr_accessor :matrices, :max_rows, :max_columns
+  
+    def initialize(*args)
+      self.matrices = args.map do |a|
+        a.respond_to?(:to_excel_matrix) ? a.to_excel_matrix : ExcelMatrix.new(a)
+      end
+      coerce_to_equal_sizes
+    end
+  
+    def coerce_to_equal_sizes
+      self.max_rows = matrices.max_by(&:rows).rows
+      self.max_columns = matrices.max_by(&:columns).columns
+      matrices.each do |m|
+        m.add_columns!(max_columns - m.columns)
+        m.add_rows!(max_rows - m.rows)
+      end
+    end
+  
+    def each &block
+      block ? to_enum.each { |e| yield e } : to_enum
+    end
+  
+    def to_enum
+      Enumerator.new do |yielder|
+        0.upto(max_rows-1) do |j|
+          0.upto(max_columns-1) do |i|
+            yielder << matrices.map { |m| m.values[j][i] }
+          end
+        end
+      end
+    end
+  
+    def matrix_map
+      results = Array.new(max_rows) { Array.new(max_columns) }
+      0.upto(max_rows-1) do |j|
+        0.upto(max_columns-1) do |i|
+          results[j][i] =  yield *matrices.map { |m| m.values[j][i] }
+        end
+      end
+      em = ExcelMatrix.new(results)
+      if em.rows == 1 && em.columns == 1
+        return em.values.first.first
+      else
+        return em
+      end
+    end
+  
+  end
+
+
+  class ExcelMatrix < ExcelRange
+    include Enumerable
+  
+    attr_accessor :values
+  
+    def initialize(values)
+      @values = values.is_a?(Array) ? (values.first.is_a?(Array) ? values : [values] ) : [[values]]
+    end
+  
+    # origin 0,0
+    def array_formula_offset(row_index,column_index)
+      row_index = 0 if values.size == 1
+      column_index = 0 if values[row_index].size == 1
+      values[row_index][column_index] || :na
+    end
+  
+    def rows
+      return 0 unless values
+      values.size
+    end
+  
+    def columns
+      return 0 unless values && values.first
+      values.first.size
+    end
+  
+    def add_rows!(number = 1)
+      return if number < 1
+      number.times { self.values << self.values.first }
+    end
+  
+    def add_columns!(number = 1)
+      return if number < 1
+      number.times do 
+        values.each do |row|
+          row << row.last
+        end
+      end
+    end
+  
+    def each &block
+      block ? to_enum.each { |e| yield e } : to_enum
+    end
+  
+    def to_enum
+      Enumerator.new do |yielder|
+        values.each do |row|
+          row.each do |value|
+            yielder << value
+          end
+        end
+      end
+    end
+  
+    def to_excel_matrix
+      self
+    end
+  
+  end
+end

data/lib/formulae/run/excel_range.rb

@@ -0,0 +1,256 @@
+module RubyFromExcel
+
+  class ExcelRange
+  end
+
+  class ExcelRangeCommon < ExcelRange
+    include Enumerable
+    attr_accessor :sheet
+  
+    def each &block
+      block ? to_enum.each { |e| yield e } : to_enum
+    end
+  
+    private
+  
+    def defined_cells(regexp = /^[a-z]{1,3}\d+$/io)
+      sheet.methods.find_all {|m| m =~ regexp }
+    end
+  
+    def value_at(reference)
+      sheet.send(reference.to_s)
+    rescue ZeroDivisionError => e
+      return :div0
+    end
+  end
+
+  class Area < ExcelRangeCommon
+    attr_accessor :start_cell, :end_cell
+  
+    def initialize(sheet, start_cell,end_cell)
+      self.sheet = sheet
+      self.start_cell = Reference.new(start_cell)
+      self.end_cell = Reference.new(end_cell)
+    end
+  
+    def row(index) # index = 0 for top row
+      row_number = row_number_for_index(index)
+      Area.new(sheet,"#{start_cell.column}#{row_number}","#{end_cell.column}#{row_number}")
+    end
+  
+    def rows(start_index, end_index)
+      start_row_number = row_number_for_index(start_index)
+      end_row_number = row_number_for_index(end_index)
+      Area.new(sheet,"#{start_cell.column}#{start_row_number}","#{end_cell.column}#{end_row_number}")
+    end
+  
+    def column(index) # index = 0 for first column
+      column_number = start_cell.column_number + index
+      Area.new(sheet,Reference.ruby_for(column_number,start_cell.row_number),Reference.ruby_for(column_number,end_cell.row_number))
+    end
+  
+    def index(row_number,column_number) #origin at 1,1
+      reference = index_reference(row_number,column_number)
+      return reference if reference.is_a?(Symbol)
+      value_at(reference.to_ruby)
+    end
+  
+    def index_reference(row_number,column_number)
+      ref = array_formula_index(row_number-1, column_number-1)
+      return ref if ref.is_a?(Symbol)
+      ref.worksheet = sheet
+      ref
+    end
+  
+    def array_formula_offset(row_index,column_index)
+      value_at array_formula_index(row_index,column_index).to_ruby
+    end
+  
+    def array_formula_index(row_index,column_index)
+      column_index = 0 if single_column?
+      row_index = 0 if single_row?
+      reference = start_cell.shift([row_index,column_index])
+      return :ref unless include?(reference)
+      reference
+    end
+  
+    def each(&block)
+      return @array.each(&block) if @array
+      start_cell.row_number.upto(end_cell.row_number) do |row|
+        start_cell.column_number.upto(end_cell.column_number) do |column_number|
+          yield value_at(Reference.ruby_for(column_number,row))
+        end
+      end    
+    end
+  
+    # def to_enum
+    #   to_reference_enum.map {|reference| value_at reference}
+    # end
+  
+    def to_a
+      @array ||= self.map {|v| v }
+    end
+  
+    def dependencies
+      @dependencies ||=
+      (start_cell.row_number..end_cell.row_number).map do |row|
+        (start_cell.column_number..end_cell.column_number).map do |column_number|
+          Reference.ruby_for(column_number,row,sheet)
+        end
+      end.flatten
+    end
+  
+    def to_reference_enum
+      Enumerator.new do |yielder|
+        start_cell.row_number.upto(end_cell.row_number) do |row|
+          start_cell.column_number.upto(end_cell.column_number) do |column_number|
+            yielder << Reference.ruby_for(column_number,row)
+          end
+        end
+      end    
+    end
+  
+    def to_excel_matrix
+      ExcelMatrix.new(to_grid)
+    end
+  
+    def to_grid
+      (start_cell.row_number..end_cell.row_number).map do |row|
+        (start_cell.column_number..end_cell.column_number).map do |column_number|
+          value_at(Reference.ruby_for(column_number,row))
+        end
+      end
+    end
+  
+    def single_row_or_column?
+      single_row? || single_column?
+    end
+  
+    def single_column?
+      start_cell.column == end_cell.column
+    end
+  
+    def single_row?
+      start_cell.row_number == end_cell.row_number
+    end
+  
+    def to_s
+      "#{sheet}.a('#{start_cell.to_ruby}','#{end_cell.to_ruby}')"
+    end
+  
+    def include_cell?(cell)
+      return false unless cell.worksheet == sheet
+      include?(cell.reference)
+    end
+  
+    def row_number_for_index(index)
+      return (end_cell.row_number + 1 + index) if index < 0
+      row_number = start_cell.row_number + index
+    end
+  
+    def include?(reference)
+      return false unless reference.column_number >= start_cell.column_number
+      return false unless reference.column_number <= end_cell.column_number
+      return false unless reference.row_number >= start_cell.row_number
+      return false unless reference.row_number <= end_cell.row_number
+      true
+    end
+  
+    def method_missing(method,*args,&block)
+      super unless start_cell.to_s == end_cell.to_s
+      super unless value_at(start_cell).respond_to?(method)
+      value_at(start_cell).send(method,*args,&block)
+    end
+  
+  end
+
+  class Columns < ExcelRangeCommon
+  
+    attr_accessor :start_column_number, :end_column_number
+  
+    def initialize(sheet,start_column,end_column)
+      self.sheet = sheet
+      self.start_column_number = Reference.column_to_integer(start_column)
+      self.end_column_number = Reference.column_to_integer(end_column)
+    end
+
+    def array_formula_index(row_index,column_index)
+      column_index = 0 if single_column?
+      reference = Reference.new(Reference.ruby_for(start_column_number+column_index,row_index+1))
+      return :na unless include?(reference)
+      reference.to_ruby
+    end
+  
+    def to_enum
+      Enumerator.new do |yielder|
+        (start_column_number..end_column_number).each do |column_number|
+          (1..maximum_row_in_column_number(column_number)).each do |row|
+            yielder << value_at(Reference.ruby_for(column_number,row))
+          end
+        end
+      end
+    end
+  
+    private
+  
+    def include?(reference)
+      return false unless reference.column_number >= start_column_number
+      return false unless reference.column_number <= end_column_number
+      true
+    end
+  
+    def maximum_row_in_column_number(column_number)
+      cells_in_column = defined_cells(/^#{Reference.integer_to_column(column_number)}\d+$/i)
+      cells_in_column.empty? ? 0 : cells_in_column.last[/\d+/i].to_i
+    end
+  
+    def single_column?
+      start_column_number == end_column_number
+    end
+  end
+
+  class Rows < ExcelRangeCommon
+    attr_accessor :start_row_number, :end_row_number
+
+    def initialize(sheet,start_row_number,end_row_number)
+      self.sheet = sheet
+      self.start_row_number = start_row_number.to_i
+      self.end_row_number = end_row_number.to_i
+    end
+
+    def array_formula_index(row_index,column_index)
+      row_index = 0 if single_row?
+      reference = Reference.new(Reference.ruby_for(column_index+1,row_index+1))
+      return :na unless include?(reference)
+      reference.to_ruby
+    end
+  
+    def to_enum
+      Enumerator.new do |yielder|
+        (start_row_number..end_row_number).each do |row|
+          (1..maximum_column_number_in_row_number(row)).each do |column_number|
+            yielder << value_at(Reference.ruby_for(column_number,row))
+          end
+        end
+      end
+    end
+  
+    private
+  
+    def maximum_column_number_in_row_number(row_number)
+      cells_in_row = defined_cells(/^[a-z]{1,3}#{row_number}$/i)
+      cells_in_row.empty? ? 0 : Reference.column_to_integer(cells_in_row.last[/[a-z]+/i])
+    end
+  
+    def single_row?
+      start_row_number == end_row_number
+    end
+  
+    def include?(reference)
+      return false unless reference.row_number >= start_row_number
+      return false unless reference.row_number <= end_row_number
+      true
+    end
+  
+  end
+end

data/lib/formulae/run/reference.rb

@@ -0,0 +1,79 @@
+module RubyFromExcel
+  class Reference
+    attr_accessor :row, :column, :worksheet
+    attr_accessor :absolute_row, :absolute_column
+  
+    def self.ruby_for(column_number,row_number,worksheet = nil)
+      worksheet ? "#{worksheet}.#{integer_to_column(column_number)}#{row_number.to_i}" : "#{integer_to_column(column_number)}#{row_number.to_i}"
+    end
+  
+    def self.column_to_integer(string)
+      @column_to_integer_cache ||= {}
+      return @column_to_integer_cache[string] ||= string.downcase.each_byte.to_a.reverse.each.with_index.inject(0) do |memo,byte_with_index|
+        memo = memo + ((byte_with_index.first - 96) * (26**byte_with_index.last))
+      end
+    end
+
+    def self.integer_to_column(integer)
+      @integer_to_column_cache ||= {}
+      return @integer_to_column_cache[integer] ||= self.calculate_integer_to_column(integer)
+    end
+  
+    def self.calculate_integer_to_column(integer)
+      raise Exception.new("Column numbering starts at 1, received #{integer}") unless integer >= 1
+      text = (integer-1).to_i.to_s(26)
+      (text[0...-1].tr('1-9a-z','abcdefghijklmnopqrstuvwxyz')+text[-1,1].tr('0-9a-z','abcdefghijklmnopqrstuvwxyz')).gsub('a0','z').gsub(/([b-z])0/) { $1.tr('b-z','a-y')+"z" }
+    end
+
+    def initialize(reference_as_text, worksheet = nil)
+      @worksheet = worksheet
+      reference_as_text.downcase!
+      @row = reference_as_text[/\d+/]
+      @column = reference_as_text[/[a-z]+/]
+      @absolute_row = (reference_as_text =~ /\$\d/)
+      @absolute_column = (reference_as_text =~ /\$[a-z]/)
+    end
+  
+    def shift(offset_array)
+      self.dup.shift!(offset_array)
+    end
+  
+    def shift!(offset_array)
+      return self unless offset_array && offset_array.size == 2
+      shift_row_by! offset_array.first
+      shift_column_by! offset_array.last
+      self
+    end
+  
+    def to_ruby(include_worksheet = false)
+       include_worksheet ? "#{worksheet}.#{column}#{row && row.to_i}".downcase  : "#{column}#{row && row.to_i}".downcase
+    end
+  
+    alias to_s to_ruby
+  
+    def row_number
+      row.to_i
+    end
+  
+    def column_number
+      Reference.column_to_integer(column)
+    end
+
+    def -(other_reference)
+      [row_number - other_reference.row_number, column_number - other_reference.column_number]
+    end
+
+    private
+
+    def shift_row_by!(offset)
+      return if absolute_row
+      self.row = (row_number + offset).to_s
+    end
+
+    def shift_column_by!(offset)
+      return if absolute_column
+      self.column = Reference.integer_to_column(column_number + offset)
+    end
+
+  end
+end

data/lib/optimiser/dependency_builder.rb

@@ -0,0 +1,86 @@
+module RubyFromExcel
+  class DependencyBuilder
+    attr_accessor :formula_cell, :dependencies, :worksheet
+  
+    def initialize(formula_cell = nil)
+      self.formula_cell = formula_cell
+      self.worksheet = formula_cell.worksheet
+    end
+  
+    def formula(*expressions)
+      self.dependencies = []
+      expressions.each do |e| 
+        e.visit(self)
+      end
+      self.dependencies.uniq.sort
+    end
+  
+    def sheet_reference(sheet_name,reference)
+      sheet_name = $1 if sheet_name.to_s =~ /^(\d+)\.0+$/
+      using_worksheet(SheetNames.instance[sheet_name]) do
+        reference.visit(self)
+      end
+    end
+  
+    alias quoted_sheet_reference sheet_reference
+  
+    def named_reference(name)
+      dependencies_for reference_for_name(name)
+    end
+  
+    def dependencies_for(full_reference)
+      return [] unless full_reference  =~ /(sheet\d+)\.(.*)/
+      sheet_name, reference = $1, $2
+      using_worksheet(sheet_name) do
+        case reference
+        when /a\('(.*?)','(.*?)'\)/; area($1,$2)
+        else; self.dependencies << full_reference
+        end
+      end    
+    end
+  
+    def table_reference(table_name,structured_reference)
+      dependencies_for Table.reference_for(table_name,structured_reference,formula_cell && formula_cell.reference).to_s
+    end
+  
+    def local_table_reference(structured_reference)
+      dependencies_for Table.reference_for_local_reference(formula_cell,structured_reference).to_s
+    end
+  
+    def cell(reference)
+      self.dependencies << Reference.new(reference,worksheet).to_ruby(true)
+      Reference.new(reference).to_ruby
+    end
+  
+    def area(start_area,end_area)
+      self.dependencies.concat Area.new(worksheet,Reference.new(start_area).to_ruby,Reference.new(end_area).to_ruby).dependencies
+    end
+  
+    def function(name,*args)
+      if name == "INDIRECT"
+        args.first.visit(self)
+        dependencies_for FormulaBuilder.new(formula_cell).indirect_function(args.first)
+      else
+        args.each { |a| a.visit(self) }
+      end
+    end
+  
+    def reference_for_name(name)
+      worksheet.named_references[name.to_method_name] || 
+      workbook.named_references[name.to_method_name] || 
+      (raise Exception.new("#{name} not found"))
+    end
+  
+    def workbook
+      formula_cell.worksheet.workbook
+    end
+  
+    def using_worksheet(sheet_name)
+      original_worksheet = self.worksheet
+      self.worksheet = workbook.worksheets[sheet_name] || (raise Exception.new("#{sheet_name} not found"))
+      yield
+      self.worksheet = original_worksheet
+    end
+  
+  end
+end

data/lib/optimiser/optimiser.rb

@@ -0,0 +1,3 @@
+require_relative 'dependency_builder'
+require_relative 'shared_formula_dependency_builder'
+require_relative 'workbook_pruner'

data/lib/optimiser/shared_formula_dependency_builder.rb

@@ -0,0 +1,43 @@
+module RubyFromExcel
+
+  class SharedFormulaDependencyBuilder < DependencyBuilder
+    attr_accessor :shared_formula_offset
+  
+    def initialize(formula_cell = nil, shared_formula_offset = nil)
+      super formula_cell
+      self.shared_formula_offset = shared_formula_offset
+    end
+  
+    def cell(reference)
+      self.dependencies << Reference.new(reference,worksheet).shift!(shared_formula_offset).to_ruby(true)
+      Reference.new(reference).to_ruby
+    end
+  
+    def function(name,*args)
+      if name == "INDIRECT"
+        args.first.visit(self)
+        dependencies_for SharedFormulaBuilder.new(formula_cell,shared_formula_offset).indirect_function(args.first)
+      else
+        args.each { |a| a.visit(self) }
+      end
+    end
+  
+    alias area_without_offset area
+  
+    def area(start_area,end_area)
+      self.dependencies.concat Area.new(worksheet,Reference.new(start_area).shift!(shared_formula_offset).to_ruby,Reference.new(end_area).shift!(shared_formula_offset).to_ruby).dependencies
+    end
+  
+    def dependencies_for(full_reference)
+      return [] unless full_reference  =~ /(sheet\d+)\.(.*)/
+      sheet_name, reference = $1, $2
+      using_worksheet(sheet_name) do
+        case reference
+        when /a\('(.*?)','(.*?)'\)/; area_without_offset($1,$2)
+        else; self.dependencies << full_reference
+        end
+      end    
+    end
+  
+  end
+end

data/lib/optimiser/workbook_pruner.rb

@@ -0,0 +1,80 @@
+module RubyFromExcel
+
+  class WorkbookPruner
+    attr_reader :workbook, :cells_to_keep, :output_sheet_names
+  
+    def initialize(workbook)
+      @workbook = workbook
+    end
+  
+    def prune_cells_not_needed_for_output_sheets(*output_sheet_names)
+      @cells_to_keep = {}
+      workbook.work_out_dependencies
+      @output_sheet_names = output_sheet_names
+      find_dependencies_of output_sheet_names
+      delete_cells_that_we_dont_want_to_keep
+      cells_to_keep = nil # So that we can garbage collect
+      GC.start
+    end
+
+    def find_dependencies_of(output_sheet_names)
+      output_sheet_names.each do |output_sheet_name|
+        puts "Cascading dependencies for #{output_sheet_name}"
+        output_sheet = workbook.worksheets[SheetNames.instance[output_sheet_name]] 
+        raise Exception.new("#{output_sheet_name} not found #{SheetNames.instance.inspect} #{workbook.worksheets.keys.inspect}") unless output_sheet
+        output_sheet.cells.each do |reference,cell|
+          keep_dependencies_for(cell)
+        end
+      end
+      puts "#{cells_to_keep.size} cells kept, #{workbook.total_cells - cells_to_keep.size} pruned"
+    end
+  
+    def keep_dependencies_for(cell)
+      return unless cell
+      return if cells_to_keep.has_key?(cell.to_s)
+      cells_to_keep[cell.to_s] = cell
+      cell.dependencies.each do |reference|
+        keep_dependencies_for workbook.cell(reference)
+      end
+    end
+  
+    def delete_cells_that_we_dont_want_to_keep
+      workbook.worksheets.each do |name,sheet|
+        sheet.cells.delete_if do |reference,cell|
+          !cells_to_keep.has_key?(cell.to_s)
+        end
+      end
+    end
+  
+    def convert_cells_to_values_when_independent_of_input_sheets(*input_sheet_names)
+      input_sheet_names = input_sheet_names.map { |name| SheetNames.instance[name] }
+      count = 0
+      workbook.worksheets.each do |name,sheet|
+        puts "Converting cells into values in #{name}"
+        sheet.cells.each do |reference,cell|
+          next if cell.is_a?(ValueCell)
+          unless depends_on_input_sheets?(cell,input_sheet_names)
+            # puts "converting #{cell}"
+            count = count + 1
+            sheet.replace_cell(reference,ValueCell.for(cell))
+          end
+        end
+      end
+      puts "#{count} formula cells replaced with their values"
+      GC.start
+      prune_cells_not_needed_for_output_sheets(*output_sheet_names)
+    end
+  
+    def depends_on_input_sheets?(cell,input_sheet_names,stack_level = 0)
+      return true if stack_level > 100
+      return false unless cell
+      return true if input_sheet_names.include?(cell.worksheet.variable_name)
+      return false unless cell.dependencies
+      return true if cell.dependencies.any? do |reference|
+        depends_on_input_sheets?(workbook.cell(reference),input_sheet_names,stack_level + 1)
+      end
+      return false
+    end
+  
+  end
+end