osheet 0.10.0 → 1.0.0.rc.1

data/lib/osheet/xmlss_writer/elements.rb

@@ -1,56 +0,0 @@
-module Osheet::XmlssWriter::Elements
-
-  protected
-
-  def worksheet(xworkbook, oworksheet)
-    xworkbook.worksheet(oworksheet.attributes[:name]) do
-      oworksheet.columns.each { |ocolumn| column(xworkbook, ocolumn) }
-      oworksheet.rows.each { |orow| row(xworkbook, orow) }
-    end
-  end
-
-  def column(xworkbook, ocolumn)
-    xworkbook.column({
-      :style_id => style_id(xworkbook, ocolumn.attributes[:style_class]),
-      :width => ocolumn.attributes[:width],
-      :auto_fit_width => ocolumn.attributes[:autofit],
-      :hidden => ocolumn.attributes[:hidden]
-    })
-  end
-
-  def row(xworkbook, orow)
-    xworkbook.row({
-      :style_id => style_id(xworkbook, orow.attributes[:style_class]),
-      :height => orow.attributes[:height],
-      :auto_fit_height => orow.attributes[:autofit],
-      :hidden => orow.attributes[:hidden]
-    }) do
-      orow.cells.each { |ocell| cell(xworkbook, ocell) }
-    end
-  end
-
-  def cell(xworkbook, ocell)
-    xworkbook.cell({
-      :style_id => style_id(xworkbook, ocell.attributes[:style_class], ocell.attributes[:format]),
-      :href => ocell.attributes[:href],
-      :index => ocell.attributes[:index],
-      :merge_across => cell_merge(ocell.attributes[:colspan]),
-      :merge_down => cell_merge(ocell.attributes[:rowspan]),
-      :formula => ocell.attributes[:formula]
-    }) do
-      data(xworkbook, ocell.attributes[:data])
-    end
-  end
-
-  def data(xworkbook, odata)
-    xworkbook.data(odata)
-  end
-
-  private
-
-  # 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

data/lib/osheet/xmlss_writer/styles.rb

@@ -1,216 +0,0 @@
-require 'osheet/format'
-module Osheet::XmlssWriter::Styles
-
-  protected
-
-  def style_id(xworkbook, style_class, oformat=nil)
-    xstyle = style(xworkbook, style_class, oformat)
-    xstyle.nil? ? '' : xstyle.id
-  end
-
-  def style(xworkbook, style_class, oformat=nil)
-    oformat ||= Osheet::Format.new(:general)
-
-    # generate the style key for the given class/format
-    key = style_key(style_class, oformat.key)
-
-    # see if we have already created/used an xmlss style for the given key
-    xstyle = @used_xstyles.find{ |xs| xs.id == key }
-
-    # if not, create an xmlss style for the key and add it to the used cache
-    if !key.empty? && xstyle.nil?
-      xstyle = xmlss_style(xworkbook, key, oformat)
-      @used_xstyles << xstyle
-    end
-
-    xstyle
-  end
-
-  private
-
-  def style_key(style_class, format_key)
-    (style_class || '').strip.split(/\s+/).collect do |c|
-      ".#{c}"
-    end.join('') + (format_key.nil? || format_key.empty? ? '' : "..#{format_key}")
-  end
-
-  def xmlss_style(xworkbook, key, oformat)
-    # take all the matching osheet styles for the given key,
-    # and build up xmlss style settings for them
-    settings = style_settings(key)
-
-    xworkbook.style(key) do
-
-      if settings.has_key?(:align) && !settings[:align].empty?
-        xworkbook.alignment(settings[:align])
-      end
-
-      if settings.has_key?(:font) && !settings[:font].empty?
-        xworkbook.font(settings[:font])
-      end
-
-      if settings.has_key?(:bg) && !settings[:bg].empty?
-        xworkbook.interior(settings[:bg])
-      end
-
-      border_set = ::Osheet::Style::BORDERS.inject([]) do |set, bp|
-        if settings.has_key?(bp) && !settings[bp].empty?
-          set << settings[bp]
-        end
-        set
-      end
-      if !border_set.empty?
-        xworkbook.borders {
-          border_set.each { |border_setting| xworkbook.border(border_setting) }
-        }
-      end
-
-      if oformat
-        xworkbook.number_format(oformat.style)
-      end
-
-    end
-  end
-
-  # TODO: would be nice to have a class handle all of the osheet-xmlss style translations...
-
-  def style_settings(key)
-    @oworkbook.styles.for(key).inject({}) do |style_settings, ostyle|
-      merged_settings(style_settings, ostyle_settings(ostyle))
-    end
-  end
-
-  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 ostyle_settings(ostyle)
-    ostyle_settings = {}
-    ostyle.attributes.each do |k,v|
-      unless v.empty?
-        ostyle_settings[k] = send("#{k}_settings", v)
-      end
-    end
-    ostyle_settings
-  end
-
-  def align_settings(align_cmds)
-    align_cmds.inject({}) do |align_settings, align_cmd|
-      if (setting = case align_cmd
-        when :left, :center, :right
-          [:horizontal, align_cmd]
-        when :top, :bottom
-          [:vertical, align_cmd]
-        when :middle
-          [:vertical, :center]
-        when :wrap
-          [:wrap_text, true]
-        when ::Fixnum
-          [:rotate, align_cmd]
-        end
-      )
-        align_settings[setting.first] = setting.last
-      end
-      align_settings
-    end
-  end
-
-  def font_settings(font_cmds)
-    font_cmds.inject({}) do |font_settings, font_cmd|
-      if (setting = case font_cmd
-        when ::Fixnum
-          [:size, font_cmd]
-        when ::String
-          if font_cmd =~ /^#/
-            [:color, font_cmd]
-          else
-            [:name, font_cmd]
-          end
-        when :bold, :italic, :shadow
-          [font_cmd, true]
-        when :subscript, :superscript
-          [:alignment, font_cmd]
-        when :strikethrough
-          [:strike_through, true]
-        when :underline
-          [:underline, :single]
-        when :double_underline
-          [:underline, :double]
-        when :accounting_underline
-          [:underline, :single_accounting]
-        when :double_accounting_underline
-          [:underline, :double_accounting]
-        end
-      )
-        font_settings[setting.first] = setting.last
-      end
-      font_settings
-    end
-  end
-
-  def bg_settings(bg_cmds)
-    bg_cmds.inject({}) do |bg_settings, bg_cmd|
-      if (settings = case bg_cmd
-        when ::String
-          if bg_cmd =~ /^#/
-            [[:color, bg_cmd]]
-          end
-        when ::Symbol
-          if ::Xmlss::Style::Interior.pattern_set.include?(bg_cmd)
-            [[:pattern, bg_cmd]]
-          end
-        when ::Hash
-          bg_cmd.inject([]) do |set, kv|
-            if ::Xmlss::Style::Interior.pattern_set.include?(kv.first) && kv.last =~ /^#/
-              set << [:pattern, kv.first]
-              set << [:pattern_color, kv.last]
-            end
-            set
-          end
-        end
-      )
-        settings.each do |setting|
-          bg_settings[setting.first] = setting.last
-        end
-      end
-      if !bg_settings[:color].nil? && bg_settings[:pattern].nil?
-        bg_settings[:pattern] = :solid
-      end
-      bg_settings
-    end
-  end
-
-  def border_settings(border_cmds)
-    border_cmds.inject({}) do |border_settings, border_cmd|
-      if (setting = case border_cmd
-        when ::String
-          if border_cmd =~ /^#/
-            [:color, border_cmd]
-          end
-        when ::Symbol
-          if ::Xmlss::Style::Border.position_set.include?(border_cmd)
-            [:position, border_cmd]
-          elsif ::Xmlss::Style::Border.weight_set.include?(border_cmd)
-            [:weight, border_cmd]
-          elsif ::Xmlss::Style::Border.line_style_set.include?(border_cmd)
-            [:line_style, border_cmd]
-          end
-        end
-      )
-        border_settings[setting.first] = setting.last
-      end
-      border_settings
-    end
-  end
-  ::Osheet::Style::BORDER_POSITIONS.each do |p|
-    define_method("border_#{p}_settings") do |cmds|
-      border_settings(cmds+[p])
-    end
-  end
-
-end

data/test/osheet_test.rb

@@ -1,13 +0,0 @@
-require "assert"
-
-class OsheetTest < Assert::Context
-  desc "Osheet"
-  subject {::Osheet}
-
-  should have_instance_method :register
-
-  should "use provide a default mime type" do
-    assert_equal "application/vnd.ms-excel", Osheet::MIME_TYPE
-  end
-
-end

data/test/partial_set_test.rb

@@ -1,64 +0,0 @@
-require "assert"
-require "osheet/partial_set"
-
-module Osheet
-
-  class PartialSetTest < Assert::Context
-    desc "Osheet::PartialSet"
-    before { @ps = PartialSet.new }
-    subject { @ps }
-
-    should "be a Hash" do
-      assert_kind_of ::Hash, subject
-    end
-
-    should have_instance_method :<<
-    should have_reader :get
-
-    should "verify set objs are partials" do
-      assert_raises ArgumentError do
-        subject.send(:verify, {})
-      end
-      assert_nothing_raised do
-        subject.send(:verify, Partial.new(:poo) {})
-      end
-    end
-
-    should "key using name values" do
-      assert_equal 'poo', subject.send(:key, :poo)
-    end
-
-    should "key on partial objs" do
-      assert_equal 'poo', subject.send(:partial_key, Partial.new(:poo) {})
-    end
-
-    should "init the key in the set when verifying" do
-      key = subject.send(:verify, Partial.new(:thing) {})
-      assert_equal 'thing', key
-      assert_equal({'thing' => nil}, subject)
-    end
-
-    should "push partials onto the set" do
-      assert_nothing_raised do
-        subject << Partial.new(:poo) {}
-        subject << Partial.new(:not_poo) {}
-        subject << Partial.new(:awesome) {}
-        subject << Partial.new(:poo) {}
-      end
-
-      assert_equal 3, subject.keys.size
-      assert subject["poo"]
-      assert_kind_of Partial, subject["poo"]
-    end
-
-    should "lookup a partial by name" do
-      p = Partial.new(:poo) {}
-      subject << p
-      assert_equal p, subject.get(:poo)
-      assert_equal p, subject.get('poo')
-      assert_equal nil, subject.get(:ugh)
-    end
-
-  end
-
-end

data/test/style_set_test.rb

@@ -1,47 +0,0 @@
-require "assert"
-require "osheet/style_set"
-
-module Osheet
-  class StyleSetTest < Assert::Context
-    desc "Osheet::StyleSet"
-    before { @set = StyleSet.new }
-    subject { @set }
-
-    should "be an Array" do
-      assert_kind_of ::Array, subject
-    end
-
-    should have_reader :for
-
-    should "verify Template objs" do
-      assert_raises ArgumentError do
-        subject.send(:verify, {})
-      end
-      assert_nothing_raised do
-        subject.send(:verify, Style.new('.awesome') {})
-      end
-    end
-
-    should "be able to lookup styles by class" do
-      subject << (a = Style.new('.awesome') {})
-      subject << (at = Style.new('.awesome.thing') {})
-      subject << (b = Style.new('.boring') {})
-      subject << (bt = Style.new('.boring.thing') {})
-      subject << (a_b = Style.new('.awesome', '.boring') {})
-      subject << (t = Style.new('.thing') {})
-      subject << (s = Style.new('.stupid') {})
-
-      { 'awesome' => [a, a_b],
-        'boring' => [b, a_b],
-        'thing' => [t],
-        'awesome thing' => [a, at, a_b, t],
-        'thing awesome' => [a, at, a_b, t],
-        'other' => []
-      }.each do |style_class, styles_set|
-        assert_equal styles_set, subject.for(style_class)
-      end
-    end
-
-  end
-
-end

data/test/template_set_test.rb

@@ -1,74 +0,0 @@
-require "assert"
-require "osheet/template_set"
-
-module Osheet
-  class TemplateSetTest < Assert::Context
-    desc "Osheet::TemplateSet"
-    before { @set = TemplateSet.new }
-    subject { @set }
-
-    should "be a PartialSet" do
-      assert_kind_of PartialSet, subject
-    end
-
-    should "verify set objs are templates" do
-      assert_raises ArgumentError do
-        subject.send(:verify, {})
-      end
-      assert_nothing_raised do
-        subject.send(:verify, Template.new(:row, :poo) {})
-      end
-    end
-
-    should "key templates using an array of their element and name" do
-      assert_equal ['row','poo'], subject.send(:key, :row, :poo)
-    end
-
-    should "key on templates objs" do
-      assert_equal ['row', 'poo'], subject.send(:template_key, Template.new(:row, :poo) {})
-    end
-
-    should "init the key in the set when verifying" do
-      key = subject.send(:verify, Template.new(:row, :poo) {})
-      assert_equal ['row', 'poo'], key
-      assert_equal({
-        key.first => { key.last => nil }
-      }, subject)
-    end
-
-    should "push templates onto the set" do
-      assert_nothing_raised do
-        subject << Template.new(:row, :poo) {}
-        subject << Template.new(:row, :not_poo) {}
-        subject << Template.new(:column, :awesome) {}
-        subject << Template.new(:column, :not_awesome) {}
-      end
-
-      assert_equal 2, subject.keys.size
-      assert subject["row"]
-      assert_equal 2, subject["row"].keys.size
-      assert subject["row"]["poo"]
-      assert_kind_of Template, subject["row"]["poo"]
-      assert subject["row"]["not_poo"]
-      assert_kind_of Template, subject["row"]["not_poo"]
-      assert subject["column"]
-      assert_equal 2, subject["column"].keys.size
-      assert subject["column"]["awesome"]
-      assert_kind_of Template, subject["column"]["awesome"]
-      assert subject["column"]["not_awesome"]
-      assert_kind_of Template, subject["column"]["not_awesome"]
-    end
-
-    should "lookup a template by element, name" do
-      t = Template.new(:row, :poo) {}
-      subject << t
-      assert_equal t, subject.get(:row, :poo)
-      assert_equal t, subject.get('row', 'poo')
-
-      assert_equal nil, subject.get(:row, :ugh)
-      assert_equal nil, subject.get(:col, :ugh)
-    end
-
-  end
-
-end

data/test/xmlss_writer/base_test.rb

@@ -1,103 +0,0 @@
-require "assert"
-require 'osheet/xmlss_writer'
-
-module Osheet
-
-  class XmlssWriter::BaseTest < Assert::Context
-    desc "XmlssWriter::Base"
-    before { @writer = XmlssWriter::Base.new }
-    subject { @writer }
-
-    should have_readers :used_xstyles
-    should have_writer :oworkbook
-    should have_instance_methods :xworkbook
-
-  end
-
-  class XmlssWriter::WorkbookTests < XmlssWriter::BaseTest
-    before do
-      @workbook = Workbook.new {
-        title "xmlss"
-        worksheet { name "testsheet1" }
-      }
-    end
-
-    should "only allow writing an Osheet::Workbook" do
-      assert_nothing_raised do
-        subject.oworkbook = @workbook
-      end
-      assert_raises ArgumentError do
-        subject.oworkbook = "poo"
-      end
-    end
-
-    should "not allow writing a workbook that has multiple worksheets with the same name" do
-      assert_raises ArgumentError do
-        subject.workbook = Workbook.new {
-          title "invalid"
-          worksheet { name "testsheet1" }
-          worksheet { name "testsheet1" }
-        }
-      end
-    end
-
-    should "create an Xmlss workbook" do
-      subject.oworkbook = @workbook
-      assert_kind_of ::Xmlss::Workbook, subject.xworkbook
-
-      assert_equal(
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Workbook xmlns=\"urn:schemas-microsoft-com:office:spreadsheet\" xmlns:ss=\"urn:schemas-microsoft-com:office:spreadsheet\"><Styles></Styles><Worksheet ss:Name=\"testsheet1\"><Table></Table></Worksheet></Workbook>",
-        subject.xworkbook.to_s
-      )
-    end
-
-  end
-
-  class XmlssWriter::ToFileTests < Assert::Context
-    desc "XmlssWriter::Base"
-    before do
-      @writer = XmlssWriter::Base.new({
-        :workbook => Workbook.new {
-          title "written"
-          worksheet {
-            name "Poo!"
-            column
-            row {
-              cell {
-                data 1
-                format :number
-              }
-            }
-          }
-        }
-      })
-    end
-    after do
-      # remove any test files this creates
-    end
-    subject { @writer }
-
-    should have_instance_methods :to_data, :to_file
-
-    should "return string xml data" do
-      xml_data = nil
-      assert_nothing_raised do
-        xml_data = subject.to_data
-      end
-      assert_kind_of ::String, xml_data
-      assert_match /^<\?xml/, xml_data
-    end
-
-    should "write xml data to a file path" do
-      path = nil
-      assert_nothing_raised do
-        path = subject.to_file("./tmp/base_test.xls")
-      end
-      assert_kind_of ::String, path
-      assert_equal './tmp/base_test.xls', path
-      assert File.exists?(path)
-    end
-
-  end
-
-end