osheet 0.1.0 → 0.2.0

data/test/format/text_test.rb

@@ -0,0 +1,18 @@
+require "test/helper"
+require 'osheet/format/text'
+
+module Osheet::Format
+
+  class TextTest < Test::Unit::TestCase
+    context "Text format" do
+      subject { Text.new }
+
+      should "generate a style strings and key" do
+        assert_equal "@", subject.style
+        assert_equal "text", subject.key
+      end
+
+    end
+  end
+
+end

data/test/format_test.rb

@@ -0,0 +1,35 @@
+require "test/helper"
+require 'osheet/format'
+
+module Osheet
+
+  class FormatTest < Test::Unit::TestCase
+    context "Osheet::Format" do
+      subject do
+        Format.new(:number, {
+          :decimal_places => 4,
+          :comma_separator => true,
+          :negative_numbers => :black_parenth
+        })
+      end
+
+      should "build format class instances" do
+        assert_kind_of Format::Number, subject
+        assert_equal 4, subject.decimal_places
+        assert_equal true, subject.comma_separator
+        assert_equal :black_parenth, subject.negative_numbers
+      end
+
+      should "error for invalid format types" do
+        assert_raises ArgumentError do
+          Format.new(:awesome, {})
+        end
+        assert_nothing_raised do
+          Format.new(:general)
+        end
+      end
+
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'test_belt'
+require 'test/env'
+
+class Test::Unit::TestCase
+  class << self
+
+    def should_be_a_workbook_element(klass)
+      should_have_instance_methods :workbook, :styles, :templates
+      context "given a workbook with templates and styles" do
+        before do
+          @wkbk = Osheet::Workbook.new {
+            template(:column, :thing) {}
+            template(:row, :empty) {}
+            style('.title') {
+              font 14
+            }
+            style('.title', '.header') {
+              font :bold
+            }
+          }
+          @klass = klass.new(@wkbk)
+        end
+
+        should "be able to read the workbook and it's styles/templates" do
+          assert_equal @wkbk, @klass.workbook
+          assert_equal @wkbk.styles, @klass.styles
+          assert_equal @wkbk.templates, @klass.templates
+        end
+      end
+    end
+
+    def should_be_a_worksheet_element(klass)
+      should_have_instance_methods :worksheet, :columns
+      context "given a worksheet with columns" do
+        before do
+          @wksht = Osheet::Worksheet.new {
+            column {}
+            column {}
+            column {}
+          }
+          @klass = klass.new(nil, @wksht)
+        end
+
+        should "be able to read the worksheet and it's columns" do
+          assert_equal @wksht, @klass.worksheet
+          assert_equal @wksht.columns, @klass.columns
+        end
+      end
+    end
+
+    def should_be_a_styled_element(klass)
+      should_have_instance_methods :style_class
+
+      context "by default" do
+        before { @default = klass.new }
+        should "default an empty style class" do
+          assert_equal nil, @default.send(:instance_variable_get, "@style_class")
+        end
+      end
+
+      should "default an empty style class" do
+        styled = klass.new{ style_class "awesome thing" }
+        assert_equal "awesome thing", styled.send(:instance_variable_get, "@style_class")
+      end
+
+      should "verify the style class string" do
+        ['.thing', 'thing.thing', 'thing .thing > thing', 'thin>g'].each do |s|
+          assert_raises ArgumentError do
+            klass.new { style_class s }
+          end
+        end
+        ['thing', '#thing 123', 'thing-one thing_one'].each do |s|
+          assert_nothing_raised do
+            klass.new { style_class s }
+          end
+        end
+      end
+    end
+
+    def should_hm(klass, collection, item_klass)
+      should_have_reader collection
+      should_have_instance_method collection.to_s.sub(/s$/, '')
+
+      should "should initialize #{collection} and add them to it's collection" do
+        singular = collection.to_s.sub(/s$/, '')
+        thing = klass.new do
+          self.send(singular) {}
+        end
+
+        items = thing.send(:instance_variable_get, "@#{collection}")
+        assert_equal items, thing.send(collection)
+        assert !items.empty?
+        assert_equal 1, items.size
+        assert_kind_of item_klass, items.first
+      end
+
+    end
+
+  end
+end

data/test/osheet_test.rb

@@ -0,0 +1,14 @@
+require "test/helper"
+
+class OsheetTest < Test::Unit::TestCase
+
+  context "Osheet" do
+
+    should "use Excel" do
+      assert_equal "application/vnd.ms-excel", Osheet::MIME_TYPE
+      assert_equal "Excel", Osheet::SPREADSHEET_TYPE
+    end
+
+  end
+
+end

data/test/row_test.rb

@@ -0,0 +1,78 @@
+require "test/helper"
+require 'osheet/row'
+
+module Osheet
+  class RowTest < Test::Unit::TestCase
+
+    context "Osheet::Row" do
+      subject { Row.new }
+
+      should_be_a_styled_element(Row)
+      should_be_a_worksheet_element(Row)
+      should_be_a_workbook_element(Row)
+
+      should_have_instance_method :height
+      should_have_instance_methods :autofit, :autofit?
+      should_have_instance_methods :hidden, :hidden?
+
+      should "set it's defaults" do
+        assert_equal nil, subject.send(:instance_variable_get, "@height")
+        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 [], subject.cells
+      end
+
+      context "that has attributes" do
+        subject do
+          Row.new do
+            style_class "poo"
+            height  100
+            autofit true
+            hidden true
+          end
+        end
+
+        should "should set them correctly" do
+          assert_equal 100, subject.send(:instance_variable_get, "@height")
+          assert_equal true, subject.send(:instance_variable_get, "@autofit")
+          assert subject.autofit?
+          assert_equal true, subject.send(:instance_variable_get, "@hidden")
+          assert subject.hidden?
+        end
+
+        should "know it's height" do
+          subject.height(false)
+          assert_equal false, subject.height
+          subject.height(180)
+          assert_equal 180, subject.height
+          subject.height(nil)
+          assert_equal 180, subject.height
+        end
+
+        should "know it's attribute(s)" do
+          [:style_class, :height, :autofit, :hidden].each do |a|
+            assert subject.attributes.has_key?(a)
+          end
+          assert_equal 'poo', subject.attributes[:style_class]
+          assert_equal 100, subject.attributes[:height]
+          assert_equal true, subject.attributes[:autofit]
+          assert_equal true, subject.attributes[:hidden]
+        end
+
+      end
+
+      should "cast autofit and hidden to bool" do
+        rw = Row.new { autofit :true; hidden 'false'}
+        assert_kind_of ::TrueClass, rw.send(:instance_variable_get, "@autofit")
+        assert_kind_of ::TrueClass, rw.send(:instance_variable_get, "@hidden")
+      end
+
+      should_hm(Row, :cells, Cell)
+
+    end
+
+  end
+end

data/test/style_set_test.rb

@@ -0,0 +1,50 @@
+require "test/helper"
+require "osheet/style_set"
+
+module Osheet
+  class StyleSetTest < Test::Unit::TestCase
+
+    context "Osheet::StyleSet" do
+      subject { StyleSet.new }
+
+      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|
+          if style_class == 'awesome'
+            assert_equal styles_set, subject.for(style_class)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/test/style_test.rb

@@ -0,0 +1,92 @@
+require "test/helper"
+require "osheet/style"
+
+module Osheet
+  class StyleTest < Test::Unit::TestCase
+
+    context "Osheet::Style" do
+      subject { Style.new('.test') }
+
+      should_have_reader :selectors
+      should_have_instance_methods :align, :font, :bg
+      should_have_instance_methods :border, :border_left, :border_top, :border_right, :border_bottom
+      should_have_instance_method :match?
+
+      should "verify the selector" do
+        ['poo', '#poo', 'poo poo', 'poo > poo', :poo, 123].each do |s|
+          assert_raises ArgumentError do
+            Style.new(s)
+          end
+        end
+        ['.poo', '.poo.poo', '.poo-poo', '.poo_poo'].each do |s|
+          assert_nothing_raised do
+            Style.new(s)
+          end
+        end
+      end
+
+      should "set it's defaults" do
+        assert_equal 1, subject.selectors.size
+        assert_equal '.test', subject.selectors.first
+        [ :align, :font, :bg,
+          :border_left, :border_top, :border_right, :border_bottom
+        ].each do |a|
+          assert_equal [], subject.send(:instance_variable_get, "@#{a}")
+        end
+      end
+
+      should "know it's attribute(s)" do
+        [ :align, :font, :bg,
+          :border_left, :border_top, :border_right, :border_bottom
+        ].each do |a|
+          assert subject.attributes.has_key?(a)
+        end
+      end
+
+
+
+      [ :align, :font, :bg,
+        :border_left, :border_top, :border_right, :border_bottom
+      ].each do |a|
+        should "collect styles for #{a}" do
+          args = [1, "#FF0000", "Verdana", :love, 1.2]
+          subject.send(a, *args)
+          assert_equal args, subject.send(:instance_variable_get, "@#{a}")
+        end
+      end
+
+      should "set all border positions to the same styles using 'border' macro" do
+        args = [:thick, '#FF00FF', :dot]
+        subject.border *args
+        [ :border_left, :border_top, :border_right, :border_bottom].each do |a|
+          assert_equal args, subject.send(:instance_variable_get, "@#{a}")
+        end
+      end
+
+      should "match on style class strings" do
+        a = Style.new('.awesome') {}
+        at = Style.new('.awesome.thing') {}
+        b = Style.new('.boring') {}
+        bt = Style.new('.boring.thing') {}
+        a_b = Style.new('.awesome', '.boring') {}
+        t = Style.new('.thing') {}
+        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|
+          styles.each do |style|
+            assert_equal true, style.match?(style_class)
+          end
+        end
+        assert_equal false, a.match?('stupid')
+      end
+
+    end
+
+  end
+end

data/test/template_set_test.rb

@@ -0,0 +1,76 @@
+require "test/helper"
+require "osheet/template_set"
+
+module Osheet
+  class TemplateSetTest < Test::Unit::TestCase
+
+    context "Osheet::TemplateSet" do
+      subject { TemplateSet.new }
+
+      should "be a Hash" do
+        assert_kind_of ::Hash, subject
+      end
+
+      should_have_instance_method :<<
+      should_have_reader :get
+
+      should "key templates using their element and name" do
+        assert_equal [:row, :poo], subject.send(:key, :row, :poo)
+        assert_equal [:row, :row], subject.send(:key, :row, :row)
+        assert_equal ['row', 'poo'], subject.send(:template_key, Template.new(:row, :poo) {})
+      end
+
+      should "verify Template objs" do
+        assert_raises ArgumentError do
+          subject.send(:verify, {})
+        end
+        assert_nothing_raised do
+          subject.send(:verify, Template.new(:row, :poo) {})
+        end
+      end
+
+      should "init the key when verify templates" 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 "be able to 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
+end

data/test/template_test.rb

@@ -0,0 +1,63 @@
+require "test/helper"
+require "osheet/template"
+
+module Osheet
+  class TemplateTest < Test::Unit::TestCase
+
+    context "Osheet::Template" do
+      subject do
+        Template.new('column', :thing) { |a_thing|
+          width 100
+          meta(
+            :thing => a_thing
+          )
+        }
+      end
+
+      should "define what elements it is valid for" do
+        assert_equal ['worksheet', 'column', 'row', 'cell'], Template::ELEMENTS
+      end
+
+      should_have_accessors :element, :name
+
+      should "be a Proc" do
+        assert_kind_of ::Proc, subject
+      end
+
+      should "convert the element and name args to string and store off" do
+        assert_equal 'column', subject.element
+        assert_equal 'thing', subject.name
+      end
+
+      should "verify the element argument" do
+        assert_raises ArgumentError do
+          Template.new({}, :poo) {}
+        end
+        assert_raises ArgumentError do
+          Template.new('workbook', :poo) {}
+        end
+        Template::ELEMENTS.each do |elem|
+          assert_nothing_raised do
+            Template.new(elem, :poo) {}
+          end
+        end
+      end
+
+      should "verify the name argument" do
+        assert_raises ArgumentError do
+          Template.new('worksheet', []) {}
+        end
+        assert_raises ArgumentError do
+          Template.new('worksheet', 1) {}
+        end
+        assert_nothing_raised do
+          Template.new('worksheet', :poo) {}
+        end
+        assert_nothing_raised do
+          Template.new('worksheet', 'poo') {}
+        end
+      end
+    end
+
+  end
+end

data/test/workbook_test.rb

@@ -0,0 +1,142 @@
+require "test/helper"
+require 'osheet/workbook'
+
+module Osheet
+  class WorkbookTest < Test::Unit::TestCase
+
+    context "Osheet::Workbook" do
+      subject { Workbook.new }
+
+      should_have_readers :styles, :templates
+      should_have_instance_methods :title, :style, :template, :attributes
+
+      should_hm(Workbook, :worksheets, Worksheet)
+
+      should "set it's defaults" do
+        assert_equal nil, subject.send(:instance_variable_get, "@title")
+        assert_equal [], subject.worksheets
+        assert_equal StyleSet.new, subject.styles
+        assert_equal TemplateSet.new, subject.templates
+      end
+
+      context "that has some columns and rows" do
+        subject do
+          Workbook.new {
+            title "The Poo"
+
+            worksheet {
+              name "Poo!"
+
+              column
+
+              row {
+                cell {
+                  format  :number
+                  data    1
+                }
+              }
+            }
+          }
+        end
+
+        should "set it's title" do
+          assert_equal "The Poo", subject.send(:instance_variable_get, "@title")
+        end
+
+        should "know it's title" do
+          subject.title(false)
+          assert_equal false, subject.title
+          subject.title('la')
+          assert_equal 'la', subject.title
+          subject.title(nil)
+          assert_equal 'la', subject.title
+        end
+
+        should "set it's worksheets" do
+          worksheets = subject.send(:instance_variable_get, "@worksheets")
+          assert_equal 1, worksheets.size
+          assert_kind_of Worksheet, worksheets.first
+        end
+
+        should "know it's attribute(s)" do
+          [:title].each do |a|
+            assert subject.attributes.has_key?(a)
+          end
+          assert_equal "The Poo", subject.attributes[:title]
+        end
+      end
+
+      context "that defines styles" do
+        subject do
+          Workbook.new {
+            style('.test')
+            style('.test.awesome')
+          }
+        end
+
+        should "add them to it's styles" do
+          assert_equal 2, subject.styles.size
+          assert_equal 1, subject.styles.first.selectors.size
+          assert_equal '.test', subject.styles.first.selectors.first
+          assert_equal 1, subject.styles.last.selectors.size
+          assert_equal '.test.awesome', subject.styles.last.selectors.first
+        end
+      end
+
+      context "that defines templates" do
+        subject do
+          Workbook.new {
+            template(:column, :yo) { |color|
+              width 200
+              meta(:color => color)
+            }
+            template(:row, :yo_yo) {
+              height 500
+            }
+            template(:worksheet, :go) {
+              column(:yo, 'blue')
+              row(:yo_yo)
+            }
+          }
+        end
+
+        should "add them to it's templates" do
+          assert subject.templates
+          assert_kind_of TemplateSet, subject.templates
+          assert_equal 3, subject.templates.keys.size
+          assert_kind_of Template, subject.templates.get('column', 'yo')
+          assert_kind_of Template, subject.templates.get('row', 'yo_yo')
+          assert_kind_of Template, subject.templates.get('worksheet', 'go')
+
+          subject.worksheet(:go)
+          assert_equal 1, subject.worksheets.size
+          assert_equal 'blue', subject.worksheets.first.columns.first.meta[:color]
+          assert_equal 500, subject.worksheets.first.rows.first.attributes[:height]
+        end
+      end
+
+    end
+
+  end
+
+  class WorkbookWriter < Test::Unit::TestCase
+    context "a workbook" do
+      subject do
+        Workbook.new {
+          style('.test')
+          style('.test.awesome')
+        }
+      end
+
+      should_have_instance_method :writer, :to_data, :to_file
+
+      should "provide a writer for itself" do
+        writer = subject.writer
+        assert writer
+        assert_kind_of XmlssWriter::Base, writer
+      end
+
+    end
+  end
+
+end