osheet 0.10.0 → 1.0.0.rc.1

data/lib/osheet/workbook_api.rb

@@ -0,0 +1,208 @@
+module Osheet; end
+module Osheet::WorkbookApi
+
+  # reference API
+
+  [ :templates,
+    :partials,
+    :styles
+  ].each do |meth|
+    define_method(meth) do |*args|
+      workbook.send(meth, *args)
+    end
+  end
+
+  def worksheets
+    workbook.worksheets
+  end
+
+  def columns
+    worksheets.last.columns
+  end
+
+  def rows
+    worksheets.last.rows
+  end
+
+  def cells
+    rows.last.cells
+  end
+
+  # markup handling API
+
+  def template(*args, &build)
+    Osheet::Template.new(*args, &build).tap do |template|
+      element_stack.current.template(template)
+    end
+  end
+
+  def partial(*args, &build)
+    Osheet::Partial.new(*args, &build).tap do |partial|
+      element_stack.current.partial(partial)
+    end
+  end
+
+  class StyleBuild
+
+    def initialize(scope, *args, &build)
+      @scope = scope
+      @style = Osheet::Style.new(*args, &build)
+    end
+
+    def add
+      @scope.element_stack.current.style(@style)
+      if block_given?
+        @scope.element_stack.using(@style) { yield @style.build }
+      end
+    end
+  end
+
+  def style(*args, &build)
+    StyleBuild.new(self, *args, &build).add do |build|
+      build.call
+    end
+  end
+
+  # element handling API
+
+  class TemplatedElement
+
+    # this class is used to create elements that can be templated.
+    # Arguments are handled differently if building an element from
+    # a template vs. building from a build block.
+    # After the element is built, it is added to the current stack element
+    # and either the build or writer is called.
+
+    ELEMENT_CLASS = {
+      :worksheet => Osheet::Worksheet,
+      :column    => Osheet::Column,
+      :row       => Osheet::Row,
+      :cell      => Osheet::Cell
+    }
+
+    def initialize(scope, name, *args, &build)
+      @scope = scope
+      @workbook = @scope.workbook
+      @name = name
+      @args = args
+      if (@template = @workbook.templates.get(@name, @args.first))
+        @element = ELEMENT_CLASS[@name].new
+        @build   = Proc.new { @scope.instance_exec(*@args[1..-1], &@template) }
+      else
+        @element = ELEMENT_CLASS[@name].new(*@args)
+        @build   = build || Proc.new {}
+      end
+    end
+
+    def add
+      @scope.element_stack.current.send(@name, @element)
+      @scope.element_stack.using(@element) do
+        if @scope.writer
+          @scope.writer.send(@name, @element, &@build)
+        else
+          @build.call
+        end
+      end
+    end
+
+  end
+
+  # used on: workbook
+  def worksheet(*args, &block)
+    if args.empty? && block.nil?
+      worksheets.last
+    else
+      TemplatedElement.new(self, :worksheet, *args, &block).add
+    end
+  end
+
+  # used on: worksheet
+  def column(*args, &block)
+    TemplatedElement.new(self, :column, *args, &block).add
+  end
+
+  # used on: worksheet
+  def row(*args, &block)
+    if args.empty? && block.nil?
+      rows.last
+    else
+      TemplatedElement.new(self, :row, *args, &block).add
+    end
+  end
+
+  # used on: row
+  def cell(*args, &block)
+    if args.empty? && block.nil?
+      cells.last
+    else
+      TemplatedElement.new(self, :cell, *args, &block).add
+    end
+  end
+
+  # style attribute API
+
+  Osheet::Style::SETTINGS.each do |setting|
+    define_method(setting) do |*args|
+      element_stack.current.send(setting, *args)
+    end
+  end
+
+  def border(*args)
+    element_stack.current.border(*args)
+  end
+
+  # element attribute API
+
+  def meta(*args)
+    element_stack.current.meta(*args)
+  end
+
+  # on both style_class and format attribute updates
+  # call the writer's style hook, passing it the current element's
+  # style_class and format values.  Both are needed to write
+  # an elements style data and style_id.
+
+  # used by: column, row, cell
+  def style_class(value)
+    current_class  = element_stack.current.style_class(value)  # for self referencing
+    if self.writer                                             # for writing
+      self.writer.style(current_class, element_stack.current.format)
+    end
+  end
+
+  # used by: cell
+  def format(*args)
+    current_format = element_stack.current.format(*args)  # for self referencing
+    if self.writer                                        # for writing
+      self.writer.style(element_stack.current.style_class, current_format)
+    end
+  end
+
+  # used by: workbook_element
+  def title(*args)
+    element_stack.current.title(*args)
+  end
+
+  [ :name,        # worksheet
+    :width,       # column
+    :height,      # row
+    :autofit,     # column, row
+    :autofit?,    # column, row
+    :hidden,      # column, row
+    :hidden?,     # column, row
+    :data,        # cell
+    :href,        # cell
+    :formula,     # cell
+    :index,       # cell
+    :rowspan,     # cell
+    :colspan,     # cell
+  ].each do |meth|
+    define_method(meth) do |*args|
+      element_stack.current.send(meth, *args)  # for self referencing
+      if self.writer                           # for writing
+        self.writer.send(meth, *args)
+      end
+    end
+  end
+
+end

data/lib/osheet/workbook_element.rb

@@ -1,17 +1,234 @@
-module Osheet::WorkbookElement
+require 'osheet/style'
+require 'osheet/worksheet'
+
+module Osheet
+
+
+  class WorkbookElement
+
+    # This 'WorkbookElement' class handles all workbook state.  It is setup
+    # and referenced by the 'Workbook' class when it runs builds
+
+    class PartialSet < ::Hash; end
+    class TemplateSet < PartialSet; end
+    class StyleSet < ::Array; end
+    class WorksheetSet < ::Array; end
+
+    attr_reader :title
+    attr_reader :templates, :partials, :styles, :worksheets
+
+    def initialize
+      @title = nil
+
+      @templates  = TemplateSet.new
+      @partials   = PartialSet.new
+      @styles     = StyleSet.new
+      @worksheets = WorksheetSet.new
+    end
+
+    def title(value=nil)
+      value.nil? ? @title : @title = value.to_s
+    end
+
+    def template(template)
+      @templates << template
+    end
+
+    def partial(partial)
+      @partials << partial
+    end
+
+    def style(style)
+      @styles << style
+    end
+
+    def worksheet(worksheet)
+      @worksheets << worksheet
+    end
+
+    def styles(*args)
+      @styles.for(*args)
+    end
+
+    def ==(other)
+      title == other.title &&
+      templates == other.templates &&
+      partials == other.partials &&
+      styles == other.styles &&
+      worksheets == other.worksheets
+    end
+
+  end
+
+
+
+  class WorkbookElement::PartialSet
+
+    # this class is a Hash that behaves kinda like a set.  I want to
+    # push partials into the set using the '<<' operator, only allow
+    # Osheet::Partial objs to be pushed, and then be able to reference
+    # a particular partial using its name
+
+    def initialize
+      super
+    end
+
+    def <<(partial)
+      if (key = verify(partial))
+        push(key, partial)
+      end
+    end
+
+    # return the named partial
+    def get(name)
+      lookup(key(name.to_s))
+    end
+
+    private
+
+    def lookup(key)
+      self[key]
+    end
+
+    # push the partial onto the key
+    def push(key, partial)
+      self[key] = partial
+    end
+
+    # verify the partial, init and return the key
+    #  otherwise ArgumentError it up
+    def verify(partial)
+      unless partial.kind_of?(Partial)
+        raise ArgumentError, 'you can only push Osheet::Partial objs to the partial set'
+      end
+      pkey = partial_key(partial)
+      self[pkey] ||= nil
+      pkey
+    end
+
+    def partial_key(partial)
+      key(partial.instance_variable_get("@name"))
+    end
+
+    def key(name)
+      name.to_s
+    end
+
+  end
+
+
+
+  class WorkbookElement::TemplateSet < WorkbookElement::PartialSet
+
+    # this class is a PartialSet that keys off of the template element
+    # and name.  Only Osheet::Template objs can be pushed, and you reference
+    # a particular template by its element and name
+
+    def initialize
+      super
+    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.instance_variable_get("@element"), template.instance_variable_get("@name"))
+    end
+
+    def key(element, name)
+      [element.to_s, name.to_s]
+    end
 
-  def workbook
-    get_ivar(:workbook)
   end
 
-  [:styles, :templates].each do |thing|
-    define_method(thing) do
-      if workbook && workbook.respond_to?(thing)
-        workbook.send(thing)
+
+
+  class WorkbookElement::StyleSet < ::Array
+
+    # this class is an Array with 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=nil)
+      style_class.nil? ? self : self.select{|s| s.match?(style_class)}
+    end
+
+    private
+
+    # 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
+
+
+
+  class WorkbookElement::WorksheetSet < ::Array
+
+    # this class is just a wrapper to Array.  I want to push worksheets
+    # into the set using the '<<' operator, but only allow Worksheet objs
+    # to be pushed.
+
+    def initialize
+      super
+    end
+
+    def <<(value)
+      super if verify(value)
+    end
+
+    private
+
+    # verify the worksheet, otherwise ArgumentError it up
+    def verify(worksheet)
+      if worksheet.kind_of?(Worksheet)
+        true
       else
-        nil
+        raise ArgumentError, 'can only push Osheet::Worksheet to the set'
       end
     end
+
   end
 
+
 end

data/lib/osheet/worksheet.rb

@@ -1,44 +1,38 @@
+require 'osheet/meta_element'
 require 'osheet/column'
 require 'osheet/row'
 
+# this class is collects and validates worksheet meta-data.  It allows
+# for storing a set of columns for referencing when building rows.  It is
+# up to the writer to take this data and use it as needed.
+
 module Osheet
   class Worksheet
-    include Instance
-    include Associations
-    include WorkbookElement
+
     include MetaElement
-    include MarkupElement
-
-    hm :columns
-    hm :rows
-
-    def initialize(workbook=nil, *args, &block)
-      set_ivar(:workbook, workbook)
-      set_ivar(:name, nil)
-      if block_given?
-        set_binding_ivars(block.binding)
-        instance_exec(*args, &block)
-      end
+
+    attr_reader :columns, :rows
+
+    def initialize(name=nil, *args)
+      @name = name
+      @columns = []
+      @rows = []
     end
 
     def name(value=nil)
-      !value.nil? ? set_ivar(:name, sanitized_name(value)) : get_ivar(:name)
+      value.nil? ? @name : @name = value.to_s
     end
 
-    def attributes
-      { :name => get_ivar(:name) }
+    def column(column_obj)
+      @columns << column_obj
     end
 
-    private
-
-    def sanitized_name(name_value)
-      if get_ivar(:workbook) && get_ivar(:workbook).worksheets.collect{|ws| ws.name}.include?(name_value)
-        raise ArgumentError, "the sheet name '#{name_value}' is already in use.  choose a sheet name that is not used by another sheet"
-      end
-      if name_value.to_s.length > 31
-        raise ArgumentError, "worksheet names must be less than 32 characters long"
-      end
-      name_value.to_s
+    # Osheet only stores the latest row in memory for reference
+    # memory bloat would be unmanageable in large spreadsheets if
+    # all rows were stored
+    def row(row_obj)
+      @rows.pop
+      @rows << row_obj
     end
 
   end

data/lib/osheet/xmlss_writer/style_cache.rb

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