osheet 1.0.0.rc.1 → 1.0.0.rc.2

data/examples/trivial.xls

@@ -1,18 +0,0 @@
-<?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_writer/style_cache.rb

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

@@ -1,148 +0,0 @@
-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,143 +0,0 @@
-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/test/xmlss_writer/api_test.rb

@@ -1,139 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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