rubyfromexcel 0.0.4

data/spec/excel_matrix_spec.rb

@@ -0,0 +1,92 @@
+require_relative 'spec_helper'
+
+class TestSheet2
+  
+  def variable_name
+    'sheet1'
+  end
+
+  def a1; 1.0; end
+  def a2; 2.0; end
+  def a3; 3.0; end
+  
+end
+
+describe ExcelMatrixCollection do
+  
+  it "can be created with a series of values" do
+    emc = ExcelMatrixCollection.new("one",[[3]],[[:a,:b,:c],[1,2,3]],ExcelMatrix.new([:a,:b,:c]))
+  end
+  
+  it "can enumerate the values in the collection, making sure that each matrix is the size of the largest" do
+    emc = ExcelMatrixCollection.new("one",[[3]],[[:a,:b,:c],[1,2,3]],ExcelMatrix.new([:a,:b,:c]))
+    emc.to_a.should == [["one",3,:a,:a],["one",3,:b,:b],["one",3,:c,:c],["one",3,1,:a],["one",3,2,:b],["one",3,3,:c]]
+  end
+  
+  it "can map the values to a new excel matrix of he size of the largest argument" do
+    emc = ExcelMatrixCollection.new("one",[[3]],[[:a,:b,:c],[1,2,3]],ExcelMatrix.new([:a,:b,:c]))
+    emc.matrix_map do |a,b,c,d,e|
+      1
+    end.values.should == [[1,1,1],[1,1,1]]
+  end
+  
+  it "if the mapped ExcelMatrix is a single cell, then transforms into that" do
+    result = ExcelMatrixCollection.new([[3]]).matrix_map do |r1|
+      Area.new(TestSheet2.new,'a1','a3')
+    end
+    result.should be_kind_of(Area)
+    result.to_a.should == [1.0,2.0,3.0]
+    result.array_formula_offset(1,0).should == 2.0
+    result = ExcelMatrixCollection.new([[3]]).matrix_map do |r1|
+      r1 + 1
+    end
+    result.should  == 4    
+  end
+  
+end
+
+describe ExcelMatrix do
+  
+  it "can be created from a single value" do
+    em = ExcelMatrix.new(3)
+    em.rows.should == 1
+    em.columns.should == 1
+    em.values.should == [[3]]
+  end
+  
+  it "can be created from an array of arrays" do
+    em = ExcelMatrix.new([[:a,:b,:c],[1,2,3]])
+    em.rows.should == 2
+    em.columns.should == 3
+    em.values.should == [[:a,:b,:c],[1,2,3]]
+  end
+  
+  it "can be created from a single array" do
+    em = ExcelMatrix.new([:a,:b,:c])
+    em.rows.should == 1
+    em.columns.should == 3
+    em.values.should == [[:a,:b,:c]]
+  end
+    
+  it "can have its number of rows expanded" do
+    em = ExcelMatrix.new([:a,:b,:c])
+    em.rows.should == 1
+    em.add_rows!(2)
+    em.rows.should == 3
+    em.values.should == [[:a,:b,:c],[:a,:b,:c],[:a,:b,:c]]
+  end
+  
+  it "can have its number of columns expanded" do
+    em = ExcelMatrix.new([[:a],[1]])
+    em.columns.should == 1
+    em.add_columns!(2)
+    em.columns.should == 3
+    em.values.should == [[:a,:a,:a],[1,1,1]]
+  end
+    
+  it "responds to #array_formula_offset(row_index,column_index) with origin 0,0" do
+    em = ExcelMatrix.new([[1,2,3],[4,5,6]])
+    em.array_formula_offset(0,0).should == 1
+    em.array_formula_offset(1,1).should == 5
+  end
+end

data/spec/excel_range_spec.rb

@@ -0,0 +1,161 @@
+require_relative 'spec_helper'
+
+class TestSheet
+  include RubyFromExcel::ExcelFunctions
+  
+  {
+    :a => ['a1',  'a2', 'a3', nil , 'a5'],
+    :b => ['b1',  nil,  nil,  'b4', 'b5'],
+    :c => ['c1',  'c2', 'c3', 'c4', 'c5']
+  }.each do |column,row_values|
+    row_values.each_with_index do |value,row|
+      next unless value
+      class_eval "def #{column}#{row+1}; '#{value}'; end"
+    end
+  end
+
+  def to_s
+    'sheet1'
+  end
+
+end
+
+describe Area do
+  it "should return the values in an area" do
+    Area.new(TestSheet.new,'a1','a3').to_a.should == ['a1','a2','a3']
+    Area.new(TestSheet.new,'a1','b1').to_a.should == ['a1','b1']
+  end
+  
+  it "should return references in its area" do
+    Area.new(TestSheet.new,'a1','a3').to_reference_enum.to_a.should == ['a1','a2','a3']
+    Area.new(TestSheet.new,'r9','r11').to_reference_enum.to_a.should == ['r9','r10','r11']
+    Area.new(TestSheet.new,'zx10','zz10').to_reference_enum.to_a.should == ['zx10','zy10','zz10']
+  end
+  
+  it "should respond to array_formula_index(row_index,column_index) by returning the reference at those coordinates" do
+    Area.new(TestSheet.new,'a1','c5').array_formula_index(0,0).to_ruby.should == 'a1'
+    Area.new(TestSheet.new,'a1','c5').array_formula_index(1,1).to_ruby.should == 'b2'
+    Area.new(TestSheet.new,'a1','c5').array_formula_index(10,10).to_ruby.should == :ref
+  end
+  
+  it "should respond to array_formula_offset(row_index,column_index) by returning the value at those coordinates (origin is 0,0)" do
+    Area.new(TestSheet.new,'a1','c5').array_formula_offset(0,0).should == 'a1'
+    Area.new(TestSheet.new,'a1','c5').array_formula_offset(1,1).should == 0.0
+    Area.new(TestSheet.new,'a1','c5').array_formula_offset(10,10).should == :ref    
+  end
+  
+  it "if the area is a single column, then it should ignore the column index when responding to array_formula_index(row_index,column_index)" do
+      Area.new(TestSheet.new,'a1','a5').array_formula_index(0,1).to_ruby.should == 'a1'
+      Area.new(TestSheet.new,'a1','a5').array_formula_index(1,1).to_ruby.should == 'a2'
+      Area.new(TestSheet.new,'a1','a5').array_formula_index(6,1).to_ruby.should == :ref
+  end
+
+  it "if the area is a single row, then it should ignore the row index when responding to array_formula_index(row_index,column_index)" do
+      Area.new(TestSheet.new,'a1','c1').array_formula_index(1,0).to_ruby.should == 'a1'
+      Area.new(TestSheet.new,'a1','c1').array_formula_index(1,1).to_ruby.should == 'b1'
+      Area.new(TestSheet.new,'a1','c1').array_formula_index(6,4).to_ruby.should == :ref
+  end  
+  
+  it "#row(index) returns a subset of the area for just that row (index=0 is the top row, index=-1 is the last row)" do
+    Area.new(TestSheet.new,'a1','c5').row(0).start_cell.to_s.should == 'a1'
+    Area.new(TestSheet.new,'a1','c5').row(0).end_cell.to_s.should == 'c1'
+    Area.new(TestSheet.new,'a1','c5').row(-1).start_cell.to_s.should == 'a5'
+    Area.new(TestSheet.new,'a1','c5').row(-1).end_cell.to_s.should == 'c5'
+  end
+  
+  it "#rows(start_index,end_index) returns a subset of the area for those rows (index=0 is the top row, index=-1 is the last row)" do
+    Area.new(TestSheet.new,'a1','c5').rows(0,-1).start_cell.to_s.should == 'a1'
+    Area.new(TestSheet.new,'a1','c5').rows(0,-1).end_cell.to_s.should == 'c5'
+    Area.new(TestSheet.new,'a1','c5').rows(1,-2).start_cell.to_s.should == 'a2'
+    Area.new(TestSheet.new,'a1','c5').rows(1,-2).end_cell.to_s.should == 'c4'
+  end
+  
+  it "#column(index) returns a subset of the area for just that column (index=0 is the first column)" do
+    Area.new(TestSheet.new,'a1','c5').column(0).start_cell.to_s.should == 'a1'
+    Area.new(TestSheet.new,'a1','c5').column(0).end_cell.to_s.should == 'a5'
+    Area.new(TestSheet.new,'a1','c5').column(2).start_cell.to_s.should == 'c1'
+    Area.new(TestSheet.new,'a1','c5').column(2).end_cell.to_s.should == 'c5'
+  end
+  
+  it "#to_s returns the area in the form of the excel function used to create it" do
+    Area.new(TestSheet.new,'a1','c5').to_s.should == "sheet1.a('a1','c5')"
+  end
+  
+  it "#to_excel_matrix returns the area in the form of a matrix, with methods to allow excel array formula manipulations" do
+    em = Area.new(TestSheet.new,'a1','c5').to_excel_matrix
+    em.rows.should == 5
+    em.columns.should == 3
+    em.values.should == [['a1','b1','c1'],['a2',0.0,'c2'],['a3',0.0,'c3'],[0.0,'b4','c4'],['a5','b5','c5']]
+  end
+  
+end
+
+describe Area, "when area refers to just a single cell" do
+  
+  it "should duck type as if it were just that cell for use in arithmetic, string joins etc" do
+     (Area.new(TestSheet.new,'a1','a1') + "-cell").should == "a1-cell"
+     (1 + Area.new(TestSheet.new,'b3','b3') + 10).should == 11
+  end
+  
+end
+
+describe Columns do
+  it "should return all the defined values in a single column" do
+    Columns.new(TestSheet.new,'c','c').each.to_a.should ==  ['c1',  'c2', 'c3', 'c4', 'c5']
+  end
+  
+  it "should cope with undefined values where they are in the middle of the column" do
+    Columns.new(TestSheet.new,'a','a').each.to_a.should == ['a1','a2','a3',0.0,'a5']
+  end
+  
+  it "should return all the defined values in several columns as a single array" do
+    Columns.new(TestSheet.new,'a','c').each.to_a.should == ['a1','a2','a3',0.0,'a5','b1',0.0,0.0,'b4','b5','c1',  'c2', 'c3', 'c4', 'c5']
+  end
+  
+  it "should cope with references to columns that aren't defined at all" do
+    Columns.new(TestSheet.new,'aa','zz').each.to_a.should == []
+  end
+
+  it "should respond to array_formula_index(row_index,column_index) by returning the reference for those coordinates" do
+    Columns.new(TestSheet.new,'a','c').array_formula_index(0,0).should == 'a1'
+    Columns.new(TestSheet.new,'a','c').array_formula_index(1,1).should == 'b2'
+    Columns.new(TestSheet.new,'a','c').array_formula_index(10,10).should == :na
+  end
+  
+  it "if the area is a single column, then it should ignore the column index when responding to array_formula_index(row_index,column_index)" do
+    Columns.new(TestSheet.new,'c','c').array_formula_index(0,1).should == 'c1'
+    Columns.new(TestSheet.new,'c','c').array_formula_index(1,1).should == 'c2'
+    Columns.new(TestSheet.new,'c','c').array_formula_index(6,6).should == 'c7'
+  end    
+    
+end
+
+describe Rows do 
+  it "should return all the defined values in a single row" do
+    Rows.new(TestSheet.new,1,1).each.to_a.should ==  ['a1','b1','c1']
+  end
+  
+  it "should cope with undefined values where they are in the middle of the row" do
+    Rows.new(TestSheet.new,2,2).each.to_a.should == ['a2',0.0,'c2']
+  end
+  
+  it "should return all the defined values in several columns as a single array" do
+    Rows.new(TestSheet.new,1,4).each.to_a.should == ['a1','b1','c1','a2',0.0,'c2','a3',0.0,'c3',0.0,'b4','c4']
+  end
+   
+  it "should cope with references to rows that aren't defined at all" do
+    Rows.new(TestSheet.new,100,105).each.to_a.should == []
+  end
+
+  it "should respond to array_formula_index(row_index,column_index) by returning the reference at those coordinates" do
+    Rows.new(TestSheet.new,1,4).array_formula_index(0,0).should == 'a1'
+    Rows.new(TestSheet.new,1,4).array_formula_index(1,1).should == 'b2'
+    Rows.new(TestSheet.new,1,4).array_formula_index(10,10).should == :na
+  end
+  
+  it "if the area is a single row, then it should ignore the row index when responding to array_formula_index(row_index,column_index)" do
+    Rows.new(TestSheet.new,1,1).array_formula_index(1,0).should == 'a1'
+    Rows.new(TestSheet.new,1,1).array_formula_index(1,1).should == 'b1'
+    Rows.new(TestSheet.new,1,1).array_formula_index(6,6).should == 'g1'
+  end
+end

data/spec/formula_builder_spec.rb

@@ -0,0 +1,230 @@
+require_relative 'spec_helper'
+
+describe FormulaBuilder do
+  
+  before(:each) do
+    @builder = FormulaBuilder.new
+    SheetNames.instance['asheetname'] = 'sheet1'
+    SheetNames.instance['a long sheet name with spaces'] = 'sheet2'
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "Should convert simple references to ruby method calls" do
+    ruby_for("AA1").should == "aa1"
+    ruby_for("$AA$100").should == "aa100"
+    ruby_for("A$1").should == "a1"
+    ruby_for("$A1").should == "a1"
+    ruby_for("I9+J9+K9+P9+Q9").should == "i9+j9+k9+p9+q9"
+  end
+  
+  it "Should convert simple arithmetic, converting numbers to floats" do
+    ruby_for("(1+3)*(12+13/2.0E-12)").should == "(1.0+3.0)*(12.0+13.0/2.0e-12)"
+    ruby_for("((1+3)*(12+13/2.0))").should == "((1.0+3.0)*(12.0+13.0/2.0))"
+  end
+  
+  it "Should convert percentages appropriately to their float equivalents" do
+    ruby_for("1+3%").should == "1.0+0.03"
+    ruby_for("1+103.12%").should == "1.0+1.0312"
+  end
+  
+  it "Should convert powers to their ruby equivalent" do
+    ruby_for("1^12").should == "1.0**12.0"
+  end
+  
+  it "Should join strings together, adding to_s where appropriate" do
+    ruby_for('"Hello"&"world"').should == '"Hello"+"world"'
+    ruby_for('"Hello "&A1').should == '"Hello "+a1.to_s'
+    ruby_for('AA1&"GW"').should == 'aa1.to_s+"GW"'
+    ruby_for('"GW"&ISERR($AA$1)').should == '"GW"+iserr(aa1).to_s'
+  end
+  
+  it "Should convert area references to a(start,end) functions" do
+    ruby_for('$A$1:BZ$2000').should == "a('a1','bz2000')"
+  end
+  
+  it "Should convert column references to c(start,end) functions" do
+    ruby_for('A:ZZ').should == "c('a','zz')"
+  end
+  
+  it "should convert row references to r(start,end) functions" do
+    ruby_for('1:1000').should == 'r(1,1000)'
+  end
+  
+  it "should leave strings as they are, even if they look like formulas" do
+    ruby_for('"A1+3*2"&$A3').should == '"A1+3*2"+a3.to_s'
+  end
+  
+  it "should properly escape strings where necessary" do
+    ruby_for(%q{"String with 'quotes' in it"}).should == '"String with \'quotes\' in it"'
+  end
+  
+  it "should convert sheet names to ruby methods" do
+    ruby_for("asheetname!A3:B20").should == "sheet1.a('a3','b20')"
+    ruby_for("'a long sheet name with spaces'!A3:B20").should == "sheet2.a('a3','b20')"
+  end
+  
+  it "should convert named references to ruby methods and inline their values" do
+    worksheet = mock(:worksheet)
+    workbook = mock(:workbook)
+    @builder.formula_cell = mock(:cell,:worksheet => worksheet)
+    worksheet.should_receive(:named_references).and_return({"one_and2"=>'sheet1.a(\'a1\',\'f10\')'})
+    ruby_for("SUM(OneAnd2)").should == "sum(sheet1.a('a1','f10'))"
+    worksheet.should_receive(:named_references).and_return({})
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:named_references).and_return({"reference_one" => "sheet10.a1"})
+    ruby_for("ReferenceOne").should == "sheet10.a1"
+    worksheet.should_receive(:named_references).and_return({"one_and2"=>'sheet1.a(\'a1\',\'f10\')'})
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:named_references).and_return({"reference_one" => "sheet10.a1"})
+    ruby_for("Reference.2").should == ":name"
+    worksheet.should_receive(:named_references).and_return({"one_and2"=>'sheet1.a(\'a1\',\'f10\')'})
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:named_references).and_return({"reference_one" => "sheet10.a1","ef_natural_gas_n2o"=> "sheet10.a1"})
+    ruby_for("-($AG70+$X70)*EF.NaturalGas.N2O").should == "-(ag70+x70)*sheet10.a1"
+  end
+  
+  it "should convert table names to references" do
+    Table.new(mock(:worksheet,:to_s => 'sheet1'),'Vectors','a1:c41',['ColA','Description','ColC'],1)
+    ruby_for("Vectors[Description]").should == "sheet1.a('b2','b40')"
+    ruby_for("Vectors[#all]").should == "sheet1.a('a1','c41')"
+    ruby_for("Vectors[#totals]").should == "sheet1.a('a41','c41')"
+    ruby_for("Vectors[[#totals],[Description]]").should == "sheet1.b41"
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('f30'))
+    ruby_for("Vectors[[#This Row],[Description]]").should == "sheet1.b30"
+  end
+  
+  it "should convert unkown table names to :ref" do
+    ruby_for("Unknown[Not likely]").should == ":ref"
+  end
+  
+  it "should convert unqualified table names to references" do
+    sheet = mock(:worksheet,:to_s => 'sheet1')
+    Table.new(sheet,'Vectors','a1:c41',['ColA','Description','ColC'],1)
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('c30',sheet), :worksheet => sheet)
+    ruby_for("[Description]").should == "sheet1.b30"
+    ruby_for("[#all]").should == "sheet1.a('a1','c41')"
+    ruby_for("[#headers]").should == "sheet1.c1"
+    ruby_for("[#totals]").should == "sheet1.c41"
+    ruby_for("[[#totals],[Description]]").should == "sheet1.b41"
+    ruby_for("[[#This Row],[Description]]").should == "sheet1.b30"
+  end
+    
+  it "should convert booleans to their ruby equivalents" do
+    ruby_for("TRUE*FALSE").should == "true*false"
+  end
+  
+  it "should convert the not function to !()" do
+    ruby_for("NOT(TRUE)").should == "!(true)"
+  end
+  
+  it "should throw an exception if trying to convert an unknown function" do
+    lambda { ruby_for("NEWEXCELFUNCTION(TRUE,FALSE)") }.should raise_error(ExcelFunctionNotImplementedError)
+  end
+    
+  it "should convert clashing excel function names to excel_name variants" do
+    ruby_for("IF(TRUE,FALSE,TRUE)").should == "excel_if(true,false,true)"
+    ruby_for("AND(TRUE,FALSE)").should == "excel_and(true,false)"
+    ruby_for("OR(TRUE,FALSE)").should == "excel_or(true,false)"
+  end
+  
+  it "should add the cell reference as a second argument to indirect() functions, setting workbook.indirects_used to true" do
+    worksheet = mock(:worksheet)
+    workbook = mock(:workbook)    
+    worksheet.should_receive(:workbook).and_return(workbook)
+    cell = mock(:cell,:value => 'ASD',:can_be_replaced_with_value? => false)
+    worksheet.should_receive(:cell).with('a1').and_return(cell)
+    workbook.should_receive(:indirects_used=).with(true)
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('f30'),:worksheet => worksheet)
+    ruby_for('INDIRECT("ONE"&A1)').should == 'indirect("ONE"+a1.to_s,\'f30\')'
+  end
+  
+  it "should attempt to interpret indirect functions where that is appropriate" do
+    worksheet = mock(:worksheet, :to_s => 'sheet1')
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('f30',worksheet),:worksheet => worksheet)
+    ruby_for('INDIRECT("A1")').should == "a1"
+    ruby_for('INDIRECT("A"&"1")').should == "a1"
+    ruby_for('INDIRECT("A"&1)').should == "a1"
+
+    SheetNames.instance['sheet100'] = 'sheet100'    
+    cell = mock(:cell,:value_for_including => 'sheet100',:can_be_replaced_with_value? => true)
+    worksheet.should_receive(:cell).with('a1').and_return(cell)
+    ruby_for('INDIRECT(A1&"!A1")').should == "sheet100.a1"
+
+    SheetNames.instance['sheet100'] = 'sheet100'    
+    workbook = mock(:workbook)    
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:worksheets).and_return({'sheet100' => worksheet})
+    worksheet.should_receive(:cell).with('a1').and_return(cell)
+    ruby_for('INDIRECT(sheet100!A1&"!A1")').should == "sheet100.a1"
+    
+    worksheet.should_receive(:named_references).and_return({"this_year" => 'sheet1.a1'})
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:worksheets).and_return({'sheet1' => worksheet})
+    worksheet.should_receive(:cell).with('a1').and_return(nil)
+    ruby_for('INDIRECT(this.Year & "!A1")').should == ":name"
+    
+    Table.new(worksheet,'Vectors','a1:c41',['ColA','Description','ColC'],1)
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:worksheets).and_return({'sheet1' => worksheet})
+    worksheet.should_receive(:cell).with('b30').and_return(cell)
+    ruby_for('INDIRECT(Vectors[[#This Row],[Description]] & "!A1")').should == "sheet100.a1"
+
+    Table.new(worksheet,'Vectors','a1:f41',['ColA','Description','ColC','ColD','ColE','ColF'],1)
+    worksheet.should_receive(:workbook).and_return(workbook)
+    workbook.should_receive(:worksheets).and_return({'sheet1' => worksheet})
+    worksheet.should_receive(:cell).with('f1').and_return(cell)
+    ruby_for('INDIRECT([#Headers]& "!A1")').should == "sheet100.a1"
+    
+    worksheet.should_receive(:cell).with('c120').and_return(cell)
+    ruby_for('INDIRECT($C120&".Outputs[Vector]")').should == ":ref"
+  end
+  
+  
+  it "should convert comparators into single expressions so that they work in ifs" do
+    ruby_for('IF(A1=3,"A","B")').should == 'excel_if(a1==3.0,"A","B")'
+  end
+
+  it "should convert complex formulas" do
+    # SheetNames.instance['DUKES 09 (2.5)'] = 'sheet100'
+    # SheetNames.instance['DUKES 09 (1.2)'] = 'sheet101'
+    # ruby_for("(-'DUKES 09 (2.5)'!$B$25*1000000*Constants.GCV.Coke)+(-'DUKES 09 (2.5)'!$C$25*1000000*Constants.GCV.CokeBreeze)+('DUKES 09 (1.2)'!$B$22*Unit.ktoe)").should == "(-sheet100.b25*1000000.0*constants_gcv_coke)+(-sheet100.c25*1000000.0*constants_gcv_coke_breeze)+(sheet101.b22*unit_ktoe)"
+    # complex_formula = %q{-(INDEX(INDIRECT(BI$19&"!Year.Matrix"),MATCH("Subtotal.Supply",INDIRECT(BI$19&"!Year.Modules"),0),MATCH("V.04",INDIRECT(BI$19&"!Year.Vectors"),0))+INDEX(INDIRECT(BI$19&"!Year.Matrix"),MATCH("Subtotal.Consumption",INDIRECT(BI$19&"!Year.Modules"),0),MATCH("V.04",INDIRECT(BI$19&"!Year.Vectors"),0)))}
+    # # ruby_for(complex_formula).should == "-(index(indirect(bi19.to_s+\"!Year.Matrix\",''),match(\"Subtotal.Supply\",indirect(bi19.to_s+\"!Year.Modules\",''),0.0),match(\"V.04\",indirect(bi19.to_s+\"!Year.Vectors\",''),0.0))+index(indirect(bi19.to_s+\"!Year.Matrix\",''),match(\"Subtotal.Consumption\",indirect(bi19.to_s+\"!Year.Modules\",''),0.0),match(\"V.04\",indirect(bi19.to_s+\"!Year.Vectors\",''),0.0)))"
+    # ruby_for("MAX(MIN(F121, -F22),0)").should == "max(min(f121,-f22),0.0)"
+  end
+  
+  
+  it "should replace MATCH() with its answer where it depends only on cells that can be replaced with their values" do
+    worksheet = mock(:worksheet, :to_s => 'sheet1')
+    a1 = mock(:cell,:reference => Reference.new('a1',worksheet),:worksheet => worksheet,:value_for_including => 'A', :can_be_replaced_with_value? => true)
+    a2 = mock(:cell,:reference => Reference.new('a2',worksheet),:worksheet => worksheet,:value_for_including => 'A', :can_be_replaced_with_value? => true)
+    a3 = mock(:cell,:reference => Reference.new('a3',worksheet),:worksheet => worksheet,:value_for_including => 'B', :can_be_replaced_with_value? => true)
+    worksheet.should_receive(:cell).with('a1').and_return(a1)
+    worksheet.should_receive(:cell).with('a2').and_return(a2)
+    worksheet.should_receive(:cell).with('a3').and_return(a3)
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('f30',worksheet),:worksheet => worksheet)
+    ruby_for('MATCH("A",A1:A3)').should == "2.0"
+    ruby_for('MATCH("X",A1:A3,FALSE)').should == "na"
+  end
+  
+  it "should replace INDEX() with a cell reference where it depends only on cells that can be replaced with their values" do
+    worksheet = mock(:worksheet, :to_s => 'sheet1')
+    @builder.formula_cell = mock(:cell,:reference => Reference.new('f30',worksheet),:worksheet => worksheet)
+    ruby_for('INDEX(A1:A3,3.0)').should == "sheet1.a3"
+    ruby_for('INDEX(A1:A3,2.0,1.0)').should == "sheet1.a2"
+  end
+  
+  it "should put multiple items as single arguments in a function" do
+    ruby_for("IF(A23>=(1.0+B38),1.0,2.0)").should == "excel_if(a23>=(1.0+b38),1.0,2.0)"
+    ruby_for("MAX(F60+(G$59-F$59)*G38,0)").should == "max(f60+(g59-f59)*g38,0.0)"
+  end
+
+  it "should convert formulas with null arguments, replacing the null with 0.0" do
+    spaced4 = "SUMIFS(INDEX($G$62:$J$73, , MATCH($E$11, $G$61:$J$61, 0)), $C$62:$C$73, $C195, $D$62:$D$73, $D195)"
+    ruby_for(spaced4).should == "sumifs(index(a('g62','j73'),0.0,match(e11,a('g61','j61'),0.0)),a('c62','c73'),c195,a('d62','d73'),d195)"
+  end
+end

data/spec/formula_peg_spec.rb

@@ -0,0 +1,165 @@
+require_relative 'spec_helper'
+
+require 'textpeg2rubypeg'
+text_peg = IO.readlines(File.join(File.dirname(__FILE__),'..','lib','formulae','parse','formula_peg.txt')).join
+ast = TextPeg.parse(text_peg)
+# puts ast.to_ast
+# exit
+builder = TextPeg2RubyPeg.new
+ruby = ast.visit(builder)
+Kernel.eval(ruby)
+
+describe Formula do
+  
+  def check(text)
+    puts
+    e = Formula.new
+    e.parse(text)
+    e.pretty_print_cache(true)
+    puts
+  end
+  
+  it "returns formulas" do
+    Formula.parse('1+1').to_ast.first.should == :formula
+  end
+  
+  it "returns cells" do
+    Formula.parse('$A$1').to_ast.should == [:formula,[:cell,'$A$1']]
+    Formula.parse('A1').to_ast.should == [:formula,[:cell,'A1']]    
+    Formula.parse('$A1').to_ast.should == [:formula,[:cell,'$A1']]    
+    Formula.parse('A$1').to_ast.should == [:formula,[:cell,'A$1']]    
+    Formula.parse('AAA1123').to_ast.should == [:formula,[:cell,'AAA1123']]
+    Formula.parse("IF(a23>=(1.0+b38),1.0,2.0)") == [:formula, [:function, "IF", [:comparison, [:cell, "a23"], [:comparator, ">="], [:brackets, [:arithmetic, [:number, "1.0"], [:operator, "+"], [:cell, "b38"]]]], [:number, "1.0"], [:number, "2.0"]]]
+  end
+  
+  it "returns areas" do
+    Formula.parse('$A$1:$Z$1').to_ast.should == [:formula,[:area,'$A$1','$Z$1']]
+    Formula.parse('A1:$Z$1').to_ast.should == [:formula,[:area,'A1','$Z$1']]    
+  end
+  
+  it "returns row ranges" do
+    Formula.parse('$1:$1000').to_ast.should == [:formula,[:row_range,'$1','$1000']]
+    Formula.parse('1000:1').to_ast.should == [:formula,[:row_range,'1000','1']]    
+  end
+  
+  it "returns column ranges" do
+    Formula.parse('$C:$AZ').to_ast.should == [:formula,[:column_range,'$C','$AZ']]
+    Formula.parse('C:AZ').to_ast.should == [:formula,[:column_range,'C','AZ']]    
+  end
+  
+  it "returns references to other sheets" do
+    Formula.parse('sheet1!$A$1').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:cell,'$A$1']]]    
+    Formula.parse('sheet1!$A$1:$Z$1').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:area,'$A$1','$Z$1']]]
+    Formula.parse('sheet1!$1:$1000').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:row_range,'$1','$1000']]]
+    Formula.parse('sheet1!$C:$AZ').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:column_range,'$C','$AZ']]]
+  end
+  
+  it "returns references to other sheets with extended names" do
+    Formula.parse("'sheet 1'!$A$1").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:cell,'$A$1']]]    
+    Formula.parse("'sheet 1'!$A$1:$Z$1").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:area,'$A$1','$Z$1']]]
+    Formula.parse("'sheet 1'!$1:$1000").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:row_range,'$1','$1000']]]
+    Formula.parse("'sheet 1'!$C:$AZ").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:column_range,'$C','$AZ']]]
+    Formula.parse("'2007.0'!Year.Matrix").to_ast.should == [:formula, [:quoted_sheet_reference, "2007.0", [:named_reference, "Year.Matrix"]]]
+  end
+  
+  it "returns numbers" do
+    Formula.parse("1").to_ast.should == [:formula,[:number,'1']]
+    Formula.parse("103.287").to_ast.should == [:formula,[:number,'103.287']]
+    Formula.parse("-1.0E-27").to_ast.should == [:formula,[:number,'-1.0E-27']]
+  end
+
+  it "returns percentages" do
+    Formula.parse("1%").to_ast.should == [:formula,[:percentage,'1']]
+    Formula.parse("103.287%").to_ast.should == [:formula,[:percentage,'103.287']]
+    Formula.parse("-1.0%").to_ast.should == [:formula,[:percentage,'-1.0']]
+  end
+  
+  it "returns strings" do
+    Formula.parse('"A handy string"').to_ast.should == [:formula,[:string,"A handy string"]]
+    Formula.parse('"$A$1"').to_ast.should == [:formula,[:string,"$A$1"]]  
+  end
+  
+  it "returns string joins" do
+    Formula.parse('"A handy string"&$A$1').to_ast.should == [:formula,[:string_join,[:string,"A handy string"],[:cell,'$A$1']]]
+    Formula.parse('$A$1&"A handy string"').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:string,"A handy string"]]]
+    Formula.parse('$A$1&"A handy string"&$A$1').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:string,"A handy string"],[:cell,'$A$1'],]]
+    Formula.parse('$A$1&$A$1&$A$1').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:cell,'$A$1'],[:cell,'$A$1'],]]
+    Formula.parse('"GW"&ISERR($AA$1)').to_ast.should == [:formula,[:string_join,[:string,'GW'],[:function,'ISERR',[:cell,'$AA$1']]]]
+  end
+  
+  it "returns numeric operations" do
+    Formula.parse('$A$1+$A$2+1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"+"],[:cell,'$A$2'],[:operator,"+"],[:number,'1']]]
+    Formula.parse('$A$1-$A$2-1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"-"],[:cell,'$A$2'],[:operator,"-"],[:number,'1']]]
+    Formula.parse('$A$1*$A$2*1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"*"],[:cell,'$A$2'],[:operator,"*"],[:number,'1']]]
+    Formula.parse('$A$1/$A$2/1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"/"],[:cell,'$A$2'],[:operator,"/"],[:number,'1']]            ]
+    Formula.parse('$A$1^$A$2^1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"^"],[:cell,'$A$2'],[:operator,"^"],[:number,'1']]]
+  end
+  
+  it "returns expressions in brackets" do
+    Formula.parse('($A$1+$A$2)').to_ast.should == [:formula,[:brackets,[:arithmetic,[:cell,'$A$1'],[:operator,"+"],[:cell,'$A$2']]]]
+    Formula.parse('($A$1+$A$2)+2').to_ast.should == [:formula, [:arithmetic, [:brackets, [:arithmetic, [:cell,'$A$1'], [:operator,"+"], [:cell,'$A$2']]], [:operator,"+"], [:number,'2']]]
+    Formula.parse('($A$1+$A$2)+(2+(1*2))').to_ast.should == [:formula, [:arithmetic, [:brackets, [:arithmetic, [:cell,'$A$1'], [:operator,"+"], [:cell,'$A$2']]], [:operator,"+"], [:brackets, [:arithmetic, [:number,'2'], [:operator,'+'] ,[:brackets, [:arithmetic, [:number,'1'], [:operator,'*'], [:number,'2']]]]]]]  
+  end
+  
+  it "returns comparisons" do
+    Formula.parse('$A$1>$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,">"],[:cell,'$A$2']]]
+    Formula.parse('$A$1<$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<"],[:cell,'$A$2']]]
+    Formula.parse('$A$1=$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"="],[:cell,'$A$2']]]
+    Formula.parse('$A$1>=$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,">="],[:cell,'$A$2']]]
+    Formula.parse('$A$1<=$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<="],[:cell,'$A$2']]]
+    Formula.parse('$A$1<>$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<>"],[:cell,'$A$2']]]
+  end
+  
+  it "returns functions" do
+    Formula.parse('PI()').to_ast.should  == [:formula,[:function,'PI']]
+    Formula.parse('ERR($A$1)').to_ast.should  == [:formula,[:function,'ERR',[:cell,'$A$1']]]
+    Formula.parse('SUM($A$1,sheet1!$1:$1000,1)').to_ast.should  == [:formula,[:function,'SUM',[:cell,'$A$1'],[:sheet_reference,'sheet1',[:row_range,'$1','$1000']],[:number,'1']]]
+    Formula.parse('IF(A2="Hello","hello",sheet1!B4)').to_ast.should == [:formula, [:function, "IF", [:comparison, [:cell, "A2"], [:comparator, "="], [:string, "Hello"]], [:string, "hello"], [:sheet_reference, "sheet1", [:cell, "B4"]]]]
+  end
+  
+  it "returns fully qualified structured references (i.e., Table[column])" do
+    Formula.parse('DeptSales[Sale Amount]').to_ast.should  == [:formula,[:table_reference,'DeptSales','Sale Amount']]
+    Formula.parse('DeptSales[[#Totals],[ColA]]').to_ast.should == [:formula,[:table_reference,'DeptSales','[#Totals],[ColA]']]
+    Formula.parse('IV.Outputs[Vector]').to_ast.should == [:formula,[:table_reference,'IV.Outputs','Vector']]
+    Formula.parse("I.b.Outputs[2007.0]").to_ast.should == [:formula,[:table_reference,'I.b.Outputs','2007.0']]
+    Formula.parse("INDEX(Global.Assumptions[Households], MATCH(F$321,Global.Assumptions[Year], 0))").to_ast.should == [:formula, [:function, "INDEX", [:table_reference, "Global.Assumptions", "Households"], [:function, "MATCH", [:cell, "F$321"], [:table_reference, "Global.Assumptions", "Year"], [:number, "0"]]]]
+    Formula.parse("MAX(-SUM(I.a.Inputs[2007])-F$80,0)").to_ast.should == [:formula, [:function, "MAX", [:arithmetic, [:prefix, "-", [:function, "SUM", [:table_reference, "I.a.Inputs", "2007"]]], [:operator, "-"], [:cell, "F$80"]], [:number, "0"]]]
+  end
+  
+  it "returns booleans" do
+    Formula.parse("TRUE*FALSE").to_ast.should == [:formula,[:arithmetic,[:boolean_true],[:operator,'*'],[:boolean_false]]]
+  end
+  
+  it "returns prefixes (+/-)" do
+    Formula.parse("-(3-1)").to_ast.should == [:formula, [:prefix, "-", [:brackets, [:arithmetic, [:number, "3"], [:operator, "-"], [:number, "1"]]]]]
+  end
+  
+  it "returns local structured references (i.e., [column])" do
+    Formula.parse('[Sale Amount]').to_ast.should  == [:formula,[:local_table_reference,'Sale Amount']]
+  end
+  
+  it "returns named references" do
+    Formula.parse('EF.NaturalGas.N2O').to_ast.should == [:formula,[:named_reference,'EF.NaturalGas.N2O']]
+  end
+  
+  it "returns infix modifiers in edge cases" do
+    complex = "(-'DUKES 09 (2.5)'!$B$25)"
+    Formula.parse(complex).to_ast.should == [:formula, [:brackets, [:prefix, "-", [:quoted_sheet_reference, "DUKES 09 (2.5)", [:cell, "$B$25"]]]]]
+    complex2 = %q{-(INDEX(INDIRECT(BI$19&"!Year.Matrix"),MATCH("Subtotal.Supply",INDIRECT(BI$19&"!Year.Modules"),0),MATCH("V.04",INDIRECT(BI$19&"!Year.Vectors"),0))+
+INDEX(INDIRECT(BI$19&"!Year.Matrix"),MATCH("Subtotal.Consumption",INDIRECT(BI$19&"!Year.Modules"),0),MATCH("V.04",INDIRECT(BI$19&"!Year.Vectors"),0)))}
+    Formula.parse(complex2).to_ast.should == [:formula, [:prefix, "-", [:brackets, [:arithmetic, [:function, "INDEX", [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Matrix"]]], [:function, "MATCH", [:string, "Subtotal.Supply"], [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Modules"]]], [:number, "0"]], [:function, "MATCH", [:string, "V.04"], [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Vectors"]]], [:number, "0"]]], [:operator, "+"], [:function, "INDEX", [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Matrix"]]], [:function, "MATCH", [:string, "Subtotal.Consumption"], [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Modules"]]], [:number, "0"]], [:function, "MATCH", [:string, "V.04"], [:function, "INDIRECT", [:string_join, [:cell, "BI$19"], [:string, "!Year.Vectors"]]], [:number, "0"]]]]]]]
+    Formula.parse("MAX(MIN(F121, -F22),0)").to_ast.should == [:formula, [:function, "MAX", [:function, "MIN", [:cell, "F121"], [:prefix, "-", [:cell, "F22"]]], [:number, "0"]]]
+  end
+  
+  it "returns formulas with spaces" do
+    spaced = "(13.56 / 96935) * EF.IndustrialCoal.CO2 * GWP.CH4"
+    Formula.parse(spaced).to_ast.should == [:formula, [:arithmetic, [:brackets, [:arithmetic, [:number, "13.56"], [:operator, "/"], [:number, "96935"]]], [:operator, "*"], [:named_reference, "EF.IndustrialCoal.CO2"], [:operator, "*"], [:named_reference, "GWP.CH4"]]]
+    spaced2 ='"per " & Preferences.EnergyUnits'
+    Formula.parse(spaced2).to_ast.should == [:formula, [:string_join, [:string, "per "],[:named_reference, "Preferences.EnergyUnits"]]]
+    spaced3 = ' 0.00403/$F$76'
+    Formula.parse(spaced3).to_ast.should == [:formula, [:arithmetic, [:number, "0.00403"], [:operator, "/"], [:cell, "$F$76"]]]
+    spaced4 = "SUMIFS(INDEX($G$62:$J$73, , MATCH($E$11, $G$61:$J$61, 0)), $C$62:$C$73, $C195, $D$62:$D$73, $D195)"
+    Formula.parse(spaced4).to_ast.should == [:formula, [:function, "SUMIFS", [:function, "INDEX", [:area, "$G$62", "$J$73"], [:null], [:function, "MATCH", [:cell, "$E$11"], [:area, "$G$61", "$J$61"], [:number, "0"]]], [:area, "$C$62", "$C$73"], [:cell, "$C195"], [:area, "$D$62", "$D$73"], [:cell, "$D195"]]]
+  end
+  
+end