xmlss 0.3.1 → 0.4.0

data/lib/xmlss/undies_writer.rb

@@ -0,0 +1,172 @@
+require 'undies'
+require 'stringio'
+
+module Xmlss
+  class UndiesWriter
+
+    XML_NS   = "xmlns"
+    SHEET_NS = "ss"
+    NS_URI   = "urn:schemas-microsoft-com:office:spreadsheet"
+
+    # 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.
+
+    def self.attributes(thing, *attrs)
+      [*attrs].flatten.inject({}) do |xattrs, a|
+        xattrs.merge(if !(xv = self.coerce(thing.send(a))).nil?
+          {"#{SHEET_NS}:#{self.classify(a)}" => xv.to_s}
+        else
+          {}
+        end)
+      end
+    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 :style_markup, :element_markup
+
+    def initialize(output_opts={})
+      @opts = output_opts || {}
+
+      # buffer style markup and create a template to write to it
+      @style_markup = ""
+      styles_out = Undies::Output.new(StringIO.new(@style_markup), @opts.merge({
+        :pp_level => 2
+      }))
+      @styles_t = Undies::Template.new(styles_out)
+
+      # buffer worksheet markup and create a template to write to it
+      @element_markup = ""
+      worksheets_out = Undies::Output.new(StringIO.new(@element_markup), @opts.merge({
+        :pp_level => 1
+      }))
+      @worksheets_t = Undies::Template.new(worksheets_out)
+    end
+
+    def flush
+      Undies::Template.flush(@worksheets_t)
+      Undies::Template.flush(@styles_t)
+      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\"?>"
+          _Workbook(XML_NS => NS_URI, "#{XML_NS}:#{SHEET_NS}" => NS_URI) {
+            _Styles {
+              ___ style_markup.to_s.strip
+            }
+            __ element_markup.to_s.strip
+          }
+        end), {
+          :style_markup => @style_markup,
+          :element_markup => @element_markup
+        }, Undies::Output.new(StringIO.new(markup), @opts))
+      end.strip
+    end
+
+    # workbook style markup directives
+
+    def alignment(alignment, &block)
+      @styles_t._Alignment(self.class.attributes(alignment, [
+        :horizontal, :vertical, :wrap_text, :rotate
+      ]))
+    end
+
+    def border(border, &block)
+      @styles_t._Border(self.class.attributes(border, [
+        :color, :position, :weight, :line_style
+      ]))
+    end
+
+    def borders(&block)
+      @styles_t._Borders(&block)
+    end
+
+    def font(font, &block)
+      @styles_t._Font(self.class.attributes(font, [
+        :bold, :color, :italic, :size, :shadow, :font_name,
+        :strike_through, :underline, :vertical_align
+      ]))
+    end
+
+    def interior(interior, &block)
+      @styles_t._Interior(self.class.attributes(interior, [
+        :color, :pattern, :pattern_color
+      ]))
+    end
+
+    def number_format(number_format, &block)
+      @styles_t._NumberFormat(self.class.attributes(number_format, [
+        :format
+      ]))
+    end
+
+    def protection(protection, &block)
+      @styles_t._Protection(self.class.attributes(protection, [
+        :protect
+      ]))
+    end
+
+    def style(style, &block)
+      @styles_t._Style(self.class.attributes(style, :i_d), &block)
+    end
+
+    # workbook element markup directives
+
+    def data(data, &block)
+      @worksheets_t._Data(self.class.attributes(data, :type)) {
+        @worksheets_t.__ data.xml_value
+      }
+    end
+
+    def cell(cell, &block)
+      @worksheets_t._Cell(self.class.attributes(cell, [
+        :index, :style_i_d, :formula, :h_ref, :merge_across, :merge_down
+      ]), &block)
+    end
+
+    def row(row, &block)
+      @worksheets_t._Row(self.class.attributes(row, [
+        :style_i_d, :height, :auto_fit_height, :hidden
+      ]), &block)
+    end
+
+    def column(column, &block)
+      @worksheets_t._Column(self.class.attributes(column, [
+        :style_i_d, :width, :auto_fit_width, :hidden
+      ]))
+    end
+
+    def worksheet(worksheet, &block)
+      @worksheets_t._Worksheet(self.class.attributes(worksheet, :name)) {
+        @worksheets_t._Table(&block)
+      }
+    end
+
+  end
+end

data/lib/xmlss/version.rb

@@ -1,3 +1,3 @@
 module Xmlss
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/xmlss/workbook.rb

@@ -1,50 +1,116 @@
-require 'xmlss/item_set'
-require 'xmlss/xml'
-
+require 'xmlss/undies_writer'
 require 'xmlss/style/base'
-require 'xmlss/worksheet'
+require 'xmlss/element/worksheet'
 
 module Xmlss
   class Workbook
 
-    include Xmlss::Xml
-    def xml
-      { :node => :workbook,
-        :children => [:styles, :worksheets] }
+    def initialize(opts={}, &build)
+      # (don't pollute workbook scope that the build may run in)
+
+      # apply :data options to workbook scope
+      data = (opts || {})[:data] || {}
+      if (data.keys.map(&:to_s) & self.public_methods.map(&:to_s)).size > 0
+        raise ArgumentError, "data conflicts with template public methods."
+      end
+      metaclass = class << self; self; end
+      data.each {|key, value| metaclass.class_eval { define_method(key){value} }}
+
+      # setup the Undies xml writer with any :output options
+      @__xmlss_undies_writer = UndiesWriter.new((opts || {})[:output] || {})
+
+      # run any instance workbook build given
+      instance_eval(&build) if build
+    end
+
+    def to_s
+      @__xmlss_undies_writer.workbook
+    end
+
+    def to_file(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') { |f| f.write self.to_s }
+      File.exists?(path) ? path : false
+    end
+
+    # Workbook elements API
+
+    def worksheet(*args, &block)
+      Element::Worksheet.new(*args).tap do |elem|
+        @__xmlss_undies_writer.worksheet(elem, &block)
+      end
+    end
+
+    def column(*args, &block)
+      Element::Column.new(*args).tap do |elem|
+        @__xmlss_undies_writer.column(elem, &block)
+      end
+    end
+
+    def row(*args, &block)
+      Element::Row.new(*args).tap do |elem|
+        @__xmlss_undies_writer.row(elem, &block)
+      end
+    end
+
+    def cell(*args, &block)
+      Element::Cell.new(*args).tap do |elem|
+        @__xmlss_undies_writer.cell(elem, &block)
+      end
+    end
+
+    def data(*args, &block)
+      Element::Data.new(*args).tap do |elem|
+        @__xmlss_undies_writer.data(elem, &block)
+      end
     end
 
-    attr_accessor :styles, :worksheets
+    # Workbook styles API
 
-    def initialize(attrs={})
-      self.styles = attrs[:styles]
-      self.worksheets = attrs[:worksheets]
+    def style(*args, &block)
+      Style::Base.new(*args).tap do |style|
+        @__xmlss_undies_writer.style(style, &block)
+      end
     end
 
-    def styles=(collection)
-      @styles = if (set = collection || []).kind_of?(ItemSet)
-        set
-      else
-        ItemSet.new(:styles, set)
+    def alignment(*args, &block)
+      Style::Alignment.new(*args).tap do |style|
+        @__xmlss_undies_writer.alignment(style, &block)
       end
     end
 
-    def worksheets=(collection)
-      @worksheets = if (set = collection || []).kind_of?(ItemSet)
-        set
-      else
-        ItemSet.new(nil, set)
+    def borders(*args, &block)
+      @__xmlss_undies_writer.borders(&block)
+    end
+
+    def border(*args, &block)
+      Style::Border.new(*args).tap do |style|
+        @__xmlss_undies_writer.border(style, &block)
       end
     end
 
-    def to_xml(*options)
-      xml_builder do |builder|
-        build_node(builder, {
-          Xmlss::XML_NS => Xmlss::NS_URI,
-          "#{Xmlss::XML_NS}:#{Xmlss::SHEET_NS}" => Xmlss::NS_URI
-        })
-      end.
-        to_xml({:save_with => xml_save_with(*options)}).
-        gsub(/#{Xmlss::Data::LB.gsub(/&/, "&amp;")}/, Xmlss::Data::LB)
+    def font(*args, &block)
+      Style::Font.new(*args).tap do |style|
+        @__xmlss_undies_writer.font(style, &block)
+      end
+    end
+
+    def interior(*args, &block)
+      Style::Interior.new(*args).tap do |style|
+        @__xmlss_undies_writer.interior(style, &block)
+      end
+    end
+
+    def number_format(*args, &block)
+      Style::NumberFormat.new(*args).tap do |style|
+        @__xmlss_undies_writer.number_format(style, &block)
+      end
+    end
+
+    def protection(*args, &block)
+      Style::Protection.new(*args).tap do |style|
+        @__xmlss_undies_writer.protection(style, &block)
+      end
     end
 
   end

data/lib/xmlss.rb

@@ -1,31 +1,4 @@
-module Xmlss
-  # some helpers
-  class << self
+module Xmlss; end
 
-    def classify(underscored_string)
-      underscored_string.
-        to_s.downcase.
-        split("_").
-        collect{|part| part.capitalize}.
-        join('')
-    end
-
-    def xmlify(value)
-      if value == true
-        1
-      elsif ["",false].include?(value)
-        # don't include false or empty string values
-        nil
-      else
-        value
-      end
-    end
-
-  end
-end
-
-require 'enumeration'
-require 'xmlss/xml'
-require 'xmlss/style/base'
 require 'xmlss/workbook'
 

data/test/{cell_test.rb → element/cell_test.rb}

@@ -1,23 +1,22 @@
 require "assert"
-require 'xmlss/cell'
 
-module Xmlss
+require 'xmlss/element/cell'
+
+module Xmlss::Element
   class CellTest < Assert::Context
     desc "Xmlss::Cell"
-    subject { Cell.new }
+    before { @c = Cell.new }
+    subject { @c }
 
-    should have_accessor :index, :data
-    should have_accessor :formula, :href, :merge_across, :merge_down
+    should be_styled
+    should have_accessor :index, :formula, :href, :merge_across, :merge_down
     should have_reader :h_ref
 
-    should_have_style(Cell)
-
     should "set it's defaults" do
-      [:data, :formula, :href].each do |a|
-        assert_equal nil, subject.send(a)
-      end
-      assert_equal nil, subject.merge_across
-      assert_equal nil, subject.merge_down
+      assert_nil subject.formula
+      assert_nil subject.href
+      assert_nil subject.merge_across
+      assert_nil subject.merge_down
     end
 
     should "provide alias for :href" do
@@ -63,27 +62,4 @@ module Xmlss
 
   end
 
-  class CellDataTest < Assert::Context
-    desc "when using cell data"
-    subject do
-      Cell.new({
-        :data => Data.new(12, {:type => :number})
-      })
-    end
-
-    should "should build a data object" do
-      assert_kind_of Data, subject.data
-      assert_equal 12, subject.data.value
-    end
-
-  end
-
-  class CellDataXmlTest < CellDataTest
-    desc "for generating XML"
-
-    should have_reader :xml
-    should_build_node
-
-  end
-
 end

data/test/{column_test.rb → element/column_test.rb}

@@ -1,12 +1,14 @@
 require "assert"
-require 'xmlss/column'
 
-module Xmlss
+require 'xmlss/element/column'
+
+module Xmlss::Element
   class ColumnTest < Assert::Context
     desc "Xmlss::Column"
-    subject { Column.new }
+    before { @c = Column.new }
+    subject { @c }
 
-    should_have_style(Column)
+    should be_styled
     should have_accessor :width, :auto_fit_width, :hidden
 
     should "set it's defaults" do
@@ -36,12 +38,4 @@ module Xmlss
 
   end
 
-  class ColumnXmlTest < ColumnTest
-    desc "for generating XML"
-
-    should have_reader :xml
-    should_build_node
-
-  end
-
 end

data/test/{data_test.rb → element/data_test.rb}

@@ -1,12 +1,24 @@
 require "assert"
-require 'xmlss/data'
+require 'enumeration/assert_macros'
 
-module Xmlss
+require 'xmlss/element/data'
+
+module Xmlss::Element
   class DataTest < Assert::Context
+    include Enumeration::AssertMacros
+
     desc "Xmlss::Data"
     subject { Data.new }
 
-    should have_accessor :type, :value
+    should have_enum :type, {
+      :number => "Number",
+      :date_time => "DateTime",
+      :boolean => "Boolean",
+      :string => "String",
+      :error => "Error"
+    }
+
+    should have_accessor :value
     should have_instance_method :xml_value
 
     should "set it's defaults" do
@@ -72,11 +84,4 @@ Should
 
   end
 
-  class XmlDataTest < DataTest
-    desc "for generating XML"
-
-    should have_reader :xml
-    should_build_node
-  end
-
 end

data/test/{row_test.rb → element/row_test.rb}

@@ -1,31 +1,20 @@
 require "assert"
-require 'xmlss/cell'
-require 'xmlss/row'
 
-module Xmlss
+require 'xmlss/element/row'
+
+module Xmlss::Element
   class RowTest < Assert::Context
     desc "Xmlss::Row"
     before { @row = Row.new }
     subject { @row }
 
-    should_have_style(Row)
+    should be_styled
     should have_accessors :height, :auto_fit_height, :hidden
-    should have_accessor :cells
 
     should "set it's defaults" do
-      assert_equal nil, subject.height
+      assert_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
@@ -48,23 +37,4 @@ module Xmlss
     end
   end
 
-  class RowCellsTest < RowTest
-    desc "when using cells"
-    before do
-      r = subject.cells << Cell.new
-    end
-
-    should "should build a data object" do
-      assert_equal 1, subject.cells.size
-      assert_kind_of Cell, subject.cells.first
-    end
-  end
-
-  class RowXmlTest < RowTest
-    desc "for generating XML"
-
-    should have_reader :xml
-    should_build_node
-  end
-
 end

data/test/{worksheet_test.rb → element/worksheet_test.rb}

@@ -1,19 +1,17 @@
 require "assert"
-require 'xmlss/worksheet'
 
-module Xmlss
+require 'xmlss/element/worksheet'
+
+module Xmlss::Element
   class WorksheetTest < Assert::Context
     desc "Xmlss::Worksheet"
     before { @wksht = Worksheet.new('sheet') }
     subject { @wksht }
 
-    should have_accessor :name, :table
+    should have_accessor :name
 
     should "set it's defaults" do
       assert_equal 'sheet', subject.name
-      assert_kind_of Table, subject.table
-      assert_equal [], subject.table.columns
-      assert_equal [], subject.table.rows
     end
 
     should "filter name chars" do
@@ -31,17 +29,6 @@ module Xmlss
       assert_equal "t[e]st test", ws.name
     end
 
-    should "allow defining a table at init" do
-      wksht = Worksheet.new('table', {
-        :table => Table.new({
-          :columns => [Column.new]
-        })
-      })
-
-      assert_equal 1, wksht.table.columns.size
-      assert_kind_of Column, wksht.table.columns.first
-    end
-
     should "bark when no name is given" do
       assert_raises ArgumentError do
         Worksheet.new(nil)
@@ -51,19 +38,6 @@ module Xmlss
       end
     end
 
-    should "bark when setting a table to something other" do
-      assert_raises ArgumentError do
-        subject.table = "not a table"
-      end
-    end
-
-  end
-
-  class WorksheetXmlTest < WorksheetTest
-    desc "for generating XML"
-
-    should have_reader :xml
-    should_build_node
   end
 
 end

data/test/helper.rb

@@ -4,42 +4,25 @@
 # add root dir to the load path
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
-require 'xmlss'
-
 class Assert::Context
 
   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 be_styled
+      called_from = caller.first
+      Assert::Macro.new("have style attributes") do
+        should have_accessor :style_id
+        should have_reader :style_i_d
 
-    def should_build_no_attributes_by_default(klass)
-      should "have no element attributes" do
-        xmlthing = klass.new
-        assert_equal({}, xmlthing.send(:build_attributes))
-      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 "set the style default" do
+          assert_equal nil, subject.class.new.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
+        should "provide aliases for style_id" do
+          c = subject.class.new({:style_id => :poo})
+          assert_equal :poo, c.style_id
+          assert_equal :poo, c.style_i_d
+        end
       end
     end