xmlss 0.0.1

data/test/data_test.rb

@@ -0,0 +1,75 @@
+require "test/helper"
+require 'xmlss/data'
+
+module Xmlss
+  class DataTest < Test::Unit::TestCase
+
+    context "Xmlss::Data" do
+      subject { Data.new }
+
+      should_have_accessor :type, :value
+      should_have_instance_method :xml_value
+
+      should "set it's defaults" do
+        assert_equal Data.type(:string), subject.type
+        assert_equal "", subject.value
+      end
+
+      should "generate it's xml value" do
+        assert_equal "12", Data.new(12).xml_value
+        assert_equal "string", Data.new("string").xml_value
+        assert_equal "line#{Data::LB}break", Data.new("line\nbreak").xml_value
+        assert_equal "return#{Data::LB}break", Data.new("return\rbreak").xml_value
+        assert_equal "returnline#{Data::LB}break", Data.new("returnline\r\nbreak").xml_value
+        assert_equal "2011-03-01T00:00:00", Data.new(DateTime.parse('03/01/2011')).xml_value
+        assert_equal "2011-03-01T00:00:00", Data.new(Date.parse('03/01/2011')).xml_value
+        time = Time.now
+        assert_equal time.strftime("%Y-%m-%dT%H:%M:%S"), Data.new(time).xml_value
+      end
+
+      context "when using explicit type" do
+        subject do
+          Data.new(12, {:type => :string})
+        end
+
+        should "should ignore the value type" do
+          assert_equal Data.type(:string), subject.type
+        end
+      end
+
+      context "when no type is specified" do
+        should "cast types for Number, DateTime, Boolean, String" do
+          assert_equal Data.type(:number), Data.new(12).type
+          assert_equal Data.type(:number), Data.new(123.45).type
+          assert_equal Data.type(:date_time), Data.new(Time.now).type
+          assert_equal Data.type(:boolean), Data.new(true).type
+          assert_equal Data.type(:boolean), Data.new(false).type
+          assert_equal Data.type(:string), Data.new("a string").type
+          assert_equal Data.type(:string), Data.new(:symbol).type
+        end
+      end
+
+      context "dealing with line breaks and leading space" do
+        subject do
+          Data.new(%s{
+Should
+  honor
+    this
+          })
+        end
+
+        should "honor them when generating xml" do
+          reg = /#{Data::LB}Should#{Data::LB}\s{2}honor#{Data::LB}\s{4}this#{Data::LB}/
+          assert_match reg, subject.xml_value
+        end
+      end
+
+      context "for generating XML" do
+        should_have_reader :xml
+        should_build_node
+      end
+
+    end
+
+  end
+end

data/test/enum_test.rb

@@ -0,0 +1,63 @@
+require "test/helper"
+require 'xmlss/enum'
+require 'test/thing'
+
+module Xmlss
+  class EnumTest < Test::Unit::TestCase
+
+    context "Xmlss::Enum mixin" do
+      subject { Thing.new }
+      before do
+        Thing.send :include, Xmlss::Enum
+      end
+
+      should_have_class_method :enum
+
+      context "instance" do
+        before do
+          Thing.send(:enum, :stuff, {
+            :a => "eh",
+            :b => "bee",
+            :c => "see"
+          })
+        end
+
+        should_have_class_method :stuff
+        should "provide class level access to the enum" do
+          assert Thing.send(:class_variable_get, "@@stuff")
+          assert_equal 3, Thing.send(:class_variable_get, "@@stuff").size
+          assert_equal "eh", Thing.stuff(:a)
+        end
+
+        should_have_accessor :stuff
+
+        should "write by key and read by value" do
+          subject.stuff = :a
+          assert_equal "eh", subject.stuff
+        end
+
+        should "write by value and read by value" do
+          subject.stuff = "bee"
+          assert_equal "bee", subject.stuff
+        end
+
+        should "not read by key" do
+          subject.stuff = :c
+          assert_not_equal :c, subject.stuff
+        end
+
+        should "write nil for keys that aren't in the enum" do
+          subject.stuff = :bad
+          assert_equal nil, subject.stuff
+        end
+
+        should "write nil for values that aren't in the enum" do
+          subject.stuff = "bady-bad"
+          assert_equal nil, subject.stuff
+        end
+
+      end
+    end
+
+  end
+end

data/test/env.rb

@@ -0,0 +1,10 @@
+# Add test and lib paths to the $LOAD_PATH
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), '..', 'lib')
+].each do |path|
+  full_path = File.expand_path(path)
+  $LOAD_PATH.unshift(full_path) unless $LOAD_PATH.include?(full_path)
+end
+
+require 'xmlss'
+

data/test/helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'test_belt'
+require 'test/env'
+
+class Test::Unit::TestCase
+
+  class << self
+
+    def should_build_node
+      should_have_instance_methods :build_node
+      should "build it's node" do
+        assert_nothing_raised do
+          ::Nokogiri::XML::Builder.new do |builder|
+            subject.build_node(builder)
+          end
+        end
+      end
+    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
+      end
+    end
+
+    def should_have_style(klass)
+      should_have_accessor :style_id
+      should_have_reader :style_i_d
+
+      should "set the style default" do
+        assert_equal nil, subject.style_id
+      end
+
+      should "provide aliases for style_id" do
+        c = klass.new({:style_id => :poo})
+        assert_equal :poo, c.style_id
+        assert_equal :poo, c.style_i_d
+      end
+
+
+    end
+
+  end
+
+end

data/test/item_set_test.rb

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

data/test/row_test.rb

@@ -0,0 +1,67 @@
+require "test/helper"
+require 'xmlss/row'
+
+module Xmlss
+  class RowTest < Test::Unit::TestCase
+
+    context "Xmlss::Row" do
+      subject { Row.new }
+
+      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 "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
+
+      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
+      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
+
+
+      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
+
+    end
+
+  end
+end

data/test/style/alignment_test.rb

@@ -0,0 +1,107 @@
+require "test/helper"
+require 'xmlss/style/alignment'
+
+class Xmlss::Style::AlignmentTest < Test::Unit::TestCase
+
+  context "Xmlss::Style::Alignment" do
+    subject { Xmlss::Style::Alignment.new }
+
+    should_have_class_method :horizontal
+    {
+      :automatic => "Automatic",
+      :left => "Left",
+      :center => "Center",
+      :right => "Right"
+    }.each do |horizontal, value|
+      should "provide the value for the '#{horizontal}' horizontal" do
+        assert_equal value, Xmlss::Style::Alignment.horizontal(horizontal)
+      end
+    end
+
+    should_have_class_method :vertical
+    {
+      :automatic => "Automatic",
+      :top => "Top",
+      :center => "Center",
+      :bottom => "Bottom"
+    }.each do |vertical, value|
+      should "provide the value for the '#{vertical}' vertical" do
+        assert_equal value, Xmlss::Style::Alignment.vertical(vertical)
+      end
+    end
+
+    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
+      assert_equal nil, subject.horizontal
+      assert_equal nil, subject.vertical
+      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
+    end
+
+    context "that sets underline and alignment by key" do
+      before do
+        subject.horizontal = :left
+        subject.vertical = :top
+      end
+
+      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
+      end
+    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 "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
+    end
+
+    context "for generating XML" do
+      should_have_reader :xml
+      should_build_node
+      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
+    end
+
+  end
+end

data/test/style/base_test.rb

@@ -0,0 +1,126 @@
+require "test/helper"
+require 'xmlss/style/base'
+
+class Xmlss::Style::BaseTest < Test::Unit::TestCase
+  context "Xmlss::Style::Base" do
+    subject { Xmlss::Style::Base.new(:test) }
+
+    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)
+      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
+    end
+
+    should "set it's defaults" do
+      assert_equal 'test', subject.id
+      assert_equal [],  subject.borders
+      [ :alignment, :border, :font,
+        :interior, :number_format, :protection
+      ].each do |s|
+        assert_equal nil, subject.send(s)
+      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
+
+      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
+      end
+    end
+
+    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 "error if manually setting borders to non ItemSet collection" do
+        assert_raises ArgumentError do
+          subject.borders = []
+        end
+      end
+    end
+
+    context "that sets font" do
+      subject do
+        Xmlss::Style::Base.new(:font) { font(:bold => true) }
+      end
+
+      should "should create a Font object" do
+        assert_kind_of Xmlss::Style::Font, subject.font
+        assert subject.font.bold?
+      end
+    end
+
+    context "that sets interior" do
+      subject do
+        Xmlss::Style::Base.new(:interior) { interior(:color => "#000000") }
+      end
+
+      should "should create an Interior object" do
+        assert_kind_of Xmlss::Style::Interior, subject.interior
+        assert_equal "#000000", subject.interior.color
+      end
+    end
+
+    context "that sets number format" do
+      subject do
+        Xmlss::Style::Base.new(:number_format) { number_format(:format => "General") }
+      end
+
+      should "should create a NumberFormat object" do
+        assert_kind_of Xmlss::Style::NumberFormat, subject.number_format
+        assert_equal "General", subject.number_format.format
+      end
+    end
+
+    context "that sets protection" do
+      subject do
+        Xmlss::Style::Base.new(:protection) { protection(:protect => true) }
+      end
+
+      should "should create a Protection object" do
+        assert_kind_of Xmlss::Style::Protection, subject.protection
+        assert subject.protection.protected?
+      end
+    end
+
+    context "for generating XML" do
+      should_have_reader :xml
+      should_build_node
+      should_build_no_attributes_by_default(Xmlss::Style::Alignment)
+    end
+
+  end
+end

data/test/style/border_test.rb

@@ -0,0 +1,114 @@
+require "test/helper"
+require 'xmlss/style/border'
+
+class Xmlss::Style::BorderTest < Test::Unit::TestCase
+
+  context "Xmlss::Style::Border" do
+    subject { Xmlss::Style::Border.new }
+
+    should_have_class_method :position
+    {
+      :left => "Left",
+      :top => "Top",
+      :right => "Right",
+      :bottom => "Bottom",
+      :diagonal_left => "DiagonalLeft",
+      :diagonal_right => "DiagonalRight"
+    }.each do |position, value|
+      should "provide the value for the '#{position}' position" do
+        assert_equal value, Xmlss::Style::Border.position(position)
+      end
+    end
+
+    should_have_class_method :weight
+    {
+      :hairline => 0,
+      :thin => 1,
+      :medium => 2,
+      :thick => 3
+    }.each do |weight, value|
+      should "provide the value for the '#{weight}' weight" do
+        assert_equal value, Xmlss::Style::Border.weight(weight)
+      end
+    end
+
+    should_have_class_method :line_style
+    {
+      :none => "None",
+      :continuous => "Continuous",
+      :dash => "Dash",
+      :dot => "Dot",
+      :dash_dot => "DashDot",
+      :dash_dot_dot => "DashDotDot"
+    }.each do |style, value|
+      should "provide the value for the '#{style}' line_style" do
+        assert_equal value, Xmlss::Style::Border.line_style(style)
+      end
+    end
+
+    should_have_accessors :color, :position, :weight, :line_style
+
+    should "set it's defaults" do
+      assert_equal nil, subject.color
+      assert_equal nil, subject.position
+      assert_equal Xmlss::Style::Border.weight(:thin), subject.weight
+      assert_equal Xmlss::Style::Border.line_style(:continuous), subject.line_style
+    end
+
+    context "that sets attributes at init" do
+      before do
+        @attrs = {
+          :color => '#FF0000',
+          :position => :top,
+          :weight => :thick,
+          :line_style => :dot
+        }
+        @border = Xmlss::Style::Border.new(@attrs)
+      end
+      subject{ @border }
+
+      should "should set them correctly" do
+        @attrs.reject{|a, v| [:position, :weight, :line_style].include?(a)}.each do |a,v|
+          assert_equal v, subject.send(a)
+        end
+        assert_equal Xmlss::Style::Border.position(:top), subject.position
+        assert_equal Xmlss::Style::Border.weight(:thick), subject.weight
+        assert_equal Xmlss::Style::Border.line_style(:dot), subject.line_style
+      end
+    end
+
+    context "that sets position, weight, and style by key" do
+      before do
+        subject.position = :bottom
+        subject.weight = :medium
+        subject.line_style = :dash_dot
+      end
+
+      should "should returm it by value" do
+        assert_equal Xmlss::Style::Border.position(:bottom), subject.position
+        assert_equal Xmlss::Style::Border.weight(:medium), subject.weight
+        assert_equal Xmlss::Style::Border.line_style(:dash_dot), subject.line_style
+      end
+    end
+
+    context "that sets position, weight, and style by value" do
+      before do
+        subject.position = Xmlss::Style::Border.position(:bottom)
+        subject.weight = Xmlss::Style::Border.weight(:medium)
+        subject.line_style = Xmlss::Style::Border.line_style(:dash_dot)
+      end
+
+      should "should returm it by value" do
+        assert_equal Xmlss::Style::Border.position(:bottom), subject.position
+        assert_equal Xmlss::Style::Border.weight(:medium), subject.weight
+        assert_equal Xmlss::Style::Border.line_style(:dash_dot), subject.line_style
+      end
+    end
+
+    context "for generating XML" do
+      should_have_reader :xml
+      should_build_node
+    end
+
+  end
+end