osheet 0.1.0 → 0.2.0

data/lib/osheet/xmlss_writer/base.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+module Osheet::XmlssWriter; end
+require 'xmlss'
+require 'osheet/xmlss_writer/elements'
+require 'osheet/xmlss_writer/styles'
+
+module Osheet::XmlssWriter
+  class Base
+    include Elements
+    include Styles
+
+    attr_reader :workbook, :styles
+
+    def initialize(opts={})
+      @styles = []
+      @ostyles = ::Osheet::StyleSet.new
+      self.workbook = opts[:workbook] if opts.has_key?(:workbook)
+    end
+
+    def workbook=(oworkbook)
+      unless oworkbook.kind_of?(::Osheet::Workbook)
+        raise ArgumentError, "'#{oworkbook.inspect}' is not an Osheet::Workbook"
+      end
+      @ostyles = oworkbook.styles
+      @workbook = ::Xmlss::Workbook.new({
+        :worksheets => worksheets(oworkbook.worksheets)
+      })
+    end
+
+    def to_data
+      @workbook.styles = @styles
+      @workbook.to_xml
+    end
+
+    def to_file(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') {|f| f.write self.to_data}
+      File.exists?(path) ? path : false
+    end
+
+  end
+end

data/lib/osheet/xmlss_writer/elements.rb

@@ -0,0 +1,68 @@
+module Osheet::XmlssWriter::Elements
+
+  protected
+
+  def worksheets(oworksheets)
+    oworksheets.collect do |oworksheet|
+      worksheet(oworksheet)
+    end
+  end
+  def worksheet(oworksheet)
+    ::Xmlss::Worksheet.new(oworksheet.attributes[:name], {
+      :table => table(oworksheet)
+    })
+  end
+  def table(oworksheet)
+    ::Xmlss::Table.new({
+      :columns => columns(oworksheet.columns),
+      :rows => rows(oworksheet.rows)
+    })
+  end
+
+  def columns(ocolumns)
+    ocolumns.collect do |ocolumn|
+      column(ocolumn)
+    end
+  end
+  def column(ocolumn)
+    ::Xmlss::Column.new({
+      :style_id => style_id(ocolumn.attributes[:style_class]),
+      :width => ocolumn.attributes[:width],
+      :auto_fit_width => ocolumn.attributes[:autofit],
+      :hidden => ocolumn.attributes[:hidden]
+    })
+  end
+
+  def rows(orows)
+    orows.collect{|orow| row(orow)}
+  end
+  def row(orow)
+    ::Xmlss::Row.new({
+      :style_id => style_id(orow.attributes[:style_class]),
+      :height => orow.attributes[:height],
+      :auto_fit_height => orow.attributes[:autofit],
+      :hidden => orow.attributes[:hidden],
+      :cells => cells(orow.cells)
+    })
+  end
+
+  def cells(ocells)
+    ocells.collect{|ocell| cell(ocell)}
+  end
+  def cell(ocell)
+    ::Xmlss::Cell.new({
+      :style_id => style_id(ocell.attributes[:style_class], ocell.attributes[:format]),
+      :href => ocell.attributes[:href],
+      :merge_across => cell_merge(ocell.attributes[:colspan]),
+      :merge_down => cell_merge(ocell.attributes[:rowspan]),
+      :data => data(ocell.attributes[:data])
+    })
+  end
+  def cell_merge(span)
+    span.kind_of?(::Fixnum) && span > 1 ? span-1 : 0
+  end
+  def data(ocell_data)
+    ::Xmlss::Data.new(ocell_data)
+  end
+
+end

data/lib/osheet/xmlss_writer/styles.rb

@@ -0,0 +1,176 @@
+require 'osheet/format'
+module Osheet::XmlssWriter::Styles
+
+  protected
+
+  def style_id(style_class, oformat=nil)
+    oformat ||= Osheet::Format.new(:general)
+    (xmlss_style = style(style_class, oformat)).nil? ? '' : xmlss_style.id
+  end
+
+  def style(style_class, oformat=nil)
+    oformat ||= Osheet::Format.new(:general)
+    key = style_key(style_class, oformat.key)
+    xmlss_style = @styles.find{|style| style.id == key}
+    if !key.empty? && xmlss_style.nil?
+      settings = style_settings(key)
+      @styles << (xmlss_style = ::Xmlss::Style::Base.new(key) {
+        if settings.has_key?(:align) && !settings[:align].empty?
+          alignment(settings[:align])
+        end
+        if settings.has_key?(:font) && !settings[:font].empty?
+          font(settings[:font])
+        end
+        if settings.has_key?(:bg) && !settings[:bg].empty?
+          interior(settings[:bg])
+        end
+        ::Osheet::Style::BORDERS.each do |bp|
+          if settings.has_key?(bp) && !settings[bp].empty?
+            border(settings[bp])
+          end
+        end
+        if oformat
+          number_format(:format => oformat.style)
+        end
+      })
+    end
+    xmlss_style
+  end
+
+  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 style_settings(key)
+    @ostyles.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 :underline
+          [:underline, :single]
+        when :double_underline
+          [:underline, :double]
+        when :subscript, :superscript
+          [:alignment, font_cmd]
+        when :bold, :italic
+          [font_cmd, true]
+        when :strikethrough
+          [:strike_through, true]
+        when ::Fixnum
+          [:size, font_cmd]
+        when ::String
+          if font_cmd =~ /^#/
+            [:color, font_cmd]
+          end
+        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
+      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/lib/osheet/xmlss_writer.rb

@@ -0,0 +1 @@
+require 'osheet/xmlss_writer/base'

data/lib/osheet.rb

@@ -1,32 +1,12 @@
-require 'osheet/base'
-require 'osheet/workbook'
-require 'osheet/worksheet'
-
 module Osheet
   SPREADSHEET_TYPE = "Excel"
   MIME_TYPE = "application/vnd.ms-excel"
-=begin
-  @@config = Config.new
-  
-  class << self
-    
-    # Configuration accessors for Rack::Less
-    # (see config.rb for details)
-    def configure
-      yield @@config if block_given?
-    end
-    def config
-      @@config
-    end
-    def config=(value)
-      @@config = value
-    end
-    
-    # Combinations config convenience method
-    def combinations(key=nil)
-      @@config.combinations(key)
-    end
 
-  end
-=end
 end
+
+require 'osheet/associations'
+require 'osheet/workbook_element'
+require 'osheet/worksheet_element'
+require 'osheet/styled_element'
+
+require 'osheet/workbook'

data/osheet.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "osheet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "osheet"
+  s.version     = Osheet::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kelly Redding"]
+  s.email       = ["kelly@kelredd.com"]
+  s.homepage    = "http://github.com/kelredd/osheet"
+  s.summary     = %q{A DSL for generating spreadsheets that doesn't totally suck - pronounced 'Oh sheeeeeet!'}
+  s.description = %q{A DSL for specifying and generating rich spreasheetML.  Specify your spreadsheet using the richness of Ruby and easily produce the corresponding spreadsheetML to render in MS Excel.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("bundler", ["~> 1.0"])
+  s.add_development_dependency("test-belt", ["= 0.2.1"]) # locked to a specific version for test stability
+
+  s.add_dependency("enumeration", ["~>1.1.0"])
+  s.add_dependency("xmlss", "~>0.0.2")
+
+end

data/test/cell_test.rb

@@ -0,0 +1,83 @@
+require "test/helper"
+require 'osheet/cell'
+
+module Osheet
+  class CellTest < Test::Unit::TestCase
+
+    context "Osheet::Cell" do
+      subject { Cell.new }
+
+      should_be_a_styled_element(Cell)
+      should_be_a_worksheet_element(Cell)
+      should_be_a_workbook_element(Cell)
+
+      should_have_instance_methods :data, :format, :colspan, :rowspan, :href
+
+      should "set it's defaults" do
+        assert_equal nil, subject.send(:instance_variable_get, "@data")
+        assert_kind_of Format::General, subject.send(:instance_variable_get, "@format")
+        assert_equal 1,   subject.send(:instance_variable_get, "@colspan")
+        assert_equal 1,   subject.send(:instance_variable_get, "@rowspan")
+        assert_equal nil,   subject.send(:instance_variable_get, "@href")
+      end
+
+      context "that has attributes" do
+        subject do
+          Cell.new do
+            style_class 'more poo'
+            data    "Poo"
+            format  :number
+            colspan 4
+            rowspan 2
+            href "http://www.google.com"
+          end
+        end
+
+        should "should set them correctly" do
+          assert_equal "Poo", subject.send(:instance_variable_get, "@data")
+          assert_kind_of Format::Number, subject.send(:instance_variable_get, "@format")
+          assert_equal 4,     subject.send(:instance_variable_get, "@colspan")
+          assert_equal 2,     subject.send(:instance_variable_get, "@rowspan")
+          assert_equal "http://www.google.com", subject.send(:instance_variable_get, "@href")
+        end
+
+        should "know it's attribute(s)" do
+          [:style_class, :data, :format, :rowspan, :colspan, :href].each do |a|
+            assert subject.attributes.has_key?(a)
+          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 "http://www.google.com", subject.attributes[:href]
+        end
+      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(:instance_variable_get, "@data")
+        end
+      end
+      should "type cast data dates" do
+        cell = Cell.new{data Date.today}
+        assert_kind_of ::Date, cell.send(:instance_variable_get, "@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(:instance_variable_get, "@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(:instance_variable_get, "@data")
+        end
+      end
+
+    end
+
+  end
+end

data/test/column_test.rb

@@ -0,0 +1,81 @@
+require "test/helper"
+require "osheet/column"
+
+module Osheet
+  class ColumnTest < Test::Unit::TestCase
+
+    context "Osheet::Column" do
+      subject { Column.new }
+
+      should_be_a_styled_element(Column)
+      should_be_a_worksheet_element(Column)
+      should_be_a_workbook_element(Column)
+
+      should_have_instance_method :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(:instance_variable_get, "@width")
+        assert_equal false, subject.send(:instance_variable_get, "@autofit")
+        assert !subject.autofit?
+        assert_equal false, subject.send(:instance_variable_get, "@hidden")
+        assert !subject.hidden?
+
+        assert_equal nil, subject.meta
+      end
+
+      context "that has attributes" do
+        subject do
+          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(:instance_variable_get, "@width")
+          assert_equal true, subject.send(:instance_variable_get, "@autofit")
+          assert subject.autofit?
+          assert_equal true, subject.send(:instance_variable_get, "@hidden")
+          assert subject.hidden?
+          assert_equal({}, subject.meta)
+        end
+
+        should "know 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 "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
+
+      should "cast autofit and hidden to bool" do
+        col = Column.new { autofit :true; hidden 'false'}
+        assert_kind_of ::TrueClass, col.send(:instance_variable_get, "@autofit")
+        assert_kind_of ::TrueClass, col.send(:instance_variable_get, "@hidden")
+      end
+
+    end
+
+  end
+end

data/test/env.rb

@@ -0,0 +1,9 @@
+# Add test and lib paths to the $LOAD_PATH
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), '..', 'lib')
+].each do |path|
+  full_path = File.expand_path(path)
+  $LOAD_PATH.unshift(full_path) unless $LOAD_PATH.include?(full_path)
+end
+
+require 'osheet'

data/test/format/accounting_test.rb

@@ -0,0 +1,158 @@
+require "test/helper"
+require 'osheet/format/accounting'
+
+module Osheet::Format
+
+  class AccountingTest < Test::Unit::TestCase
+    context "Accounting format" do
+      subject { Accounting.new }
+
+      should_have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
+
+      should "provide symbol options" do
+        assert_equal 3, Accounting.symbol_set.size
+        [:none, :dollar, :euro].each do |a|
+          assert Accounting.symbol_set.include?(a)
+        end
+      end
+
+      should "provide negative numbers options" do
+        assert_equal 4, Accounting.negative_numbers_set.size
+        [:black, :black_parenth, :red, :red_parenth].each do |a|
+          assert Accounting.negative_numbers_set.include?(a)
+        end
+      end
+
+      should "set default values" do
+        assert_equal 2, subject.decimal_places
+        assert_equal :dollar, subject.symbol
+        assert_equal true, subject.comma_separator
+        assert_equal :black, subject.negative_numbers
+      end
+
+      should "only allow Fixnum decimal places between 0 and 30" do
+        assert_raises ArgumentError do
+          Accounting.new({:decimal_places => -1})
+        end
+        assert_raises ArgumentError do
+          Accounting.new({:decimal_places => 31})
+        end
+        assert_raises ArgumentError do
+          Accounting.new({:decimal_places => 'poo'})
+        end
+        assert_nothing_raised do
+          Accounting.new({:decimal_places => 1})
+        end
+      end
+
+      should "generate decimal place style strings" do
+        assert_equal "0", Accounting.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        (1..5).each do |n|
+          assert_equal "0.#{'0'*n}", Accounting.new({
+            :decimal_places => n,
+            :comma_separator => false,
+            :symbol => :none
+          }).style
+        end
+      end
+
+      should "generate comma separator style strings" do
+        assert_equal "0", Accounting.new({
+          :comma_separator => false,
+          :decimal_places => 0,
+          :symbol => :none
+        }).style
+        assert_equal "#,##0", Accounting.new({
+          :comma_separator => true,
+          :decimal_places => 0,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate parenth negative numbers style strings" do
+        assert_equal "0", Accounting.new({
+          :negative_numbers => :black,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "0_);\(0\)", Accounting.new({
+          :negative_numbers => :black_parenth,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate red negative numbers style strings" do
+        assert_equal "0;[Red]0", Accounting.new({
+          :negative_numbers => :red,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "0_);[Red]\(0\)", Accounting.new({
+          :negative_numbers => :red_parenth,
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+      end
+
+      should "generate symbol style strings" do
+        assert_equal "0", Accounting.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :none
+        }).style
+        assert_equal "\"$\"* 0", Accounting.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :dollar
+        }).style
+        assert_equal "[$€-2]\ * 0", Accounting.new({
+          :decimal_places => 0,
+          :comma_separator => false,
+          :symbol => :euro
+        }).style
+      end
+
+      should "generate complex style string" do
+        assert_equal("\"$\"* 0.00_);\(\"$\"* 0.00\)", Accounting.new({
+          :symbol => :dollar,
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).style)
+        assert_equal("[$€-2]\ * #,##0.0000_);[Red]\([$€-2]\ * #,##0.0000\)", Accounting.new({
+          :symbol => :euro,
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).style)
+      end
+
+      should "provide unique format keys" do
+        assert_equal("accounting_dollar_2_nocomma_blackparenth", Accounting.new({
+          :decimal_places => 2,
+          :negative_numbers => :black_parenth,
+          :comma_separator => false
+        }).key)
+        assert_equal("accounting_none_4_comma_redparenth", Accounting.new({
+          :symbol => :none,
+          :decimal_places => 4,
+          :negative_numbers => :red_parenth,
+          :comma_separator => true
+        }).key)
+      end
+
+
+
+    end
+  end
+
+end