osheet-xmlss 1.0.0.rc.1

data/examples/trivial.xls

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet" xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
+  <Styles>
+    <Style ss:ID="..currency_dollar_2_comma_black">
+      <NumberFormat ss:Format="&quot;$&quot;#,##0.00" />
+    </Style>
+  </Styles>
+  <Worksheet ss:Name="one dollar">
+    <Table>
+      <Column />
+      <Row>
+        <Cell ss:StyleID="..currency_dollar_2_comma_black">
+          <Data ss:Type="Number">1</Data>
+        </Cell>
+      </Row>
+    </Table>
+  </Worksheet>
+</Workbook>

data/lib/osheet/xmlss/style_cache.rb

@@ -0,0 +1,63 @@
+require 'osheet/style'
+require 'osheet/xmlss/style_settings'
+
+module Osheet::Xmlss
+  class StyleCache
+
+    attr_reader :styles
+
+    def initialize(osheet_workbook, xmlss_workbook)
+      @osheet_workbook = osheet_workbook
+      @xmlss_workbook  = xmlss_workbook
+      @styles = {}
+    end
+
+    def [](key); @styles[key];      end
+    def empty?;  @styles.empty?;    end
+    def size;    @styles.keys.size; end
+
+    def keys
+      @styles.keys
+    end
+
+    def get(style_class, format)
+      # generate the style key and get the get the cached style or
+      # build and cache and return a style for the key
+      return nil if (key = self.key(style_class, format.key)).empty?
+      @styles[key] ||
+      build_and_cache(key, @osheet_workbook.styles.for(style_class), format)
+    end
+
+    # build a unique key for styling based off the style and format keys
+    def key(class_value, format_key)
+      (class_value || '').strip.split(/\s+/).collect do |c|
+        ".#{c}"
+      end.join('') + (format_key.nil? || format_key.empty? ? '' : "..#{format_key}")
+    end
+
+    protected
+
+    # build and cache an xmlss style
+    def build_and_cache(key, styles, format)
+      settings = StyleSettings.new(styles)
+      @styles[key] = @xmlss_workbook.style(key) {
+        settings.setting(:align) { @xmlss_workbook.alignment(settings[:align]) }
+        settings.setting(:font) { @xmlss_workbook.font(settings[:font]) }
+        settings.setting(:bg) { @xmlss_workbook.interior(settings[:bg]) }
+
+        border_set = ::Osheet::Style::BORDERS.inject([]) do |set, bp|
+          settings.setting(bp) { set << settings[bp] }
+          set
+        end
+        if !border_set.empty?
+          @xmlss_workbook.borders {
+            border_set.each { |setting| @xmlss_workbook.border(setting) }
+          }
+        end
+
+        @xmlss_workbook.number_format(format.style)
+      }
+    end
+
+  end
+end

data/lib/osheet/xmlss/style_settings.rb

@@ -0,0 +1,148 @@
+require 'osheet/style'
+require 'osheet/xmlss_writer'
+
+module Osheet::Xmlss
+  class StyleSettings
+
+    attr_reader :styles, :value
+
+    def initialize(styles)
+      @styles = styles
+      @value = @styles.inject({}) do |value, style|
+        merged_settings(value, style_settings(style))
+      end
+    end
+
+    def [](setting); @value[setting]; end
+
+    # call the given block passing it the setting if that setting
+    # exists and is not empty
+    def setting(s, &block)
+      block.call if self.value[s] && !self.value[s].empty?
+    end
+
+    protected
+
+    def merged_settings(current, add)
+      # concat values for keys in both sets
+      current.keys.each do |k|
+        current[k].merge!(add.delete(k) || {})
+      end
+      # merge keys for anything not in the current
+      current.merge(add)
+    end
+
+    def style_settings(osheet_style_obj)
+      settings = {}
+      Osheet::Style::SETTINGS.each do |setting|
+        if !(v = osheet_style_obj.send(setting)).empty?
+          settings[setting] = self.send("#{setting}_settings", v)
+        end
+      end
+      settings
+    end
+
+    def align_settings(osheet_align_directives)
+      osheet_align_directives.inject({}) do |settings, directive|
+        case directive
+        when :left, :center, :right
+          settings[:horizontal] = directive
+        when :top, :bottom
+          settings[:vertical] = directive
+        when :middle
+          settings[:vertical] = :center
+        when :wrap
+          settings[:wrap_text] = true
+        when ::Fixnum
+          settings[:rotate] = directive
+        end
+        settings
+      end
+    end
+
+    def font_settings(osheet_font_directives)
+      osheet_font_directives.inject({}) do |settings, directive|
+        case directive
+        when ::Fixnum
+          settings[:size] = directive
+        when ::String
+          if directive =~ /^#/
+            settings[:color] = directive
+          else
+            settings[:name] = directive
+          end
+        when :bold, :italic, :shadow
+          settings[directive] = true
+        when :subscript, :superscript
+          settings[:alignment] = directive
+        when :strikethrough
+          settings[:strike_through] = true
+        when :underline
+          settings[:underline] = :single
+        when :double_underline
+          settings[:underline] = :double
+        when :accounting_underline
+          settings[:underline] = :single_accounting
+        when :double_accounting_underline
+          settings[:underline] = :double_accounting
+        end
+        settings
+      end
+    end
+
+    def bg_settings(osheet_bg_directives)
+      osheet_bg_directives.inject({}) do |settings, directive|
+        case directive
+        when ::String
+          if directive =~ /^#/
+            settings[:color] = directive
+          end
+        when ::Symbol
+          if ::Xmlss::Style::Interior.pattern_set.include?(directive)
+            settings[:pattern] = directive
+          end
+        when ::Hash
+          directive.each do |pattern, color|
+            if ::Xmlss::Style::Interior.pattern_set.include?(pattern) && color =~ /^#/
+              settings[:pattern] = pattern
+              settings[:pattern_color] = color
+            end
+          end
+        end
+
+        if !settings[:color].nil? && settings[:pattern].nil?
+          settings[:pattern] = :solid
+        end
+
+        settings
+      end
+    end
+
+    def border_settings(osheet_border_directives)
+      osheet_border_directives.inject({}) do |settings, directive|
+        case directive
+        when ::String
+          if directive =~ /^#/
+            settings[:color] = directive
+          end
+        when ::Symbol
+          if ::Xmlss::Style::Border.position_set.include?(directive)
+            settings[:position] = directive
+          elsif ::Xmlss::Style::Border.weight_set.include?(directive)
+            settings[:weight] = directive
+          elsif ::Xmlss::Style::Border.line_style_set.include?(directive)
+            settings[:line_style] = directive
+          end
+        end
+        settings
+      end
+    end
+
+    ::Osheet::Style::BORDER_POSITIONS.each do |p|
+      define_method("border_#{p}_settings") do |cmds|
+        border_settings(cmds+[p])
+      end
+    end
+
+  end
+end

data/lib/osheet/xmlss/version.rb

@@ -0,0 +1,4 @@
+module Osheet;end
+module Osheet::Xmlss
+  VERSION = "1.0.0.rc.1"
+end

data/lib/osheet/xmlss.rb

@@ -0,0 +1,7 @@
+require 'osheet'
+require 'xmlss'
+require 'osheet/xmlss_writer'
+
+module Osheet; end
+module Osheet::Xmlss; end
+

data/lib/osheet/xmlss_writer.rb

@@ -0,0 +1,143 @@
+require 'osheet'
+require 'xmlss'
+
+require 'osheet/xmlss/style_cache'
+
+module Osheet
+  class XmlssWriter
+
+    # The Osheet::XmlssWriter provides the logic/translation needed to drive
+    # an xmlss workbook using the Osheet API.  The writer creates an xmlss
+    # workbook and uses the builder approach to drive the workbook creation.
+
+    # The writer maintains a set of used xmlss styles and handles creating
+    # xmlss style objects as needed and manages style keys
+
+    attr_reader :style_cache, :xmlss_workbook
+
+    def initialize(*args, &block)
+      @xmlss_workbook = ::Xmlss::Workbook.new(::Xmlss::Writer.new(*args, &block))
+      @osheet_workbook = nil
+      @osheet_worksheet_names = []
+      @style_cache = nil
+    end
+
+    def bind(osheet_workbook)
+      @osheet_workbook = osheet_workbook
+      @style_cache = Osheet::Xmlss::StyleCache.new(@osheet_workbook, @xmlss_workbook)
+    end
+
+    def to_s
+      @xmlss_workbook.to_s
+    end
+    alias_method :to_data, :to_s
+
+    def to_file(file_path)
+      @xmlss_workbook.to_file(file_path)
+    end
+
+    # Element writers
+
+    def worksheet(worksheet, &build)
+      if @osheet_workbook && @osheet_worksheet_names.include?(worksheet.name.to_s)
+        raise ArgumentError, "you can't write two worksheets with the same name ('#{worksheet.name}')"
+      end
+      @osheet_worksheet_names << worksheet.name.to_s
+      @xmlss_workbook.worksheet(worksheet.name, &build)
+    end
+
+    def column(column, &build)
+      attrs = {
+        :width => column.width,
+        :auto_fit_width => column.autofit,
+        :hidden => column.hidden
+      }
+      if s = @style_cache.get(column.style_class, column.format)
+        attrs[:style_id] = s.id
+      end
+      @xmlss_workbook.column(attrs, &build)
+    end
+
+    def row(row, &build)
+      attrs = {
+        :height => row.height,
+        :auto_fit_height => row.autofit,
+        :hidden => row.hidden
+      }
+      if s = @style_cache.get(row.style_class, row.format)
+        attrs[:style_id] = s.id
+      end
+      @xmlss_workbook.row(attrs, &build)
+    end
+
+    def cell(cell, &build)
+      attrs = {
+        :href => cell.href,
+        :index => cell.index,
+        :merge_across => cell_merge(cell.colspan),
+        :merge_down => cell_merge(cell.rowspan),
+        :formula => cell.formula
+      }
+      if s = @style_cache.get(cell.style_class, cell.format)
+        attrs[:style_id] = s.id
+      end
+      @xmlss_workbook.cell(cell.data, attrs, &build)
+    end
+
+    # Element style writers
+
+    # given an elements style_class or format attributes:
+    # 1) write a new xmlss style object and
+    # 2) set the current element's style_id attribute
+
+    def style(style_class, format=nil)
+      @style_cache.get(
+        style_class,
+        format || Osheet::Format.new(:general)
+      ).tap do |xmlss_style|
+        @xmlss_workbook.style_id(xmlss_style.id) if xmlss_style
+      end
+    end
+
+    def colspan(count)
+      @xmlss_workbook.merge_across(cell_merge(count))
+    end
+
+    def rowspan(count)
+      @xmlss_workbook.merge_down(cell_merge(count))
+    end
+
+    def name(value)
+      @osheet_worksheet_names.pop
+      @osheet_worksheet_names << value
+      @xmlss_workbook.name(value)
+    end
+
+    # Element attribute writers
+
+    [ :width,       # column
+      :height,      # row
+      :autofit,     # column, row
+      :autofit?,    # column, row
+      :hidden,      # column, row
+      :hidden?,     # column, row
+      :data,        # cell
+      :format,      # cell
+      :href,        # cell
+      :formula,     # cell
+      :index        # cell
+    ].each do |meth|
+      define_method(meth) do |*args, &block|
+        @xmlss_workbook.send(meth, *args, &block)
+      end
+    end
+
+    protected
+
+    # convert osheet col/row span value to xmlss merge value
+    def cell_merge(span)
+      span.kind_of?(::Fixnum) && span > 1 ? span-1 : 0
+    end
+
+  end
+end

data/osheet-xmlss.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/osheet/xmlss/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "osheet-xmlss"
+  gem.version     = Osheet::Xmlss::VERSION
+  gem.description = %q{An Osheet writer (https://github.com/kellyredding/osheet) for the XMLSS format (https://github.com/kellyredding/xmlss)}
+  gem.summary     = %q{An Osheet writer (https://github.com/kellyredding/osheet) for the XMLSS format (https://github.com/kellyredding/xmlss)}
+
+  gem.authors     = ["Kelly Redding"]
+  gem.email       = ["kelly@kellyredding.com"]
+  gem.homepage    = "http://github.com/kellyredding/osheet-xmlss"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert")
+
+  gem.add_dependency("osheet", ["~> 1.0.0.rc.2"])
+  gem.add_dependency("xmlss",  ["~> 1.0.0.rc"])
+
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+class Assert::Context
+
+  def xmlss_style_markup(writer)
+    Xmlss::Workbook.writer(writer.xmlss_workbook).styles_markup.flush.to_s
+  end
+
+  def xmlss_element_markup(writer)
+    Xmlss::Workbook.writer(writer.xmlss_workbook).worksheets_markup.flush.to_s
+  end
+
+end

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'osheet/xmlss'

data/test/xmlss/api_test.rb

@@ -0,0 +1,139 @@
+require "assert"
+
+require 'osheet/xmlss_writer'
+
+module Osheet::Xmlss
+
+  class ApiTests < Assert::Context
+    before do
+      @writer = Osheet::XmlssWriter.new
+      @workbook = Osheet::Workbook.new(@writer)
+    end
+    subject { @writer }
+
+  end
+
+  class CellTests < ApiTests
+    desc "when writing a cell"
+    before do
+      @cell = Osheet::Cell.new(100)
+      @cell.style_class "awesome thing"
+      @cell.format  :number
+      @cell.href    'http://example.com'
+      @cell.rowspan 2
+      @cell.colspan 5
+      @cell.index   3
+      @cell.formula "=R1C1"
+      @xmlss_cell = subject.cell(@cell)
+    end
+
+    should "create an Xmlss::Cell with correct attributes" do
+      assert_kind_of ::Xmlss::Element::Cell, @xmlss_cell
+      assert_equal 100, @xmlss_cell.data
+      assert_equal 'http://example.com', @xmlss_cell.href
+      assert_equal 3, @xmlss_cell.index
+      assert_equal "=R1C1", @xmlss_cell.formula
+      assert_equal 1, @xmlss_cell.merge_down
+      assert_equal 4, @xmlss_cell.merge_across
+    end
+
+    should "style the cell" do
+      assert_equal ".awesome.thing..number_none_0_nocomma_black", @xmlss_cell.style_id
+      assert_equal 1, subject.style_cache.size
+    end
+
+    should "write cell element markup" do
+      assert_equal(
+        "<Cell ss:Formula=\"=R1C1\" ss:HRef=\"http://example.com\" ss:Index=\"3\" ss:MergeAcross=\"4\" ss:MergeDown=\"1\" ss:StyleID=\".awesome.thing..number_none_0_nocomma_black\"><Data ss:Type=\"Number\">100</Data></Cell>",
+        xmlss_element_markup(subject)
+      )
+    end
+
+  end
+
+  class RowTests < ApiTests
+    desc "when writing a row"
+    before do
+      @row = Osheet::Row.new
+      @row.style_class "awesome thing"
+      @row.height  100
+      @row.autofit true
+      @row.hidden  true
+      @xmlss_row = subject.row(@row)
+    end
+
+    should "create an Xmlss::Row with correct attributes" do
+      assert_kind_of ::Xmlss::Element::Row, @xmlss_row
+      assert_equal 100,  @xmlss_row.height
+      assert_equal true, @xmlss_row.auto_fit_height
+      assert_equal true, @xmlss_row.hidden
+    end
+
+    should "style the row" do
+      assert_equal ".awesome.thing", @xmlss_row.style_id
+      assert_equal 1, subject.style_cache.size
+    end
+
+    should "write row element markup" do
+      assert_equal(
+        "<Row ss:AutoFitHeight=\"1\" ss:Height=\"100\" ss:Hidden=\"1\" ss:StyleID=\".awesome.thing\" />",
+        xmlss_element_markup(subject)
+      )
+    end
+
+  end
+
+  class ColumnTests < ApiTests
+    desc "when writing a column"
+    before do
+      @column = Osheet::Column.new
+      @column.style_class "awesome"
+      @column.width   100
+      @column.autofit true
+      @column.hidden  true
+      @xmlss_column = subject.column(@column)
+    end
+
+    should "create an Xmlss::Column with correct attributes" do
+      assert_kind_of ::Xmlss::Element::Column, @xmlss_column
+      assert_equal 100,  @xmlss_column.width
+      assert_equal true, @xmlss_column.auto_fit_width
+      assert_equal true, @xmlss_column.hidden
+    end
+
+    should "style an Xmlss column" do
+      assert_equal ".awesome", @xmlss_column.style_id
+      assert_equal 1, subject.style_cache.size
+    end
+
+    should "write column element markup" do
+      assert_equal(
+        "<Column ss:AutoFitWidth=\"1\" ss:Hidden=\"1\" ss:StyleID=\".awesome\" ss:Width=\"100\" />",
+        xmlss_element_markup(subject)
+      )
+    end
+
+  end
+
+  class WorksheetTests < ApiTests
+    desc "when writing a worksheet"
+    before do
+      @worksheet = Osheet::Worksheet.new("testsheet2")
+      @xmlss_worksheet = subject.worksheet(@worksheet)
+    end
+
+    should "create an Xmlss::Worksheet with correct attributes" do
+      assert_kind_of ::Xmlss::Element::Worksheet, @xmlss_worksheet
+      assert_equal "testsheet2", @xmlss_worksheet.name
+    end
+
+    should "write worksheet element markup" do
+      assert_equal(
+        "<Worksheet ss:Name=\"testsheet2\"><Table /></Worksheet>",
+        xmlss_element_markup(subject)
+      )
+    end
+
+  end
+
+end

data/test/xmlss/style_cache_test.rb

@@ -0,0 +1,65 @@
+require "assert"
+
+require 'osheet/xmlss/style_cache'
+
+module Osheet::Xmlss
+
+  class StyleCacheTests < Assert::Context
+    desc "the style cache"
+    before do
+      @workbook = Osheet::Workbook.new
+      @workbook.style('.align.center') { @workbook.align  :center }
+      @workbook.style('.font.size')    { @workbook.font   14      }
+      @workbook.style('.font.weight')  { @workbook.font   :bold   }
+      @workbook.style('.font.style')   { @workbook.font   :italic }
+      @workbook.style('.bg.color')     { @workbook.bg     '#FF0000' }
+      @workbook.style('.border.color') { @workbook.border '#FF0000', :thin }
+      @xmlss_workbook = ::Xmlss::Workbook.new(Xmlss::Writer.new)
+
+      @cache = StyleCache.new(@workbook, @xmlss_workbook)
+    end
+    subject { @cache }
+
+    should have_reader :styles
+    should have_instance_method :get, :keys, :empty?, :size, :[]
+
+    should "have no cached styles by default" do
+      assert_empty subject
+    end
+
+    should "key based off class value and format key" do
+      assert_equal '',                    subject.send(:key, '', nil)
+      assert_equal '.awesome',            subject.send(:key, 'awesome', nil)
+      assert_equal '.awesome.thing',      subject.send(:key, 'awesome thing', nil)
+      assert_equal '.awesome..something', subject.send(:key, 'awesome', 'something')
+      assert_equal '..something',         subject.send(:key, '', 'something')
+    end
+
+    should "return nil if trying to get the style for an empty class and general format" do
+      assert_not_nil subject.get('font', Osheet::Format.new(:general))
+      assert_nil     subject.get('',     Osheet::Format.new(:general))
+    end
+
+    should "build and cache styles if not already cached" do
+      assert_equal 0, subject.size
+      subject.get('font', Osheet::Format.new(:currency))
+      assert_equal 1, subject.size
+    end
+
+    should "return cached style if requesting an already cached style" do
+      assert_equal 0, subject.size
+      subject.get('font', Osheet::Format.new(:currency))
+      subject.get('font', Osheet::Format.new(:currency))
+      assert_equal 1, subject.size
+    end
+
+    should "build styles with ids matching the cache key" do
+      key = subject.key('font', Osheet::Format.new(:currency).key)
+      assert_equal key, subject.get('font', Osheet::Format.new(:currency)).id
+    end
+
+  end
+
+
+
+end