rubyfromexcel 0.0.4

data/lib/rubyfromexcel.rb

@@ -0,0 +1,105 @@
+# Standard library
+require 'fileutils'
+require 'singleton'
+
+# Gems
+require 'nokogiri'
+require 'rubyscriptwriter'
+require 'rubyspecwriter'
+require 'rubypeg'
+
+# Components of RubyFromExcel
+require_relative 'excelfile/excelfile'
+require_relative 'formulae/formulae'
+require_relative 'cells/cells'
+require_relative 'optimiser/optimiser'
+
+require_relative 'runtime/runtime_formula_builder'
+
+module RubyFromExcel
+  class Process
+    attr_accessor :source_excel_directory
+    attr_accessor :target_ruby_directory
+    attr_accessor :workbook
+    attr_accessor :skip_tests
+    attr_accessor :prune_except_output_sheets
+    attr_accessor :convert_independent_of_input_sheets
+  
+    def initialize(&block)
+      instance_eval(&block) if block
+    end
+  
+    def workbook_filename
+      File.join(source_excel_directory,'xl','workbook.xml')
+    end
+  
+    def start!
+      reset_global_classes
+      
+      time "Preparing destination folder..." do
+        prepare_destination_folder
+      end
+    
+      time "Loading..." do
+        self.workbook = Workbook.new(workbook_filename)
+      end
+    
+      if prune_except_output_sheets
+        time "Pruning..." do
+          workbook.prune_cells_not_needed_for_output_sheets(*prune_except_output_sheets)
+          workbook.convert_cells_to_values_when_independent_of_input_sheets(*convert_independent_of_input_sheets)
+        end
+      end
+        
+      time "Workbook contains #{workbook.worksheets.size} sheets:\n" do
+    
+        puts "0) Generating ruby for the workbook"
+        write workbook.to_ruby, :to, "spreadsheet.rb"
+    
+        i = 0
+        workbook.worksheets.each do |variable_name, worksheet|
+          time "#{i+=1}) Generating ruby for #{variable_name}..." do
+            print 'ruby...'
+            write worksheet.to_ruby, :to, 'sheets', "#{variable_name}.rb"
+            unless skip_tests
+              print 'test...'
+              write worksheet.to_test, :to, 'specs',"#{variable_name}_rspec.rb"
+            end
+            # worksheet.nil_memory_consuming_variables!
+          end
+        end
+    
+      end
+      unless skip_tests
+        puts "Running tests of generated files"
+        puts `spec -fo #{File.join(target_ruby_directory,'specs',"*")}`
+      end
+    end
+    
+    # FIXME: Urgh. Global variables. Need to eliminate these!
+    def reset_global_classes
+      SheetNames.instance.clear
+      SharedStrings.instance.clear
+    end
+    
+    def prepare_destination_folder
+      FileUtils.mkpath(File.join(target_ruby_directory,'specs'))
+      FileUtils.mkpath(File.join(target_ruby_directory,'sheets'))
+    end
+  
+    def write(thing,to,*filenames)
+      File.open(File.join(target_ruby_directory,*filenames),'w') do |f|
+        f.puts thing.to_s
+      end
+    end
+  
+    def time(message)
+      print message
+      STDOUT.flush
+      start_time = Time.now
+      yield
+      puts "took #{(Time.now-start_time).to_i} seconds."
+    end
+  
+  end
+end

data/lib/runtime/runtime_formula_builder.rb

@@ -0,0 +1,32 @@
+module RubyFromExcel
+
+  class RuntimeFormulaBuilder < FormulaBuilder
+  
+    attr_accessor :worksheet, :refering_cell_reference
+  
+    def initialize(worksheet, refering_cell_reference = nil)
+      self.worksheet = worksheet
+      self.refering_cell_reference = refering_cell_reference
+    end
+    
+    def sheet_reference(sheet_name,reference)
+      "s('#{sheet_name}').#{reference.visit(self)}"
+    end
+  
+    alias :quoted_sheet_reference :sheet_reference
+  
+    def table_reference(table_name,structured_reference)
+      table = worksheet.t(table_name)
+      table.respond_to?(:reference_for) ? table.reference_for(structured_reference,refering_cell_reference).to_s : table
+    end
+  
+    def named_reference(name)
+      name.to_method_name
+    end
+  
+    def indirect_function(text_formula)
+      "indirect(#{text_formula.visit(self)},'#{formula_cell && formula_cell.reference}')"
+    end
+  
+  end
+end

data/spec/array_formula_builder_spec.rb

@@ -0,0 +1,35 @@
+require_relative 'spec_helper'
+
+describe ArrayFormulaBuilder, "Formulas with shared_formula_offsets" do
+  
+  before(:each) do
+    @builder = ArrayFormulaBuilder.new
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "should leave individual references alone" do
+    ruby_for("A1").should == "a1"
+    ruby_for("A$1").should == "a1"
+    ruby_for("$A1").should == "a1"
+    ruby_for("$A$1").should == "a1"
+  end
+  
+  it "should replace range references with individual cell references" do
+    ruby_for("A:C").should == "c('a','c')"
+    ruby_for("1:10").should == "r(1,10)"
+    ruby_for("IF(A1:A5>0,A1:A5,1+2)").should == "m(m(a('a1','a5'),0.0) { |r1,r2| r1>r2 },a('a1','a5'),m(1.0,2.0) { |r1,r2| r1+r2 }) { |r1,r2,r3| excel_if(r1,r2,r3) }"
+    ruby_for("B10:B20+B5").should == "m(a('b10','b20'),b5) { |r1,r2| r1+r2 }"
+  end
+  
+  it "should not replace range references where they are expected by the formula" do
+    ruby_for("INDEX($F$16:$I$19, ,MATCH($E$8, $F$15:$I$15, 0))").should == "m(0.0,m(e8,0.0) { |r1,r2| match(r1,a('f15','i15'),r2) }) { |r1,r2| index(a('f16','i19'),r1,r2) }"
+    ruby_for("SUMIF($F$16:$I$19,C8)").should == "m(c8) { |r1| sumif(a('f16','i19'),r1) }"
+    ruby_for("SUMIF($F$16:$I$19,C8,$Q$16:$R$19)").should == "m(c8) { |r1| sumif(a('f16','i19'),r1,a('q16','r19')) }"
+    ruby_for("SUMIFS($F$16:$F$19,$G$16:$G$19,1.0,$H$16:$H$19,Q1:Q4)").should == "m(1.0,a('q1','q4')) { |r1,r2| sumifs(a('f16','f19'),a('g16','g19'),r1,a('h16','h19'),r2) }"
+  end
+    
+end

data/spec/array_formula_cell_spec.rb

@@ -0,0 +1,17 @@
+require_relative 'spec_helper'
+
+describe ArrayFormulaCell do
+  
+#  <c r="B3"><f t="array" ref="B3:E6">B2:E2+A3:A6</f><v>2</v></c>
+
+it "it is given a value cell and a pre-parsed formula and picks out values from its array references according to array_formula_offset" do
+  value_cell = ValueCell.new(mock('worksheet',:to_s => 'sheet1'),Nokogiri::XML('<c r="D6"><v>7</v></c>').root)
+  
+  cell = ArrayFormulaCell.from_other_cell(value_cell)
+  cell.array_formula_reference = "b3_array"
+  cell.array_formula_offset = [1,1]
+  cell.to_ruby.should == "def d6; @d6 ||= b3_array.array_formula_offset(1,1); end\n"
+  cell.to_test.should == "it 'cell d6 should equal 7.0' do\n  sheet1.d6.should be_close(7.0,0.7)\nend\n\n"
+end
+
+end

data/spec/arraying_formula_cell_spec.rb

@@ -0,0 +1,38 @@
+require_relative 'spec_helper'
+
+describe ArrayingFormulaCell do
+  
+#  <c r="B3"><f t="array" ref="B3:E6">B2:E2+A3:A6</f><v>2</v></c>
+
+  before do
+    @worksheet = mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1')
+
+    @arraying_cell = ArrayingFormulaCell.new(
+      @worksheet,
+      Nokogiri::XML('<c r="B3"><f t="array" ref="B3:C3">D2:E2+A3:A6</f><v>2</v></c>').root
+    )
+    @value_cell = ValueCell.new(
+      @worksheet,
+      Nokogiri::XML('<c r="C3"><v>7</v></c>').root
+    )
+    @worksheet.should_receive(:cell).with('c3').and_return(@value_cell)
+    @worksheet.should_receive(:replace_cell) do |reference,new_cell|
+      reference.should == 'c3'
+      new_cell.to_ruby.should == "def c3; @c3 ||= b3_array.array_formula_offset(0,1); end\n"
+    end
+    @arraying_cell.alter_other_cells_if_required
+  end
+  
+  it "it is given a pre-parsed formula and picks out values from its array references according to array_formula_offset" do
+    @arraying_cell.to_ruby.should == "def b3_array; @b3_array ||= m(a('d2','e2'),a('a3','a6')) { |r1,r2| r1+r2 }; end\ndef b3; @b3 ||= b3_array.array_formula_offset(0,0); end\n"
+  end
+  
+  it "should know its dependencies, and also apply them to the cells that it arrays with" do
+    array_cell = mock(:array_cell)
+    array_cell.should_receive(:dependencies=).with(["sheet1.a3", "sheet1.a4", "sheet1.a5", "sheet1.a6", "sheet1.d2", "sheet1.e2"])
+    @worksheet.should_receive(:cell).with('c3').and_return(array_cell)
+    @arraying_cell.work_out_dependencies
+    @arraying_cell.dependencies.should == ["sheet1.a3", "sheet1.a4", "sheet1.a5", "sheet1.a6", "sheet1.d2", "sheet1.e2"]
+  end
+  
+end

data/spec/dependency_builder_spec.rb

@@ -0,0 +1,71 @@
+require_relative 'spec_helper'
+
+describe DependencyBuilder do
+  
+  before(:each) do
+    SheetNames.instance.clear
+    SheetNames.instance['Other Sheet'] = 'sheet2'
+    @workbook = mock(:workbook, :named_references => {'named_cell' => 'sheet2.z10', 'named_cell2' => "sheet2.a('z10','ab10')"})
+    @worksheet1 = mock(:worksheet, :to_s => 'sheet1', :workbook => @workbook, :named_references => {'named_cell' => 'sheet1.a1'})
+    @worksheet2 = mock(:worksheet, :to_s => 'sheet2', :workbook => @workbook, :named_references => {})
+    @workbook.stub!(:worksheets => {'sheet1' => @worksheet1, 'sheet2' => @worksheet2 })
+    @cell = mock(:cell,:worksheet => @worksheet1, :reference => Reference.new('c30',@worksheet1))
+    @builder = DependencyBuilder.new(@cell)
+  end
+  
+  def dependencies_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "should know about single dependencies to referred cells" do
+     dependencies_for("A1").should == ['sheet1.a1']
+   end
+
+   it "should know about multiple dependencies to referred cells " do
+     dependencies_for("A1+(B2*A1)").should == ['sheet1.a1','sheet1.b2']
+   end
+
+   it "should know about dependences to other worksheets" do
+     dependencies_for("A1+'Other Sheet'!A1").should == ['sheet1.a1','sheet2.a1']
+   end
+
+   it "should know about dependences in ranges" do
+     dependencies_for("A1:A3").should == ['sheet1.a1','sheet1.a2','sheet1.a3']
+   end
+
+   it "should know about dependences in ranges on other sheets" do
+     dependencies_for("'Other Sheet'!A1:A3").should == ['sheet2.a1','sheet2.a2','sheet2.a3']
+   end
+
+   it "should know about dependencies in named ranges" do
+     dependencies_for("named_cell").should == ['sheet1.a1']
+   end
+
+   it "should know about dependencies in named ranges on other sheets" do
+     dependencies_for("'Other Sheet'!named_cell").should == ['sheet2.z10']
+     dependencies_for("'Other Sheet'!named_cell2").should == ['sheet2.aa10','sheet2.ab10','sheet2.z10']
+   end
+   
+   it "should know about dependencies created by table references" do
+     Table.new(@worksheet2,'Vectors','a1:b2',['ColA','Description'],1)     
+     dependencies_for("Vectors[#all]").should == ["sheet2.a1","sheet2.a2",'sheet2.b1','sheet2.b2']
+   end
+   
+   it "should know about dependencies created by table references provided without table names" do
+     Table.new(@worksheet1,'Vectors','a1:c41',['ColA','Description','ColC'],1)
+     dependencies_for("[Description]").should == ["sheet1.b30"]
+   end
+   
+   it "should know about dependencies created by indirect formulae" do
+      Table.new(@worksheet2,'IndirectVectors','a1:b2',['ColA','Description'],1)
+      dependencies_for('INDIRECT("IndirectVectors[#all]")').should == ["sheet2.a1","sheet2.a2",'sheet2.b1','sheet2.b2']
+   end
+  
+   it "and be able to deal with indirect formulae that call upon other vectors" do
+      Table.new(@worksheet2,'IndirectVectors2','a1:b10',['ColA','Description'],1)
+      @worksheet1.should_receive(:cell).with('c1').and_return(mock(:cell,:value_for_including => 'ColA',:can_be_replaced_with_value? => true))
+      dependencies_for('INDIRECT("IndirectVectors2["&C1&"]")').should == ["sheet1.c1","sheet2.a2", "sheet2.a3", "sheet2.a4", "sheet2.a5", "sheet2.a6", "sheet2.a7", "sheet2.a8", "sheet2.a9"]
+   end  
+    
+end

data/spec/excel_functions_spec.rb

@@ -0,0 +1,381 @@
+require_relative 'spec_helper'
+
+class FunctionTest
+  extend ExcelFunctions
+  def self.a1; 10.0; end
+  def self.a2; 100.0; end
+  def self.b1; 'Pear'; end
+  def self.b2; 'Bear'; end
+  def self.b3; 'Apple'; end
+  def self.zx10; 2.0; end
+  def self.zy10; 3.0; end
+  def self.zz10; 4.0; end
+end
+
+describe "set" do
+  it "should set the value of existing cells" do
+    class ValueSetTest
+      include ExcelFunctions
+      def a1; 10.0; end
+    end
+    v = ValueSetTest.new
+    v.a1.should == 10.0
+    v.set('a1',99.0)
+    v.a1.should == 99.0
+    v.set('a1',nil)
+    v.a1.should == 10.0
+  end
+end
+
+describe "sum" do
+  it "should total areas correctly" do
+    FunctionTest.sum(1,2,3).should == 6
+    FunctionTest.sum(FunctionTest.a('a1','a2'),3).should == 113    
+  end
+end
+
+describe "choose" do
+  it "should return whichever argument is matched by the first argument" do
+    FunctionTest.choose(1,1,2,3,4).should == 1
+    FunctionTest.choose(2,1,2,3,4).should == 2
+    FunctionTest.choose(3,1,2,3,4).should == 3
+  end
+end
+
+describe "abs" do
+  it "should return the absolute value of the input" do
+    FunctionTest.abs(1.0).should == 1
+    FunctionTest.abs(-1.0).should == 1.0
+  end
+end
+
+describe "sumif" do
+  it "should only sum values in the area that meet the criteria" do
+    FunctionTest.sumif(FunctionTest.a('a1','a3'),10.0).should == 10.0
+    FunctionTest.sumif(FunctionTest.a('b1','b3'),'Bear',FunctionTest.a('a1','a2')).should == 100.0
+  end
+end
+
+describe "sumifs" do
+  it "should only sum values that meet all of the criteria" do
+    FunctionTest.sumifs(FunctionTest.a('a1','a3'),FunctionTest.a('a1','a3'),10.0,FunctionTest.a('b1','b3'),'Bear').should == 0.0
+    FunctionTest.sumifs(FunctionTest.a('a1','a3'),FunctionTest.a('a1','a3'),10.0,FunctionTest.a('b1','b3'),'Pear').should == 10.0
+  end
+  
+  it "should work when single cells are given where ranges expected" do
+    FunctionTest.sumifs(0.143897265452564, "CAR", "CAR", "FCV", "FCV").should == 0.143897265452564
+  end
+end
+
+describe "sumproduct" do
+  it "should multiply together and then sum the elements in row or column areas given as arguments" do
+    FunctionTest.sumproduct(FunctionTest.a('a1','a3'),FunctionTest.a('zx10','zz10')).should == 320.0
+  end
+end
+
+describe "count" do
+  it "should count the number of numeric values in an area" do
+    FunctionTest.count(1,"two",FunctionTest.a('a1','a3')).should == 3    
+  end
+end
+
+describe "counta" do
+  it "should count the number of numeric or text values in an area" do
+    FunctionTest.counta(1,"two",FunctionTest.a('a1','a3')).should == 4    
+  end
+end
+
+describe "average" do
+  it "should calculate the mean of its arguments" do
+    FunctionTest.average(1,2,3).should == 2
+    FunctionTest.average(1,"two",FunctionTest.a('a1','a3')).should == 111.0/3.0    
+  end
+end
+
+describe "subtotal" do
+  it "should calculate averages, counts, countas, sums depending on first argument" do
+    FunctionTest.subtotal(1.0,1,"two",FunctionTest.a('a1','a3')).should == 111.0/3.0 # Average
+    FunctionTest.subtotal(2.0,1,"two",FunctionTest.a('a1','a3')).should == 3 # count
+    FunctionTest.subtotal(3.0,1,"two",FunctionTest.a('a1','a3')).should == 4 # counta
+    FunctionTest.subtotal(9.0,1,"two",FunctionTest.a('a1','a3')).should == 111 # sum
+
+    FunctionTest.subtotal(101.0,1,"two",FunctionTest.a('a1','a3')).should == 111.0/3.0 # Average
+    FunctionTest.subtotal(102.0,1,"two",FunctionTest.a('a1','a3')).should == 3 # count
+    FunctionTest.subtotal(103.0,1,"two",FunctionTest.a('a1','a3')).should == 4 # counta
+    FunctionTest.subtotal(109.0,1,"two",FunctionTest.a('a1','a3')).should == 111 # sum    
+  end
+end
+
+describe "match" do
+  it "should return the index of the first match of the first argument in the area" do
+    FunctionTest.match(10.0,FunctionTest.a('a1','a2'),0.0).should == 1
+    FunctionTest.match(100.0,FunctionTest.a('a1','a2'),0.0).should == 2
+    FunctionTest.match(1000.0,FunctionTest.a('a1','a2'),0.0).should == :na
+    FunctionTest.match('bEAr',FunctionTest.a('b1','b3'),0.0).should == 2
+    FunctionTest.match(1000.0,FunctionTest.a('a1','a2'),1.0).should == 2
+    FunctionTest.match(1.0,FunctionTest.a('a1','a2'),1.0).should == :na
+    FunctionTest.match('Care',FunctionTest.a('b1','b3'),-1.0).should == 1  
+    FunctionTest.match('Zebra',FunctionTest.a('b1','b3'),-1.0).should == :na
+    FunctionTest.match('a',FunctionTest.a('b1','b3'),-1.0).should == 2    
+  end
+end
+
+describe "index" do
+  it "should return the value at the row and column number given" do
+    FunctionTest.index(FunctionTest.a('a1','b1'),2.0).should == "Pear"
+    FunctionTest.index(FunctionTest.a('a1','a3'),2.0).should == 100.0
+    FunctionTest.index(FunctionTest.a('b1','b3'),2.0).should == "Bear"
+    FunctionTest.index(FunctionTest.a('a1','b3'),1.0,2.0).should == "Pear"
+    FunctionTest.index(FunctionTest.a('a1','b3'),2.0,1.0).should == 100.0
+    FunctionTest.index(FunctionTest.a('a1','b3'),3.0,1.0).should == 0.0
+    FunctionTest.index(FunctionTest.a('a1','b3'),3.0,3.0).should == :ref
+    FunctionTest.index(FunctionTest.a('a1','b3'),3.0).should == :ref
+    FunctionTest.index(FunctionTest.a('a1','b3'),1.0,0.0).to_a.should == [10.0,"Pear"]
+    FunctionTest.index(FunctionTest.a('a1','b3'),0.0,2.0).to_a.should == ["Pear","Bear","Apple"]    
+  end
+end
+
+describe "max" do
+  it "should return the argument with the greatest value" do
+    FunctionTest.max(1,"two",FunctionTest.a('a1','a3')).should == 100    
+  end
+end
+
+describe "min" do
+  it "should return the argument with the smallest value" do
+    FunctionTest.min(1000,"two",FunctionTest.a('a1','a3')).should == 10    
+  end
+end
+
+describe "na" do
+  it "should return an na error" do
+    FunctionTest.na().should == :na    
+  end
+end
+
+describe "iserr" do
+  it "should return true if passed a symbol" do
+    FunctionTest.iserr(:na).should == true
+    FunctionTest.iserr(:ref).should == true
+  end
+  
+  it "should return false if passed anything else" do
+    FunctionTest.iserr(123).should == false
+  end
+end
+
+describe "excel_if" do
+  it "should return its second argument if its first argument is true" do
+    FunctionTest.excel_if(true,:second,:third).should == :second
+  end
+  
+  it "should return its third argument if its first argument is false" do
+    FunctionTest.excel_if(false,:second,:third).should == :third
+  end
+end
+
+describe "iferror" do
+  it "should return its second value if there is an error in the first" do
+    FunctionTest.iferror(FunctionTest.index(FunctionTest.a('a1','b3'),3.0,1.0),"Not found").should == 0.0
+    FunctionTest.iferror(FunctionTest.index(FunctionTest.a('a1','b3'),3.0,3.0),"Not found").should == "Not found"
+  end
+end
+
+describe "excel_and" do
+  it "should return true if all its arguments are true" do
+    FunctionTest.excel_and(true,true,true) == true
+  end
+  
+  it "should return false if any of its arguments are false" do
+    FunctionTest.excel_and(true,false,true) == false
+  end
+end
+
+describe "excel_or" do
+  it "should return false if all of its arguments are false" do
+    FunctionTest.excel_or(false,false,false) == false
+  end
+  
+  it "should return true if any of its arguments are true" do
+    FunctionTest.excel_or(false,false,true) == true
+    FunctionTest.excel_or(true,true,true) == true
+  end
+end
+
+describe "left" do
+  it "should return the left n characters from a string" do
+    FunctionTest.left("ONE").should == "O"
+    FunctionTest.left("ONE",1).should == "O"
+    FunctionTest.left("ONE",3).should == "ONE"
+  end
+end
+
+describe "find" do
+  it "should find the first occurrence of one string in another" do
+    FunctionTest.find("one","onetwothree").should == 1
+    FunctionTest.find("one","twoonethree").should == 4
+    FunctionTest.find("one","twoonthree").should == :value
+  end
+  
+  it "should find the first occurrence of one string in another after a given index" do
+    FunctionTest.find("one","onetwothree",1).should == 1
+    FunctionTest.find("one","twoonethree",5).should == :value
+    FunctionTest.find("one","oneone",2).should == 4
+  end
+end
+
+describe "ability to respond to empty cell references" do
+  it "should return 0 if a reference is made to an empty cell" do
+    FunctionTest.a23.should == 0.0
+  end
+  
+  it "should return an object that is kind_of?(Empty) if a reference is made to an empty cell" do
+    FunctionTest.a23.should be_kind_of(Empty)
+  end
+end
+
+describe "ability to respond to the a, r and c methods for creating area references" do
+  it "should return an Area object for a(start_cell,end_cell)" do
+    FunctionTest.a('a1','b10').should be_kind_of(Area)
+  end
+  
+  it "should return a Columns object for c(start_column_as_text,end_column_as_text)" do
+    FunctionTest.c('a','b').should be_kind_of(Columns)
+  end
+  
+  it "should return a Rows object for r(start_row_number,end_row_number)" do
+    FunctionTest.r(1,10).should be_kind_of(Rows)
+  end
+end
+
+class FunctionTest2
+  include RubyFromExcel::ExcelFunctions
+  def initialize
+    @worksheet_names = {'first sheet'=>'sheet1'}
+    @workbook_tables = {"FirstTable"=>'Table.new(sheet1,"FirstTable","A1:C3",["ColA", "ColB", "ColC"],1)'}
+  end
+  def sheet1
+    self
+  end
+  def a1; "Cell A1"; end
+  def a2; "Middle A2"; end
+  def a3; "Total A3"; end
+  def to_s; 'sheet1'; end
+end
+
+describe "ability to return a sheet from the full excel name using s('excel name')" do
+  it "should return a string for known sheets" do
+    sheet = FunctionTest2.new
+    sheet.s('first sheet').should == sheet
+  end
+end
+
+describe "ability to return the table for a given name using t('table name')" do
+  it "should return a string for known sheets" do
+    FunctionTest2.new.t('FirstTable').reference_for('[#Totals],[ColA]').to_s.should == 'sheet1.a3'
+  end
+  
+  it "should return a lowercase form of the class name as variable_name for compatibility with Table" do
+    FunctionTest.variable_name.should == "class"
+  end
+end
+
+describe "indirect method" do
+  it "should deal with the simple case where the indirect is pointing to a sheet or cell" do
+    FunctionTest2.new.indirect("A$1$").should == "Cell A1"
+  end
+  
+  it "should also work with sheet name references" do
+    FunctionTest2.new.indirect("'first sheet'!A$1$").should == "Cell A1"
+  end
+  
+  it "should also work with table references" do
+    FunctionTest2.new.indirect("FirstTable[[#Totals],[ColA]]").should == "Total A3"
+    FunctionTest2.new.indirect("FirstTable[[#This Row],[ColA]]",'B2').should == "Middle A2"
+  end
+  
+end
+
+describe "boolean values" do
+  it "should be possible to treat true values as 1.0 when using them in arithmetic" do
+    (true*5.0).should == 5.0
+    (true+1.0).should == 2.0
+    (true/5.0).should == 0.2
+    (true-2.0).should == -1.0
+    (5.0*true).should == 5.0
+    (1.0+true).should == 2.0
+    (5.0/true).should == 5.0
+    (2.0-true).should == 1.0
+  end
+  
+  it "should be possible to treat false values as 0.0 when using them in arithmetic" do
+    (false*5.0).should == 0.0
+    (false+1.0).should == 1.0
+    (false/5.0).should == 0.0
+    (false-2.0).should == -2.0    
+    (5.0*false).should == 0.0
+    (1.0+false).should == 1.0
+    (5.0/false).should == (5.0/0.0)
+    (2.0-false).should == 2.0
+  end
+end
+
+describe "symbols" do
+  it "should be able to have infix operators applied to them" do
+    (-:one).should == :one
+  end
+  
+  it "should be able to participate in arithmetic" do
+    (1 + :na).should == :na
+    (1 - :na).should == :na
+    (1 * :na).should == :na
+    (1 / :na).should == :na
+    (:na + 1).should == :na
+    (:na - 1).should == :na
+    (:na * 1).should == :na
+    (:na / 1).should == :na
+  end
+end
+
+describe "Strings", "should be able to operate as numbers if they appear to be numbers" do
+  it "should be able to have infix operators applied to them" do
+    (-"10").should == -10.0
+  end
+  
+  it "should be able to participate in arithmetic" do
+    (1 + "10").should == 11.0
+    (1 - "10").should == -9.0
+    (1 * "10").should == 10.0
+    (1 / "10").should == 0.1
+    ("10" + 1).should == 11.0
+    ("10" + "20").should == 30.0
+    ("10" + " apples").should == "10 apples"
+    ("10" - 1).should == 9.0
+    ("10" * 2).should == 20.0
+    ("10" / 1).should == 10.0
+  end
+end
+
+class CacheFuncitonTest
+  attr_accessor :method_executed
+  include RubyFromExcel::ExcelFunctions
+  def a23
+    @method_executed = true
+    "one"
+  end
+  
+  def other_function
+    @method_executed = true
+    "one"
+  end
+end
+
+describe "array formula operations" do
+  
+  it "m(expression) should create an ExcelMatrixCollection, carry out an excel_map using the associated block and return an ExcelMatrix" do
+    m = FunctionTest.m("one",[[3]],[[:a,:b,:c],[1,2,3]],ExcelMatrix.new([:a,:b,:c])) { |i,j,k| "#{i}#{j}#{k}" }
+    m.should be_kind_of(ExcelMatrix)
+    m.values.should == [["one3a", "one3b", "one3c"], ["one31", "one32", "one33"]]
+  end
+  
+end