xmlss 0.0.1

data/lib/xmlss/row.rb

@@ -0,0 +1,34 @@
+require 'xmlss/item_set'
+require 'xmlss/cell'
+
+module Xmlss
+  class Row
+
+    include Xmlss::Xml
+    def xml
+      { :node => :row,
+        :attributes => [:style_i_d, :height, :auto_fit_height, :hidden],
+        :children => [:cells] }
+    end
+
+    attr_accessor :style_id, :height, :auto_fit_height, :hidden
+    attr_accessor :cells
+    alias_method :style_i_d, :style_id
+
+    def initialize(attrs={})
+      self.style_id = attrs[:style_id]
+      self.height = attrs[:height]
+      self.auto_fit_height = attrs[:auto_fit_height] || false
+      self.hidden = attrs[:hidden] || false
+      self.cells = Xmlss::ItemSet.new(nil, attrs[:cells] || [])
+    end
+
+    def height=(value)
+      if value && !value.kind_of?(::Numeric)
+        raise ArgumentError, "must specify height as a Numeric"
+      end
+      @height = value && value < 0 ? nil : value
+    end
+
+  end
+end

data/lib/xmlss/style/alignment.rb

@@ -0,0 +1,47 @@
+module Xmlss::Style
+  class Alignment
+    include Xmlss::Xml
+    def xml
+      { :node => :alignment,
+        :attributes => [:horizontal, :vertical, :wrap_text, :rotate] }
+    end
+
+    include Xmlss::Enum
+    enum :horizontal, {
+      :automatic => "Automatic",
+      :left => "Left",
+      :center => "Center",
+      :right => "Right"
+    }
+    enum :vertical, {
+      :automatic => "Automatic",
+      :top => "Top",
+      :center => "Center",
+      :bottom => "Bottom"
+    }
+
+    attr_accessor :wrap_text, :rotate
+
+    def initialize(attrs={})
+      self.wrap_text = attrs[:wrap_text] || false
+      self.rotate = attrs[:rotate]
+      self.horizontal = attrs[:horizontal]
+      self.vertical = attrs[:vertical]
+    end
+
+    def wrap_text?; !!self.wrap_text; end
+
+    def rotate=(value)
+      @rotate = if value.kind_of?(::Numeric)
+        if value <= 90 && value >= -90
+          value.round
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/xmlss/style/base.rb

@@ -0,0 +1,63 @@
+require 'xmlss/item_set'
+require 'xmlss/style/alignment'
+require 'xmlss/style/border'
+require 'xmlss/style/font'
+require 'xmlss/style/interior'
+require 'xmlss/style/number_format'
+require 'xmlss/style/protection'
+
+module Xmlss::Style
+  class Base
+    include Xmlss::Xml
+    def xml
+      { :node => :style,
+        :attributes => [:i_d],
+        :children => [
+          :alignment, :borders, :font, :interior, :number_format, :protection
+        ]}
+    end
+
+    attr_reader :id, :borders
+    alias_method :i_d, :id
+    attr_writer :alignment, :font, :interior, :number_format, :protection
+
+    def initialize(id, &block)
+      raise ArgumentError, "please choose an id for the style" if id.nil?
+      @id = id.to_s
+      self.borders = Xmlss::ItemSet.new(:borders)
+      instance_eval(&block) if block
+    end
+
+    def borders=(value)
+      if !value.kind_of? Xmlss::ItemSet
+        raise ArgumentError, "must set borders to an Xmlss::ItemSet value"
+      end
+      @borders = value
+    end
+
+    def border(opts = nil)
+      valid_attrs?(opts) do |attrs|
+        @borders << Border.new(attrs)
+      end
+    end
+
+    [:alignment, :font, :interior, :number_format, :protection].each do |meth|
+      define_method(meth) do |*args|
+        valid_attrs?(args.first) do |attrs|
+          instance_variable_set("@#{meth}", klass(meth).new(attrs))
+        end
+        instance_variable_get("@#{meth}")
+      end
+    end
+
+    protected
+
+    def valid_attrs?(attrs)
+      yield attrs if block_given? && attrs && attrs.kind_of?(::Hash)
+    end
+
+    def klass(method_name)
+      Xmlss::Style.const_get(Xmlss.classify(method_name))
+    end
+  end
+end

data/lib/xmlss/style/border.rb

@@ -0,0 +1,43 @@
+module Xmlss::Style
+  class Border
+    include Xmlss::Xml
+    def xml
+      { :node => :border,
+        :attributes => [:color, :position, :weight, :line_style] }
+    end
+
+    include Xmlss::Enum
+    enum :position, {
+      :left => "Left",
+      :top => "Top",
+      :right => "Right",
+      :bottom => "Bottom",
+      :diagonal_left => "DiagonalLeft",
+      :diagonal_right => "DiagonalRight"
+    }
+    enum :weight, {
+      :hairline => 0,
+      :thin => 1,
+      :medium => 2,
+      :thick => 3
+    }
+    enum :line_style, {
+      :none => "None",
+      :continuous => "Continuous",
+      :dash => "Dash",
+      :dot => "Dot",
+      :dash_dot => "DashDot",
+      :dash_dot_dot => "DashDotDot"
+    }
+
+    attr_accessor :color
+
+    def initialize(attrs={})
+      self.color = attrs[:color]
+      self.position = attrs[:position]
+      self.weight = attrs[:weight] || :thin
+      self.line_style = attrs[:line_style] || :continuous
+    end
+
+  end
+end

data/lib/xmlss/style/font.rb

@@ -0,0 +1,41 @@
+module Xmlss::Style
+  class Font
+    include Xmlss::Xml
+    def xml
+      { :node => :font,
+        :attributes => [
+          :bold, :color, :italic, :size,
+          :strike_through, :underline, :alignment
+        ] }
+    end
+
+    include Xmlss::Enum
+    enum :underline, {
+      :none => 0,
+      :single => 1,
+      :double => 2
+    }
+    enum :alignment, {
+      :none => 0,
+      :subscript => 1,
+      :superscript => 2
+    }
+
+    attr_accessor :bold, :color, :italic, :size, :strike_through
+
+    def initialize(attrs={})
+      self.bold = attrs[:bold] || false
+      self.color = attrs[:color]
+      self.italic = attrs[:italic] || false
+      self.size = attrs[:size]
+      self.strike_through = attrs[:strike_through] || false
+      self.underline = attrs[:underline]
+      self.alignment = attrs[:alignment]
+    end
+
+    def bold?; !!self.bold; end
+    def italic?; !!self.italic; end
+    def strike_through?; !!self.strike_through; end
+
+  end
+end

data/lib/xmlss/style/interior.rb

@@ -0,0 +1,41 @@
+module Xmlss::Style
+  class Interior
+    include Xmlss::Xml
+    def xml
+      { :node => :interior,
+        :attributes => [:color, :pattern, :pattern_color] }
+    end
+
+    include Xmlss::Enum
+    enum :pattern, {
+      :none => "None",
+      :solid => "Solid",
+      :gray75 => "Gray75",
+      :gray50 => "Gray50",
+      :gray25 => "Gray25",
+      :gray125 => "Gray125",
+      :gray0625 => "Gray0625",
+      :horz_stripe => "HorzStripe",
+      :vert_stripe => "VertStripe",
+      :reverse_diag_stripe => "ReverseDiagStripe",
+      :diag_stripe => "DiagStripe",
+      :diag_cross => "DiagCross",
+      :thick_diag_cross => "ThickDiagCross",
+      :thin_horz_stripe => "ThinHorzStripe",
+      :thin_vert_stripe => "ThinVertStripe",
+      :thin_reverse_diag_stripe => "ThinReverseDiagStripe",
+      :thin_diag_stripe => "ThineDiagStripe",
+      :thin_horz_cross => "ThinHorzCross",
+      :thin_diag_cross => "ThinDiagCross"
+    }
+
+    attr_accessor :color, :pattern_color
+
+    def initialize(attrs={})
+      self.color = attrs[:color]
+      self.pattern = attrs[:pattern]
+      self.pattern_color = attrs[:pattern_color]
+    end
+
+  end
+end

data/lib/xmlss/style/number_format.rb

@@ -0,0 +1,20 @@
+module Xmlss::Style
+  class NumberFormat
+    include Xmlss::Xml
+    def xml
+      { :node => :number_format,
+        :attributes => [:format] }
+    end
+
+    attr_accessor :format
+
+    def initialize(attrs={})
+      self.format = attrs[:format]
+    end
+
+    def format=(value)
+      @format = (value && value.respond_to?(:to_s) ? value.to_s : nil)
+    end
+
+  end
+end

data/lib/xmlss/style/protection.rb

@@ -0,0 +1,18 @@
+module Xmlss::Style
+  class Protection
+    include Xmlss::Xml
+    def xml
+      { :node => :protection,
+        :attributes => [:protect] }
+    end
+
+    attr_accessor :protect
+
+    def initialize(attrs={})
+      self.protect = attrs[:protect] || false
+    end
+
+    def protected?; !!self.protect; end
+
+  end
+end

data/lib/xmlss/table.rb

@@ -0,0 +1,22 @@
+require 'xmlss/item_set'
+require 'xmlss/column'
+require 'xmlss/row'
+
+module Xmlss
+  class Table
+
+    include Xmlss::Xml
+    def xml
+      { :node => :table,
+        :children => [:columns, :rows] }
+    end
+
+    attr_accessor :columns, :rows
+
+    def initialize(attrs={})
+      self.columns = Xmlss::ItemSet.new(nil, attrs[:columns] || [])
+      self.rows = Xmlss::ItemSet.new(nil, attrs[:rows] || [])
+    end
+
+  end
+end

data/lib/xmlss/version.rb

@@ -0,0 +1,3 @@
+module Xmlss
+  VERSION = "0.0.1"
+end

data/lib/xmlss/workbook.rb

@@ -0,0 +1,33 @@
+require 'xmlss/item_set'
+require 'xmlss/xml'
+
+require 'xmlss/style/base'
+require 'xmlss/worksheet'
+
+module Xmlss
+  class Workbook
+
+    include Xmlss::Xml
+    def xml
+      { :node => :workbook,
+        :children => [:styles, :worksheets] }
+    end
+
+    attr_accessor :styles, :worksheets
+
+    def initialize(attrs={})
+      self.styles = Xmlss::ItemSet.new(:styles, attrs[:styles] || [])
+      self.worksheets = Xmlss::ItemSet.new(nil, attrs[:worksheets] || [])
+    end
+
+    def to_xml
+      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.gsub(/#{Xmlss::Data::LB.gsub(/&/, "&")}/, Xmlss::Data::LB)
+    end
+
+  end
+end

data/lib/xmlss/worksheet.rb

@@ -0,0 +1,37 @@
+require 'xmlss/table'
+
+module Xmlss
+  class Worksheet
+
+    include Xmlss::Xml
+    def xml
+      { :node => :worksheet,
+        :attributes => [:name],
+        :children => [:table] }
+    end
+
+    attr_accessor :name, :table
+
+    def initialize(name, attrs={})
+      if name.nil? || name.empty?
+        raise ArgumentError, "'#{name.inspect}' is not a good name for a worksheet"
+      end
+      self.name = sanitized_name(name)
+      self.table = attrs[:table] || Table.new
+    end
+
+    def table=(value)
+      if value.nil? || !value.kind_of?(Table)
+        raise ArgumentError, "you must set table to an actual Table object"
+      end
+      @table = value
+    end
+
+    private
+
+    def sanitized_name(value)
+      # worksheet name cannot contain: /, \, ?, *, [, ]
+      value.to_s.gsub(/[\/|\\|\?|\*|\[|\]]/, '')
+    end
+  end
+end

data/lib/xmlss/xml.rb

@@ -0,0 +1,55 @@
+require 'nokogiri'
+
+# common methods used for generating XML
+module Xmlss
+  XML_NS   = "xmlns"
+  SHEET_NS = "ss"
+  NS_URI   = "urn:schemas-microsoft-com:office:spreadsheet"
+
+  module Xml
+
+    def xml_builder
+      ::Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |builder|
+        yield(builder) if block_given?
+      end
+    end
+
+    def build_node(builder, attrs={})
+      unless xml && xml.kind_of?(::Hash)
+        raise ArgumentError, "no xml config provided"
+      end
+      if xml[:node] && !xml[:node].to_s.empty?
+        if xml[:value] && (v = self.send(xml[:value]).to_s)
+          builder.send(Xmlss.classify(xml[:node]), v, build_attributes(attrs))
+        else
+          builder.send(Xmlss.classify(xml[:node]), build_attributes(attrs)) do
+            build_children(builder)
+          end
+        end
+      else
+        build_children(builder)
+      end
+    end
+
+    def build_attributes(attrs={})
+      (xml[:attributes] || []).inject({}) do |xattrs, a|
+        xattrs.merge(if !(xv = Xmlss.xmlify(self.send(a))).nil?
+          {"#{Xmlss::SHEET_NS}:#{Xmlss.classify(a)}" => xv}
+        else
+          {}
+        end)
+      end.merge(attrs)
+    end
+    private :build_attributes
+
+    def build_children(builder)
+      (xml[:children] || []).each do |c|
+        if (child = c.kind_of?(::Symbol) ? self.send(c) : c)
+          child.build_node(builder) if child.respond_to?(:build_node)
+        end
+      end
+    end
+    private :build_children
+
+  end
+end

data/lib/xmlss.rb

@@ -0,0 +1,31 @@
+module Xmlss
+  # some helpers
+  class << self
+
+    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 'xmlss/xml'
+require 'xmlss/enum'
+require 'xmlss/style/base'
+require 'xmlss/workbook'
+

data/test/cell_test.rb

@@ -0,0 +1,86 @@
+require "test/helper"
+require 'xmlss/cell'
+
+module Xmlss
+  class CellTest < Test::Unit::TestCase
+
+    context "Xmlss::Cell" do
+      subject { Cell.new }
+
+      should_have_accessor :index, :data
+      should_have_accessor :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
+      end
+
+      should "provide alias for :href" do
+        c = Cell.new({:href => "http://www.google.com"})
+        assert_equal "http://www.google.com", c.href
+        assert_equal "http://www.google.com", c.h_ref
+      end
+
+      should "bark when setting non Fixnum indices" do
+        assert_raises ArgumentError do
+          Cell.new({:index => "do it"})
+        end
+        assert_raises ArgumentError do
+          Cell.new({:index => 2.5})
+        end
+        assert_nothing_raised do
+          Cell.new({:index => 2})
+        end
+      end
+
+      should "bark when setting non Fixnum merge attrs" do
+        assert_raises ArgumentError do
+          Cell.new({:merge_across => "do it"})
+        end
+        assert_raises ArgumentError do
+          Cell.new({:merge_down => 2.5})
+        end
+        assert_nothing_raised do
+          Cell.new({:merge_across => 2})
+        end
+        assert_nothing_raised do
+          Cell.new({:merge_down => 3})
+        end
+      end
+
+      should "nil out merge/index values that are <= 0" do
+        [:index, :merge_across, :merge_down].each do |a|
+          assert_equal nil, Cell.new({a => -1}).send(a)
+          assert_equal nil, Cell.new({a => 0}).send(a)
+          assert_equal 1, Cell.new({a => 1}).send(a)
+        end
+      end
+
+      context "when using cell data" do
+        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
+
+      context "for generating XML" do
+        should_have_reader :xml
+        should_build_node
+      end
+
+    end
+
+  end
+end

data/test/column_test.rb

@@ -0,0 +1,46 @@
+require "test/helper"
+require 'xmlss/column'
+
+module Xmlss
+  class ColumnTest < Test::Unit::TestCase
+
+    context "Xmlss::Column" do
+      subject { Column.new }
+
+      should_have_style(Column)
+      should_have_accessor :width, :auto_fit_width, :hidden
+
+      should "set it's defaults" do
+        assert_equal nil, subject.width
+        assert_equal false, subject.auto_fit_width
+        assert_equal false, subject.hidden
+      end
+
+      should "bark when setting non Numeric width" do
+        assert_raises ArgumentError do
+          Column.new({:width => "do it"})
+        end
+        assert_nothing_raised do
+          Column.new({:width => 2})
+        end
+        assert_nothing_raised do
+          Column.new({:width => 3.5})
+        end
+      end
+
+      should "nil out height values that are < 0" do
+        assert_equal nil, Column.new({:width => -1.2}).width
+        assert_equal nil, Column.new({:width => -1}).width
+        assert_equal 0, Column.new({:width => 0}).width
+        assert_equal 1.2, Column.new({:width => 1.2}).width
+      end
+
+      context "for generating XML" do
+        should_have_reader :xml
+        should_build_node
+      end
+
+    end
+
+  end
+end