osheet 0.7.0 → 0.8.0

data/test/format/scientific_test.rb

@@ -1,116 +1,114 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/scientific'
 
 module Osheet::Format
 
-  class ScientificTest < Test::Unit::TestCase
-    context "Scientific format" do
-      subject { Scientific.new }
+  class ScientificTest < Assert::Context
+    desc "Scientific format"
+    before { @sc = Scientific.new }
+    subject { @sc }
 
-      should_have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
+    should have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
 
-      should "provide negative numbers options" do
-        assert_equal 4, Scientific.negative_numbers_set.size
-        [:black, :black_parenth, :red, :red_parenth].each do |a|
-          assert Scientific.negative_numbers_set.include?(a)
-        end
+    should "provide negative numbers options" do
+      assert_equal 4, Scientific.negative_numbers_set.size
+      [:black, :black_parenth, :red, :red_parenth].each do |a|
+        assert Scientific.negative_numbers_set.include?(a)
       end
+    end
 
-      should "set default values" do
-        assert_equal 2, subject.decimal_places
-        assert_equal false, subject.comma_separator
-        assert_equal :black, subject.negative_numbers
-      end
+    should "set default values" do
+      assert_equal 2, subject.decimal_places
+      assert_equal false, subject.comma_separator
+      assert_equal :black, subject.negative_numbers
+    end
 
-      should "only allow Fixnum decimal places between 0 and 30" do
-        assert_raises ArgumentError do
-          Scientific.new({:decimal_places => -1})
-        end
-        assert_raises ArgumentError do
-          Scientific.new({:decimal_places => 31})
-        end
-        assert_raises ArgumentError do
-          Scientific.new({:decimal_places => 'poo'})
-        end
-        assert_nothing_raised do
-          Scientific.new({:decimal_places => 1})
-        end
+    should "only allow Fixnum decimal places between 0 and 30" do
+      assert_raises ArgumentError do
+        Scientific.new({:decimal_places => -1})
       end
-
-      should "generate decimal place style strings" do
-        assert_equal "0E+00", Scientific.new({
-          :decimal_places => 0
-        }).style
-        (1..5).each do |n|
-          assert_equal "0.#{'0'*n}E+00", Scientific.new({
-            :decimal_places => n
-          }).style
-        end
+      assert_raises ArgumentError do
+        Scientific.new({:decimal_places => 31})
       end
-
-      should "generate comma separator style strings" do
-        assert_equal "0E+00", Scientific.new({
-          :comma_separator => false,
-          :decimal_places => 0
-        }).style
-        assert_equal "#,##0E+00", Scientific.new({
-          :comma_separator => true,
-          :decimal_places => 0
-        }).style
+      assert_raises ArgumentError do
+        Scientific.new({:decimal_places => 'poo'})
       end
-
-      should "generate parenth negative numbers style strings" do
-        assert_equal "0E+00", Scientific.new({
-          :negative_numbers => :black,
-          :decimal_places => 0
-        }).style
-        assert_equal "0E+00_);\(0E+00\)", Scientific.new({
-          :negative_numbers => :black_parenth,
-          :decimal_places => 0
-        }).style
+      assert_nothing_raised do
+        Scientific.new({:decimal_places => 1})
       end
+    end
 
-      should "generate red negative numbers style strings" do
-        assert_equal "0E+00;[Red]0E+00", Scientific.new({
-          :negative_numbers => :red,
-          :decimal_places => 0
-        }).style
-        assert_equal "0E+00_);[Red]\(0E+00\)", Scientific.new({
-          :negative_numbers => :red_parenth,
-          :decimal_places => 0
+    should "generate decimal place style strings" do
+      assert_equal "0E+00", Scientific.new({
+        :decimal_places => 0
+      }).style
+      (1..5).each do |n|
+        assert_equal "0.#{'0'*n}E+00", Scientific.new({
+          :decimal_places => n
         }).style
       end
+    end
 
-      should "generate complex style string" do
-        assert_equal("0.00E+00_);\(0.00E+00\)", Scientific.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).style)
-        assert_equal("#,##0.0000E+00_);[Red]\(#,##0.0000E+00\)", Scientific.new({
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).style)
-      end
+    should "generate comma separator style strings" do
+      assert_equal "0E+00", Scientific.new({
+        :comma_separator => false,
+        :decimal_places => 0
+      }).style
+      assert_equal "#,##0E+00", Scientific.new({
+        :comma_separator => true,
+        :decimal_places => 0
+      }).style
+    end
 
-      should "provide unique format keys" do
-        assert_equal("scientific_none_2_nocomma_blackparenth", Scientific.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).key)
-        assert_equal("scientific_none_4_comma_redparenth", Scientific.new({
-          :symbol => :none,
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).key)
-      end
+    should "generate parenth negative numbers style strings" do
+      assert_equal "0E+00", Scientific.new({
+        :negative_numbers => :black,
+        :decimal_places => 0
+      }).style
+      assert_equal "0E+00_);\(0E+00\)", Scientific.new({
+        :negative_numbers => :black_parenth,
+        :decimal_places => 0
+      }).style
+    end
 
+    should "generate red negative numbers style strings" do
+      assert_equal "0E+00;[Red]0E+00", Scientific.new({
+        :negative_numbers => :red,
+        :decimal_places => 0
+      }).style
+      assert_equal "0E+00_);[Red]\(0E+00\)", Scientific.new({
+        :negative_numbers => :red_parenth,
+        :decimal_places => 0
+      }).style
+    end
 
+    should "generate complex style string" do
+      assert_equal("0.00E+00_);\(0.00E+00\)", Scientific.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).style)
+      assert_equal("#,##0.0000E+00_);[Red]\(#,##0.0000E+00\)", Scientific.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).style)
+    end
 
+    should "provide unique format keys" do
+      assert_equal("scientific_none_2_nocomma_blackparenth", Scientific.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).key)
+      assert_equal("scientific_none_4_comma_redparenth", Scientific.new({
+        :symbol => :none,
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).key)
     end
+
   end
 
 end

data/test/format/special_test.rb

@@ -1,51 +1,51 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/special'
 
 module Osheet::Format
 
-  class SpecialTest < Test::Unit::TestCase
-    context "Special format" do
-      subject { Special.new }
+  class SpecialTest < Assert::Context
+    desc "Special format"
+    before { @sp = Special.new }
+    subject { @sp }
 
-      should_have_accessors :type
+    should have_accessors :type
 
-      should "provide options for type" do
-        assert_equal 4, Special.type_set.size
-        [ :zip_code, :zip_code_plus_4, :phone_number, :social_security_number].each do |a|
-          assert Special.type_set.include?(a)
-        end
-      end
-
-      should "set default values" do
-        assert_equal nil, subject.type
-        assert_equal nil, subject.type_key
+    should "provide options for type" do
+      assert_equal 4, Special.type_set.size
+      [ :zip_code, :zip_code_plus_4, :phone_number, :social_security_number].each do |a|
+        assert Special.type_set.include?(a)
       end
+    end
 
-      should "generate a zip_code type style strings and key" do
-        f = Special.new(:type => :zip_code)
-        assert_equal "00000", f.style
-        assert_equal "special_zipcode", f.key
-      end
+    should "set default values" do
+      assert_equal nil, subject.type
+      assert_equal nil, subject.type_key
+    end
 
-      should "generate a zip_code_plus_4 type style strings and key" do
-        f = Special.new(:type => :zip_code_plus_4)
-        assert_equal "00000-0000", f.style
-        assert_equal "special_zipcodeplus4", f.key
-      end
+    should "generate a zip_code type style strings and key" do
+      f = Special.new(:type => :zip_code)
+      assert_equal "00000", f.style
+      assert_equal "special_zipcode", f.key
+    end
 
-      should "generate a phone_number type style strings and key" do
-        f = Special.new(:type => :phone_number)
-        assert_equal "[<=9999999]###-####;(###) ###-####", f.style
-        assert_equal "special_phonenumber", f.key
-      end
+    should "generate a zip_code_plus_4 type style strings and key" do
+      f = Special.new(:type => :zip_code_plus_4)
+      assert_equal "00000-0000", f.style
+      assert_equal "special_zipcodeplus4", f.key
+    end
 
-      should "generate a social_security_number type style strings and key" do
-        f = Special.new(:type => :social_security_number)
-        assert_equal "000-00-0000", f.style
-        assert_equal "special_socialsecuritynumber", f.key
-      end
+    should "generate a phone_number type style strings and key" do
+      f = Special.new(:type => :phone_number)
+      assert_equal "[<=9999999]###-####;(###) ###-####", f.style
+      assert_equal "special_phonenumber", f.key
+    end
 
+    should "generate a social_security_number type style strings and key" do
+      f = Special.new(:type => :social_security_number)
+      assert_equal "000-00-0000", f.style
+      assert_equal "special_socialsecuritynumber", f.key
     end
+
   end
 
 end

data/test/format/text_test.rb

@@ -1,18 +1,18 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/text'
 
 module Osheet::Format
 
-  class TextTest < Test::Unit::TestCase
-    context "Text format" do
-      subject { Text.new }
-
-      should "generate a style strings and key" do
-        assert_equal "@", subject.style
-        assert_equal "text", subject.key
-      end
+  class TextTest < Assert::Context
+    desc "Text format"
+    before { @txt = Text.new }
+    subject { @txt }
 
+    should "generate a style strings and key" do
+      assert_equal "@", subject.style
+      assert_equal "text", subject.key
     end
+
   end
 
 end

data/test/format_test.rb

@@ -1,35 +1,35 @@
-require "test/helper"
+require "assert"
 require 'osheet/format'
 
 module Osheet
 
-  class FormatTest < Test::Unit::TestCase
-    context "Osheet::Format" do
-      subject do
-        Format.new(:number, {
-          :decimal_places => 4,
-          :comma_separator => true,
-          :negative_numbers => :black_parenth
-        })
-      end
+  class FormatTest < Assert::Context
+    desc "Osheet::Format"
+    before do
+      @f = Format.new(:number, {
+        :decimal_places => 4,
+        :comma_separator => true,
+        :negative_numbers => :black_parenth
+      })
+    end
+    subject { @f }
 
-      should "build format class instances" do
-        assert_kind_of Format::Number, subject
-        assert_equal 4, subject.decimal_places
-        assert_equal true, subject.comma_separator
-        assert_equal :black_parenth, subject.negative_numbers
-      end
+    should "build format class instances" do
+      assert_kind_of Format::Number, subject
+      assert_equal 4, subject.decimal_places
+      assert_equal true, subject.comma_separator
+      assert_equal :black_parenth, subject.negative_numbers
+    end
 
-      should "error for invalid format types" do
-        assert_raises ArgumentError do
-          Format.new(:awesome, {})
-        end
-        assert_nothing_raised do
-          Format.new(:general)
-        end
+    should "error for invalid format types" do
+      assert_raises ArgumentError do
+        Format.new(:awesome, {})
+      end
+      assert_nothing_raised do
+        Format.new(:general)
       end
-
     end
+
   end
 
 end

data/test/helper.rb

@@ -1,66 +1,61 @@
-require 'rubygems'
-require 'test_belt'
-require 'test/env'
+# this file is automatically required in when you require 'assert' in your tests
 
-class Test::Unit::TestCase
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+require 'osheet'
+
+class Assert::Context
   class << self
 
 
     def should_be_a_workbook_element(klass)
-      should_have_instance_methods :workbook, :styles, :templates
-      context "given a workbook with templates and styles" do
-        before do
-          @wkbk = Osheet::Workbook.new {
-            template(:column, :thing) {}
-            template(:row, :empty) {}
-            style('.title') {
-              font 14
-            }
-            style('.title', '.header') {
-              font :bold
-            }
+      should have_instance_methods :workbook, :styles, :templates
+
+      should "be able to read the workbook and it's styles/templates" do
+        wkbk = Osheet::Workbook.new {
+          template(:column, :thing) {}
+          template(:row, :empty) {}
+          style('.title') {
+            font 14
           }
-          @klass = klass.new(@wkbk)
-        end
+          style('.title', '.header') {
+            font :bold
+          }
+        }
+        klass = klass.new(wkbk)
 
-        should "be able to read the workbook and it's styles/templates" do
-          assert_equal @wkbk, @klass.workbook
-          assert_equal @wkbk.styles, @klass.styles
-          assert_equal @wkbk.templates, @klass.templates
-        end
+        assert_equal wkbk, klass.workbook
+        assert_equal wkbk.styles, klass.styles
+        assert_equal wkbk.templates, klass.templates
       end
     end
 
     def should_be_a_worksheet_element(klass)
-      should_have_instance_methods :worksheet, :columns
-      context "given a worksheet with columns" do
-        before do
-          @wksht = Osheet::Worksheet.new {
-            column {}
-            column {}
-            column {}
-          }
-          @klass = klass.new(nil, @wksht)
-        end
+      should have_instance_methods :worksheet, :columns
 
-        should "be able to read the worksheet and it's columns" do
-          assert_equal @wksht, @klass.worksheet
-          assert_equal @wksht.columns, @klass.columns
-        end
+      should "be able to read the worksheet and it's columns" do
+        wksht = Osheet::Worksheet.new {
+          column {}
+          column {}
+          column {}
+        }
+        klass = klass.new(nil, wksht)
+
+        assert_equal wksht, klass.worksheet
+        assert_equal wksht.columns, klass.columns
       end
     end
 
     def should_be_a_styled_element(klass)
-      should_have_instance_methods :style_class
+      should have_instance_methods :style_class
 
-      context "by default" do
-        before { @default = klass.new }
-        should "default an empty style class" do
-          assert_equal nil, @default.send(:get_ivar, "style_class")
-        end
+      should "default an empty style class" do
+        default = klass.new
+        assert_equal nil, default.send(:get_ivar, "style_class")
       end
 
-      should "default an empty style class" do
+      should "set a style class" do
         styled = klass.new{ style_class "awesome thing" }
         assert_equal "awesome thing", styled.send(:get_ivar, "style_class")
       end
@@ -80,8 +75,8 @@ class Test::Unit::TestCase
     end
 
     def should_hm(klass, collection, item_klass)
-      should_have_reader collection
-      should_have_instance_method collection.to_s.sub(/s$/, '')
+      should have_reader collection
+      should have_instance_method collection.to_s.sub(/s$/, '')
 
       should "should initialize #{collection} and add them to it's collection" do
         singular = collection.to_s.sub(/s$/, '')
@@ -99,4 +94,4 @@ class Test::Unit::TestCase
     end
 
   end
-end
+end

data/test/irb.rb

@@ -0,0 +1,9 @@
+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 'osheet'

data/test/mixin_test.rb

@@ -1,90 +1,86 @@
-require "test/helper"
+require "assert"
 require "test/mixins"
 
 module Osheet
 
-  class MixinBaseTest < Test::Unit::TestCase
-    context "Osheet::Mixin thing" do
-      subject { DefaultMixin }
+  class MixinBaseTest < Assert::Context
+    desc "Osheet::Mixin thing"
+    subject { DefaultMixin }
 
-      should_have_readers :styles, :templates, :partials
-      should_have_instance_methods :style, :template, :partial
+    should have_readers :styles, :templates, :partials
+    should have_instance_methods :style, :template, :partial
 
-      should "set it's defaults" do
-        assert_equal [], subject.styles
-        assert_equal [], subject.templates
-        assert_equal [], subject.partials
-      end
+    should "set it's defaults" do
+      assert_equal [], subject.styles
+      assert_equal [], subject.templates
+      assert_equal [], subject.partials
     end
   end
 
-  class MixinStyleTest < Test::Unit::TestCase
-    context "that defines styles" do
-      subject { StyledMixin }
+  class MixinStyleTest < Assert::Context
+    desc "that defines styles"
+    subject { StyledMixin }
 
-      should "have it's styles defined" do
-        assert_equal 2, subject.styles.size
-        assert_equal 1, subject.styles.first.selectors.size
-        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
-      end
+    should "have it's styles defined" do
+      assert_equal 2, subject.styles.size
+      assert_equal 1, subject.styles.first.selectors.size
+      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
     end
   end
 
-  class MixinTemplateTest < Test::Unit::TestCase
-    context "that defines templates" do
-      subject { TemplatedMixin }
+  class MixinTemplateTest < Assert::Context
+    desc "that defines templates"
+    subject { TemplatedMixin }
 
-      should "have it's templates defined" do
-        assert subject.templates
-        assert_equal 3, subject.templates.size
-        assert_kind_of Template, subject.templates.first
-      end
+    should "have it's templates defined" do
+      assert subject.templates
+      assert_equal 3, subject.templates.size
+      assert_kind_of Template, subject.templates.first
     end
   end
 
-  class MixinPartialTest < Test::Unit::TestCase
-    context "that defines partials" do
-      subject { PartialedMixin }
+  class MixinPartialTest < Assert::Context
+    desc "that defines partials"
+    subject { PartialedMixin }
 
-      should "have it's partials defined" do
-        assert subject.partials
-        assert_equal 2, subject.partials.size
-        assert_kind_of Partial, subject.partials.first
-      end
+    should "have it's partials defined" do
+      assert subject.partials
+      assert_equal 2, subject.partials.size
+      assert_kind_of Partial, subject.partials.first
     end
   end
 
-  class MixinUseTest < Test::Unit::TestCase
-    context "A workbook that uses mixins" do
-      setup do
-        @workbook = Osheet::Workbook.new do
-          use PartialedMixin
-          use TemplatedMixin
-          use StyledMixin
-        end
+  class MixinUseTest < Assert::Context
+    desc "A workbook that uses mixins"
+    setup do
+      @workbook = Osheet::Workbook.new do
+        use PartialedMixin
+        use TemplatedMixin
+        use StyledMixin
       end
-      subject { @workbook }
+    end
+    subject { @workbook }
 
-      should "have mixin partials" do
-        workbook_partials = @workbook.partials.values
-        PartialedMixin.partials.each do |partial|
-          assert workbook_partials.include?(partial)
-        end
+    should "have mixin partials" do
+      workbook_partials = @workbook.partials.values
+      PartialedMixin.partials.each do |partial|
+        assert workbook_partials.include?(partial)
       end
+    end
 
-      should "have mixin templates" do
-        workbook_templates = @workbook.templates.values.collect{ |t| t.values.first }
-        TemplatedMixin.templates.each do |template|
-          assert workbook_templates.include?(template)
-        end
+    should "have mixin templates" do
+      workbook_templates = @workbook.templates.values.collect{ |t| t.values.first }
+      TemplatedMixin.templates.each do |template|
+        assert workbook_templates.include?(template)
       end
+    end
 
-      should "have mixin styles" do
-        assert_equal StyledMixin.styles, @workbook.styles
-      end
+    should "have mixin styles" do
+      assert_equal StyledMixin.styles, @workbook.styles
     end
+
   end
 
 end