osheet 0.10.0 → 1.0.0.rc.1

data/lib/osheet/xmlss_writer/style_settings.rb

@@ -0,0 +1,148 @@
+require 'osheet/style'
+require 'osheet/xmlss_writer'
+
+class Osheet::XmlssWriter
+  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_writer.rb

@@ -1 +1,143 @@
-require 'osheet/xmlss_writer/base'
+require 'osheet'
+require 'xmlss'
+
+require 'osheet/xmlss_writer/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 = 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)
+      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/lib/osheet.rb

@@ -1,31 +1,5 @@
-module Osheet
-
-  MIME_TYPE = "application/vnd.ms-excel"
-
-  class << self
-    # used to register an appropriate view handler
-    # and register a mime type if necessary
-    def register
-      ::Mime::Type.register MIME_TYPE, :xls if defined? ::Mime::Type
-      require 'osheet/view_handler'
-    end
-  end
-
-end
-
-require 'osheet/instance'
-require 'osheet/partial'
-require 'osheet/associations'
-require 'osheet/mixin'
-
-require 'osheet/markup_element'
-require 'osheet/styled_element'
-require 'osheet/meta_element'
-require 'osheet/workbook_element'
-require 'osheet/worksheet_element'
-
-if defined? Rails::Railtie
-  require 'osheet/railtie'
-end
+module Osheet; end
 
 require 'osheet/workbook'
+require 'osheet/xmlss_writer'
+

data/osheet.gemspec

@@ -19,7 +19,10 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency("bundler", ["~> 1.0"])
   s.add_development_dependency("assert", ["~> 0.3"])
+  s.add_development_dependency("whysoslow", ["~> 0.0"])
+  s.add_development_dependency("ruby-prof")
+
   s.add_dependency("enumeration", ["~> 1.3"])
-  s.add_dependency("xmlss", ["~> 0.4"])
+  s.add_dependency("xmlss", ["~> 1.0.0.rc"])
 
 end

data/test/cell_test.rb

@@ -3,133 +3,68 @@ require 'osheet/cell'
 
 module Osheet
 
-  class CellTest < Assert::Context
-    desc "Osheet::Cell"
+  class CellTests < Assert::Context
+    desc "a Cell"
     before { @c = Cell.new }
     subject { @c }
 
-    should_be_a_styled_element(Cell)
-    should_be_a_worksheet_element(Cell)
-    should_be_a_workbook_element(Cell)
+    should be_a_styled_element
+    should be_a_meta_element
 
-    should have_instance_methods :data, :format, :colspan, :rowspan, :href, :index
+    should have_instance_methods :data, :format, :href, :index
+    should have_instance_methods :colspan, :rowspan
 
     should "set it's defaults" do
-      assert_equal nil, subject.send(:get_ivar, "data")
-      assert_kind_of Format::General, subject.send(:get_ivar, "format")
-      assert_equal 1,   subject.send(:get_ivar, "colspan")
-      assert_equal 1,   subject.send(:get_ivar, "rowspan")
-      assert_equal nil,   subject.send(:get_ivar, "href")
-      assert_equal nil,   subject.send(:get_ivar, "index")
-      assert_equal nil,   subject.send(:get_ivar, "formula")
+      assert_equal nil, subject.data
+      assert_equal 1,   subject.colspan
+      assert_equal 1,   subject.rowspan
+      assert_equal nil, subject.href
+      assert_equal nil, subject.index
+      assert_equal nil, subject.formula
+      assert_kind_of Format::General, subject.format
+    end
+
+    should "set its data from an init arg" do
+      assert_equal "something", Cell.new("something").data
     end
 
     should "type cast data strings/symbols" do
       ['a string', :symbol].each do |thing|
-        cell = Cell.new{data thing}
-        assert_kind_of ::String, cell.send(:get_ivar, "data")
+        subject.data thing
+        assert_kind_of ::String, subject.data
+        assert_kind_of ::String, Cell.new(thing).data
       end
     end
 
     should "type cast data dates" do
-      cell = Cell.new{data Date.today}
-      assert_kind_of ::Date, cell.send(:get_ivar, "data")
+      subject.data Date.today
+      assert_kind_of ::Date, subject.data
+      assert_kind_of ::Date, Cell.new(Date.today).data
     end
 
     should "type cast data numerics" do
       [1, 1.0].each do |thing|
-        cell = Cell.new{data thing}
-        assert_kind_of ::Numeric, cell.send(:get_ivar, "data")
+        subject.data thing
+        assert_kind_of ::Numeric, subject.data
+        assert_kind_of ::Numeric, Cell.new(thing).data
       end
     end
 
     should "type cast all other data to string" do
       [Osheet, [:a, 'Aye'], {:a => 'Aye'}].each do |thing|
-        cell = Cell.new{data thing}
-        assert_kind_of ::String, cell.send(:get_ivar, "data")
-      end
-    end
-
-  end
-
-  class CellAttributeTest < CellTest
-    desc "a celll that has attributes"
-    before do
-      @c = Cell.new do
-        style_class 'more poo'
-        data    "Poo"
-        format  :number
-        colspan 4
-        rowspan 2
-        index 3
-        formula "=R1C1"
-        href "http://www.google.com"
-      end
-    end
-
-    should "should set them correctly" do
-      assert_equal "Poo", subject.send(:get_ivar, "data")
-      assert_kind_of Format::Number, subject.send(:get_ivar, "format")
-      assert_equal 4,       subject.send(:get_ivar, "colspan")
-      assert_equal 2,       subject.send(:get_ivar, "rowspan")
-      assert_equal 3,       subject.send(:get_ivar, "index")
-      assert_equal "=R1C1", subject.send(:get_ivar, "formula")
-      assert_equal "http://www.google.com", subject.send(:get_ivar, "href")
-    end
-
-    should "know it's attribute(s)" do
-      [:style_class, :data, :format, :rowspan, :colspan, :index, :href].each do |a|
-        assert subject.attributes.has_key?(a)
+        subject.data thing
+        assert_kind_of ::String, subject.data
+        assert_kind_of ::String, Cell.new(thing).data
       end
-
-      assert_equal "more poo", subject.attributes[:style_class]
-      assert_equal "Poo", subject.attributes[:data]
-      assert_kind_of Format::Number, subject.attributes[:format]
-      assert_equal 4, subject.attributes[:colspan]
-      assert_equal 2, subject.attributes[:rowspan]
-      assert_equal 3, subject.attributes[:index]
-      assert_equal "=R1C1", subject.attributes[:formula]
-      assert_equal "http://www.google.com", subject.attributes[:href]
     end
 
-  end
-
-  class CellPartialTest < Assert::Context
-    desc "A workbook that defines column partials"
-    before do
-      @wkbk = Workbook.new {
-        partial(:cell_stuff) {
-          style_class 'more poo'
-          data "Poo"
-        }
-
-        worksheet { row { cell {
-          add :cell_stuff
-        } } }
-      }
-    end
-    subject { @wkbk }
+    should "format data explicitly" do
+      subject.data Time.now
+      subject.format :datetime, 'mm/dd/yyyy'
 
-    should "add it's partials to it's markup" do
-      assert_equal 'more poo', subject.worksheets.first.rows.first.cells.first.attributes[:style_class]
-      assert_equal 'Poo', subject.worksheets.first.rows.first.cells.first.attributes[:data]
+      assert_kind_of Format::Datetime, subject.format
     end
 
   end
 
-  class CellBindingTest < Assert::Context
-    desc "a cell defined w/ a block"
-
-    should "access instance vars from that block's binding" do
-      @test = 'test'
-      @cell = Cell.new { data @test}
-
-      assert !@cell.send(:instance_variable_get, "@test").nil?
-      assert_equal @test, @cell.send(:instance_variable_get, "@test")
-      assert_equal @test.object_id, @cell.send(:instance_variable_get, "@test").object_id
-      assert_equal @test, @cell.attributes[:data]
-      assert_equal @test.object_id, @cell.attributes[:data].object_id
-    end
-  end
-
 end

data/test/column_test.rb

@@ -1,119 +1,51 @@
 require "assert"
+
 require "osheet/column"
 
 module Osheet
 
-  class ColumnTest < Assert::Context
-    desc "Osheet::Column"
+  class ColumnTests < Assert::Context
+    desc "a Column"
     before { @c = Column.new }
     subject { @c }
 
-    should_be_a_styled_element(Column)
-    should_be_a_worksheet_element(Column)
-    should_be_a_workbook_element(Column)
+    should be_a_styled_element
+    should be_a_meta_element
 
-    should have_instance_method :width
+    should have_reader :format
+    should have_instance_methods :width
     should have_instance_methods :autofit, :autofit?
     should have_instance_methods :hidden, :hidden?
-    should have_instance_method :meta
 
     should "set it's defaults" do
-      assert_equal nil, subject.send(:get_ivar, "width")
-      assert_equal false, subject.send(:get_ivar, "autofit")
+      assert_equal nil, subject.width
+      assert_equal false, subject.autofit
       assert !subject.autofit?
-      assert_equal false, subject.send(:get_ivar, "hidden")
+      assert_equal false, subject.hidden
       assert !subject.hidden?
-
-      assert_equal nil, subject.meta
+      assert_kind_of Format::General, subject.format
     end
 
     should "set it's width" do
       subject.width(false)
       assert_equal false, subject.width
+
       subject.width(180)
       assert_equal 180, subject.width
+
       subject.width(nil)
       assert_equal 180, subject.width
-    end
 
-    should "cast autofit and hidden to bool" do
-      col = Column.new { autofit :true; hidden 'false'}
-      assert_kind_of ::TrueClass, col.send(:get_ivar, "autofit")
-      assert_kind_of ::TrueClass, col.send(:get_ivar, "hidden")
+      assert_equal 200, Column.new(200).width
     end
 
-  end
-
-  class ColumnAttributesTest < ColumnTest
-    desc "that has attributes"
-    before do
-      @c = Column.new do
-        style_class "more poo"
-        width  100
-        autofit true
-        hidden true
-        meta(
-          {}
-        )
-      end
-    end
-
-    should "should set them correctly" do
-      assert_equal 100, subject.send(:get_ivar, "width")
-      assert_equal true, subject.send(:get_ivar, "autofit")
-      assert subject.autofit?
-      assert_equal true, subject.send(:get_ivar, "hidden")
-      assert subject.hidden?
-      assert_equal({}, subject.meta)
-    end
-
-    should "know it's attribute(s)" do
-      [:style_class, :width, :autofit, :hidden].each do |a|
-        assert subject.attributes.has_key?(a)
-      end
-      assert_equal 'more poo', subject.attributes[:style_class]
-      assert_equal 100, subject.attributes[:width]
-      assert_equal true, subject.attributes[:autofit]
-      assert_equal true, subject.attributes[:hidden]
-    end
-
-  end
-
-  class ColumnPartialTest < Assert::Context
-    desc "A workbook that defines column partials"
-    before do
-      @wkbk = Workbook.new {
-        partial(:column_stuff) {
-          width 200
-          meta(:label => 'awesome')
-        }
-
-        worksheet { column {
-          add :column_stuff
-        } }
-      }
-    end
-    subject { @wkbk }
-
-    should "add it's partials to it's markup" do
-      assert_equal 200, subject.worksheets.first.columns.first.width
-      assert_equal({:label => 'awesome'}, subject.worksheets.first.columns.first.meta)
-    end
-
-  end
-
-  class ColumnBindingTest < Assert::Context
-    desc "a column defined w/ a block"
-
-    should "access instance vars from that block's binding" do
-      @test = 50
-      @col = Column.new { width @test }
+    should "cast autofit and hidden to bool" do
+      col = Column.new
+      col.autofit :true
+      col.hidden 'false'
 
-      assert !@col.send(:instance_variable_get, "@test").nil?
-      assert_equal @test, @col.send(:instance_variable_get, "@test")
-      assert_equal @test.object_id, @col.send(:instance_variable_get, "@test").object_id
-      assert_equal @test, @col.attributes[:width]
-      assert_equal @test.object_id, @col.attributes[:width].object_id
+      assert_equal true, col.autofit
+      assert_equal true, col.hidden
     end
 
   end

data/test/{mixins.rb → fixtures/mixins.rb}

@@ -9,7 +9,9 @@ class StyledMixin
   include Osheet::Mixin
 
   style('.test')
-  style('.test.awesome')
+  style('.test.awesome') {
+    align :left
+  }
 
 end
 
@@ -39,10 +41,10 @@ class PartialedMixin
     row { }
   }
 
-  partial(:two_cells_in_a_row) {
+  partial(:two_cells_in_a_row) { |data_one, data_two|
     row {
-      cell { data "one" }
-      cell { data "two" }
+      cell { data data_one.to_s }
+      cell { data data_two.to_s }
     }
   }
 end