osheet 0.10.0 → 1.0.0.rc.1

data/test/worksheet_test.rb

@@ -1,134 +1,87 @@
 require "assert"
+
+require 'osheet/column'
+require 'osheet/row'
 require 'osheet/worksheet'
 
 module Osheet
 
-  class WorksheetTest < Assert::Context
-    desc "Osheet::Worksheet"
+  class WorksheetTests < Assert::Context
+    desc "a Worksheet"
     before { @wksht = Worksheet.new }
     subject { @wksht }
 
-    should_be_a_workbook_element(Worksheet)
+    should be_a_meta_element
 
-    should have_instance_methods :name, :attributes, :meta
+    should have_instance_methods :name
+    should have_instance_methods :columns, :column
+    should have_instance_methods :rows, :row
 
     should "set it's defaults" do
-      assert_equal nil, subject.send(:get_ivar, "name")
-      assert_equal [], subject.columns
-      assert_equal [], subject.rows
-
-      assert_equal nil, subject.meta
-    end
-
-    should_hm(Worksheet, :columns, Column)
-    should_hm(Worksheet, :rows, Row)
-
-    should "know it's attribute(s)" do
-      subject.send(:name, "Poo!")
-      [:name].each do |a|
-        assert subject.attributes.has_key?(a)
-      end
-      assert_equal "Poo!", subject.attributes[:name]
+      assert_equal nil, subject.name
+      assert_equal [],  subject.columns
+      assert_equal [],  subject.rows
     end
 
   end
 
-  class WorksheetNameMetaTest < WorksheetTest
-    desc "A named worksheet with meta"
-    before do
-      @wksht = Worksheet.new {
-        name "Poo!"
-        meta({})
-      }
-    end
-
-    should "know it's name and meta" do
-      assert_equal "Poo!", subject.send(:get_ivar, "name")
-      assert_equal({}, subject.meta)
-    end
-
-    should "set it's name" do
-      subject.name(false)
-      assert_equal 'false', subject.name
-      subject.name('la')
-      assert_equal 'la', subject.name
-      subject.name(nil)
-      assert_equal 'la', subject.name
-    end
+  class WorksheetColumnTests < WorksheetTests
+    desc "with columns"
+    before {
+      @col = Column.new
+      @wksht.column(@col)
+    }
 
-    should "complain if name is longer than 31 chars" do
-      assert_raises ArgumentError do
-        subject.name('a'*32)
-      end
-      assert_nothing_raised do
-        subject.name('a'*31)
-      end
+    should "know its cols" do
+      assert_equal 1, subject.columns.size
+      assert_same @col, subject.columns.first
     end
 
   end
 
-  class WorksheetColumnRowTest < WorksheetTest
-    desc "A worksheet that has columns and rows"
-    before do
-      @wksht = Worksheet.new {
-        column
-        row { cell {
-          format  :number
-          data    1
-        } }
-      }
-    end
+  class WorksheetRowTests < WorksheetTests
+    desc "with rows"
+    before {
+      @row = Row.new
+      @wksht.row(@row)
+    }
 
-    should "set it's columns" do
-      columns = subject.columns
-      assert_equal 1, columns.size
-      assert_kind_of Column, columns.first
-      assert_equal subject.columns, columns.first.columns
+    should "know its rows" do
+      assert_equal 1, subject.rows.size
+      assert_same @row, subject.rows.first
     end
 
-    should "set it's rows" do
-      rows = subject.rows
-      assert_equal 1, rows.size
-      assert_kind_of Row, rows.first
-      assert_equal subject.columns, rows.first.columns
-      assert_equal subject.columns, rows.first.cells.first.columns
+    should "only keep the latest row" do
+      new_row = Row.new(120)
+      subject.row(new_row)
+
+      assert_equal 1, subject.rows.size
+      assert_same new_row, subject.rows.last
     end
 
   end
 
-  class WorksheetWorkbookPartialTest < WorksheetTest
-    desc "A workbook that defines worksheet partials"
+  class WorksheetNameTests < WorksheetTests
+    desc "with a name"
     before do
-      @wksht = Workbook.new {
-        partial(:worksheet_stuff) {
-          row {}
-          row {}
-        }
-
-        worksheet {
-          add :worksheet_stuff
-        }
-      }
+      @wksht = Worksheet.new("fun")
     end
 
-    should "add it's partials to it's markup" do
-      assert_equal 2, subject.worksheets.first.rows.size
+    should "know it's name" do
+      assert_equal "fun", subject.name
     end
 
-  end
-
-  class WorksheetBindingTest < WorksheetTest
-    desc "a worksheet defined w/ a block"
-
-    should "access instance vars from that block's binding" do
-      @test = 'test'
-      @worksheet = Worksheet.new { name @test }
+    should "set it's name" do
+      subject.name(false)
+      assert_equal 'false', subject.name
+      subject.name('la')
+      assert_equal 'la', subject.name
+      subject.name(nil)
+      assert_equal 'la', subject.name
+    end
 
-      assert !@worksheet.send(:instance_variable_get, "@test").nil?
-      assert_equal @test, @worksheet.send(:instance_variable_get, "@test")
-      assert_equal @test.object_id, @worksheet.send(:instance_variable_get, "@test").object_id
-      assert_equal @test, @worksheet.attributes[:name]
-      assert_equal @test.object_id, @worksheet.attributes[:name].object_id
+    should "set it's name with an init parameter" do
+      assert_equal "more fun", Worksheet.new("more fun").name
     end
 
   end

data/test/xmlss_writer/api_test.rb

@@ -0,0 +1,139 @@
+require "assert"
+
+require 'osheet/xmlss_writer'
+
+module Osheet
+
+  class XmlssWriter::ApiTest < Assert::Context
+    before do
+      @writer = XmlssWriter.new
+      @workbook = Workbook.new(@writer)
+    end
+    subject { @writer }
+
+  end
+
+  class XmlssWriter::CellTests < XmlssWriter::ApiTest
+    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 XmlssWriter::RowTests < XmlssWriter::ApiTest
+    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 XmlssWriter::ColumnTests < XmlssWriter::ApiTest
+    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 XmlssWriter::WorksheetTests < XmlssWriter::ApiTest
+    desc "when writing a worksheet"
+    before do
+      @worksheet = 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_writer/style_cache_test.rb

@@ -0,0 +1,65 @@
+require "assert"
+
+require 'osheet/xmlss_writer/style_cache'
+
+module Osheet
+
+  class XmlssWriterStyleCacheTests < Assert::Context
+    desc "the style cache"
+    before do
+      @workbook = 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 = XmlssWriter::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.send(:key, 'font', Osheet::Format.new(:currency).key)
+      assert_equal key, subject.get('font', Osheet::Format.new(:currency)).id
+    end
+
+  end
+
+
+
+end

data/test/xmlss_writer/style_settings_test.rb

@@ -0,0 +1,263 @@
+require "assert"
+
+require 'osheet/xmlss_writer/style_settings'
+
+module Osheet
+
+  class XmlssWriterStyleSettingsTests < Assert::Context
+    desc "the style writer when building"
+    before do
+      @settings = XmlssWriter::StyleSettings.new([])
+      @workbook = 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 }
+    end
+    subject { @settings }
+
+    should have_reader :styles, :value
+    should have_instance_method :setting, :[]
+
+    should "be empty if no styles given" do
+      assert_equal({}, subject.value)
+    end
+
+    should "conditionally run a block if the setting exists and is not empty" do
+      settings = XmlssWriter::StyleSettings.new([@workbook.styles.first])
+      @something = ''
+
+      settings.setting(:font) { @something = 'i should be empty' }
+      assert_empty @something
+
+      settings.setting(:align) { @something = 'i should not be empty' }
+      assert_not_empty @something
+    end
+
+  end
+
+
+
+  class XmlssWriterAlignmentSettingsTests < XmlssWriterStyleSettingsTests
+    desc "align settings"
+
+    should "translate horizontal directives" do
+      assert_equal({:horizontal => :left},   subject.send(:align_settings, [:left]))
+      assert_equal({:horizontal => :center}, subject.send(:align_settings, [:center]))
+      assert_equal({:horizontal => :right},  subject.send(:align_settings, [:right]))
+    end
+
+    should "translate vertical directives" do
+      assert_equal({:vertical => :top},    subject.send(:align_settings, [:top]))
+      assert_equal({:vertical => :center}, subject.send(:align_settings, [:middle]))
+      assert_equal({:vertical => :bottom}, subject.send(:align_settings, [:bottom]))
+    end
+
+    should "translate wrap text and rotate directives" do
+      assert_equal({:wrap_text => true}, subject.send(:align_settings, [:wrap]))
+      assert_equal({:rotate => 90},       subject.send(:align_settings, [90]))
+    end
+
+  end
+
+
+
+  class XmlssWriterFontSettingsTests < XmlssWriterStyleSettingsTests
+    desc "font settings"
+
+    should "translate size, color and name directives" do
+      assert_equal({:size  => 12},   subject.send(:font_settings, [12]))
+      assert_equal({:color => '#FFFFFF'}, subject.send(:font_settings, ['#FFFFFF']))
+      assert_equal({:name  => 'Arial'},  subject.send(:font_settings, ['Arial']))
+    end
+
+    should "translate style directives" do
+      assert_equal({:bold   => true}, subject.send(:font_settings, [:bold]))
+      assert_equal({:italic => true}, subject.send(:font_settings, [:italic]))
+      assert_equal({:shadow => true}, subject.send(:font_settings, [:shadow]))
+      assert_equal({:alignment => :subscript},   subject.send(:font_settings, [:subscript]))
+      assert_equal({:alignment => :superscript}, subject.send(:font_settings, [:superscript]))
+      assert_equal({:strike_through => true}, subject.send(:font_settings, [:strikethrough]))
+    end
+
+    should "translate underline directives" do
+      assert_equal({:underline => :single}, subject.send(:font_settings, [:underline]))
+      assert_equal({:underline => :double}, subject.send(:font_settings, [:double_underline]))
+      assert_equal({:underline => :single_accounting}, subject.send(:font_settings, [:accounting_underline]))
+      assert_equal({:underline => :double_accounting}, subject.send(:font_settings, [:double_accounting_underline]))
+    end
+
+  end
+
+
+
+
+  class XmlssWriterBgSettingsTests < XmlssWriterStyleSettingsTests
+    desc "bg settings"
+
+    should "translate color directives" do
+      assert_equal({:color => '#FFFFFF', :pattern => :solid}, subject.send(:bg_settings, ['#FFFFFF']))
+    end
+
+    should "translate pattern directives" do
+      assert_equal({:pattern => :solid}, subject.send(:bg_settings, [:solid]))
+      assert_equal({
+        :pattern => :horz_stripe,
+        :pattern_color => '#0000FF'
+      }, subject.send(:bg_settings, [{:horz_stripe => '#0000FF'}]))
+    end
+
+  end
+
+
+
+
+
+  class XmlssWriterBorderSettingsTests < XmlssWriterStyleSettingsTests
+    desc "border settings"
+
+    should "translate color directives" do
+      assert_equal({:color => '#FFFFFF'}, subject.send(:border_settings, ['#FFFFFF']))
+    end
+
+    should "translate position directives" do
+      assert_equal({:position => :top}, subject.send(:border_settings, [:top]))
+    end
+
+    should "translate weight directives" do
+      assert_equal({:weight => :thick}, subject.send(:border_settings, [:thick]))
+    end
+
+    should "translate line_style directives" do
+      assert_equal({:line_style => :dot}, subject.send(:border_settings, [:dot]))
+    end
+
+    should "translate position specific directives" do
+      assert_equal({
+        :position => :left,
+        :color => '#FFFFFF',
+        :weight => :thin
+      }, subject.send(:border_left_settings, ['#FFFFFF', :thin]))
+    end
+
+  end
+
+
+
+  class XmlssWriterParseSettingsTests < XmlssWriterStyleSettingsTests
+    desc "settings"
+
+    should "parse Osheet style objs for their settings" do
+      assert_equal({
+        :align => {
+          :horizontal => :center
+        }
+      }, subject.send(:style_settings, @workbook.styles.first))
+
+      assert_equal({
+        :border_top => {
+          :position=>:top,
+          :color=>"#FF0000",
+          :weight=>:thin
+        },
+        :border_right => {
+          :position=>:right,
+          :color=>"#FF0000",
+          :weight=>:thin
+        },
+        :border_bottom => {
+          :position=>:bottom,
+          :color=>"#FF0000",
+          :weight=>:thin
+        },
+        :border_left => {
+          :position=>:left,
+          :color=>"#FF0000",
+          :weight=>:thin
+        }
+      }, subject.send(:style_settings, @workbook.styles.last))
+    end
+
+    should "merge style settings from multiple Osheet style objs" do
+      set1 = {
+        :font => {
+          :color => '#FF0000',
+          :name => "Arial"
+        }
+      }
+      set2 = {
+        :font => {
+          :color => '#0000FF',
+          :size => 12
+        }
+      }
+      set3 = {
+        :align => {
+          :horizontal => :center
+        }
+      }
+
+      # should concat keys in both sets
+      assert_equal({
+        :font => {
+          :color => '#0000FF',
+          :name => "Arial",
+          :size => 12
+        }
+      }, subject.send(:merged_settings, set1.dup, set2.dup))
+
+      # should add keys not in first set
+      assert_equal({
+        :font => {
+          :color => '#0000FF',
+          :size => 12
+        },
+        :align => {
+          :horizontal => :center
+        }
+      }, subject.send(:merged_settings, set2.dup, set3.dup))
+
+    end
+
+    should "set its value given its set of styles" do
+      assert_equal({
+        :align => {
+          :horizontal => :center
+        },
+        :font => {
+          :bold => true,
+          :italic => true,
+          :size => 14
+        },
+        :bg => {
+          :pattern => :solid,
+          :color => "#FF0000"
+        },
+        :border_top => {
+          :position => :top,
+          :color => "#FF0000",
+          :weight => :thin
+        },
+        :border_right => {
+          :position => :right,
+          :color => "#FF0000",
+          :weight => :thin
+        },
+        :border_bottom => {
+          :position => :bottom,
+          :color => "#FF0000",
+          :weight => :thin
+        },
+        :border_left => {
+          :position => :left,
+          :color => "#FF0000",
+          :weight => :thin
+        }
+      }, XmlssWriter::StyleSettings.new(@workbook.styles).value)
+    end
+  end
+
+end
+