osheet 0.10.0 → 1.0.0.rc.1

data/test/workbook_element_test.rb

@@ -0,0 +1,231 @@
+require "assert"
+
+require 'osheet/workbook_element'
+
+module Osheet
+
+
+  class WorkbookElementTests < Assert::Context
+    desc "a WorkbookElement object"
+    before do
+      @wd = WorkbookElement.new
+    end
+    subject { @wd }
+
+    should have_reader :title
+    should have_readers :templates, :partials, :styles, :worksheets
+    should have_instance_methods :template, :partial, :style, :worksheet
+
+    should "set it's defaults" do
+      assert_nil subject.title
+      assert_equal WorkbookElement::TemplateSet.new,  subject.templates
+      assert_equal WorkbookElement::PartialSet.new,   subject.partials
+      assert_equal WorkbookElement::StyleSet.new,     subject.styles
+      assert_equal WorkbookElement::WorksheetSet.new, subject.worksheets
+    end
+
+  end
+
+
+
+  class PartialSetTests < Assert::Context
+    desc "a PartialSet"
+    before { @ps = WorkbookElement::PartialSet.new }
+    subject { @ps }
+
+    should "be a Hash" do
+      assert_kind_of ::Hash, subject
+    end
+
+    should have_instance_method :<<
+    should have_reader :get
+
+    should "verify set objs are partials" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
+      end
+      assert_nothing_raised do
+        subject.send(:verify, Partial.new(:poo) {})
+      end
+    end
+
+    should "key using name values" do
+      assert_equal 'poo', subject.send(:key, :poo)
+    end
+
+    should "key on partial objs" do
+      assert_equal 'poo', subject.send(:partial_key, Partial.new(:poo) {})
+    end
+
+    should "init the key in the set when verifying" do
+      key = subject.send(:verify, Partial.new(:thing) {})
+      assert_equal 'thing', key
+      assert_equal({'thing' => nil}, subject)
+    end
+
+    should "push partials onto the set" do
+      assert_nothing_raised do
+        subject << Partial.new(:poo) {}
+        subject << Partial.new(:not_poo) {}
+        subject << Partial.new(:awesome) {}
+        subject << Partial.new(:poo) {}
+      end
+
+      assert_equal 3, subject.keys.size
+      assert subject["poo"]
+      assert_kind_of Partial, subject["poo"]
+    end
+
+    should "lookup a partial by name" do
+      p = Partial.new(:poo) {}
+      subject << p
+      assert_equal p, subject.get(:poo)
+      assert_equal p, subject.get('poo')
+      assert_equal nil, subject.get(:ugh)
+    end
+
+  end
+
+
+
+  class TemplateSetTests < Assert::Context
+    desc "a TemplateSet"
+    before { @set = WorkbookElement::TemplateSet.new }
+    subject { @set }
+
+    should "be a PartialSet" do
+      assert_kind_of WorkbookElement::PartialSet, subject
+    end
+
+    should "verify set objs are templates" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
+      end
+      assert_nothing_raised do
+        subject.send(:verify, Template.new(:row, :poo) {})
+      end
+    end
+
+    should "key templates using an array of their element and name" do
+      assert_equal ['row','poo'], subject.send(:key, :row, :poo)
+    end
+
+    should "key on templates objs" do
+      assert_equal ['row', 'poo'], subject.send(:template_key, Template.new(:row, :poo) {})
+    end
+
+    should "init the key in the set when verifying" do
+      key = subject.send(:verify, Template.new(:row, :poo) {})
+      assert_equal ['row', 'poo'], key
+      assert_equal({
+        key.first => { key.last => nil }
+      }, subject)
+    end
+
+    should "push templates onto the set" do
+      assert_nothing_raised do
+        subject << Template.new(:row, :poo) {}
+        subject << Template.new(:row, :not_poo) {}
+        subject << Template.new(:column, :awesome) {}
+        subject << Template.new(:column, :not_awesome) {}
+      end
+
+      assert_equal 2, subject.keys.size
+      assert subject["row"]
+      assert_equal 2, subject["row"].keys.size
+      assert subject["row"]["poo"]
+      assert_kind_of Template, subject["row"]["poo"]
+      assert subject["row"]["not_poo"]
+      assert_kind_of Template, subject["row"]["not_poo"]
+      assert subject["column"]
+      assert_equal 2, subject["column"].keys.size
+      assert subject["column"]["awesome"]
+      assert_kind_of Template, subject["column"]["awesome"]
+      assert subject["column"]["not_awesome"]
+      assert_kind_of Template, subject["column"]["not_awesome"]
+    end
+
+    should "lookup a template by element, name" do
+      t = Template.new(:row, :poo) {}
+      subject << t
+      assert_equal t, subject.get(:row, :poo)
+      assert_equal t, subject.get('row', 'poo')
+
+      assert_equal nil, subject.get(:row, :ugh)
+      assert_equal nil, subject.get(:col, :ugh)
+    end
+
+  end
+
+
+
+  class StyleSetTests < Assert::Context
+    desc "a StyleSet"
+    before { @set = WorkbookElement::StyleSet.new }
+    subject { @set }
+
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+    end
+
+    should have_reader :for
+
+    should "verify Style objs" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
+      end
+      assert_nothing_raised do
+        subject.send(:verify, Style.new('.awesome') {})
+      end
+    end
+
+    should "be able to lookup styles by class" do
+      subject << (a = Style.new('.awesome') {})
+      subject << (at = Style.new('.awesome.thing') {})
+      subject << (b = Style.new('.boring') {})
+      subject << (bt = Style.new('.boring.thing') {})
+      subject << (a_b = Style.new('.awesome', '.boring') {})
+      subject << (t = Style.new('.thing') {})
+      subject << (s = Style.new('.stupid') {})
+
+      { 'awesome' => [a, a_b],
+        'boring' => [b, a_b],
+        'thing' => [t],
+        'awesome thing' => [a, at, a_b, t],
+        'thing awesome' => [a, at, a_b, t],
+        'other' => []
+      }.each do |style_class, styles_set|
+        assert_equal styles_set, subject.for(style_class)
+      end
+    end
+
+    should "return itself if calling for w/ no args" do
+      assert_equal subject, subject.for
+    end
+
+  end
+
+
+
+  class WorksheetSetTests < Assert::Context
+    desc "a WorksheetSet"
+    before { @set = WorkbookElement::WorksheetSet.new }
+    subject { @set }
+
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+    end
+
+    should "verify Worksheet objs" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
+      end
+      assert_nothing_raised do
+        subject.send(:verify, Worksheet.new {})
+      end
+    end
+
+  end
+
+
+end

data/test/workbook_test.rb

@@ -1,105 +1,143 @@
 require "assert"
+require 'test/fixtures/mixins'
+require 'test/fixtures/test_writer'
+
 require 'osheet/workbook'
-require 'test/mixins'
 
 module Osheet
 
-  class WorkbookTest < Assert::Context
-    desc "Osheet::Workbook"
-    before {  @wkbk = Workbook.new }
+  class WorkbookTests < Assert::Context
+    desc "a Workbook"
+    before do
+      @wkbk = Workbook.new
+      @test_writer = TestWriter.new
+    end
     subject { @wkbk }
 
-    should have_readers :styles, :templates, :partials
-    should have_instance_methods :title, :attributes, :use, :add
-    should have_instance_methods :style, :template, :partial
+    should have_instance_methods :writer, :element_stack
+    should have_instance_methods :use, :add
+    should have_instance_methods :to_s, :to_data, :to_file
+
+    should have_instance_methods :workbook_element, :workbook
+    should have_instance_methods :templates, :template
+    should have_instance_methods :partials, :partial
+    should have_instance_methods :styles, :style
+    should have_instance_methods :worksheets, :worksheet
+    should have_instance_methods :columns, :column
+    should have_instance_methods :rows, :row
+    should have_instance_methods :cells, :cell
 
-    should_hm(Workbook, :worksheets, Worksheet)
+    should have_instance_methods :use, :add, :template, :partial
+
+    should have_instance_methods :align, :font, :bg, :border
+    should have_instance_methods :border_left, :border_top
+    should have_instance_methods :border_right, :border_bottom
+
+    should have_instance_methods :style_class, :format
+    should have_instance_methods :title, :meta, :name
+    should have_instance_methods :width, :height
+    should have_instance_methods :autofit, :autofit?, :hidden, :hidden?
+    should have_instance_methods :data, :href, :formula
+    should have_instance_methods :index, :rowspan, :colspan
 
     should "set it's defaults" do
-      assert_equal nil, subject.send(:get_ivar, "title")
-      assert_equal [], subject.worksheets
-      assert_equal StyleSet.new, subject.styles
-      assert_equal TemplateSet.new, subject.templates
-      assert_equal PartialSet.new, subject.partials
+      assert_equal nil, subject.workbook.title
+
+      assert_equal WorkbookElement.new, subject.workbook_element
+      assert_equal subject.workbook_element, subject.workbook
+
+      assert_kind_of Workbook::ElementStack, subject.element_stack
+      assert_equal 1, subject.element_stack.size
+      assert_equal subject.workbook_element, subject.element_stack.current
     end
 
-    should "know it's attribute(s)" do
-      subject.send(:title, "The Poo")
-      [:title].each do |a|
-        assert subject.attributes.has_key?(a)
-      end
-      assert_equal "The Poo", subject.attributes[:title]
+    should "set its title, casting it to a string" do
+      wb = Workbook.new { title :fun }
+      assert_equal "fun", wb.workbook.title
     end
 
   end
 
-  class WorkbookTitleTest < WorkbookTest
-    desc "A workbook with a title"
-    before { @wkbk = Workbook.new { title "The Poo" } }
+  class ElementStackTests < Assert::Context
+    desc "an ElementStack"
+    before { @s = Workbook::ElementStack.new }
+    subject { @s }
 
-    should "know it's title" do
-      assert_equal "The Poo", subject.title
+    should "be an Array" do
+      assert_kind_of ::Array, subject
     end
 
-    should "set it's title" do
-      subject.title(false)
-      assert_equal false, subject.title
-      subject.title('la')
-      assert_equal 'la', subject.title
-      subject.title(nil)
-      assert_equal 'la', subject.title
+    should have_instance_method :push, :pop, :current, :size, :using
+
+    should "push objects onto the stack" do
+      assert_nothing_raised do
+        subject.push("something")
+        subject.push("something else")
+      end
+
+      assert_equal 2, subject.size
     end
 
-  end
+    should "push objects onto the stack for the duration of a block" do
+      subject.push("something")
 
-  class WorkbookWorksheetsTest < WorkbookTest
-    desc "A workbook with worksheets"
-    before do
-      @wkbk = Workbook.new {
-        worksheet {
-          name "Poo!"
-          column
-          row {
-            cell {
-              format  :number
-              data    1
-            }
-          }
-        }
-      }
+      assert_equal "something", subject.current
+      subject.using("using") do
+        assert_equal "using", subject.current
+      end
+      assert_equal "something", subject.current
     end
 
-    should "set it's worksheets" do
-      assert_equal 1, subject.worksheets.size
-      assert_kind_of Worksheet, subject.worksheets.first
+    should "fetch the last item in the array with the current method" do
+      subject.push("something")
+      subject.push("something else")
+
+      assert_equal "something else", subject.current
     end
 
-    should "not allow multiple worksheets with the same name" do
-      assert_raises ArgumentError do
-        Workbook.new {
-          worksheet { name "awesome" }
-          worksheet { name "awesome" }
-        }
-      end
+    should "remove the last item in the array with the pop method" do
+      subject.push("something")
+      subject.push("something else")
+
+      assert_equal 2, subject.size
+
+      item = subject.pop
+      assert_equal "something else", item
+      assert_equal 1, subject.size
+    end
+
+    should "return nil if trying to pop on an empty stack" do
+      assert_equal 0, subject.size
+
       assert_nothing_raised do
-        Workbook.new {
-          worksheet { name "awesome" }
-          worksheet { name "awesome1" }
-        }
+        subject.pop
       end
+
+      assert_nil subject.pop
     end
 
   end
 
-  class WorkbookStyleTest < WorkbookTest
-    desc "A workbook that defines styles"
+  class WorkbookStyleTests < WorkbookTests
+    desc "that defines styles"
     before do
-      @wkbk = Workbook.new {
+      @wkbk = Workbook.new(@test_writer) {
         style('.test')
         style('.test.awesome')
+
+        worksheet("styles") {
+          column { style_class "test awesome" }
+        }
       }
     end
 
+    should "return the style obj created" do
+      style = subject.style(".a.test.style")
+
+      assert_kind_of Style, style
+      assert_equal '.a.test.style', style.selectors.first
+    end
+
     should "add them to it's styles" do
       assert_equal 2, subject.styles.size
       assert_equal 1, subject.styles.first.selectors.size
@@ -108,12 +146,104 @@ module Osheet
       assert_equal '.test.awesome', subject.styles.last.selectors.first
     end
 
+    should "write the style class on the element" do
+      assert_equal "test awesome", subject.worksheets.last.columns.last.style_class
+    end
+
   end
 
-  class WorkbookPartialTest < WorkbookTest
-    desc "A workbook that defines partials"
+  class WorkbookWorksheetTests < WorkbookTests
+    desc "with worksheets"
     before do
-      @wkbk = Workbook.new {
+      @wkbk = Workbook.new(@test_writer) {
+        worksheet {
+          name "one"
+        }
+        worksheet {
+          name "two"
+          meta :some_meta
+        }
+      }
+    end
+
+    should "return the worksheet obj created" do
+      assert_kind_of Worksheet, subject.worksheet("test")
+    end
+
+    should "add them to it's worksheets reader" do
+      assert_equal 2, subject.worksheets.size
+      assert_equal "one", subject.worksheets.first.name
+      assert_equal "two", subject.worksheets.last.name
+      assert_equal :some_meta, subject.worksheets.last.meta
+    end
+
+    should "return the last worksheet added if called with no args" do
+      assert_equal subject.worksheets.last, subject.worksheet
+    end
+
+    should "call the writer with the created worksheet obj" do
+      assert_equal subject.worksheets.last, subject.writer.worksheets.last
+    end
+
+  end
+
+  class WorkbookRowCellMetaTests < WorkbookTests
+    desc "with columns, meta, rows, and cells"
+    before do
+      @wkbk = Workbook.new(@test_writer) {
+        worksheet {
+          column(100) { meta(:label => 'One') }
+          column { meta(:label => 'Two') }
+
+          row {
+            columns.each do |column|
+              cell(column.meta[:label])
+            end
+          }
+          row(120) {
+            cell {
+              data 12234
+              format :currency
+            }
+            cell(Time.now) {
+              format :datetime, 'mm/dd/yyyy'
+            }
+
+          }
+        }
+      }
+    end
+
+    should "add the columns to it's columns reader" do
+      assert_equal 2, subject.columns.size
+      assert_equal 100, subject.columns.first.width
+      assert_equal nil, subject.columns.last.width
+
+      assert_equal subject.columns.last, subject.writer.columns.last
+    end
+
+    should "just keep the last row in its rows reader" do
+      assert_equal 1, subject.rows.size
+      assert_equal 120, subject.rows.first.height
+
+      assert_equal 2, subject.writer.rows.size
+      assert_equal subject.rows.first, subject.writer.rows.last
+    end
+
+    should "access the cells of its last row" do
+      assert_equal 2, subject.cells.size
+      assert_equal 12234, subject.cells.first.data
+
+      assert_equal 4, subject.writer.cells.size
+      assert_equal subject.cells.last, subject.writer.rows.last.cells.last
+    end
+
+  end
+
+  class WorkbookPartialTests < WorkbookTests
+    desc "that defines partials"
+    before do
+      @wkbk = Workbook.new(@test_writer) {
         partial(:named_styles) { |name|
           style(".#{name}")
           style(".#{name}.awesome")
@@ -123,10 +253,10 @@ module Osheet
     end
 
     should "add them to it's partials" do
-      assert_equal 2, subject.partials.keys.size
-      assert subject.partials.has_key?('named_styles')
-      assert subject.partials.has_key?('stuff')
-      assert_kind_of Partial, subject.partials.get('stuff')
+      assert_equal 2, subject.workbook.partials.keys.size
+      assert subject.workbook.partials.has_key?('named_styles')
+      assert subject.workbook.partials.has_key?('stuff')
+      assert_kind_of Partial, subject.workbook.partials.get('stuff')
     end
 
     should "add it's partials to it's markup" do
@@ -138,10 +268,10 @@ module Osheet
 
   end
 
-  class WorkbookTemplateTest < WorkbookTest
-    desc "A workbook that defines templates"
+  class WorkbookTemplateTests < WorkbookTests
+    desc "that defines templates"
     before do
-      @wkbk = Workbook.new {
+      @wkbk = Workbook.new(@test_writer) {
         template(:column, :yo) { |color|
           width 200
           meta(:color => color)
@@ -158,7 +288,7 @@ module Osheet
 
     should "add them to it's templates" do
       assert subject.templates
-      assert_kind_of TemplateSet, subject.templates
+      assert_kind_of WorkbookElement::TemplateSet, subject.templates
       assert_equal 3, subject.templates.keys.size
       assert_kind_of Template, subject.templates.get('column', 'yo')
       assert_kind_of Template, subject.templates.get('row', 'yo_yo')
@@ -169,32 +299,18 @@ module Osheet
       subject.worksheet(:go)
       assert_equal 1, subject.worksheets.size
       assert_equal 'blue', subject.worksheets.first.columns.first.meta[:color]
-      assert_equal 500, subject.worksheets.first.rows.first.attributes[:height]
+      assert_equal 500, subject.worksheets.first.rows.first.height
     end
 
   end
 
-  class WorkbookBindingTest < WorkbookTest
-    desc "a workbook defined w/ a block"
-    should "access instance vars from that block's binding" do
-      @test = 'test'
-      @workbook = Workbook.new { title @test }
-
-      assert !@workbook.send(:instance_variable_get, "@test").nil?
-      assert_equal @test, @workbook.send(:instance_variable_get, "@test")
-      assert_equal @test.object_id, @workbook.send(:instance_variable_get, "@test").object_id
-      assert_equal @test, @workbook.attributes[:title]
-      assert_equal @test.object_id, @workbook.attributes[:title].object_id
-    end
-
-  end
-
-  class WorkbookMixins < WorkbookTest
-    desc "a workbook w/ mixins"
+  class WorkbookMixinTests < WorkbookTests
+    desc "with mixins"
     before do
-      @wkbk = Workbook.new {
+      @wkbk = Workbook.new(@test_writer) {
         use StyledMixin
         use TemplatedMixin
+        use PartialedMixin
       }
     end
 
@@ -204,39 +320,32 @@ module Osheet
       assert_equal '.test', subject.styles.first.selectors.first
       assert_equal 1, subject.styles.last.selectors.size
       assert_equal '.test.awesome', subject.styles.last.selectors.first
+      assert_equal [:left], subject.styles.last.align
     end
 
     should "add the mixin templates to it's templates" do
-      assert subject.templates
-      assert_kind_of TemplateSet, subject.templates
-      assert_equal 3, subject.templates.keys.size
-      assert_kind_of Template, subject.templates.get('column', 'yo')
-      assert_kind_of Template, subject.templates.get('row', 'yo_yo')
-      assert_kind_of Template, subject.templates.get('worksheet', 'go')
-
       subject.worksheet(:go)
+
       assert_equal 1, subject.worksheets.size
       assert_equal 'blue', subject.worksheets.first.columns.first.meta[:color]
-      assert_equal 500, subject.worksheets.first.rows.first.attributes[:height]
+      assert_equal 500, subject.worksheets.first.rows.first.height
     end
 
-  end
-
-  class WorkbookWriter < WorkbookTest
-    desc "a workbook"
-    before do
-      @wkbk = Workbook.new {
-        style('.test')
-        style('.test.awesome')
+    should "add the mixin partials to it's partials" do
+      subject.worksheet {
+        subject.add(:three_empty_rows)
+        subject.add(:two_cells_in_a_row, "one", "two")
       }
-    end
 
-    should have_instance_method :writer, :to_data, :to_file
+      assert_equal 4, subject.writer.rows.size
+
+      assert_empty subject.writer.rows[0].cells
+      assert_empty subject.writer.rows[1].cells
+      assert_empty subject.writer.rows[2].cells
 
-    should "provide a writer for itself" do
-      writer = subject.writer
-      assert writer
-      assert_kind_of XmlssWriter::Base, writer
+      assert_equal 2, subject.writer.rows.last.cells.size
+      assert_equal "one", subject.writer.rows.last.cells.first.data
+      assert_equal "two", subject.writer.rows.last.cells.last.data
     end
 
   end