osheet 0.7.0 → 0.8.0

data/test/osheet_test.rb

@@ -1,16 +1,13 @@
-require "test/helper"
+require "assert"
 
-class OsheetTest < Test::Unit::TestCase
+class OsheetTest < Assert::Context
+  desc "Osheet"
+  subject {::Osheet}
 
-  context "Osheet" do
-    subject {::Osheet}
-
-    should_have_instance_method :register
-
-    should "use provide a default mime type" do
-      assert_equal "application/vnd.ms-excel", Osheet::MIME_TYPE
-    end
+  should have_instance_method :register
 
+  should "use provide a default mime type" do
+    assert_equal "application/vnd.ms-excel", Osheet::MIME_TYPE
   end
 
 end

data/test/partial_set_test.rb

@@ -1,84 +1,64 @@
-require "test/helper"
+require "assert"
 require "osheet/partial_set"
 
 module Osheet
 
-  class PartialSetTest < Test::Unit::TestCase
-    context "Osheet::PartialSet" do
-      subject { PartialSet.new }
-
-      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
+  class PartialSetTest < Assert::Context
+    desc "Osheet::PartialSet"
+    before { @ps = PartialSet.new }
+    subject { @ps }
 
+    should "be a Hash" do
+      assert_kind_of ::Hash, subject
     end
-  end
 
-  class PartialSetKeyTest < Test::Unit::TestCase
-    context "A partial set" do
-      subject { PartialSet.new }
+    should have_instance_method :<<
+    should have_reader :get
 
-      should "key using name values" do
-        assert_equal 'poo', subject.send(:key, :poo)
+    should "verify set objs are partials" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
       end
-
-      should "key on partial objs" do
-        assert_equal 'poo', subject.send(:partial_key, Partial.new(:poo) {})
+      assert_nothing_raised do
+        subject.send(:verify, Partial.new(:poo) {})
       end
+    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 "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
-  end
 
-  class PartialSetPushTest < Test::Unit::TestCase
-    context "A partial set" do
-      subject { PartialSet.new }
-      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
+    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
 
-        assert_equal 3, subject.keys.size
-        assert subject["poo"]
-        assert_kind_of Partial, subject["poo"]
+    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
-  end
-
-  class PartialSetLookupTest < Test::Unit::TestCase
-    context "A partial set" do
-      subject { PartialSet.new }
-
-      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
 
+    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
 
 end

data/test/partial_test.rb

@@ -1,66 +1,64 @@
-require "test/helper"
+require "assert"
 require "osheet/partial"
 
 module Osheet
-  class PartialTest < Test::Unit::TestCase
+  class PartialTest < Assert::Context
+    desc "Osheet::Partial"
+    before { @p = Partial.new(:thing) {} }
+    subject { @p }
 
-    context "Osheet::Partial" do
-      subject do
-        Partial.new(:thing) {}
-      end
-
-      should_have_accessor :name
-
-      should "be a Proc" do
-        assert_kind_of ::Proc, subject
-      end
+    should have_accessor :name
 
-      should "convert the name arg to a string and store off" do
-        assert_equal 'thing', subject.name
-      end
+    should "be a Proc" do
+      assert_kind_of ::Proc, subject
+    end
 
+    should "convert the name arg to a string and store off" do
+      assert_equal 'thing', subject.name
     end
+
   end
 
-  class PartialNameTest < Test::Unit::TestCase
-    context "A named partial" do
-      should "verify the name argument" do
-        assert_raises ArgumentError do
-          Partial.new([]) {}
-        end
-        assert_raises ArgumentError do
-          Partial.new(1) {}
-        end
-        assert_nothing_raised do
-          Partial.new(:poo) {}
-        end
-        assert_nothing_raised do
-          Partial.new('poo') {}
-        end
-      end
+  class PartialNameTest < Assert::Context
+    desc "A named partial"
 
+    should "verify the name argument" do
+      assert_raises ArgumentError do
+        Partial.new([]) {}
+      end
+      assert_raises ArgumentError do
+        Partial.new(1) {}
+      end
+      assert_nothing_raised do
+        Partial.new(:poo) {}
+      end
+      assert_nothing_raised do
+        Partial.new('poo') {}
+      end
     end
+
   end
 
-  class PartialBindingTest < Test::Unit::TestCase
-    context "a partial defined w/ a block" do
-      should "access instance vars from that block's binding" do
-        @test = 'test thing'
-        @workbook = Workbook.new {
-          partial(:stuff) {
-            worksheet(:thing) { name @test }
-          }
+  class PartialBindingTest < Assert::Context
+    desc "a partial defined w/ a block"
 
-          add(:stuff)
+    should "access instance vars from that block's binding" do
+      @test = 'test thing'
+      @workbook = Workbook.new {
+        partial(:stuff) {
+          worksheet(:thing) { name @test }
         }
 
-        assert !@workbook.worksheets.first.send(:instance_variable_get, "@test").nil?
-        assert_equal @test, @workbook.worksheets.first.send(:instance_variable_get, "@test")
-        assert_equal @test.object_id, @workbook.worksheets.first.send(:instance_variable_get, "@test").object_id
-        assert_equal @test, @workbook.worksheets.first.attributes[:name]
-        assert_equal @test.object_id, @workbook.worksheets.first.attributes[:name].object_id
-      end
+        add(:stuff)
+      }
+
+      assert !@workbook.worksheets.first.send(:instance_variable_get, "@test").nil?
+      assert_equal @test, @workbook.worksheets.first.send(:instance_variable_get, "@test")
+      assert_equal @test.object_id, @workbook.worksheets.first.send(:instance_variable_get, "@test").object_id
+      assert_equal @test, @workbook.worksheets.first.attributes[:name]
+      assert_equal @test.object_id, @workbook.worksheets.first.attributes[:name].object_id
     end
+
   end
 
 end

data/test/row_test.rb

@@ -1,131 +1,124 @@
-require "test/helper"
+require "assert"
 require 'osheet/row'
 
 module Osheet
 
-  class RowTest < Test::Unit::TestCase
-    context "Osheet::Row" do
-      subject { Row.new }
+  class RowTest < Assert::Context
+    desc "Osheet::Row"
+    before { @rw = Row.new }
+    subject { @rw }
 
-      should_be_a_styled_element(Row)
-      should_be_a_worksheet_element(Row)
-      should_be_a_workbook_element(Row)
+    should_be_a_styled_element(Row)
+    should_be_a_worksheet_element(Row)
+    should_be_a_workbook_element(Row)
 
-      should_have_instance_method :height
-      should_have_instance_methods :autofit, :autofit?
-      should_have_instance_methods :hidden, :hidden?
-      should_have_instance_method :meta
+    should have_instance_method :height
+    should have_instance_methods :autofit, :autofit?
+    should have_instance_methods :hidden, :hidden?
+    should have_instance_method :meta
 
-      should_hm(Row, :cells, Cell)
+    should_hm(Row, :cells, Cell)
 
-      should "set it's defaults" do
-        assert_equal nil, subject.send(:get_ivar, "height")
-        assert_equal false, subject.send(:get_ivar, "autofit")
-        assert !subject.autofit?
-        assert_equal false, subject.send(:get_ivar, "hidden")
-        assert !subject.hidden?
+    should "set it's defaults" do
+      assert_equal nil, subject.send(:get_ivar, "height")
+      assert_equal false, subject.send(:get_ivar, "autofit")
+      assert !subject.autofit?
+      assert_equal false, subject.send(:get_ivar, "hidden")
+      assert !subject.hidden?
 
-        assert_equal [], subject.cells
-        assert_equal nil, subject.meta
-      end
+      assert_equal [], subject.cells
+      assert_equal nil, subject.meta
+    end
 
+    should "set it's height" do
+      subject.height(false)
+      assert_equal false, subject.height
+      subject.height(180)
+      assert_equal 180, subject.height
+      subject.height(nil)
+      assert_equal 180, subject.height
     end
-  end
 
-  class RowAttributeTest < Test::Unit::TestCase
-    context "a row that has attributes" do
-      subject do
-        Row.new do
-          style_class "poo"
-          height  100
-          autofit true
-          hidden true
-          meta(
-            {}
-          )
-        end
-      end
+    should "cast autofit and hidden to bool" do
+      rw = Row.new { autofit :true; hidden 'false'}
+      assert_kind_of ::TrueClass, rw.send(:get_ivar, "autofit")
+      assert_kind_of ::TrueClass, rw.send(:get_ivar, "hidden")
+    end
 
-      should "should set them correctly" do
-        assert_equal 100, subject.send(:get_ivar, "height")
-        assert_equal true, subject.send(:get_ivar, "autofit")
-        assert subject.autofit?
-        assert_equal true, subject.send(:get_ivar, "hidden")
-        assert subject.hidden?
-        assert_equal({}, subject.meta)
-      end
+  end
 
-      should "know it's attribute(s)" do
-        [:style_class, :height, :autofit, :hidden].each do |a|
-          assert subject.attributes.has_key?(a)
-        end
-        assert_equal 'poo', subject.attributes[:style_class]
-        assert_equal 100, subject.attributes[:height]
-        assert_equal true, subject.attributes[:autofit]
-        assert_equal true, subject.attributes[:hidden]
+  class RowAttributeTest < RowTest
+    desc "a row that has attributes"
+    before do
+      @rw = Row.new do
+        style_class "poo"
+        height  100
+        autofit true
+        hidden true
+        meta(
+          {}
+        )
       end
-
     end
-  end
 
-  class RowDataTest < Test::Unit::TestCase
-    context "A row" do
-      subject { Row.new }
-
-      should "set it's height" do
-        subject.height(false)
-        assert_equal false, subject.height
-        subject.height(180)
-        assert_equal 180, subject.height
-        subject.height(nil)
-        assert_equal 180, subject.height
-      end
+    should "should set them correctly" do
+      assert_equal 100, subject.send(:get_ivar, "height")
+      assert_equal true, subject.send(:get_ivar, "autofit")
+      assert subject.autofit?
+      assert_equal true, subject.send(:get_ivar, "hidden")
+      assert subject.hidden?
+      assert_equal({}, subject.meta)
+    end
 
-      should "cast autofit and hidden to bool" do
-        rw = Row.new { autofit :true; hidden 'false'}
-        assert_kind_of ::TrueClass, rw.send(:get_ivar, "autofit")
-        assert_kind_of ::TrueClass, rw.send(:get_ivar, "hidden")
+    should "know it's attribute(s)" do
+      [:style_class, :height, :autofit, :hidden].each do |a|
+        assert subject.attributes.has_key?(a)
       end
-
+      assert_equal 'poo', subject.attributes[:style_class]
+      assert_equal 100, subject.attributes[:height]
+      assert_equal true, subject.attributes[:autofit]
+      assert_equal true, subject.attributes[:hidden]
     end
+
   end
 
-  class RowPartialTest < Test::Unit::TestCase
-    context "A workbook that defines column partials" do
-      subject do
-        Workbook.new {
-          partial(:row_stuff) {
-            height 200
-            meta 'awesome'
-          }
-
-          worksheet { row {
-            add :row_stuff
-          } }
+  class RowPartialTest < Assert::Context
+    desc "A workbook that defines column partials"
+    before do
+      @wkbk = Workbook.new {
+        partial(:row_stuff) {
+          height 200
+          meta 'awesome'
         }
-      end
 
-      should "add it's partials to it's markup" do
-        assert_equal 200, subject.worksheets.first.rows.first.height
-        assert_equal 'awesome', subject.worksheets.first.rows.first.meta
-      end
+        worksheet { row {
+          add :row_stuff
+        } }
+      }
+    end
+    subject { @wkbk }
 
+    should "add it's partials to it's markup" do
+      assert_equal 200, subject.worksheets.first.rows.first.height
+      assert_equal 'awesome', subject.worksheets.first.rows.first.meta
     end
+
   end
 
-  class RowBindingTest < Test::Unit::TestCase
-    context "a row defined w/ a block" do
-      should "access instance vars from that block's binding" do
-        @test = 50
-        @row = Row.new { height @test }
-
-        assert !@row.send(:instance_variable_get, "@test").nil?
-        assert_equal @test, @row.send(:instance_variable_get, "@test")
-        assert_equal @test.object_id, @row.send(:instance_variable_get, "@test").object_id
-        assert_equal @test, @row.attributes[:height]
-        assert_equal @test.object_id, @row.attributes[:height].object_id
-      end
+  class RowBindingTest < Assert::Context
+    desc "a row defined w/ a block"
+
+    should "access instance vars from that block's binding" do
+      @test = 50
+      @row = Row.new { height @test }
+
+      assert !@row.send(:instance_variable_get, "@test").nil?
+      assert_equal @test, @row.send(:instance_variable_get, "@test")
+      assert_equal @test.object_id, @row.send(:instance_variable_get, "@test").object_id
+      assert_equal @test, @row.attributes[:height]
+      assert_equal @test.object_id, @row.attributes[:height].object_id
     end
+
   end
 
 end

data/test/style_set_test.rb

@@ -1,50 +1,47 @@
-require "test/helper"
+require "assert"
 require "osheet/style_set"
 
 module Osheet
-  class StyleSetTest < Test::Unit::TestCase
+  class StyleSetTest < Assert::Context
+    desc "Osheet::StyleSet"
+    before { @set = StyleSet.new }
+    subject { @set }
 
-    context "Osheet::StyleSet" do
-      subject { StyleSet.new }
-
-      should "be an Array" do
-        assert_kind_of ::Array, subject
-      end
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+    end
 
-      should_have_reader :for
+    should have_reader :for
 
-      should "verify Template objs" do
-        assert_raises ArgumentError do
-          subject.send(:verify, {})
-        end
-        assert_nothing_raised do
-          subject.send(:verify, Style.new('.awesome') {})
-        end
+    should "verify Template objs" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
       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|
-          if style_class == 'awesome'
-            assert_equal styles_set, subject.for(style_class)
-          end
-        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
 
   end
+
 end