caxlsx 2.0.2

data/lib/axlsx/util/options_parser.rb

@@ -0,0 +1,15 @@
+module Axlsx
+  # This module defines a single method for parsing options in class
+  # initializers.
+  module OptionsParser
+
+    # Parses an options hash by calling any defined method by the same
+    # name of the key postfixed with an '='
+    # @param [Hash] options Options to parse.
+    def parse_options(options={})
+      options.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to?("#{key}=") && value != nil
+      end
+    end
+  end
+end

data/lib/axlsx/util/parser.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module Axlsx
+  # The Parser module mixes in a number of methods to help in generating a model from xml
+  # This module is not included in the axlsx library at this time. It is for future development only,
+  module Parser
+
+    # The xml to be parsed
+    attr_accessor :parser_xml
+    
+    # parse and assign string attribute
+    def parse_string attr_name, xpath
+      send("#{attr_name.to_s}=", parse_value(xpath))
+    end
+    
+    # parse convert and assign node text to symbol
+    def parse_symbol attr_name, xpath
+      v = parse_value xpath
+      v = v.to_sym unless v.nil?
+      send("#{attr_name.to_s}=", v)
+    end
+    
+    # parse, convert and assign note text to integer
+    def parse_integer attr_name, xpath
+      v = parse_value xpath
+      v = v.to_i if v.respond_to?(:to_i)
+      send("#{attr_name.to_s}=", v)
+    end
+    
+    # parse, convert and assign node text to float
+    def parse_float attr_name, xpath
+      v = parse_value xpath
+      v = v.to_f if v.respond_to?(:to_f)
+      send("#{attr_name.to_s}=", v)
+    end
+
+    # return node text based on xpath
+    def parse_value xpath
+      node = parser_xml.xpath(xpath)
+      return nil if node.empty?
+      node.text.strip
+    end    
+    
+  end
+end

data/lib/axlsx/util/serialized_attributes.rb

@@ -0,0 +1,79 @@
+module Axlsx
+  # This module allows us to define a list of symbols defining which
+  # attributes will be serialized for a class.
+  module SerializedAttributes
+
+    # Extend with class methods
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    # class methods applied to all includers
+    module ClassMethods
+
+      # This is the method to be used in inheriting classes to specify 
+      # which of the instance values are serializable
+      def serializable_attributes(*symbols)
+        @xml_attributes = symbols
+      end
+
+      # a reader for those attributes
+      def xml_attributes
+        @xml_attributes
+      end
+
+      # This helper registers the attributes that will be formatted as elements.
+      def serializable_element_attributes(*symbols)
+        @xml_element_attributes = symbols
+      end
+
+      # attr reader for element attributes
+      def xml_element_attributes
+        @xml_element_attributes
+      end
+    end
+
+    # serializes the instance values of the defining object based on the 
+    # list of serializable attributes.
+    # @param [String] str The string instance to append this
+    # serialization to.
+    # @param [Hash] additional_attributes An option key value hash for
+    # defining values that are not serializable attributes list.
+    def serialized_attributes(str = '', additional_attributes = {})
+      attributes = declared_attributes.merge! additional_attributes
+      attributes.each do |key, value|
+        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(value, false)}\" "
+      end
+      str
+    end
+
+    # A hash of instance variables that have been declared with
+    # seraialized_attributes and are not nil.
+    # This requires ruby 1.9.3 or higher
+    def declared_attributes
+      instance_values.select do |key, value|
+        value != nil && self.class.xml_attributes.include?(key.to_sym)
+      end
+    end
+
+    # serialized instance values at text nodes on a camelized element of the
+    # attribute name. You may pass in a block for evaluation against non nil
+    # values. We use an array for element attributes becuase misordering will
+    # break the xml and 1.8.7 does not support ordered hashes.
+    # @param [String] str The string instance to which serialized data is appended
+    # @param [Array] additional_attributes An array of additional attribute names.
+    # @return [String] The serialized output.
+    def serialized_element_attributes(str='', additional_attributes=[], &block)
+      attrs = self.class.xml_element_attributes + additional_attributes
+      values = instance_values
+      attrs.each do |attribute_name|
+        value = values[attribute_name.to_s]
+        next if value.nil?
+        value = yield value if block_given?
+        element_name = Axlsx.camel(attribute_name, false)
+        str << "<#{element_name}>#{value}</#{element_name}>"
+      end
+      str
+    end
+  end
+end

data/lib/axlsx/util/simple_typed_list.rb

@@ -0,0 +1,203 @@
+# encoding: UTF-8
+module Axlsx
+
+  # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.
+  # @private
+  class SimpleTypedList
+    # Creats a new typed list
+    # @param [Array, Class] type An array of Class objects or a single Class object
+    # @param [String] serialize_as The tag name to use in serialization
+    # @raise [ArgumentError] if all members of type are not Class objects
+    def initialize type, serialize_as=nil
+      if type.is_a? Array
+        type.each { |item| raise ArgumentError, "All members of type must be Class objects" unless item.is_a? Class }
+        @allowed_types = type
+      else
+        raise ArgumentError, "Type must be a Class object or array of Class objects" unless type.is_a? Class
+        @allowed_types = [type]
+      end
+      @list = []
+      @locked_at = nil
+      @serialize_as = serialize_as
+    end
+
+    # The class constants of allowed types
+    # @return [Array]
+    attr_reader :allowed_types
+
+    # The index below which items cannot be removed
+    # @return [Integer]
+    attr_reader :locked_at
+
+    # The tag name to use when serializing this object
+    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
+    # @return [String]
+    attr_reader :serialize_as
+
+    # Transposes the list (without blowing up like ruby does)
+    # any non populated cell in the matrix will be a nil value
+    def transpose
+      return @list.clone if @list.size == 0
+      row_count = @list.size
+      max_column_count = @list.map{|row| row.cells.size}.max
+      result = Array.new(max_column_count) { Array.new(row_count) }
+      # yes, I know it is silly, but that warning is really annoying
+      row_count.times do |row_index|
+         max_column_count.times do |column_index|
+          datum = if @list[row_index].cells.size >= max_column_count
+                    @list[row_index].cells[column_index]
+                  elsif block_given?
+                    yield(column_index, row_index)
+                  end
+          result[column_index][row_index] = datum
+        end
+      end
+      result
+    end
+    # Lock this list at the current size
+    # @return [self]
+    def lock
+      @locked_at = @list.size
+      self
+    end
+
+    def to_ary
+      @list
+    end
+
+    alias :to_a :to_ary
+
+    # Unlock the list
+    # @return [self]
+    def unlock
+      @locked_at = nil
+      self
+    end
+
+    # join operator
+    # @param [Array] v the array to join
+    # @raise [ArgumentError] if any of the values being joined are not
+    # one of the allowed types
+    # @return [SimpleTypedList]
+    def +(v)
+      v.each do |item| 
+        DataTypeValidator.validate "SimpleTypedList.+", @allowed_types, item
+        @list << item 
+      end
+    end
+
+    # Concat operator
+    # @param [Any] v the data to be added
+    # @raise [ArgumentError] if the value being added is not one fo the allowed types
+    # @return [Integer] returns the index of the item added.
+    def <<(v)
+      DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
+      @list << v
+      @list.size - 1
+    end
+    alias :push :<<
+
+    # delete the item from the list
+    # @param [Any] v The item to be deleted.
+    # @raise [ArgumentError] if the item's index is protected by locking
+    # @return [Any] The item deleted
+    def delete(v)
+      return unless @list.include? v
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? @list.index(v)
+      @list.delete v
+    end
+
+    # delete the item from the list at the index position provided
+    # @raise [ArgumentError] if the index is protected by locking
+    # @return [Any] The item deleted
+    def delete_at(index)
+      @list[index]
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index
+      @list.delete_at index
+    end
+
+    # positional assignment. Adds the item at the index specified
+    # @param [Integer] index
+    # @param [Any] v
+    # @raise [ArgumentError] if the index is protected by locking
+    # @raise [ArgumentError] if the item is not one of the allowed types
+    def []=(index, v)
+      DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
+      raise ArgumentError, "Item is protected and cannot be changed" if protected? index
+      @list[index] = v
+      v
+    end
+
+    # inserts an item at the index specfied
+    # @param [Integer] index
+    # @param [Any] v
+    # @raise [ArgumentError] if the index is protected by locking
+    # @raise [ArgumentError] if the index is not one of the allowed types
+    def insert(index, v)
+      DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
+      raise ArgumentError, "Item is protected and cannot be changed" if protected? index
+      @list.insert(index, v)
+      v
+    end
+
+    # determines if the index is protected
+    # @param [Integer] index
+    def protected? index
+      return false unless @locked_at.is_a? Fixnum
+      index < @locked_at
+    end
+
+    # override the equality method so that this object can be compared to a simple array.
+    # if this object's list is equal to the specifiec array, we return true.
+    def ==(v)
+      v == @list
+    end
+    # method_mission override to pass allowed methods to the list.
+    # @note
+    #  the following methods are not allowed
+    #   :replace
+    #   :insert
+    #   :collect!
+    #   :map!
+    #   :pop
+    #   :delete_if
+    #   :reverse!
+    #   :shift
+    #   :shuffle!
+    #   :slice!
+    #   :sort!
+    #   :uniq!
+    #   :unshift
+    #   :zip
+    #   :flatten!
+    #   :fill
+    #   :drop
+    #   :drop_while
+    #   :delete_if
+    #   :clear
+    DESTRUCTIVE = ['replace', 'insert', 'collect!', 'map!', 'pop', 'delete_if',
+                   'reverse!', 'shift', 'shuffle!', 'slice!', 'sort!', 'uniq!',
+                   'unshift', 'zip', 'flatten!', 'fill', 'drop', 'drop_while',
+                   'delete_if', 'clear']
+    DELEGATES = Array.instance_methods - self.instance_methods - DESTRUCTIVE
+
+    DELEGATES.each do |method|
+      class_eval %{
+        def #{method}(*args, &block)
+          @list.send(:#{method}, *args, &block)
+        end
+      }
+    end
+
+    def to_xml_string(str = '')
+      classname = @allowed_types[0].name.split('::').last
+      el_name = serialize_as.to_s || (classname[0,1].downcase + classname[1..-1])
+      str << '<' << el_name << ' count="' << @list.size.to_s << '">'
+      @list.each { |item| item.to_xml_string(str) }
+      str << '</' << el_name << '>'
+    end
+
+  end
+
+
+end

data/lib/axlsx/util/storage.rb

@@ -0,0 +1,146 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The Storage class represents a storage object or stream in a compound file.
+  class Storage
+
+    # Packing for the Storage when pushing an array of items into a byte stream
+    # Name, name length, type, color, left sibling, right sibling, child, classid, state, created, modified, sector, size
+    PACKING = "s32 s1 c2 l3 x16 x4 q2 l q"
+
+    # storage types
+    TYPES = {
+      :root=>5,
+      :stream=>2,
+      :storage=>1
+    }
+
+    # Creates a byte string for this storage
+    # @return [String] 
+    def to_s
+     data = [@name.concat(Array.new(32-@name.size, 0)), 
+             @name_size, 
+             @type, 
+             @color, 
+             @left, 
+             @right, 
+             @child, 
+             @created,
+             @modified, 
+             @sector, 
+             @size].flatten
+      data.pack(PACKING)
+    end
+
+    # storage colors
+    COLORS = {
+      :red=>0, 
+      :black=>1
+    }
+
+    # The color of this node in the directory tree. Defaults to black if not specified
+    # @return [Integer] color
+    attr_reader :color
+    
+    # Sets the color for this storage
+    # @param [Integer] v Must be one of the COLORS constant hash values
+    def color=(v)
+      RestrictionValidator.validate "Storage.color", COLORS.values, v      
+      @color = v
+    end
+
+    # The size of the name for this node.
+    # interesting to see that office actually uses 'R' for the root directory and lists the size as 2 bytes - thus is it *NOT* null 
+    # terminated. I am making this r/w so that I can override the size
+    # @return [Integer] color
+    attr_reader :name_size
+
+    # the name of the stream    
+    attr_reader :name
+
+    # sets the name of the stream.
+    # This will automatically set the name_size attribute
+    # @return [String] name
+    def name=(v)
+      @name = v.bytes.to_a << 0
+      @name_size = @name.size * 2
+      @name
+    end
+
+    # The size of the stream
+    attr_reader :size
+
+    # The stream associated with this storage
+    attr_reader :data
+
+    # Set the data associated with the stream. If the stream type is undefined, we automatically specify the storage as a stream type.    # with the exception of storages that are type root, all storages with data should be type stream.
+    # @param [String] v The data for this storages stream
+    # @return [Array]
+    def data=(v)
+      Axlsx::validate_string(v)
+      self.type = TYPES[:stream] unless @type
+      @size = v.size
+      @data = v.bytes.to_a
+    end
+
+    # The starting sector for the stream. If this storage is not a stream, or the root node this is nil
+    # @return [Integer] sector
+    attr_accessor :sector
+
+    # The 0 based index in the directoies chain for this the left sibling of this storage. 
+    
+    # @return [Integer] left
+    attr_accessor :left 
+
+    # The 0 based index in the directoies chain for this the right sibling of this storage. 
+    # @return [Integer] right
+    attr_accessor :right 
+
+    # The 0 based index in the directoies chain for the child of this storage. 
+    # @return [Integer] child
+    attr_accessor :child
+
+    # The created attribute for the storage
+    # @return [Integer] created
+    attr_accessor :created
+
+    # The modified attribute for the storage
+    # @return [Integer] modified
+    attr_accessor :modified
+
+    # The type of storage
+    # see TYPES
+    # @return [Integer] type
+    attr_reader :type
+
+    # Sets the type for this storage. 
+    # @param [Integer] v the type to specify must be one of the TYPES constant hash values. 
+    def type=(v)
+      RestrictionValidator.validate "Storage.type", TYPES.values, v      
+      @type = v
+    end
+
+    # Creates a new storage object. 
+    # @param [String] name the name of the storage
+    # @option options [Integer] color @default black
+    # @option options [Integer] type @default storage
+    # @option options [String] data 
+    # @option options [Integer] left @default -1
+    # @option options [Integer] right @default -1
+    # @option options [Integer] child @default -1
+    # @option options [Integer] created @default 0
+    # @option options [Integer] modified @default 0
+    # @option options [Integer] sector @default 0
+    def initialize(name, options= {})
+      @left = @right = @child = -1
+      @sector = @size = @created = @modified = 0
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      @color ||= COLORS[:black]
+      @type ||= (data.nil? ? TYPES[:storage] : TYPES[:stream])
+      self.name = name
+    end
+ 
+  end
+end