xmlss 0.4.1 → 1.0.0.rc.1

data/lib/xmlss/writer.rb

@@ -0,0 +1,244 @@
+require 'undies'
+require 'stringio'
+
+module Xmlss
+  class Writer
+
+    class Markup; end
+
+    # Xmlss uses Undies to stream its xml markup
+    # The Undies writer is responsible for driving the Undies API to generate
+    # the xmlss xml markup for the workbook.
+    # Because order doesn't matter when defining style and worksheet elements,
+    # the writer has to buffer the style and worksheet markup separately,
+    # then put them together according to Xmlss spec to build the final
+    # workbook markup.
+
+    XML_NS   = "xmlns"
+    SHEET_NS = "ss"
+    NS_URI   = "urn:schemas-microsoft-com:office:spreadsheet"
+    LB       = "
"
+
+    def self.attributes(thing, *attrs)
+      [*attrs].flatten.inject({}) do |xattrs, a|
+        xattrs.merge(if !(xv = self.coerce(thing.send(a))).nil?
+          {xmlss_attribute_name(a) => xv.to_s}
+        else
+          {}
+        end)
+      end
+    end
+
+    def self.xmlss_attribute_name(attr_name)
+      "#{SHEET_NS}:#{self.classify(attr_name)}"
+    end
+
+    def self.classify(underscored_string)
+      underscored_string.
+        to_s.downcase.
+        split("_").
+        collect{|part| part.capitalize}.
+        join('')
+    end
+
+    def self.coerce(value)
+      if value == true
+        1
+      elsif ["",false].include?(value)
+        # don't include false or empty string values
+        nil
+      else
+        value
+      end
+    end
+
+    attr_reader :styles_markup
+    attr_reader :worksheets_markup
+
+    def initialize(output_opts={})
+      @opts = output_opts || {}
+
+      @styles_markup     = Markup.new(@opts.merge(:pp_level => 2))
+      @worksheets_markup = Markup.new(@opts.merge(:pp_level => 1))
+    end
+
+    def write(element)
+      self.send(element.class.writer, element)
+    end
+
+    def push(template)
+      self.send("#{template}_markup").push
+    end
+
+    def pop(template)
+      self.send("#{template}_markup").pop
+    end
+
+    def flush
+      # flush the worksheets markup first b/c it may add style elements to
+      # the styles markup
+      worksheets_markup.flush
+      styles_markup.flush
+      self
+    end
+
+    # return the full workbook markup, combining the buffers to xmlss spec
+    def workbook
+      self.flush
+      "".tap do |markup|
+        Undies::Template.new(Undies::Source.new(Proc.new do
+          __ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          _Workbook(XML_NS => NS_URI, "#{XML_NS}:#{SHEET_NS}" => NS_URI) {
+            _Styles {
+              __partial styles
+            }
+            __partial worksheets
+          }
+        end), {
+          :styles => styles_markup.to_s,
+          :worksheets => worksheets_markup.to_s
+        }, Undies::Output.new(StringIO.new(markup), @opts))
+      end.strip
+    end
+
+    # workbook style markup directives
+
+    def alignment(alignment)
+      styles_markup.template._Alignment(self.class.attributes(alignment, [
+        :horizontal, :vertical, :wrap_text, :rotate
+      ]))
+    end
+
+    def border(border)
+      styles_markup.template._Border(self.class.attributes(border, [
+        :color, :position, :weight, :line_style
+      ]))
+    end
+
+    def borders(borders)
+      styles_markup.template._Borders
+    end
+
+    def font(font)
+      styles_markup.template._Font(self.class.attributes(font, [
+        :bold, :color, :italic, :size, :shadow, :font_name,
+        :strike_through, :underline, :vertical_align
+      ]))
+    end
+
+    def interior(interior)
+      styles_markup.template._Interior(self.class.attributes(interior, [
+        :color, :pattern, :pattern_color
+      ]))
+    end
+
+    def number_format(number_format)
+      styles_markup.template._NumberFormat(self.class.attributes(number_format, [
+        :format
+      ]))
+    end
+
+    def protection(protection)
+      styles_markup.template._Protection(self.class.attributes(protection, [
+        :protect
+      ]))
+    end
+
+    def style(style)
+      styles_markup.template._Style(self.class.attributes(style, [
+        :i_d
+      ]))
+    end
+
+    # workbook element markup directives
+
+    def cell(cell)
+      # write the cell markup and push
+      worksheets_markup.template._Cell(self.class.attributes(cell, [
+        [:index, :style_i_d, :formula, :h_ref, :merge_across, :merge_down]
+      ]))
+      push(:worksheets)
+
+      # write nested data markup and push
+      worksheets_markup.template._Data(self.class.attributes(cell, [
+        [:type]
+      ]))
+      push(:worksheets)
+
+      # write data value
+      worksheets_markup.template.__ Undies::Template.
+        escape_html(cell.data_xml_value).
+        gsub(/(\r|\n)+/, LB)
+
+      pop(:worksheets)
+      pop(:worksheets)
+    end
+
+    def row(row)
+      worksheets_markup.template._Row(self.class.attributes(row, [
+        [:style_i_d, :height, :auto_fit_height, :hidden]
+      ]))
+    end
+
+    def column(column)
+      worksheets_markup.template._Column(self.class.attributes(column, [
+        [:style_i_d, :width, :auto_fit_width, :hidden]
+      ]))
+    end
+
+    def worksheet(worksheet)
+      # flush any previous worksheet markup
+      worksheets_markup.flush
+
+      # write the worksheet markup and push
+      worksheets_markup.template._Worksheet(self.class.attributes(worksheet, [
+        [:name]
+      ]))
+      push(:worksheets)
+
+      # write the table container
+      worksheets_markup.template._Table
+    end
+
+  end
+
+
+
+  class Writer::Markup
+
+    attr_reader :template, :push_count, :pop_count
+
+    def initialize(opts={})
+      @markup = ""
+      @template = Undies::Template.new(Undies::Output.new(StringIO.new(@markup), opts))
+      @push_count = 0
+      @pop_count  = 0
+    end
+
+    def push
+      @push_count += 1
+      @template.__push
+    end
+
+    def pop
+      @pop_count += 1
+      @template.__pop
+    end
+
+    def flush
+      while @push_count > @pop_count
+        pop
+      end
+      @template.__flush
+      self
+    end
+
+    def empty?; @markup.empty?; end
+
+    def to_s
+      @markup.to_s.strip
+    end
+
+  end
+
+end

data/test/element/cell_test.rb

@@ -1,22 +1,45 @@
 require "assert"
+require 'enumeration/assert_macros'
 
 require 'xmlss/element/cell'
 
 module Xmlss::Element
-  class CellTest < Assert::Context
+
+  class CellTests < Assert::Context
+    include Enumeration::AssertMacros
+
     desc "Xmlss::Cell"
     before { @c = Cell.new }
     subject { @c }
 
     should be_styled
+    should have_class_method :writer
     should have_accessor :index, :formula, :href, :merge_across, :merge_down
     should have_reader :h_ref
 
+    should have_enum :type, {
+      :number => "Number",
+      :date_time => "DateTime",
+      :boolean => "Boolean",
+      :string => "String",
+      :error => "Error"
+    }
+
+    should have_accessor :data
+    should have_instance_method :data_xml_value
+
+    should "know its writer hook" do
+      assert_equal :cell, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_nil subject.formula
       assert_nil subject.href
       assert_nil subject.merge_across
       assert_nil subject.merge_down
+
+      assert_equal Cell.type(:string), subject.type
+      assert_equal "", subject.data
     end
 
     should "provide alias for :href" do
@@ -60,6 +83,42 @@ module Xmlss::Element
       end
     end
 
+    should "generate it's data xml value" do
+      assert_equal "12", Cell.new(12).data_xml_value
+      assert_equal "string", Cell.new(:data => "string").data_xml_value
+      assert_equal "2011-03-01T00:00:00", Cell.new(DateTime.parse('2011/03/01')).data_xml_value
+      assert_equal "2011-03-01T00:00:00", Cell.new(Date.parse('2011/03/01')).data_xml_value
+      time = Time.now
+      assert_equal time.strftime("%Y-%m-%dT%H:%M:%S"), Cell.new(time).data_xml_value
+    end
+
+  end
+
+  class ExplicitDataTest < CellTests
+    desc "when using explicit data type"
+    subject do
+      Cell.new(12, {:type => :string})
+    end
+
+    should "should ignore the data value's implied type" do
+      assert_equal Cell.type(:string), subject.type
+    end
+
+  end
+
+  class NoTypeDataTest < CellTests
+    desc "when no data type is specified"
+
+    should "cast types for Number, DateTime, Boolean, String" do
+      assert_equal Cell.type(:number), Cell.new(12).type
+      assert_equal Cell.type(:number), Cell.new(:data => 123.45).type
+      assert_equal Cell.type(:date_time), Cell.new(Time.now).type
+      assert_equal Cell.type(:boolean), Cell.new(true).type
+      assert_equal Cell.type(:boolean), Cell.new(false).type
+      assert_equal Cell.type(:string), Cell.new("a string").type
+      assert_equal Cell.type(:string), Cell.new(:data => :symbol).type
+    end
+
   end
 
 end

data/test/element/column_test.rb

@@ -9,8 +9,13 @@ module Xmlss::Element
     subject { @c }
 
     should be_styled
+    should have_class_method :writer
     should have_accessor :width, :auto_fit_width, :hidden
 
+    should "know its writer hook" do
+      assert_equal :column, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal nil, subject.width
       assert_equal false, subject.auto_fit_width

data/test/element/row_test.rb

@@ -9,8 +9,13 @@ module Xmlss::Element
     subject { @row }
 
     should be_styled
+    should have_class_method :writer
     should have_accessors :height, :auto_fit_height, :hidden
 
+    should "know its writer hook" do
+      assert_equal :row, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_nil subject.height
       assert_equal false, subject.auto_fit_height

data/test/element/worksheet_test.rb

@@ -8,8 +8,13 @@ module Xmlss::Element
     before { @wksht = Worksheet.new('sheet') }
     subject { @wksht }
 
+    should have_class_method :writer
     should have_accessor :name
 
+    should "know its writer hook" do
+      assert_equal :worksheet, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal 'sheet', subject.name
     end
@@ -29,12 +34,12 @@ module Xmlss::Element
       assert_equal "t[e]st test", ws.name
     end
 
-    should "bark when no name is given" do
+    should "complain if given a name longer than 31 chars" do
       assert_raises ArgumentError do
-        Worksheet.new(nil)
+        Worksheet.new('a'*32)
       end
-      assert_raises ArgumentError do
-        Worksheet.new("")
+      assert_nothing_raised do
+        Worksheet.new('a'*31)
       end
     end
 

data/test/element_stack_test.rb

@@ -0,0 +1,117 @@
+require 'assert'
+
+require 'xmlss/element_stack'
+require 'xmlss/element/cell'
+require 'xmlss/writer'
+
+module Xmlss
+
+
+
+  class ElementStackTests < Assert::Context
+
+    class TestWriter
+      def initialize(io); @io = io; end
+      def write(element); @io << "|written: #{element.class.name} #{element.object_id}"; end
+      def push(template); @io << "|#{template}:opened"; end
+      def pop(template); @io << "|#{template}:closed"; end
+    end
+
+    desc "an element stack"
+    before do
+      @cell1 = Element::Cell.new("1")
+      @cell2 = Element::Cell.new("2")
+      @es = ElementStack.new(TestWriter.new(@test_io = ''), 'tests')
+    end
+    subject { @es }
+
+    should have_reader :markup_type
+    should have_instance_methods :current, :size, :level, :empty?, :first, :last
+    should have_instance_methods :push, :pop, :using
+
+    should "be empty by default" do
+      assert_empty subject
+    end
+
+    should "know the writer markup_type its driving" do
+      assert_equal 'tests', subject.markup_type
+    end
+
+  end
+
+
+
+  class StackTests < ElementStackTests
+
+    should "push elements onto the stack" do
+      assert_nothing_raised do
+        subject.push(@cell1)
+      end
+
+      assert_equal 1, subject.size
+    end
+
+    should "know its level (should be one less than the array's size)" do
+      assert_equal 0, subject.level
+      subject.push(@cell1)
+      assert_equal 1, subject.level
+    end
+
+    should "fetch the last item in the array with the current method" do
+      subject.push(@cell1)
+      subject.push(@cell2)
+
+      assert_same @cell2, subject.current
+    end
+
+    should "remove the last item in the array with the pop method" do
+      subject.push(@cell1)
+      subject.push(@cell2)
+
+      assert_equal 2, subject.size
+
+      elem = subject.pop
+      assert_same @cell2, elem
+      assert_equal 1, subject.size
+    end
+
+  end
+
+
+
+  class WriterTests < ElementStackTests
+    should "open the current element element when a new element is pushed" do
+      expected =  "|written: Xmlss::Element::Cell #{@cell1.object_id}"
+      expected += "|#{subject.markup_type}:opened"
+      subject.push(@cell1)
+      subject.push(@cell2)
+
+      assert_equal expected, @test_io
+    end
+
+    should "write the current element if no child element is pushed" do
+      subject.push(@cell1)
+      subject.push(@cell2)
+      subject.pop
+
+      assert_match /\|written: Xmlss::Element::Cell #{@cell2.object_id}$/, @test_io
+    end
+
+    should "close an element when its popped" do
+      expected =  "|written: Xmlss::Element::Cell #{@cell1.object_id}"
+      expected += "|#{subject.markup_type}:opened"
+      expected += "|written: Xmlss::Element::Cell #{@cell2.object_id}"
+      expected += "|#{subject.markup_type}:closed"
+      subject.push(@cell1)
+      subject.push(@cell2)
+      subject.pop
+      subject.pop
+
+      assert_equal expected, @test_io
+    end
+
+  end
+
+
+
+end

data/test/style/alignment_test.rb

@@ -25,9 +25,14 @@ module Xmlss::Style
       :bottom => "Bottom"
     }
 
+    should have_class_method :writer
     should have_accessors :wrap_text, :rotate
     should have_instance_methods :wrap_text?
 
+    should "know its writer" do
+      assert_equal :alignment, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal false, subject.wrap_text
       assert_equal nil,   subject.horizontal

data/test/style/base_test.rb

@@ -8,8 +8,13 @@ module Xmlss::Style
     before { @bs = Base.new(:test) }
     subject { @bs }
 
+    should have_class_method :writer
     should have_reader :id, :i_d
 
+    should "know its writer" do
+      assert_equal :style, subject.class.writer
+    end
+
     should "bark if you don't init with an id" do
       assert_raises ArgumentError do
         Base.new(nil)

data/test/style/border_test.rb

@@ -4,7 +4,10 @@ require 'enumeration/assert_macros'
 require 'xmlss/style/border'
 
 module Xmlss::Style
-  class BorderTest < Assert::Context
+
+
+
+  class BorderTests < Assert::Context
     include Enumeration::AssertMacros
 
     desc "Xmlss::Style::Border"
@@ -36,9 +39,13 @@ module Xmlss::Style
       :dash_dot_dot => "DashDotDot"
     }
 
-
+    should have_class_method :writer
     should have_accessors :color
 
+    should "know its writer" do
+      assert_equal :border, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal nil, subject.color
       assert_equal nil, subject.position
@@ -85,4 +92,21 @@ module Xmlss::Style
 
   end
 
+
+
+  class BordersTests < Assert::Context
+    desc "Xmlss::Style::Borders"
+    before { @bs = Xmlss::Style::Borders.new }
+    subject { @bs }
+
+    should have_class_method :writer
+
+    should "know its writer" do
+      assert_equal :borders, subject.class.writer
+    end
+
+  end
+
+
+
 end

data/test/style/font_test.rb

@@ -23,11 +23,16 @@ module Xmlss::Style
       :superscript => 'Superscript'
     }
 
+    should have_class_method :writer
     should have_reader :vertical_align
     should have_accessors :bold, :color, :italic, :size, :strike_through
     should have_accessors :shadow, :underline, :alignment, :name
     should have_instance_methods :bold?, :italic?, :strike_through?, :shadow?
 
+    should "know its writer" do
+      assert_equal :font, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal false, subject.bold
       assert_equal nil, subject.color

data/test/style/interior_test.rb

@@ -34,8 +34,13 @@ module Xmlss::Style
       :thin_diag_cross => "ThinDiagCross"
     }
 
+    should have_class_method :writer
     should have_accessor :color, :pattern_color
 
+    should "know its writer" do
+      assert_equal :interior, subject.class.writer
+    end
+
     should "set it's defaults" do
       assert_equal nil, subject.color
       assert_equal nil, subject.pattern

data/test/style/number_format_test.rb

@@ -11,8 +11,13 @@ module Xmlss::Style
     before { @nf = NumberFormat.new }
     subject { @nf }
 
+    should have_class_method :writer
     should have_accessor :format
 
+    should "know its writer" do
+      assert_equal :number_format, subject.class.writer
+    end
+
     should "set attributes at init" do
       nf = NumberFormat.new("General")
       assert_equal "General", nf.format

data/test/style/protection_test.rb

@@ -9,8 +9,13 @@ module Xmlss::Style
     before { @sp = Xmlss::Style::Protection.new }
     subject { @sp }
 
-    should have_instance_methods :protected?
+    should have_class_method :writer
     should have_accessor :protect
+    should have_instance_methods :protected?
+
+    should "know its writer" do
+      assert_equal :protection, subject.class.writer
+    end
 
     should "set it's defaults" do
       assert_equal false, subject.protected?