osheet 0.1.0 → 0.2.0

data/test/format/currency_test.rb

@@ -0,0 +1,158 @@
+require "test/helper"
+require 'osheet/format/currency'
+
+module Osheet::Format
+
+  class CurrencyTest < Test::Unit::TestCase
+    context "Currency format" do
+      subject { Currency.new }
+
+      should_have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
+
+      should "provide symbol options" do
+        assert_equal 3, Currency.symbol_set.size
+        [:none, :dollar, :euro].each do |a|
+          assert Currency.symbol_set.include?(a)
+        end
+      end
+
+      should "provide negative numbers options" do
+        assert_equal 4, Currency.negative_numbers_set.size
+        [:black, :black_parenth, :red, :red_parenth].each do |a|
+          assert Currency.negative_numbers_set.include?(a)
+        end
+      end
+
+      should "set default values" do
+        assert_equal 2, subject.decimal_places
+        assert_equal :dollar, subject.symbol
+        assert_equal true, 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
+          Currency.new({:decimal_places => -1})
+        end
+        assert_raises ArgumentError do
+          Currency.new({:decimal_places => 31})
+        end
+        assert_raises ArgumentError do
+          Currency.new({:decimal_places => 'poo'})
+        end
+        assert_nothing_raised do
+          Currency.new({:decimal_places => 1})
+        end
+      end
+
+      should "generate decimal place style strings" do
+        assert_equal "0", Currency.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        (1..5).each do |n|
+          assert_equal "0.#{'0'*n}", Currency.new({
+            :decimal_places => n,
+            :comma_separator => false,
+            :symbol => :none
+          }).style
+        end
+      end
+
+      should "generate comma separator style strings" do
+        assert_equal "0", Currency.new({
+          :comma_separator => false,
+          :decimal_places => 0,
+          :symbol => :none
+        }).style
+        assert_equal "#,##0", Currency.new({
+          :comma_separator => true,
+          :decimal_places => 0,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate parenth negative numbers style strings" do
+        assert_equal "0", Currency.new({
+          :negative_numbers => :black,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "0_);\(0\)", Currency.new({
+          :negative_numbers => :black_parenth,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate red negative numbers style strings" do
+        assert_equal "0;[Red]0", Currency.new({
+          :negative_numbers => :red,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "0_);[Red]\(0\)", Currency.new({
+          :negative_numbers => :red_parenth,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate symbol style strings" do
+        assert_equal "0", Currency.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "\"$\"0", Currency.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :dollar
+        }).style
+        assert_equal "[$€-2]\ 0", Currency.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :euro
+        }).style
+      end
+
+      should "generate complex style string" do
+        assert_equal("\"$\"0.00_);\(\"$\"0.00\)", Currency.new({
+          :symbol => :dollar,
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).style)
+        assert_equal("[$€-2]\ #,##0.0000_);[Red]\([$€-2]\ #,##0.0000\)", Currency.new({
+          :symbol => :euro,
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).style)
+      end
+
+      should "provide unique format keys" do
+        assert_equal("currency_dollar_2_nocomma_blackparenth", Currency.new({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).key)
+        assert_equal("currency_none_4_comma_redparenth", Currency.new({
+          :symbol => :none,
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).key)
+      end
+
+
+
+    end
+  end
+
+end

data/test/format/custom_test.rb

@@ -0,0 +1,22 @@
+require "test/helper"
+require 'osheet/format/custom'
+
+module Osheet::Format
+
+  class CustomTest < Test::Unit::TestCase
+    context "Custom format" do
+      should "generate a basic style string and key" do
+        f = 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'
+        assert_equal 'm/d/yy', f.style
+        assert_equal "custom_m/d/yy", f.key
+      end
+    end
+  end
+
+end

data/test/format/datetime_test.rb

@@ -0,0 +1,22 @@
+require "test/helper"
+require 'osheet/format/datetime'
+
+module Osheet::Format
+
+  class DatetimeTest < Test::Unit::TestCase
+    context "Datetime format" do
+      should "generate a basic style string and key" do
+        f = 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'
+        assert_equal 'yy-m', f.style
+        assert_equal "datetime_yy-m", f.key
+      end
+    end
+  end
+
+end

data/test/format/fraction_test.rb

@@ -0,0 +1,84 @@
+require "test/helper"
+require 'osheet/format/fraction'
+
+module Osheet::Format
+
+  class FractionTest < Test::Unit::TestCase
+    context "Fraction format" do
+      subject { Fraction.new }
+
+      should_have_accessors :type
+
+      should "provide options for type" do
+        assert_equal 9, 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)
+        end
+      end
+
+      should "set default values" do
+        assert_equal '??/??', subject.type
+        assert_equal :two_digits, subject.type_key
+      end
+
+      should "generate a one_digit type style strings and key" do
+        f = 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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        assert_equal "#\ ??/100", f.style
+        assert_equal "fraction_hundredths", f.key
+      end
+
+    end
+  end
+
+end

data/test/format/general_test.rb

@@ -0,0 +1,21 @@
+require "test/helper"
+require 'osheet/format/general'
+
+module Osheet::Format
+
+  class GeneralTest < Test::Unit::TestCase
+    context "General format" do
+      subject { General.new }
+
+      should "always provide a nil style string" do
+        assert_equal nil, subject.style
+      end
+
+      should "always provide and empty format key" do
+        assert_equal '', subject.key
+      end
+
+    end
+  end
+
+end

data/test/format/number_test.rb

@@ -0,0 +1,93 @@
+require "test/helper"
+require 'osheet/format/number'
+
+module Osheet::Format
+
+  class NumberTest < Test::Unit::TestCase
+    context "Number format" do
+      subject { Number.new }
+
+      should_have_accessors :decimal_places, :comma_separator, :negative_numbers
+
+      should "provide options for negative numbers" do
+        assert_equal 4, Number.negative_numbers_set.size
+        [:black, :black_parenth, :red, :red_parenth].each do |a|
+          assert 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
+          Number.new({:decimal_places => -1})
+        end
+        assert_raises ArgumentError do
+          Number.new({:decimal_places => 31})
+        end
+        assert_raises ArgumentError do
+          Number.new({:decimal_places => 'poo'})
+        end
+        assert_nothing_raised do
+          Number.new({:decimal_places => 1})
+        end
+      end
+
+      should "generate decimal place style strings" do
+        assert_equal "0", Number.new({:decimal_places => 0}).style
+        (1..5).each do |n|
+          assert_equal "0.#{'0'*n}", Number.new({:decimal_places => n}).style
+        end
+      end
+
+      should "generate comma separator style strings" do
+        assert_equal "0", Number.new({:comma_separator => false}).style
+        assert_equal "#,##0", Number.new({:comma_separator => true}).style
+      end
+
+      should "generate parenth negative numbers style strings" do
+        assert_equal "0", Number.new({:negative_numbers => :black}).style
+        assert_equal "0_);\(0\)", Number.new({:negative_numbers => :black_parenth}).style
+      end
+
+      should "generate red negative numbers style strings" do
+        assert_equal "0;[Red]0", Number.new({:negative_numbers => :red}).style
+        assert_equal "0_);[Red]\(0\)", Number.new({:negative_numbers => :red_parenth}).style
+      end
+
+      should "generate complex style string" do
+        assert_equal("0.00_);\(0.00\)", Number.new({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).style)
+        assert_equal("#,##0.0000_);[Red]\(#,##0.0000\)", 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", Number.new({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).key)
+        assert_equal("number_none_4_comma_redparenth", Number.new({
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).key)
+      end
+
+
+
+    end
+  end
+
+end

data/test/format/percentage_test.rb

@@ -0,0 +1,116 @@
+require "test/helper"
+require 'osheet/format/percentage'
+
+module Osheet::Format
+
+  class PercentageTest < Test::Unit::TestCase
+    context "Percentage format" do
+      subject { Percentage.new }
+
+      should_have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
+
+      should "provide negative numbers options" do
+        assert_equal 4, Percentage.negative_numbers_set.size
+        [:black, :black_parenth, :red, :red_parenth].each do |a|
+          assert Percentage.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 "only allow Fixnum decimal places between 0 and 30" do
+        assert_raises ArgumentError do
+          Percentage.new({:decimal_places => -1})
+        end
+        assert_raises ArgumentError do
+          Percentage.new({:decimal_places => 31})
+        end
+        assert_raises ArgumentError do
+          Percentage.new({:decimal_places => 'poo'})
+        end
+        assert_nothing_raised do
+          Percentage.new({:decimal_places => 1})
+        end
+      end
+
+      should "generate decimal place style strings" do
+        assert_equal "0%", Percentage.new({
+          :decimal_places => 0
+        }).style
+        (1..5).each do |n|
+          assert_equal "0.#{'0'*n}%", Percentage.new({
+            :decimal_places => n
+          }).style
+        end
+      end
+
+      should "generate comma separator style strings" do
+        assert_equal "0%", Percentage.new({
+          :comma_separator => false,
+          :decimal_places => 0
+        }).style
+        assert_equal "#,##0%", Percentage.new({
+          :comma_separator => true,
+          :decimal_places => 0
+        }).style
+      end
+
+      should "generate parenth negative numbers style strings" do
+        assert_equal "0%", Percentage.new({
+          :negative_numbers => :black,
+          :decimal_places => 0
+        }).style
+        assert_equal "0%_);\(0%\)", 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({
+          :negative_numbers => :red,
+          :decimal_places => 0
+        }).style
+        assert_equal "0%_);[Red]\(0%\)", 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({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).style)
+        assert_equal("#,##0.0000%_);[Red]\(#,##0.0000%\)", Percentage.new({
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).style)
+      end
+
+      should "provide unique format keys" do
+        assert_equal("percentage_none_2_nocomma_blackparenth", Percentage.new({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).key)
+        assert_equal("percentage_none_4_comma_redparenth", Percentage.new({
+          :symbol => :none,
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).key)
+      end
+
+
+
+    end
+  end
+
+end

data/test/format/scientific_test.rb

@@ -0,0 +1,116 @@
+require "test/helper"
+require 'osheet/format/scientific'
+
+module Osheet::Format
+
+  class ScientificTest < Test::Unit::TestCase
+    context "Scientific format" do
+      subject { Scientific.new }
+
+      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
+      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
+      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
+      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 "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
+
+end

data/test/format/special_test.rb

@@ -0,0 +1,51 @@
+require "test/helper"
+require 'osheet/format/special'
+
+module Osheet::Format
+
+  class SpecialTest < Test::Unit::TestCase
+    context "Special format" do
+      subject { Special.new }
+
+      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
+      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 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 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
+
+end