osheet 1.0.0.rc.4 → 1.0.0

data/test/{format/custom_test.rb → unit/format/custom_tests.rb}

@@ -1,22 +1,23 @@
 require "assert"
 require 'osheet/format/custom'
 
-module Osheet::Format
+class Osheet::Format::Custom
 
-  class CustomTest < Assert::Context
-    desc "Custom format"
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Custom format"
 
     should "generate a basic style string and key" do
-      f = Custom.new '@'
+      f = Osheet::Format::Custom.new '@'
       assert_equal "@", f.style
       assert_equal "custom_@", f.key
     end
 
     should "generate a more complex style string and key" do
-      f = Custom.new 'm/d/yy'
+      f = Osheet::Format::Custom.new 'm/d/yy'
       assert_equal 'm/d/yy', f.style
       assert_equal "custom_m/d/yy", f.key
     end
+
   end
 
 end

data/test/{format/datetime_test.rb → unit/format/datetime_tests.rb}

@@ -1,22 +1,23 @@
 require "assert"
 require 'osheet/format/datetime'
 
-module Osheet::Format
+class Osheet::Format::Datetime
 
-  class DatetimeTest < Assert::Context
-    desc "Datetime format"
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Datetime format"
 
     should "generate a basic style string and key" do
-      f = Datetime.new 'mm/dd/yyyy'
+      f = Osheet::Format::Datetime.new 'mm/dd/yyyy'
       assert_equal "mm/dd/yyyy", f.style
       assert_equal "datetime_mm/dd/yyyy", f.key
     end
 
     should "generate a more complex style string and key" do
-      f = Datetime.new 'yy-m'
+      f = Osheet::Format::Datetime.new 'yy-m'
       assert_equal 'yy-m', f.style
       assert_equal "datetime_yy-m", f.key
     end
+
   end
 
 end

data/test/{format/fraction_test.rb → unit/format/fraction_tests.rb}

@@ -1,22 +1,22 @@
 require "assert"
 require 'osheet/format/fraction'
 
-module Osheet::Format
+class Osheet::Format::Fraction
 
-  class FractionTest < Assert::Context
-    desc "Fraction format"
-    before { @f = Fraction.new }
-    subject { @f }
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Fraction format"
+    before{ @f = Osheet::Format::Fraction.new }
+    subject{ @f }
 
     should have_accessors :type
 
     should "provide options for type" do
-      assert_equal 9, Fraction.type_set.size
+      assert_equal 9, Osheet::Format::Fraction.type_set.size
       [ :one_digit, :two_digits, :three_digits,
         :halves, :quarters, :eighths, :sixteenths,
         :tenths, :hundredths
       ].each do |a|
-        assert Fraction.type_set.include?(a)
+        assert Osheet::Format::Fraction.type_set.include?(a)
       end
     end
 
@@ -26,55 +26,55 @@ module Osheet::Format
     end
 
     should "generate a one_digit type style strings and key" do
-      f = Fraction.new(:type => :one_digit)
+      f = Osheet::Format::Fraction.new(:type => :one_digit)
       assert_equal "#\ ?/?", f.style
       assert_equal "fraction_onedigit", f.key
     end
 
     should "generate a two_digit type style strings and key" do
-      f = Fraction.new(:type => :two_digits)
+      f = Osheet::Format::Fraction.new(:type => :two_digits)
       assert_equal "#\ ??/??", f.style
       assert_equal "fraction_twodigits", f.key
     end
 
     should "generate a three_digit type style strings and key" do
-      f = Fraction.new(:type => :three_digits)
+      f = Osheet::Format::Fraction.new(:type => :three_digits)
       assert_equal "#\ ???/???", f.style
       assert_equal "fraction_threedigits", f.key
     end
 
     should "generate a halves type style strings and key" do
-      f = Fraction.new(:type => :halves)
+      f = Osheet::Format::Fraction.new(:type => :halves)
       assert_equal "#\ ?/2", f.style
       assert_equal "fraction_halves", f.key
     end
 
     should "generate a quarters type style strings and key" do
-      f = Fraction.new(:type => :quarters)
+      f = Osheet::Format::Fraction.new(:type => :quarters)
       assert_equal "#\ ?/4", f.style
       assert_equal "fraction_quarters", f.key
     end
 
     should "generate a eighths type style strings and key" do
-      f = Fraction.new(:type => :eighths)
+      f = Osheet::Format::Fraction.new(:type => :eighths)
       assert_equal "#\ ?/8", f.style
       assert_equal "fraction_eighths", f.key
     end
 
     should "generate a sixteenths type style strings and key" do
-      f = Fraction.new(:type => :sixteenths)
+      f = Osheet::Format::Fraction.new(:type => :sixteenths)
       assert_equal "#\ ??/16", f.style
       assert_equal "fraction_sixteenths", f.key
     end
 
     should "generate a tenths type style strings and key" do
-      f = Fraction.new(:type => :tenths)
+      f = Osheet::Format::Fraction.new(:type => :tenths)
       assert_equal "#\ ?/10", f.style
       assert_equal "fraction_tenths", f.key
     end
 
     should "generate a hundredths type style strings and key" do
-      f = Fraction.new(:type => :hundredths)
+      f = Osheet::Format::Fraction.new(:type => :hundredths)
       assert_equal "#\ ??/100", f.style
       assert_equal "fraction_hundredths", f.key
     end

data/test/{format/general_test.rb → unit/format/general_tests.rb}

@@ -1,12 +1,12 @@
 require "assert"
 require 'osheet/format/general'
 
-module Osheet::Format
+class Osheet::Format::General
 
-  class GeneralTest < Assert::Context
-    desc "General format"
-    before { @f = General.new }
-    subject { @f }
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::General format"
+    before{ @f = Osheet::Format::General.new }
+    subject{ @f }
 
     should "always provide a nil style string" do
       assert_equal nil, subject.style

data/test/unit/format/number_tests.rb

@@ -0,0 +1,96 @@
+require "assert"
+require 'osheet/format/number'
+
+class Osheet::Format::Number
+
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Number format"
+    before{ @n = Osheet::Format::Number.new }
+    subject{ @n }
+
+    should have_accessors :decimal_places, :comma_separator, :negative_numbers
+
+    should "provide options for negative numbers" do
+      assert_equal 4, Osheet::Format::Number.negative_numbers_set.size
+      [:black, :black_parenth, :red, :red_parenth].each do |a|
+        assert Osheet::Format::Number.negative_numbers_set.include?(a)
+      end
+    end
+
+    should "set default values" do
+      assert_equal 0, 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
+        Osheet::Format::Number.new({:decimal_places => -1})
+      end
+
+      assert_raises ArgumentError do
+        Osheet::Format::Number.new({:decimal_places => 31})
+      end
+
+      assert_raises ArgumentError do
+        Osheet::Format::Number.new({:decimal_places => 'poo'})
+      end
+
+      assert_nothing_raised do
+        Osheet::Format::Number.new({:decimal_places => 1})
+      end
+    end
+
+    should "generate decimal place style strings" do
+      assert_equal "0", Osheet::Format::Number.new({:decimal_places => 0}).style
+      (1..5).each do |n|
+        assert_equal "0.#{'0'*n}", Osheet::Format::Number.new({:decimal_places => n}).style
+      end
+    end
+
+    should "generate comma separator style strings" do
+      assert_equal "0",     Osheet::Format::Number.new({:comma_separator => false}).style
+      assert_equal "#,##0", Osheet::Format::Number.new({:comma_separator => true}).style
+    end
+
+    should "generate parenth negative numbers style strings" do
+      assert_equal "0",         Osheet::Format::Number.new({:negative_numbers => :black}).style
+      assert_equal "0_);\(0\)", Osheet::Format::Number.new({:negative_numbers => :black_parenth}).style
+    end
+
+    should "generate red negative numbers style strings" do
+      assert_equal "0;[Red]0",       Osheet::Format::Number.new({:negative_numbers => :red}).style
+      assert_equal "0_);[Red]\(0\)", Osheet::Format::Number.new({:negative_numbers => :red_parenth}).style
+    end
+
+    should "generate complex style string" do
+      assert_equal("0.00_);\(0.00\)", Osheet::Format::Number.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).style)
+
+      assert_equal("#,##0.0000_);[Red]\(#,##0.0000\)", Osheet::Format::Number.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).style)
+    end
+
+    should "provide unique format keys" do
+      assert_equal("number_none_2_nocomma_blackparenth", Osheet::Format::Number.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).key)
+
+      assert_equal("number_none_4_comma_redparenth", Osheet::Format::Number.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).key)
+    end
+
+  end
+
+end

data/test/{format/percentage_test.rb → unit/format/percentage_tests.rb}

@@ -1,19 +1,19 @@
 require "assert"
 require 'osheet/format/percentage'
 
-module Osheet::Format
+class Osheet::Format::Percentage
 
-  class PercentageTest < Assert::Context
-    desc "Percentage format"
-    before { @p = Percentage.new }
-    subject { @p }
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Percentage format"
+    before{ @p = Osheet::Format::Percentage.new }
+    subject{ @p }
 
     should have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
 
     should "provide negative numbers options" do
-      assert_equal 4, Percentage.negative_numbers_set.size
+      assert_equal 4, Osheet::Format::Percentage.negative_numbers_set.size
       [:black, :black_parenth, :red, :red_parenth].each do |a|
-        assert Percentage.negative_numbers_set.include?(a)
+        assert Osheet::Format::Percentage.negative_numbers_set.include?(a)
       end
     end
 
@@ -25,70 +25,78 @@ module Osheet::Format
 
     should "only allow Fixnum decimal places between 0 and 30" do
       assert_raises ArgumentError do
-        Percentage.new({:decimal_places => -1})
+        Osheet::Format::Percentage.new({:decimal_places => -1})
       end
+
       assert_raises ArgumentError do
-        Percentage.new({:decimal_places => 31})
+        Osheet::Format::Percentage.new({:decimal_places => 31})
       end
+
       assert_raises ArgumentError do
-        Percentage.new({:decimal_places => 'poo'})
+        Osheet::Format::Percentage.new({:decimal_places => 'poo'})
       end
+
       assert_nothing_raised do
-        Percentage.new({:decimal_places => 1})
+        Osheet::Format::Percentage.new({:decimal_places => 1})
       end
     end
 
     should "generate decimal place style strings" do
-      assert_equal "0%", Percentage.new({
+      assert_equal "0%", Osheet::Format::Percentage.new({
         :decimal_places => 0
       }).style
+
       (1..5).each do |n|
-        assert_equal "0.#{'0'*n}%", Percentage.new({
+        assert_equal "0.#{'0'*n}%", Osheet::Format::Percentage.new({
           :decimal_places => n
         }).style
       end
     end
 
     should "generate comma separator style strings" do
-      assert_equal "0%", Percentage.new({
+      assert_equal "0%", Osheet::Format::Percentage.new({
         :comma_separator => false,
         :decimal_places => 0
       }).style
-      assert_equal "#,##0%", Percentage.new({
+
+      assert_equal "#,##0%", Osheet::Format::Percentage.new({
         :comma_separator => true,
         :decimal_places => 0
       }).style
     end
 
     should "generate parenth negative numbers style strings" do
-      assert_equal "0%", Percentage.new({
+      assert_equal "0%", Osheet::Format::Percentage.new({
         :negative_numbers => :black,
         :decimal_places => 0
       }).style
-      assert_equal "0%_);\(0%\)", Percentage.new({
+
+      assert_equal "0%_);\(0%\)", Osheet::Format::Percentage.new({
         :negative_numbers => :black_parenth,
         :decimal_places => 0
       }).style
     end
 
     should "generate red negative numbers style strings" do
-      assert_equal "0%;[Red]0%", Percentage.new({
+      assert_equal "0%;[Red]0%", Osheet::Format::Percentage.new({
         :negative_numbers => :red,
         :decimal_places => 0
       }).style
-      assert_equal "0%_);[Red]\(0%\)", Percentage.new({
+
+      assert_equal "0%_);[Red]\(0%\)", Osheet::Format::Percentage.new({
         :negative_numbers => :red_parenth,
         :decimal_places => 0
       }).style
     end
 
     should "generate complex style string" do
-      assert_equal("0.00%_);\(0.00%\)", Percentage.new({
+      assert_equal("0.00%_);\(0.00%\)", Osheet::Format::Percentage.new({
         :decimal_places => 2,
         :negative_numbers => :black_parenth,
         :comma_separator => false
       }).style)
-      assert_equal("#,##0.0000%_);[Red]\(#,##0.0000%\)", Percentage.new({
+
+      assert_equal("#,##0.0000%_);[Red]\(#,##0.0000%\)", Osheet::Format::Percentage.new({
         :decimal_places => 4,
         :negative_numbers => :red_parenth,
         :comma_separator => true
@@ -96,12 +104,13 @@ module Osheet::Format
     end
 
     should "provide unique format keys" do
-      assert_equal("percentage_none_2_nocomma_blackparenth", Percentage.new({
+      assert_equal("percentage_none_2_nocomma_blackparenth", Osheet::Format::Percentage.new({
         :decimal_places => 2,
         :negative_numbers => :black_parenth,
         :comma_separator => false
       }).key)
-      assert_equal("percentage_none_4_comma_redparenth", Percentage.new({
+
+      assert_equal("percentage_none_4_comma_redparenth", Osheet::Format::Percentage.new({
         :symbol => :none,
         :decimal_places => 4,
         :negative_numbers => :red_parenth,

data/test/{format/scientific_test.rb → unit/format/scientific_tests.rb}

@@ -1,19 +1,19 @@
 require "assert"
 require 'osheet/format/scientific'
 
-module Osheet::Format
+class Osheet::Format::Scientific
 
-  class ScientificTest < Assert::Context
-    desc "Scientific format"
-    before { @sc = Scientific.new }
-    subject { @sc }
+  class UnitTests < Assert::Context
+    desc "Osheet::Format::Scientific format"
+    before{ @sc = Osheet::Format::Scientific.new }
+    subject{ @sc }
 
     should have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
 
     should "provide negative numbers options" do
-      assert_equal 4, Scientific.negative_numbers_set.size
+      assert_equal 4, Osheet::Format::Scientific.negative_numbers_set.size
       [:black, :black_parenth, :red, :red_parenth].each do |a|
-        assert Scientific.negative_numbers_set.include?(a)
+        assert Osheet::Format::Scientific.negative_numbers_set.include?(a)
       end
     end
 
@@ -25,70 +25,77 @@ module Osheet::Format
 
     should "only allow Fixnum decimal places between 0 and 30" do
       assert_raises ArgumentError do
-        Scientific.new({:decimal_places => -1})
+        Osheet::Format::Scientific.new({:decimal_places => -1})
       end
+
       assert_raises ArgumentError do
-        Scientific.new({:decimal_places => 31})
+        Osheet::Format::Scientific.new({:decimal_places => 31})
       end
+
       assert_raises ArgumentError do
-        Scientific.new({:decimal_places => 'poo'})
+        Osheet::Format::Scientific.new({:decimal_places => 'poo'})
       end
+
       assert_nothing_raised do
-        Scientific.new({:decimal_places => 1})
+        Osheet::Format::Scientific.new({:decimal_places => 1})
       end
     end
 
     should "generate decimal place style strings" do
-      assert_equal "0E+00", Scientific.new({
+      assert_equal "0E+00", Osheet::Format::Scientific.new({
         :decimal_places => 0
       }).style
       (1..5).each do |n|
-        assert_equal "0.#{'0'*n}E+00", Scientific.new({
+        assert_equal "0.#{'0'*n}E+00", Osheet::Format::Scientific.new({
           :decimal_places => n
         }).style
       end
     end
 
     should "generate comma separator style strings" do
-      assert_equal "0E+00", Scientific.new({
+      assert_equal "0E+00", Osheet::Format::Scientific.new({
         :comma_separator => false,
         :decimal_places => 0
       }).style
-      assert_equal "#,##0E+00", Scientific.new({
+
+      assert_equal "#,##0E+00", Osheet::Format::Scientific.new({
         :comma_separator => true,
         :decimal_places => 0
       }).style
     end
 
     should "generate parenth negative numbers style strings" do
-      assert_equal "0E+00", Scientific.new({
+      assert_equal "0E+00", Osheet::Format::Scientific.new({
         :negative_numbers => :black,
         :decimal_places => 0
       }).style
-      assert_equal "0E+00_);\(0E+00\)", Scientific.new({
+
+      assert_equal "0E+00_);\(0E+00\)", Osheet::Format::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({
+      assert_equal "0E+00;[Red]0E+00", Osheet::Format::Scientific.new({
         :negative_numbers => :red,
         :decimal_places => 0
       }).style
-      assert_equal "0E+00_);[Red]\(0E+00\)", Scientific.new({
+
+      assert_equal "0E+00_);[Red]\(0E+00\)", Osheet::Format::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({
+      assert_equal("0.00E+00_);\(0.00E+00\)", Osheet::Format::Scientific.new({
         :decimal_places => 2,
         :negative_numbers => :black_parenth,
         :comma_separator => false
       }).style)
-      assert_equal("#,##0.0000E+00_);[Red]\(#,##0.0000E+00\)", Scientific.new({
+
+      assert_equal("#,##0.0000E+00_);[Red]\(#,##0.0000E+00\)", Osheet::Format::Scientific.new({
         :decimal_places => 4,
         :negative_numbers => :red_parenth,
         :comma_separator => true
@@ -96,12 +103,13 @@ module Osheet::Format
     end
 
     should "provide unique format keys" do
-      assert_equal("scientific_none_2_nocomma_blackparenth", Scientific.new({
+      assert_equal("scientific_none_2_nocomma_blackparenth", Osheet::Format::Scientific.new({
         :decimal_places => 2,
         :negative_numbers => :black_parenth,
         :comma_separator => false
       }).key)
-      assert_equal("scientific_none_4_comma_redparenth", Scientific.new({
+
+      assert_equal("scientific_none_4_comma_redparenth", Osheet::Format::Scientific.new({
         :symbol => :none,
         :decimal_places => 4,
         :negative_numbers => :red_parenth,