osheet 0.7.0 → 0.8.0

data/test/style_test.rb

@@ -1,129 +1,104 @@
-require "test/helper"
+require "assert"
 require "osheet/style"
 
 module Osheet
 
-  class StyleTest < Test::Unit::TestCase
-    context "Osheet::Style" do
-      subject { Style.new('.test') }
+  class StyleTest < Assert::Context
+    desc "Osheet::Style"
+    before { @st = Style.new('.test') }
+    subject { @st }
 
-      should_have_reader :selectors
-      should_have_instance_methods :align, :font, :bg
-      should_have_instance_methods :border, :border_left, :border_top, :border_right, :border_bottom
-      should_have_instance_method :match?
+    should have_reader :selectors
+    should have_instance_methods :align, :font, :bg
+    should have_instance_methods :border, :border_left, :border_top, :border_right, :border_bottom
+    should have_instance_method :match?
 
-      should "set it's defaults" do
-        assert_equal 1, subject.selectors.size
-        assert_equal '.test', subject.selectors.first
-        [ :align, :font, :bg,
-          :border_left, :border_top, :border_right, :border_bottom
-        ].each do |a|
-          assert_equal [], subject.send(:get_ivar, a)
-        end
+    should "set it's defaults" do
+      assert_equal 1, subject.selectors.size
+      assert_equal '.test', subject.selectors.first
+      [ :align, :font, :bg,
+        :border_left, :border_top, :border_right, :border_bottom
+      ].each do |a|
+        assert_equal [], subject.send(:get_ivar, a)
       end
+    end
 
-      should "know it's attribute(s)" do
-        [ :align, :font, :bg,
-          :border_left, :border_top, :border_right, :border_bottom
-        ].each do |a|
-          assert subject.attributes.has_key?(a)
-        end
+    should "know it's attribute(s)" do
+      [ :align, :font, :bg,
+        :border_left, :border_top, :border_right, :border_bottom
+      ].each do |a|
+        assert subject.attributes.has_key?(a)
       end
-
     end
-  end
-
-  class StyleSelectorTest < Test::Unit::TestCase
-    context "A Style" do
-      subject { Style.new('.test') }
 
-      should "complain about bad selectors" do
-        ['poo', '#poo', 'poo poo', 'poo > poo', :poo, 123].each do |s|
-          assert_raises ArgumentError do
-            Style.new(s)
-          end
+    should "complain about bad selectors" do
+      ['poo', '#poo', 'poo poo', 'poo > poo', :poo, 123].each do |s|
+        assert_raises ArgumentError do
+          Style.new(s)
         end
       end
+    end
 
-      should "not complain about good selectors" do
-        ['.poo', '.poo.poo', '.poo-poo', '.poo_poo'].each do |s|
-          assert_nothing_raised do
-            Style.new(s)
-          end
+    should "not complain about good selectors" do
+      ['.poo', '.poo.poo', '.poo-poo', '.poo_poo'].each do |s|
+        assert_nothing_raised do
+          Style.new(s)
         end
       end
-
     end
-  end
 
-  class StyleCollectorTest < Test::Unit::TestCase
-    context "A Style" do
-      subject { Style.new }
-
-      [ :align, :font, :bg,
-        :border_left, :border_top, :border_right, :border_bottom
-      ].each do |a|
-        should "collect styles for #{a}" do
-          args = [1, "#FF0000", "Verdana", :love, 1.2]
-          subject.send(a, *args)
-          assert_equal args, subject.send(:get_ivar, a)
-        end
+    [ :align, :font, :bg,
+      :border_left, :border_top, :border_right, :border_bottom
+    ].each do |a|
+      should "collect styles for #{a}" do
+        args = [1, "#FF0000", "Verdana", :love, 1.2]
+        subject.send(a, *args)
+        assert_equal args, subject.send(:get_ivar, a)
       end
+    end
 
-      should "set all border positions to the same styles using 'border' macro collector" do
-        args = [:thick, '#FF00FF', :dot]
-        subject.border *args
-        [ :border_left, :border_top, :border_right, :border_bottom].each do |a|
-          assert_equal args, subject.send(:get_ivar, a)
-        end
+    should "set all border positions to the same styles using 'border' macro collector" do
+      args = [:thick, '#FF00FF', :dot]
+      subject.border *args
+      [ :border_left, :border_top, :border_right, :border_bottom].each do |a|
+        assert_equal args, subject.send(:get_ivar, a)
       end
-
     end
-  end
-
-  class StyleMatcherTest < Test::Unit::TestCase
-    context "A Style" do
-      subject { Style.new }
 
-      should "match on style class strings" do
-        a = Style.new('.awesome') {}
-        at = Style.new('.awesome.thing') {}
-        b = Style.new('.boring') {}
-        bt = Style.new('.boring.thing') {}
-        a_b = Style.new('.awesome', '.boring') {}
-        t = Style.new('.thing') {}
-        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|
-          styles.each do |style|
-            assert_equal true, style.match?(style_class)
-          end
+    should "match on style class strings" do
+      a = Style.new('.awesome') {}
+      at = Style.new('.awesome.thing') {}
+      b = Style.new('.boring') {}
+      bt = Style.new('.boring.thing') {}
+      a_b = Style.new('.awesome', '.boring') {}
+      t = Style.new('.thing') {}
+      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|
+        styles.each do |style|
+          assert_equal true, style.match?(style_class)
         end
-        assert_equal false, a.match?('stupid')
       end
-
+      assert_equal false, a.match?('stupid')
     end
-  end
 
-  class StyleBindingTest < Test::Unit::TestCase
-    context "a style defined w/ a block" do
-      should "access instance vars from that block's binding" do
-        @test = 20
-        @style = Style.new('.test') { font @test }
+    should "access instance vars from that block's binding" do
+      @test = 20
+      @style = Style.new('.test') { font @test }
 
-        assert !@style.send(:instance_variable_get, "@test").nil?
-        assert_equal @test, @style.send(:instance_variable_get, "@test")
-        assert_equal @test.object_id, @style.send(:instance_variable_get, "@test").object_id
-        assert_equal @test, @style.attributes[:font].first
-        assert_equal @test.object_id, @style.attributes[:font].first.object_id
-      end
+      assert !@style.send(:instance_variable_get, "@test").nil?
+      assert_equal @test, @style.send(:instance_variable_get, "@test")
+      assert_equal @test.object_id, @style.send(:instance_variable_get, "@test").object_id
+      assert_equal @test, @style.attributes[:font].first
+      assert_equal @test.object_id, @style.attributes[:font].first.object_id
     end
+
   end
 
 end

data/test/template_set_test.rb

@@ -1,95 +1,74 @@
-require "test/helper"
+require "assert"
 require "osheet/template_set"
 
 module Osheet
-  class TemplateSetTest < Test::Unit::TestCase
-
-    context "Osheet::TemplateSet" do
-      subject { TemplateSet.new }
-
-      should "be a PartialSet" do
-        assert_kind_of 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
+  class TemplateSetTest < Assert::Context
+    desc "Osheet::TemplateSet"
+    before { @set = TemplateSet.new }
+    subject { @set }
 
+    should "be a PartialSet" do
+      assert_kind_of PartialSet, subject
     end
-  end
-
-  class TemplateSetKeyTest < Test::Unit::TestCase
-    context "A template set" do
-      subject { TemplateSet.new }
 
-      should "key templates using an array of their element and name" do
-        assert_equal ['row','poo'], subject.send(:key, :row, :poo)
+    should "verify set objs are templates" do
+      assert_raises ArgumentError do
+        subject.send(:verify, {})
       end
-
-      should "key on templates objs" do
-        assert_equal ['row', 'poo'], subject.send(:template_key, Template.new(:row, :poo) {})
+      assert_nothing_raised do
+        subject.send(:verify, Template.new(:row, :poo) {})
       end
+    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 "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
-  end
 
-  class TemplateSetPushTest < Test::Unit::TestCase
-    context "A template set" do
-      subject { TemplateSet.new }
-      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
+    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
 
-        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"]
+    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
-  end
 
-  class TemplateSetLookupTest < Test::Unit::TestCase
-    context "A template set" do
-      subject { TemplateSet.new }
-
-      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
+    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
 
 end

data/test/template_test.rb

@@ -1,66 +1,48 @@
-require "test/helper"
+require "assert"
 require "osheet/template"
 
 module Osheet
 
-  class TemplateTest < Test::Unit::TestCase
-    context "Osheet::Template" do
-      subject do
-        Template.new('column', :thing) {}
-      end
+  class TemplateTest < Assert::Context
+    desc "Osheet::Template"
+    before do
+      @tmpl = Template.new('column', :thing) {}
+    end
+    subject { @tmpl }
 
-      should "define what elements it is valid for" do
-        assert_equal ['worksheet', 'column', 'row', 'cell'], Template::ELEMENTS
-      end
+    should "define what elements it is valid for" do
+      assert_equal ['worksheet', 'column', 'row', 'cell'], Template::ELEMENTS
+    end
 
-      should_have_accessor :element
+    should have_accessor :element
 
-      should "be a Partial" do
-        assert_kind_of Partial, subject
-      end
-
-      should "convert the element ars to string and store off" do
-        assert_equal 'column', subject.element
-      end
+    should "be a Partial" do
+      assert_kind_of Partial, subject
+    end
 
+    should "convert the element ars to string and store off" do
+      assert_equal 'column', subject.element
     end
+
   end
 
-  class TemplateElementTest < Test::Unit::TestCase
-    context "a template" do
-      should "verify the element argument" do
-        assert_raises ArgumentError do
-          Template.new({}, :poo) {}
-        end
-        assert_raises ArgumentError do
-          Template.new('workbook', :poo) {}
-        end
-        Template::ELEMENTS.each do |elem|
-          assert_nothing_raised do
-            Template.new(elem, :poo) {}
-          end
+  class TemplateElementTest < TemplateTest
+    desc "a template"
+
+    should "verify the element argument" do
+      assert_raises ArgumentError do
+        Template.new({}, :poo) {}
+      end
+      assert_raises ArgumentError do
+        Template.new('workbook', :poo) {}
+      end
+      Template::ELEMENTS.each do |elem|
+        assert_nothing_raised do
+          Template.new(elem, :poo) {}
         end
       end
-
     end
-  end
 
-  # class TemplateBindingTest < Test::Unit::TestCase
-  #   context "a template defined w/ a block" do
-  #     should "access instance vars from that block's binding" do
-  #       @test = 'test thing'
-  #       @workbook = Workbook.new {
-  #         template('worksheet', :thing) { name @test }
-  #         worksheet(:thing)
-  #       }
-  #
-  #       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
+  end
 
 end