osheet 0.1.0 → 0.2.0

data/lib/osheet/format/numeric.rb

@@ -0,0 +1,113 @@
+require 'enumeration'
+
+module Osheet::Format
+
+  class Numeric
+    include Enumeration
+
+    attr_accessor :decimal_places, :comma_separator
+    enum :symbol, [:none, :dollar, :euro]
+    enum :negative_numbers, [:black, :black_parenth, :red, :red_parenth]
+
+    def initialize(opts={})
+      self.symbol = opts[:symbol] || :none
+      self.decimal_places = opts[:decimal_places] || 0
+      self.comma_separator = opts.has_key?(:comma_separator) ? opts[:comma_separator] : false
+      self.negative_numbers = opts[:negative_numbers] || :black
+    end
+
+    def decimal_places=(value)
+      if !value.kind_of?(::Fixnum) || value < 0 || value > 30
+        raise ArgumentError, ":decimal_places must be a Fixnum between 0 and 30."
+      end
+      @decimal_places = value
+    end
+
+    def comma_separator=(value)
+      @comma_separator = !!value
+    end
+
+    def style
+      negative_numbers_style
+    end
+
+    def key
+      "#{key_prefix}_#{symbol_key}_#{decimal_places_key}_#{comma_separator_key}_#{negative_numbers_key}"
+    end
+
+    protected
+
+    # used by 'key' in Numeric base class, override as necessary
+    def key_prefix
+      "number"
+    end
+
+    # used by 'symbol_style' in Numeric base class, override as necessary
+    def symbol_suffix
+      ""
+    end
+
+    # used by 'decimal_places_style' in Numeric base class, override as necessary
+    def decimal_places_suffix
+      ""
+    end
+
+    private
+
+
+    def numeric_style
+      symbol_style +
+      comma_separator_style +
+      decimal_places_style
+    end
+
+
+    def negative_numbers_style
+      case @negative_numbers
+      when :black
+        numeric_style
+      when :red
+        "#{numeric_style};[Red]#{numeric_style}"
+      when :black_parenth
+        "#{numeric_style}_);\(#{numeric_style}\)"
+      when :red_parenth
+        "#{numeric_style}_);[Red]\(#{numeric_style}\)"
+      end
+    end
+    def negative_numbers_key
+      @negative_numbers.to_s.gsub('_', '')
+    end
+
+
+    def decimal_places_style
+      "0#{'.'+'0'*@decimal_places if @decimal_places > 0}#{decimal_places_suffix}"
+    end
+    def decimal_places_key
+      @decimal_places.to_s
+    end
+
+
+    def comma_separator_style
+      @comma_separator == true ? '#,##' : ''
+    end
+    def comma_separator_key
+      @comma_separator == true ? 'comma' : 'nocomma'
+    end
+
+
+    def symbol_style
+      case @symbol
+      when :dollar
+        "\"$\"#{symbol_suffix}"
+      when :euro
+        "[$€-2]\ #{symbol_suffix}"
+      when :none
+        ''
+      end
+    end
+    def symbol_key
+      @symbol.to_s.gsub('_', '')
+    end
+
+  end
+end

data/lib/osheet/format/percentage.rb

@@ -0,0 +1,25 @@
+require 'enumeration'
+require 'osheet/format/numeric'
+
+module Osheet::Format
+
+  class Percentage < Osheet::Format::Numeric
+    def initialize(opts={})
+      super({
+        :decimal_places => 2
+      }.merge(opts))
+    end
+
+    protected
+
+    # used by 'key' in Numeric base class
+    def key_prefix
+      "percentage"
+    end
+
+    # used by 'decimal_places_style' in Numeric base class
+    def decimal_places_suffix
+      "%"
+    end
+  end
+end

data/lib/osheet/format/scientific.rb

@@ -0,0 +1,25 @@
+require 'enumeration'
+require 'osheet/format/numeric'
+
+module Osheet::Format
+
+  class Scientific < Osheet::Format::Numeric
+    def initialize(opts={})
+      super({
+        :decimal_places => 2
+      }.merge(opts))
+    end
+
+    protected
+
+    # used by 'key' in Numeric base class
+    def key_prefix
+      "scientific"
+    end
+
+    # used by 'decimal_places_style' in Numeric base class
+    def decimal_places_suffix
+      "E+00"
+    end
+  end
+end

data/lib/osheet/format/special.rb

@@ -0,0 +1,28 @@
+require 'enumeration'
+
+module Osheet::Format
+
+  class Special
+    include Enumeration
+
+    enum(:type, {
+      :zip_code => '00000',
+      :zip_code_plus_4 => '00000-0000',
+      :phone_number => '[<=9999999]###-####;(###) ###-####',
+      :social_security_number => '000-00-0000'
+    })
+
+    def initialize(opts={})
+      self.type = opts[:type]
+    end
+
+    def style
+      type
+    end
+
+    def key
+      "special_#{type_key.to_s.gsub('_', '')}"
+    end
+
+  end
+end

data/lib/osheet/format/text.rb

@@ -0,0 +1,11 @@
+module Osheet::Format
+
+  class Text
+
+    def initialize(opts={}); end
+
+    def style; '@'; end
+    def key; 'text'; end
+
+  end
+end

data/lib/osheet/format.rb

@@ -0,0 +1,30 @@
+require 'osheet/format/general'
+require 'osheet/format/number'
+require 'osheet/format/currency'
+require 'osheet/format/accounting'
+require 'osheet/format/datetime'
+require 'osheet/format/percentage'
+require 'osheet/format/fraction'
+require 'osheet/format/scientific'
+require 'osheet/format/text'
+require 'osheet/format/special'
+require 'osheet/format/custom'
+
+module Osheet::Format
+
+  VALUES = [
+    :general,:number, :currency, :accounting,
+    :datetime, :percentage, :fraction, :scientific,
+    :text, :special, :custom
+  ]
+
+  class << self
+    def new(type, opts={})
+      unless VALUES.include?(type)
+        raise ArgumentError, "'#{type.inspect}' is not a valid format type"
+      end
+      self.const_get(type.to_s.capitalize).new(opts)
+    end
+  end
+
+end

data/lib/osheet/row.rb

@@ -1,14 +1,39 @@
-require 'osheet/base'
 require 'osheet/cell'
 
 module Osheet
-  class Row < Osheet::Base
-    
-    has :cells => "Cell"
+  class Row
+    include Associations
+    include WorkbookElement
+    include WorksheetElement
+    include StyledElement
 
-    def initialize(args={})
-      super(args)
+    hm :cells
+
+    def initialize(workbook=nil, worksheet=nil, *args, &block)
+      @workbook = workbook
+      @worksheet = worksheet
+      @height = nil
+      @autofit = false
+      @hidden = false
+      instance_exec(*args, &block) if block_given?
+    end
+
+    def height(value=nil)
+      !value.nil? ? @height = value : @height
     end
-    
+    def autofit(value); @autofit = !!value; end
+    def autofit?; @autofit; end
+    def hidden(value); @hidden = !!value; end
+    def hidden?; @hidden; end
+
+    def attributes
+      {
+        :style_class => @style_class,
+        :height => @height,
+        :autofit => @autofit,
+        :hidden => @hidden
+      }
+    end
+
   end
 end

data/lib/osheet/style.rb

@@ -0,0 +1,65 @@
+module Osheet
+  class Style
+
+    # this class is essentially a set of collectors for style settings
+    #  each setting collects any arguments passed to it and
+    #  it is up to the drivers to determine how to use the settings
+
+    BORDER_POSITIONS = [:top, :right, :bottom, :left]
+    BORDERS = BORDER_POSITIONS.collect{|p| "border_#{p}".to_sym}
+    SETTINGS = [:align, :font, :bg] + BORDERS
+
+    attr_reader :selectors
+
+    def initialize(*selectors, &block)
+      @selectors = verify(selectors)
+      SETTINGS.each do |setting|
+        instance_variable_set("@#{setting}", [])
+      end
+      instance_eval(&block) if block_given?
+    end
+
+    SETTINGS.each do |setting|
+      define_method(setting) do |*args|
+        instance_variable_set("@#{setting}", instance_variable_get("@#{setting}") + args)
+      end
+    end
+
+    def border(*args)
+      BORDERS.each do |border|
+        send(border, *args)
+      end
+    end
+
+    def attributes
+      SETTINGS.inject({}) do |attrs, s|
+        attrs[s] = instance_variable_get("@#{s}")
+        attrs
+      end
+    end
+
+    def match?(style_class)
+      selectors.inject(false) do |match, s|
+        match ||= s.split('.').inject(true) do |result, part|
+          result && (part.empty? || style_class.include?(part))
+        end
+      end
+    end
+
+    private
+
+    def verify(selectors)
+      selectors.each do |selector|
+        if !selector.kind_of?(::String) || invalid?(selector)
+          raise ArgumentError, "invalid selector: '#{selector}', selectors must be strings that begin with '.' and con't have spaces or '>'."
+        end
+      end
+    end
+
+    def invalid?(selector)
+      selector =~ /\s+/ ||
+      selector =~ /^[^.]/ ||
+      selector =~ />+/
+    end
+  end
+end

data/lib/osheet/style_set.rb

@@ -0,0 +1,39 @@
+require 'osheet/style'
+
+module Osheet
+  class StyleSet < ::Array
+
+    # this class is an Array has some helper methods.  I want to
+    #  push styles into the set using the '<<' operator, only allow
+    #  Osheet::Style objs to be pushed, and then be able to reference
+    #  a particular set of styles using a style class.
+
+    def initialize
+      super
+    end
+
+    def <<(value)
+      super if verify(value)
+    end
+
+    # return the style set for the style class
+    def for(style_class)
+      self.select{|s| s.match?(style_class)}
+    end
+
+    private
+
+    def styles(class_str)
+    end
+
+    # verify the style, otherwise ArgumentError it up
+    def verify(style)
+      if style.kind_of?(Style)
+        true
+      else
+        raise ArgumentError, 'you can only push Osheet::Style objs to the style set'
+      end
+    end
+
+  end
+end

data/lib/osheet/styled_element.rb

@@ -0,0 +1,18 @@
+module Osheet::StyledElement
+  def style_class(value); @style_class = verify_style_class(value); end
+
+  private
+
+  def verify_style_class(style_class)
+    if !style_class.kind_of?(::String) || invalid_style_class?(style_class)
+      raise ArgumentError, "invalid style_class: '#{style_class}', cannot contain '.' or '>'"
+    else
+      style_class
+    end
+  end
+
+  def invalid_style_class?(style_class)
+    style_class =~ /\.+/ ||
+    style_class =~ />+/
+  end
+end

data/lib/osheet/template.rb

@@ -0,0 +1,32 @@
+module Osheet
+  class Template < ::Proc
+
+    # this class is essentially a way to define a named initializer
+    #  block and associate that with an osheet element
+    #  if an element is initialized from a template, the template
+    #  block will be instance_eval'd for the element being initialized
+
+    ELEMENTS = ['worksheet', 'column', 'row', 'cell']
+
+    attr_accessor :element, :name
+
+    def initialize(element, name)
+      verify(element, name)
+      @element = element.to_s
+      @name = name.to_s
+      super()
+    end
+
+    private
+
+    def verify(element, name)
+      unless element.respond_to?(:to_s) && ELEMENTS.include?(element.to_s)
+        raise ArgumentError, "you can only define a template for #{ELEMENTS.join(', ')} elements."
+      end
+      unless name.kind_of?(::String) || name.kind_of?(::Symbol)
+        raise ArgumentError, "please use a string or symbol for the template name."
+      end
+    end
+
+  end
+end

data/lib/osheet/template_set.rb

@@ -0,0 +1,57 @@
+require 'osheet/template'
+
+module Osheet
+  class TemplateSet < ::Hash
+
+    # this class is a Hash that behaves kinda like a set.  I want to
+    #  push templates into the set using the '<<' operator, only allow
+    #  Osheet::Template objs to be pushed, and then be able to reference
+    #  a particular set of templates using a key
+
+    def initialize
+      super
+    end
+
+    def <<(template)
+      if (key = verify(template))
+        push(key, template)
+      end
+    end
+
+    # return the template set for the named element
+    def get(element, name)
+      lookup(key(element.to_s, name.to_s))
+    end
+
+    private
+
+    def lookup(key)
+      self[key.first][key.last] if self[key.first]
+    end
+
+    # push the template onto the key
+    def push(key, template)
+      self[key.first][key.last] = template
+    end
+
+    # verify the template, init the key set, and return the key string
+    #  otherwise ArgumentError it up
+    def verify(template)
+      unless template.kind_of?(Template)
+        raise ArgumentError, 'you can only push Osheet::Template objs to the template set'
+      end
+      key = template_key(template)
+      self[key.first] ||= {}
+      self[key.first][key.last] ||= nil
+      key
+    end
+
+    def template_key(template)
+      key(template.element, template.name)
+    end
+
+    def key(element, name)
+      [element, name]
+    end
+  end
+end

data/lib/osheet/version.rb

@@ -1,13 +1,3 @@
 module Osheet
-  module Version
-    
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 0
-    
-    def self.to_s # :nodoc:
-      [MAJOR, MINOR, TINY].join('.')
-    end
-    
-  end
+  VERSION = "0.2.0"
 end

data/lib/osheet/workbook.rb

@@ -1,23 +1,39 @@
-require 'osheet/base'
+require 'osheet/style_set'
+require 'osheet/template_set'
 require 'osheet/worksheet'
-
-# === Usage
-#
-#   require 'osheet'
-#
-#   Osheet::Workbook.configure do |book|
-#     book.worksheet ...
-#     book.worksheet ...
-#   end
+require 'osheet/xmlss_writer'
 
 module Osheet
-  class Workbook < Osheet::Base
-    
-    has :worksheets => "Worksheet"
+  class Workbook
+    include Associations
+
+    hm :worksheets
+    attr_reader :styles, :templates
+
+    def initialize(&block)
+      @title = nil
+      @styles = StyleSet.new
+      @templates = TemplateSet.new
+      instance_eval(&block) if block_given?
+    end
+
+    def title(value=nil)
+      !value.nil? ? @title = value : @title
+    end
+    def style(*selectors, &block); @styles << Style.new(*selectors, &block); end
+    def template(element, name, &block); @templates << Template.new(element, name, &block); end
 
-    def initialize(args={})
-      super(args)
+    def attributes
+      { :title => @title }
     end
-    
+
+    def writer
+      XmlssWriter::Base.new(:workbook => self)
+    end
+
+    [:to_data, :to_file].each do |meth|
+      define_method(meth) {|*args| writer.send(meth, *args) }
+    end
+
   end
 end

data/lib/osheet/workbook_element.rb

@@ -0,0 +1,21 @@
+module Osheet::WorkbookElement
+  class << self
+
+    def included(receiver)
+
+      receiver.send(:attr_reader, :workbook)
+
+      [:styles, :templates].each do |thing|
+        receiver.send(:define_method, thing) do
+          if workbook && workbook.respond_to?(thing)
+            workbook.send(thing)
+          else
+            nil
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/osheet/worksheet.rb

@@ -1,29 +1,27 @@
-require 'osheet/base'
 require 'osheet/column'
 require 'osheet/row'
 
-# === Usage
-#
-#   require 'osheet'
-#
-#   Osheet::Workbook.configure do |book|
-#     book.worksheet ...
-#     book.worksheet ...
-#   end
-
 module Osheet
-  class Worksheet < Osheet::Base
-    
-    attr_reader :name
+  class Worksheet
+    include Associations
+    include WorkbookElement
+
+    hm :columns
+    hm :rows
+
+    def initialize(workbook=nil, *args, &block)
+      @workbook = workbook
+      @name = nil
+      instance_exec(*args, &block) if block_given?
+    end
 
-    needs :workbook
-    has :columns => "Column"
-    has :rows => "Row"
+    def name(value=nil)
+      !value.nil? ? @name = value : @name
+    end
 
-    def initialize(name=nil, args={})
-      @name = name
-      super(args)
+    def attributes
+      { :name => @name }
     end
-    
+
   end
 end

data/lib/osheet/worksheet_element.rb

@@ -0,0 +1,15 @@
+module Osheet::WorksheetElement
+  class << self
+    def included(receiver)
+      receiver.send(:attr_reader, :worksheet)
+    end
+  end
+
+  def columns
+    if worksheet && worksheet.respond_to?(:columns)
+      worksheet.columns
+    else
+      nil
+    end
+  end
+end