xmlss 0.2.0 → 0.2.1

data/test/helper.rb

@@ -1,13 +1,17 @@
-require 'rubygems'
-require 'test_belt'
-require 'test/env'
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
 
-class Test::Unit::TestCase
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+require 'xmlss'
+
+class Assert::Context
 
   class << self
 
     def should_build_node
-      should_have_instance_methods :build_node
+      should have_instance_methods :build_node
       should "build it's node" do
         assert_nothing_raised do
           ::Nokogiri::XML::Builder.new do |builder|
@@ -18,18 +22,15 @@ class Test::Unit::TestCase
     end
 
     def should_build_no_attributes_by_default(klass)
-      context "by default" do
-        subject{ klass.new }
-
-        should "have no element attributes" do
-          assert_equal({}, subject.send(:build_attributes))
-        end
+      should "have no element attributes" do
+        xmlthing = klass.new
+        assert_equal({}, xmlthing.send(:build_attributes))
       end
     end
 
     def should_have_style(klass)
-      should_have_accessor :style_id
-      should_have_reader :style_i_d
+      should have_accessor :style_id
+      should have_reader :style_i_d
 
       should "set the style default" do
         assert_equal nil, subject.style_id
@@ -40,10 +41,8 @@ class Test::Unit::TestCase
         assert_equal :poo, c.style_id
         assert_equal :poo, c.style_i_d
       end
-
-
     end
 
   end
 
-end
+end

data/test/irb.rb

@@ -0,0 +1,10 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert' is required above, the test helper will be
+# required in.
+
+# put any IRB setup code here
+
+require 'xmlss'
+

data/test/item_set_test.rb

@@ -1,26 +1,27 @@
-require "test/helper"
+require "assert"
 require 'xmlss/item_set'
 
 module Xmlss
-  class ItemSetTest < Test::Unit::TestCase
+  class ItemSetTest < Assert::Context
+    desc "Xmlss::ItemSet"
+    subject { ItemSet.new(:test) }
 
-    context "Xmlss::ItemSet" do
-      subject { ItemSet.new(:test) }
+    should have_reader :name
 
-      should_have_reader :name
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+      assert_respond_to :each, subject
+      assert_empty subject
+    end
 
-      should "be an Array" do
-        assert_kind_of ::Array, subject
-        assert_respond_to subject, :each
-        assert subject.empty?
-      end
+  end
 
-      context "for generating XML" do
-        should_have_reader :xml
-        should_build_node
-        should_build_no_attributes_by_default(ItemSet)
-      end
-    end
+  class ItemSetXmlTest < ItemSetTest
+    desc "for generating XML"
 
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(ItemSet)
   end
-end
+
+end

data/test/row_test.rb

@@ -1,67 +1,70 @@
-require "test/helper"
+require "assert"
+require 'xmlss/cell'
 require 'xmlss/row'
 
 module Xmlss
-  class RowTest < Test::Unit::TestCase
+  class RowTest < Assert::Context
+    desc "Xmlss::Row"
+    before { @row = Row.new }
+    subject { @row }
 
-    context "Xmlss::Row" do
-      subject { Row.new }
+    should_have_style(Row)
+    should have_accessors :height, :auto_fit_height, :hidden
+    should have_accessor :cells
 
-      should_have_style(Row)
-      should_have_accessor :height, :auto_fit_height, :hidden
-      should_have_accessor :cells
+    should "set it's defaults" do
+      assert_equal nil, subject.height
+      assert_equal false, subject.auto_fit_height
+      assert_equal false, subject.hidden
+      assert_equal [], subject.cells
+    end
 
-      should "set it's defaults" do
-        assert_equal nil, subject.height
-        assert_equal false, subject.auto_fit_height
-        assert_equal false, subject.hidden
-        assert_equal [], subject.cells
-      end
+    should "allow defining a cells at init" do
+      row = Row.new({
+        :cells => [Cell.new]
+      })
 
-      should "allow defining a cells at init" do
-        row = Row.new({
-          :cells => [Cell.new]
-        })
+      assert_equal 1, row.cells.size
+      assert_kind_of Cell, row.cells.first
+    end
 
-        assert_equal 1, row.cells.size
-        assert_kind_of Cell, row.cells.first
+    should "bark when setting non Numeric height" do
+      assert_raises ArgumentError do
+        Row.new({:height => "do it"})
       end
-
-      should "bark when setting non Numeric height" do
-        assert_raises ArgumentError do
-          Row.new({:height => "do it"})
-        end
-        assert_nothing_raised do
-          Row.new({:height => 2})
-        end
-        assert_nothing_raised do
-          Row.new({:height => 3.5})
-        end
+      assert_nothing_raised do
+        Row.new({:height => 2})
       end
-
-      should "nil out height values that are < 0" do
-        assert_equal nil, Row.new({:height => -1.2}).height
-        assert_equal nil, Row.new({:height => -1}).height
-        assert_equal 0, Row.new({:height => 0}).height
-        assert_equal 1.2, Row.new({:height => 1.2}).height
+      assert_nothing_raised do
+        Row.new({:height => 3.5})
       end
+    end
 
+    should "nil out height values that are < 0" do
+      assert_equal nil, Row.new({:height => -1.2}).height
+      assert_equal nil, Row.new({:height => -1}).height
+      assert_equal 0, Row.new({:height => 0}).height
+      assert_equal 1.2, Row.new({:height => 1.2}).height
+    end
+  end
 
-      context "when using cells" do
-        before { subject.cells << Cell.new }
-
-        should "should build a data object" do
-          assert_equal 1, subject.cells.size
-          assert_kind_of Cell, subject.cells.first
-        end
-      end
-
-      context "for generating XML" do
-        should_have_reader :xml
-        should_build_node
-      end
+  class RowCellsTest < RowTest
+    desc "when using cells"
+    before do
+      r = subject.cells << Cell.new
+    end
 
+    should "should build a data object" do
+      assert_equal 1, subject.cells.size
+      assert_kind_of Cell, subject.cells.first
     end
+  end
 
+  class RowXmlTest < RowTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
   end
+
 end

data/test/style/alignment_test.rb

@@ -1,12 +1,14 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/alignment'
 
-class Xmlss::Style::AlignmentTest < Test::Unit::TestCase
+module Xmlss::Style
+  class AlignmentTest < Assert::Context
+    desc "Xmlss::Style::Alignment"
+    before { @a = Alignment.new }
+    subject { @a }
 
-  context "Xmlss::Style::Alignment" do
-    subject { Xmlss::Style::Alignment.new }
+    should have_class_method :horizontal
 
-    should_have_class_method :horizontal
     {
       :automatic => "Automatic",
       :left => "Left",
@@ -14,11 +16,12 @@ class Xmlss::Style::AlignmentTest < Test::Unit::TestCase
       :right => "Right"
     }.each do |horizontal, value|
       should "provide the value for the '#{horizontal}' horizontal" do
-        assert_equal value, Xmlss::Style::Alignment.horizontal(horizontal)
+        assert_equal value, Alignment.horizontal(horizontal)
       end
     end
 
-    should_have_class_method :vertical
+    should have_class_method :vertical
+
     {
       :automatic => "Automatic",
       :top => "Top",
@@ -26,12 +29,12 @@ class Xmlss::Style::AlignmentTest < Test::Unit::TestCase
       :bottom => "Bottom"
     }.each do |vertical, value|
       should "provide the value for the '#{vertical}' vertical" do
-        assert_equal value, Xmlss::Style::Alignment.vertical(vertical)
+        assert_equal value, Alignment.vertical(vertical)
       end
     end
 
-    should_have_accessors :horizontal, :vertical, :wrap_text, :rotate
-    should_have_instance_methods :wrap_text?
+    should have_accessors :horizontal, :vertical, :wrap_text, :rotate
+    should have_instance_methods :wrap_text?
 
     should "set it's defaults" do
       assert_equal false, subject.wrap_text
@@ -40,68 +43,58 @@ class Xmlss::Style::AlignmentTest < Test::Unit::TestCase
       assert_equal nil, subject.rotate
     end
 
-    context "that sets attributes at init" do
-      before do
-        @attrs = {
-          :wrap_text => true,
-          :horizontal => :center,
-          :vertical => :bottom,
-          :rotate => 90
-        }
-        @alignment = Xmlss::Style::Alignment.new(@attrs)
-      end
-      subject{ @alignment }
-
-      should "should set them correctly" do
-        @attrs.reject{|a, v| [:horizontal, :vertical].include?(a)}.each do |a,v|
-          assert_equal v, subject.send(a)
-        end
-        assert_equal Xmlss::Style::Alignment.horizontal(:center), subject.horizontal
-        assert_equal Xmlss::Style::Alignment.vertical(:bottom), subject.vertical
-      end
-    end
-
     should "reject invalid rotate alignments" do
-      assert_equal nil, Xmlss::Style::Alignment.new({:rotate => 100}).rotate
-      assert_equal 90, Xmlss::Style::Alignment.new({:rotate => 90}).rotate
-      assert_equal 0, Xmlss::Style::Alignment.new({:rotate => 0}).rotate
-      assert_equal -90, Xmlss::Style::Alignment.new({:rotate => -90}).rotate
-      assert_equal nil, Xmlss::Style::Alignment.new({:rotate => -100}).rotate
-      assert_equal 0, Xmlss::Style::Alignment.new({:rotate => 0.2}).rotate
-      assert_equal 1, Xmlss::Style::Alignment.new({:rotate => 0.5}).rotate
-      assert_equal nil, Xmlss::Style::Alignment.new({:rotate => "poo"}).rotate
-      assert_equal nil, Xmlss::Style::Alignment.new({:rotate => :poo}).rotate
+      assert_equal nil, Alignment.new({:rotate => 100}).rotate
+      assert_equal 90,  Alignment.new({:rotate => 90}).rotate
+      assert_equal 0,   Alignment.new({:rotate => 0}).rotate
+      assert_equal -90, Alignment.new({:rotate => -90}).rotate
+      assert_equal nil, Alignment.new({:rotate => -100}).rotate
+      assert_equal 0,   Alignment.new({:rotate => 0.2}).rotate
+      assert_equal 1,   Alignment.new({:rotate => 0.5}).rotate
+      assert_equal nil, Alignment.new({:rotate => "poo"}).rotate
+      assert_equal nil, Alignment.new({:rotate => :poo}).rotate
     end
 
-    context "that sets underline and alignment by key" do
-      before do
-        subject.horizontal = :left
-        subject.vertical = :top
-      end
+    should "should set them correctly" do
+      attrs = {
+        :wrap_text => true,
+        :horizontal => :center,
+        :vertical => :bottom,
+        :rotate => 90
+      }
+      alignment = Alignment.new(attrs)
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Alignment.horizontal(:left), subject.horizontal
-        assert_equal Xmlss::Style::Alignment.vertical(:top), subject.vertical
+      attrs.reject{|a, v| [:horizontal, :vertical].include?(a)}.each do |a,v|
+        assert_equal v, alignment.send(a)
       end
+      assert_equal Alignment.horizontal(:center), alignment.horizontal
+      assert_equal Alignment.vertical(:bottom), alignment.vertical
     end
 
-    context "that sets underline and alignment by value" do
-      before do
-        subject.horizontal = Xmlss::Style::Alignment.horizontal(:right)
-        subject.vertical = Xmlss::Style::Alignment.vertical(:center)
-      end
+    should "set attrs by key" do
+      subject.horizontal = :left
+      subject.vertical = :top
 
-      should "should returm it by value" do
-        assert_equal Xmlss::Style::Alignment.horizontal(:right), subject.horizontal
-        assert_equal Xmlss::Style::Alignment.vertical(:center), subject.vertical
-      end
+      assert_equal Alignment.horizontal(:left), subject.horizontal
+      assert_equal Alignment.vertical(:top), subject.vertical
     end
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
+    should "set attrs by value" do
+      subject.horizontal = Alignment.horizontal(:right)
+      subject.vertical = Alignment.vertical(:center)
+
+      assert_equal Alignment.horizontal(:right), subject.horizontal
+      assert_equal Alignment.vertical(:center), subject.vertical
     end
 
   end
+
+  class AlignmentXmlTest < AlignmentTest
+    desc "for generating XML"
+
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Alignment)
+  end
+
 end

data/test/style/base_test.rb

@@ -1,24 +1,27 @@
-require "test/helper"
+require "assert"
 require 'xmlss/style/base'
 
-class Xmlss::Style::BaseTest < Test::Unit::TestCase
-  context "Xmlss::Style::Base" do
-    subject { Xmlss::Style::Base.new(:test) }
+module Xmlss::Style
 
-    should_have_reader :id, :i_d, :border
-    should_have_accessors :borders, :alignment, :font
-    should_have_accessors :interior, :number_format, :protection
+  class BaseTest < Assert::Context
+    desc "Xmlss::Style::Base"
+    before { @bs = Base.new(:test) }
+    subject { @bs }
+
+    should have_reader :id, :i_d, :border
+    should have_accessors :borders, :alignment, :font
+    should have_accessors :interior, :number_format, :protection
 
     should "bark if you don't init with an id" do
       assert_raises ArgumentError do
-        Xmlss::Style::Base.new(nil)
+        Base.new(nil)
       end
     end
 
     should "force string ids" do
-      assert_equal 'string', Xmlss::Style::Base.new('string').id
-      assert_equal 'symbol', Xmlss::Style::Base.new(:symbol).id
-      assert_equal '123', Xmlss::Style::Base.new(123).id
+      assert_equal 'string', Base.new('string').id
+      assert_equal 'symbol', Base.new(:symbol).id
+      assert_equal '123', Base.new(123).id
     end
 
     should "set it's defaults" do
@@ -31,96 +34,103 @@ class Xmlss::Style::BaseTest < Test::Unit::TestCase
       end
     end
 
-    context "that sets alignment" do
-      subject do
-        Xmlss::Style::Base.new(:alignment) do
-          alignment(
-            :horizontal => :left,
-            :vertical => :center,
-            :wrap_text => true
-          )
-        end
-      end
+  end
 
-      should "should create an Alignment object" do
-        assert_kind_of Xmlss::Style::Alignment, subject.alignment
-        assert_equal true, subject.alignment.wrap_text
-        assert_equal Xmlss::Style::Alignment.horizontal(:left), subject.alignment.horizontal
-        assert_equal Xmlss::Style::Alignment.vertical(:center), subject.alignment.vertical
+  class SetAlignmentTest < Assert::Context
+    desc "that sets alignment"
+    before do
+      @s = Base.new(:alignment) do
+        alignment(
+          :horizontal => :left,
+          :vertical => :center,
+          :wrap_text => true
+        )
       end
     end
+    subject { @s }
 
-    context "that sets borders" do
-      subject do
-        Xmlss::Style::Base.new(:borders) do
-          border(:position => :left)
-          border(:position => :right)
-        end
-      end
-
-      should "should create Border objects and add them to its borders" do
-        assert_equal 2, subject.borders.size
-        assert_kind_of Xmlss::Style::Border, subject.borders.first
-        assert_equal Xmlss::Style::Border.position(:left), subject.borders.first.position
-        assert_equal Xmlss::Style::Border.position(:right), subject.borders.last.position
-      end
+    should "create an Alignment object" do
+      assert_kind_of Alignment, subject.alignment
+      assert_equal true, subject.alignment.wrap_text
+      assert_equal Alignment.horizontal(:left), subject.alignment.horizontal
+      assert_equal Alignment.vertical(:center), subject.alignment.vertical
+    end
+  end
 
-      should "error if manually setting borders to non ItemSet collection" do
-        assert_raises ArgumentError do
-          subject.borders = []
-        end
+  class SetBorderTest < Assert::Context
+    desc "that sets borders"
+    before do
+      @s = Base.new(:borders) do
+        border(:position => :left)
+        border(:position => :right)
       end
     end
+    subject { @s }
 
-    context "that sets font" do
-      subject do
-        Xmlss::Style::Base.new(:font) { font(:bold => true) }
-      end
+    should "create Border objects and add them to its borders" do
+      assert_equal 2, subject.borders.size
+      assert_kind_of Border, subject.borders.first
+      assert_equal Border.position(:left), subject.borders.first.position
+      assert_equal Border.position(:right), subject.borders.last.position
+    end
 
-      should "should create a Font object" do
-        assert_kind_of Xmlss::Style::Font, subject.font
-        assert subject.font.bold?
+    should "error if manually setting borders to non ItemSet collection" do
+      assert_raises ::ArgumentError do
+        subject.borders = []
       end
     end
+  end
 
-    context "that sets interior" do
-      subject do
-        Xmlss::Style::Base.new(:interior) { interior(:color => "#000000") }
-      end
+  class SetFontTest < Assert::Context
+    desc "that sets font"
+    before { @s = Base.new(:font) { font(:bold => true) } }
+    subject { @s }
 
-      should "should create an Interior object" do
-        assert_kind_of Xmlss::Style::Interior, subject.interior
-        assert_equal "#000000", subject.interior.color
-      end
+    should "should create a Font object" do
+      assert_kind_of Font, subject.font
+      assert subject.font.bold?
     end
+  end
 
-    context "that sets number format" do
-      subject do
-        Xmlss::Style::Base.new(:number_format) { number_format(:format => "General") }
-      end
+  class SetInteriorTest < Assert::Context
+    desc "that sets interior"
+    before { @s = Base.new(:interior) { interior(:color => "#000000") } }
+    subject { @s }
 
-      should "should create a NumberFormat object" do
-        assert_kind_of Xmlss::Style::NumberFormat, subject.number_format
-        assert_equal "General", subject.number_format.format
-      end
+    should "should create an Interior object" do
+      assert_kind_of Interior, subject.interior
+      assert_equal "#000000", subject.interior.color
     end
+  end
 
-    context "that sets protection" do
-      subject do
-        Xmlss::Style::Base.new(:protection) { protection(:protect => true) }
-      end
+  class SetNumberFormatTest < Assert::Context
+    desc "that sets number format"
+    before { @s = Base.new(:number_format) { number_format(:format => "General") } }
+    subject { @s }
 
-      should "should create a Protection object" do
-        assert_kind_of Xmlss::Style::Protection, subject.protection
-        assert subject.protection.protected?
-      end
+    should "should create a NumberFormat object" do
+      assert_kind_of NumberFormat, subject.number_format
+      assert_equal "General", subject.number_format.format
     end
+  end
+
+  class SetProtectionTest < Assert::Context
+    desc "that sets protection"
+    before { @s = Base.new(:protection) { protection(:protect => true) } }
+    subject { @s }
 
-    context "for generating XML" do
-      should_have_reader :xml
-      should_build_node
-      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
+    should "should create a Protection object" do
+      assert_kind_of Protection, subject.protection
+      assert subject.protection.protected?
     end
+  end
+
+  class BaseXmlTest < BaseTest
+    desc "for generating XML"
 
+    should have_reader :xml
+    should_build_node
+    should_build_no_attributes_by_default(Xmlss::Style::Alignment)
   end
-end
+
+end