rubyfromexcel 0.0.4

data/spec/reference_spec.rb

@@ -0,0 +1,72 @@
+require_relative 'spec_helper'
+
+describe Reference do
+  it "converts excel A1 style references to ruby method calls" do
+    Reference.new("A1").to_ruby.should == "a1"
+    Reference.new("$AA$103").to_ruby.should == "aa103"
+    Reference.new("ZZ1").to_ruby.should == "zz1"
+  end
+  
+  it "offsets references if required, dealing with any absolute constraints" do
+    Reference.new("A1").shift!([1,1]).to_ruby.should == "b2"
+    Reference.new("A$1").shift!([1,1]).to_ruby.should == "b1"
+    Reference.new("$A1").shift!([1,1]).to_ruby.should == "a2"
+    Reference.new("$A$1").shift!([1,1]).to_ruby.should == "a1"
+  end
+  
+  it "manages wrap on column numbering when offsetting" do
+    Reference.new("Z1").shift!([1,1]).to_ruby.should == "aa2"
+    Reference.new("ZZ1").shift!([1,1]).to_ruby.should == "aaa2"  
+  end
+  
+  it "deals with a nil value as an offset, treating it as offset [0,0]" do
+    Reference.new("A1").shift!(nil).to_ruby.should == "a1"
+  end
+  
+  it "converts columns to integers" do
+    Reference.column_to_integer("A").should == 1
+    Reference.column_to_integer("B").should == 2
+    Reference.column_to_integer("Z").should == 26
+    Reference.column_to_integer("AA").should == 27
+    Reference.column_to_integer("AB").should == 28
+  end
+  
+  it "converts integers to columns" do
+    Reference.integer_to_column(1).should == "a"
+    Reference.integer_to_column(2).should == "b"
+    Reference.integer_to_column(26).should == "z"
+    Reference.integer_to_column(27).should == "aa"
+    Reference.integer_to_column(28).should == "ab"
+  end
+  
+  it "raises an exception if asked for a column number < 1 (Excel column numbering starts at 1)" do
+    lambda { Reference.integer_to_column(0) }.should raise_error(Exception)
+  end
+  
+  it "can return the column_number and row_number for a reference" do
+    Reference.new("AB1").column_number.should == 28
+    Reference.new("AB1").row_number.should == 1
+  end
+  
+  it "converts column and row numbers into ruby versions of cell references" do
+    Reference.ruby_for(28,1).should == "ab1"
+    Reference.ruby_for(16384,16384).should == "xfd16384"
+    Reference.ruby_for(26,10).should == "z10"
+    Reference.ruby_for(701,10).should == "zy10"
+    Reference.ruby_for(702,10).should == "zz10"
+    Reference.ruby_for(703,10).should == "aaa10"
+    Reference.ruby_for(704,10).should == "aab10"
+    Reference.ruby_for(1378,10).should == "azz10"
+    Reference.ruby_for(2054,10).should == "bzz10"
+  end
+  
+  it "returns its value as a ruby_method style reference when to_s is called" do
+    Reference.new("$AB$1").to_s.should == "ab1"
+  end
+  
+  it "returns an array with [row_offset,column_offset] when subtracted from another reference" do
+    (Reference.new("A1") - Reference.new("A1")).should == [0,0]
+    (Reference.new("B2") - Reference.new("A1")).should == [1,1]
+    (Reference.new("AA10") - Reference.new("Z9")).should == [1,1]
+  end
+end

data/spec/relationships_spec.rb

@@ -0,0 +1,51 @@
+require_relative 'spec_helper'
+
+describe Relationships do
+
+relationship_xml =<<END
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet3.xml"/>
+  <Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain" Target="calcChain.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet2.xml"/>
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+  <Relationship Id="rId6" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>
+  <Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+  <Relationship Id="rId4" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml"/>
+</Relationships>
+END
+
+it "it should be created from xml be equivalent to a Hash where the keys are the relationship ids and the values are the target files" do
+  wr = Relationships.new(Nokogiri::XML(relationship_xml).root)
+  wr['rId3'].should == 'worksheets/sheet3.xml'
+end
+
+it "when given a root_directory will prepend that to the target files" do
+  wr = Relationships.new(Nokogiri::XML(relationship_xml).root, root_directory = '/usr/local')
+  wr['rId3'].should == '/usr/local/worksheets/sheet3.xml'
+end
+
+it "should have a Relationships.for_file(path_to_workkbook) that loads the xml automatically" do
+  File.should_receive(:open).with('/usr/local/excel_dir/xl/_rels/workbook.xml.rels').and_yield(StringIO.new(relationship_xml))
+  File.should_receive(:exist?).with('/usr/local/excel_dir/xl/_rels/workbook.xml.rels').and_return(true)
+  
+  wr = Relationships.for_file('/usr/local/excel_dir/xl/workbook.xml')
+  wr['rId3'].should == '/usr/local/excel_dir/xl/worksheets/sheet3.xml'
+  
+  File.should_receive(:open).with('/usr/local/excel_dir/xl/worksheets/_rels/sheet1.xml.rels').and_yield(StringIO.new(relationship_xml))
+    File.should_receive(:exist?).with('/usr/local/excel_dir/xl/worksheets/_rels/sheet1.xml.rels').and_return(true)
+  wr = Relationships.for_file('/usr/local/excel_dir/xl/worksheets/sheet1.xml')
+  wr['rId3'].should == '/usr/local/excel_dir/xl/worksheets/worksheets/sheet3.xml'
+  
+end
+
+it "should return an empty Relationships if relationships xml file doesn't exist" do
+  wr = Relationships.for_file('missing_file')
+  wr.size.should == 0
+end
+
+it "should pick out the sharedStrings relationship and put in an accessor" do
+  wr = Relationships.new(Nokogiri::XML(relationship_xml).root)
+  wr.shared_strings.should == 'sharedStrings.xml'
+end
+end

data/spec/runtime_formula_builder_spec.rb

@@ -0,0 +1,55 @@
+require_relative 'spec_helper'
+
+describe RuntimeFormulaBuilder, "For parsing indirect references" do
+  
+  before(:each) do
+    @worksheet = mock(:worksheet)
+    @builder = RuntimeFormulaBuilder.new(@worksheet)
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  # These are the new conversions
+  it "should convert sheet names to ruby methods" do
+    ruby_for("asheetname!A3:B20").should == "s('asheetname').a('a3','b20')"
+    ruby_for("'a long sheet name with spaces'!A3:B20").should == "s('a long sheet name with spaces').a('a3','b20')"
+  end
+  
+  it "should convert table names to references" do
+    table = mock(:table)
+    table.should_receive('reference_for').with('[#totals],[Description]',nil).and_return("cell reference")
+    @worksheet.should_receive('t').with('Vectors').and_return(table)
+    ruby_for("Vectors[[#totals],[Description]]").should == "cell reference"
+  end  
+  
+  # All these are the standard conversions
+  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 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 convert named references to ruby methods" do
+    ruby_for("SUM(OneAnd2)").should == "sum(one_and2)"
+    ruby_for("ReferenceOne").should == "reference_one"
+    ruby_for("Reference.2").should == "reference_2"
+    ruby_for("-($AG70+$X70)*EF.NaturalGas.N2O").should == "-(ag70+x70)*ef_natural_gas_n2o"
+  end
+
+end

data/spec/shared_formula_builder_spec.rb

@@ -0,0 +1,29 @@
+require_relative 'spec_helper'
+
+describe SharedFormulaBuilder, "Formulas with shared_formula_offsets" do
+  
+  before(:each) do
+    @builder = SharedFormulaBuilder.new
+    @builder.shared_formula_offset = [1,1]
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "should move individual references appropriately" do
+    ruby_for("A1").should == "b2"
+    ruby_for("A$1").should == "b1"
+    ruby_for("$A1").should == "a2"
+    ruby_for("$A$1").should == "a1"
+  end
+  
+  it "should move several references in the same formula" do
+    ruby_for("A1+B2").should == "b2+c3"
+    ruby_for("A$1+B$1").should == "b1+c1"
+    ruby_for("$A1+$B1").should == "a2+b2"
+    ruby_for("$A$1+$B$1").should == "a1+b1"
+  end
+  
+end

data/spec/shared_formula_cell_spec.rb

@@ -0,0 +1,23 @@
+require_relative 'spec_helper'
+
+describe SharedFormulaCell do
+  
+  before do
+    @cell = SharedFormulaCell.new(
+      mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+      Nokogiri::XML('<c r="W8" s="49"><f t="shared" si="2"/><v>1</v></c>').root
+    )
+    @cell.shared_formula = Formula.parse("$A$1+B2")
+    @cell.shared_formula_offset = [1,1]  
+  end
+  
+  it "it is given a pre-parsed formula and offsets its references by the amount of its shared_formula_offset" do
+    @cell.to_ruby.should == "def w8; @w8 ||= a1+c3; end\n"
+    @cell.to_test.should == "it 'cell w8 should equal 1.0' do\n  sheet1.w8.should be_close(1.0,0.1)\nend\n\n"
+  end
+  
+  it "knows what it depends on" do
+    @cell.work_out_dependencies
+    @cell.dependencies.should == ['sheet1.a1','sheet1.c3']
+  end
+end

data/spec/shared_formula_dependency_builder_spec.rb

@@ -0,0 +1,48 @@
+require_relative 'spec_helper'
+
+describe SharedFormulaDependencyBuilder 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 = SharedFormulaDependencyBuilder.new(@cell)
+    @builder.shared_formula_offset = [1,1]
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "should offset single cell dependencies appropriately" do
+     ruby_for("A1").should == ['sheet1.b2']
+     ruby_for("$A1").should == ['sheet1.a2']
+     ruby_for("A$1").should == ['sheet1.b1']
+     ruby_for("$A$1").should == ['sheet1.a1']
+   end
+
+   it "should offset dependences on other worksheets" do
+     ruby_for("A1+'Other Sheet'!A1").should == ['sheet1.b2','sheet2.b2']
+   end
+
+   it "should offset dependences in ranges" do
+     ruby_for("A1:A3").should == ['sheet1.b2','sheet1.b3','sheet1.b4']
+   end
+
+   it "should not offset dependencies in named_cells" do
+     ruby_for("named_cell").should == ['sheet1.a1']
+   end
+   
+   it "should not offset dependencies created by table references" do
+     Table.new(@worksheet2,'Vectors','a1:b2',['ColA','Description'],1)     
+     ruby_for("Vectors[#all]").should == ["sheet2.a1","sheet2.a2",'sheet2.b1','sheet2.b2']
+     Table.new(@worksheet1,'Vectors','a1:d41',['ColA','Description','ColC'],1)
+     ruby_for("[Description]").should == ["sheet1.b30"]
+   end
+    
+end

data/spec/shared_strings_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'spec_helper'
+
+describe SharedStrings do
+  
+  it "should return a shared string when provided with an index" do
+    xml = Nokogiri::XML('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2"><si><t>This a second shared string</t><phoneticPr fontId="3" type="noConversion"/></si><si><r><t>This is, h</t></r><r><rPr><b/><sz val="10"/><rFont val="Verdana"/></rPr><t>opefully, the first</t></r><r><rPr><sz val="10"/><rFont val="Verdana"/></rPr><t xml:space="preserve"> shared string</t></r><phoneticPr fontId="3" type="noConversion"/></si></sst>')
+    shared_strings = SharedStrings.instance
+    shared_strings.clear
+    shared_strings.load_strings_from_xml xml
+    SharedStrings.shared_string_for(0).should == "This a second shared string"
+    SharedStrings.shared_string_for(1).should == "This is, hopefully, the first shared string"
+  end
+end

data/spec/sharing_formula_cell_spec.rb

@@ -0,0 +1,79 @@
+require_relative 'spec_helper'
+
+describe SharingFormulaCell do
+  it "it is given a pre-parsed formula and offsets its references by the amount of its shared_formula_offset" do
+    worksheet = mock(:worksheet,:class_name => 'Sheet1',:to_s => 'sheet1')
+    sharing_cell = SharingFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W7" s="49"><f t="shared" ref="W7:W8" si="2">A1+B2</f><v>1</v></c>').root
+    )
+    shared_cell = SharedFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W8" s="49"><f t="shared" si="2"></f><v>2</v></c>').root
+      )
+    worksheet.should_receive(:cell).with('w8').and_return(shared_cell)
+    
+    sharing_cell.alter_other_cells_if_required
+    sharing_cell.to_ruby.should == "def w7; @w7 ||= a1+b2; end\n"
+    shared_cell.to_ruby.should == "def w8; @w8 ||= a2+b3; end\n"
+  end
+  
+  it "knows what it depends upon" do
+    worksheet = mock(:worksheet,:class_name => 'Sheet1',:to_s => 'sheet1')
+    sharing_cell = SharingFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W7" s="49"><f t="shared" ref="W7:W8" si="2">A1+B2</f><v>1</v></c>').root
+    )
+    shared_cell = SharedFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W8" s="49"><f t="shared" si="2"></f><v>2</v></c>').root
+      )
+    worksheet.should_receive(:cell).with('w8').and_return(shared_cell)
+    
+    sharing_cell.alter_other_cells_if_required
+    sharing_cell.work_out_dependencies
+    shared_cell.work_out_dependencies
+    sharing_cell.dependencies.should == ['sheet1.a1','sheet1.b2']
+    shared_cell.dependencies.should == ['sheet1.a2','sheet1.b3']
+  end
+  
+  it "it should cope if it is sharing only with itself" do
+    worksheet = mock(:worksheet,:class_name => 'Sheet1')
+    sharing_cell = SharingFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W7" s="49"><f t="shared" ref="W7" si="2">A1+B2</f><v>1</v></c>').root
+    )
+    
+    sharing_cell.alter_other_cells_if_required
+    sharing_cell.to_ruby.should == "def w7; @w7 ||= a1+b2; end\n"
+  end
+  
+  it "it should cope if it is sharing to a formula that doesn't exist" do
+    worksheet = mock(:worksheet,:class_name => 'Sheet1')
+    sharing_cell = SharingFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W7" s="49"><f t="shared" ref="W7:W8" si="2">A1+B2</f><v>1</v></c>').root
+    )
+    worksheet.should_receive(:cell).with('w8').and_return(nil)
+    
+    sharing_cell.alter_other_cells_if_required
+    sharing_cell.to_ruby.should == "def w7; @w7 ||= a1+b2; end\n"
+  end
+  
+  it "it should cope if it is sharing with a cell that has its own formula" do
+    worksheet = mock(:worksheet,:class_name => 'Sheet1')
+    sharing_cell = SharingFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W7" s="49"><f t="shared" ref="W7:W8" si="2">A1+B2</f><v>1</v></c>').root
+    )
+    shared_cell = SimpleFormulaCell.new(
+      worksheet,
+      Nokogiri::XML('<c r="W8" s="49"><f>AND(1,2)</f><v>1</v></c>').root
+      )
+    worksheet.should_receive(:cell).with('w8').and_return(shared_cell)
+    
+    sharing_cell.alter_other_cells_if_required
+    sharing_cell.to_ruby.should == "def w7; @w7 ||= a1+b2; end\n"
+    shared_cell.to_ruby.should == "def w8; @w8 ||= excel_and(1.0,2.0); end\n"
+  end
+end

data/spec/simple_formula_cell_spec.rb

@@ -0,0 +1,78 @@
+require_relative 'spec_helper'
+
+describe SimpleFormulaCell, "when result is a number" do
+  
+  before do
+    @cell = SimpleFormulaCell.new(
+      mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+      Nokogiri::XML("<c r=\"C3\"><f>1+2</f><v>3</v></c>").root
+    )
+  end
+  
+  it "should use the FormulaPeg to create ruby code for a formula and turn that into a method" do
+    @cell.to_ruby.should == "def c3; @c3 ||= 1.0+2.0; end\n"
+  end
+  
+  it "should create a test for the ruby code" do
+    @cell.to_test.should == %Q{it 'cell c3 should equal 3.0' do\n  sheet1.c3.should be_close(3.0,0.3)\nend\n\n}
+  end
+  
+  it "has a method that says it cannot be replaced with its value" do
+    @cell.can_be_replaced_with_value?.should be_false
+  end
+  
+end
+
+describe SimpleFormulaCell, "when result is a boolean" do
+  
+  before do
+    @cell = SimpleFormulaCell.new(
+      mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+      Nokogiri::XML('<c r="C3" t="b"><f>AND(1,2)</f><v>TRUE</v></c>').root
+    )
+  end
+  
+  it "should use the FormulaPeg to create ruby code for a formula and turn that into a method" do
+    @cell.to_ruby.should == "def c3; @c3 ||= excel_and(1.0,2.0); end\n"
+  end
+  
+  it "should create a test for the ruby code" do
+    @cell.to_test.should == %Q{it 'cell c3 should equal true' do\n  sheet1.c3.should == true\nend\n\n}
+  end
+  
+end
+
+describe SimpleFormulaCell, "when result is a string" do
+  
+  before do
+    @cell = SimpleFormulaCell.new(
+      mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+      Nokogiri::XML('<c r="C3" t="str"><f>"Hello "&amp;A1</f><v>Hello Bob</v></c>').root
+    )
+  end
+  
+  it "should use the FormulaPeg to create ruby code for a formula and turn that into a method" do
+    @cell.to_ruby.should == %Q{def c3; @c3 ||= "Hello "+a1.to_s; end\n}
+  end
+  
+  it "should create a test for the ruby code" do
+    @cell.to_test.should == %Q{it 'cell c3 should equal "Hello Bob"' do\n  sheet1.c3.should == "Hello Bob"\nend\n\n}
+  end
+  
+end
+
+describe SimpleFormulaCell, "can list the cells upon which it depends" do
+  
+  before do
+    @cell = SimpleFormulaCell.new(
+        mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+        Nokogiri::XML("<c r=\"C3\" t=\"str\"><f>A1</f><v>Hello Bob</v></c>").root
+      )
+  end
+  
+  it "in simple cases knows what it depends upon" do
+    @cell.work_out_dependencies
+    @cell.dependencies.should == ['sheet1.a1']
+  end
+
+end  

data/spec/single_cell_array_formula_builder_spec.rb

@@ -0,0 +1,19 @@
+require_relative 'spec_helper'
+
+describe SingleCellArrayFormulaBuilder, "Single cell array formulas" do
+  
+  before(:each) do
+    @builder = SingleCellArrayFormulaBuilder.new
+  end
+  
+  def ruby_for(formula)
+    ast = Formula.parse(formula)
+    ast.visit(@builder)
+  end
+  
+  it "should wrap operations in an array_operation(left,operation,right) methods" do
+    ruby_for("SUM(F$437:F$449/$M$150:$M$162*($B454=$F$149:$N$149)*($F$150:$N$162))").should == "sum(m(a('f437','f449'),a('m150','m162'),(m(b454,a('f149','n149')) { |r1,r2| r1==r2 }),(a('f150','n162'))) { |r1,r2,r3,r4| r1/r2*r3*r4 })"
+  end
+  
+    
+end

data/spec/single_cell_array_formula_cell_spec.rb

@@ -0,0 +1,25 @@
+require_relative 'spec_helper'
+
+describe SingleCellArrayFormulaCell do
+  
+  before do
+    @cell = SingleCellArrayFormulaCell.new(
+      mock(:worksheet,:class_name => 'Sheet1', :to_s => 'sheet1'),
+      Nokogiri::XML("<c r=\"C3\"><f t=\"array\" ref=\"C3\">SUM(F$437:F$449/$M$150:$M$162*($B454=$F$149:$N$149)*($F$150:$N$162))</f><v>3</v></c>").root
+    )
+  end
+  
+  it "should use the FormulaPeg to create ruby code for a formula and turn that into a method" do
+    @cell.to_ruby.should == "def c3; @c3 ||= sum(m(a('f437','f449'),a('m150','m162'),(m(b454,a('f149','n149')) { |r1,r2| r1==r2 }),(a('f150','n162'))) { |r1,r2,r3,r4| r1/r2*r3*r4 }); end\n"
+  end
+  
+  it "should create a test for the ruby code" do
+    @cell.to_test.should == %Q{it 'cell c3 should equal 3.0' do\n  sheet1.c3.should be_close(3.0,0.3)\nend\n\n}
+  end
+  
+  it "in can list the cells upon which it depends" do
+    @cell.work_out_dependencies
+    dependencies = @cell.dependencies
+    dependencies.include?('sheet1.g151').should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require_relative '../lib/rubyfromexcel'
+include RubyFromExcel

data/spec/table_spec.rb

@@ -0,0 +1,100 @@
+require_relative 'spec_helper'
+
+describe Table do
+  
+  def table
+    table_xml =<<-END
+    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    <table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="1" name="FirstTable" displayName="FirstTable" ref="B3:D7" totalsRowCount="1">
+      <autoFilter ref="B3:D6"/>
+      <tableColumns count="3">
+        <tableColumn id="1" name="ColA" totalsRowLabel="Total"/>
+        <tableColumn id="2" name="ColB" totalsRowFunction="custom" dataDxfId="1">
+          <calculatedColumnFormula>FirstTable[[#This Row],[ColA]]+FirstTable[[#This Row],[ColC]]</calculatedColumnFormula>
+          <totalsRowFormula>AVERAGE(FirstTable[ColB])</totalsRowFormula>
+        </tableColumn>
+        <tableColumn id="3" name="ColC" totalsRowFunction="count" dataDxfId="0">
+          <calculatedColumnFormula>3*FirstTable[[#This Row],[ColA]]</calculatedColumnFormula>
+        </tableColumn>
+      </tableColumns>
+      <tableStyleInfo name="TableStyleLight16" showFirstColumn="1" showLastColumn="1" showRowStripes="1" showColumnStripes="1"/>
+    </table>
+    END
+    @worksheet ||= mock(:worksheet,:to_s => 'sheet1')
+    @table ||= Table.from_xml(@worksheet, Nokogiri::XML(table_xml).root)
+  end
+  
+  it "should know its name" do
+    table.name.should == 'FirstTable'
+  end
+  
+  it "should know the area (returned in #all) that it covers" do
+    table.all.start_cell.to_s.should == 'b3'
+    table.all.end_cell.to_s.should == 'd7'
+  end
+  
+  it "should know the area (returned in #data) covered by its data" do
+    table.data.start_cell.to_s.should == 'b4'
+    table.data.end_cell.to_s.should == 'd6'
+  end  
+  
+  it "should know the area covered by its headers" do
+    table.headers.start_cell.to_s.should == 'b3'
+    table.headers.end_cell.to_s.should == 'd3'
+  end
+  
+  it "should know the area covered by its totals" do
+    table.totals.start_cell.to_s.should == 'b7'
+    table.totals.end_cell.to_s.should == 'd7'
+  end
+  
+  it "should know the area covered by each of its columns (excluding the headers and the totals)" do
+    table.column('ColA').start_cell.to_s.should == 'b4'
+    table.column('ColA').end_cell.to_s.should == 'b6'
+    table.column('ColC').start_cell.to_s.should == 'd4'
+    table.column('ColC').end_cell.to_s.should == 'd6'    
+  end
+  
+  it "should be able to translate structured references into normal references" do
+    table.reference_for('ColA').start_cell.to_s.should == 'b4'
+    table.reference_for('ColA').end_cell.to_s.should == 'b6'
+    table.reference_for('#All').start_cell.to_s.should == 'b3'
+    table.reference_for('#All').end_cell.to_s.should == 'd7'
+    table.reference_for('#Data').start_cell.to_s.should == 'b4'
+    table.reference_for('#Data').end_cell.to_s.should == 'd6'
+    table.reference_for('#Headers').start_cell.to_s.should == 'b3'
+    table.reference_for('#Headers').end_cell.to_s.should == 'd3'
+    table.reference_for('#Totals').start_cell.to_s.should == 'b7'
+    table.reference_for('#Totals').end_cell.to_s.should == 'd7'    
+  end
+  
+  it "should be able to translate structured references that are intersections into normal references" do
+    table.reference_for('[#Totals],[ColA]').to_s.should == 'sheet1.b7'
+    table.reference_for('[#Headers],[ColC]').to_s.should == 'sheet1.d3'
+    table.reference_for('[#All],[ColB]').start_cell.to_s.should == 'c3'
+    table.reference_for('[#All],[ColB]').end_cell.to_s.should == 'c7'
+  end
+  
+  it "should be able to translate structured references that include the special variable #This Row" do
+    table.reference_for('[#This Row],[ColA]', Reference.new('e5')).to_s.should == 'sheet1.b5'
+    table.reference_for('#This Row',Reference.new('e5')).start_cell.to_s.should == 'b5'
+    table.reference_for('#This Row',Reference.new('e5')).end_cell.to_s.should == 'd5'    
+  end
+  
+  it "should be able to translate structured references from cells that are in the table, treating them as if they had indicated [#This row] as part of the reference" do
+    table.reference_for('ColA', Reference.new('e5',@worksheet)).to_s.should == "sheet1.a('b4','b6')"
+    table.reference_for('ColA', Reference.new('c5',@worksheet)).to_s.should == 'sheet1.b5'
+  end
+  
+  it "should be able to access structured references by providing the table name to Table.reference_for(table_name,structured_reference,referring_cell)" do
+    table
+    Table.reference_for('FirstTable','#Data').start_cell.to_s.should == 'b4'
+    Table.reference_for('Not a known table','#Data').should == ":ref"
+    Table.reference_for('FirstTable','[#This Row],[ColA]', Reference.new('e5')).to_s.should == 'sheet1.b5'
+  end
+  
+  it "#inspect should create a string that can be used to recreate the table" do
+    table.inspect.should == %Q{'Table.new(sheet1,"FirstTable","B3:D7",["ColA", "ColB", "ColC"],1)'}
+  end
+    
+end

data/spec/value_cell_spec.rb

@@ -0,0 +1,49 @@
+require_relative 'spec_helper'
+
+describe ValueCell do
+  
+  it "creates a ruby method that returns the cell's value as a float if it is a number" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="C22"><v>24</v></c>').root)
+    cell.to_ruby.should == "def c22; 24.0; end\n"    
+  end
+
+  it "creates a ruby method that returns the cell's value as a ruby boolean if it is a boolean" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="C22" t="b"><v>TRUE</v></c>').root)
+    cell.to_ruby.should == "def c22; true; end\n"
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="C22" t="b"><v>1</v></c>').root)
+    cell.to_ruby.should == "def c22; true; end\n"
+
+  end
+  
+  it "creates a ruby method that returns the cell's value as a ruby string if it is a string" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="B6" t="str"><v>hello</v></c>').root)
+    cell.to_ruby.should == %Q{def b6; "hello"; end\n}
+  end
+
+  it "creates a ruby method that returns the cell's value as a ruby string if it is a shared string" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="B6" t="s"><v>7</v></c>').root)
+    SharedStrings.should_receive(:shared_string_for).with(7).and_return('hello')
+    cell.to_ruby.should == %Q{def b6; "hello"; end\n}
+  end  
+  
+  it "creates a ruby method that returns an appropriate symbol if it is an error" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="B6" t="e"><v>#N/A</v></c>').root)
+    cell.to_ruby.should == "def b6; :na; end\n"
+  end
+  
+  it "has a method that confirms it can be replaced with its value" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="B6" t="str"><v>hello</v></c>').root)
+    cell.can_be_replaced_with_value?.should be_true
+  end
+  
+end
+
+describe ValueCell, "can list the cells upon which it depends" do
+  
+  it "in simple cases knows what it depends upon" do
+    cell = ValueCell.new(mock('worksheet',:ruby_name => 'sheet1'),Nokogiri::XML('<c r="B6" t="s"><v>7</v></c>').root)
+    cell.work_out_dependencies
+    cell.dependencies.should == []
+  end
+
+end