axlsx 1.0.12 → 1.0.13

data/lib/axlsx/util/parser.rb

@@ -0,0 +1,43 @@
+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/parser.rb~

@@ -0,0 +1,6 @@
+module Axlsx
+# THe Parser class unzips an xlsx spread sheet and populates a new axlsx package from it.
+  class Parser
+
+  end
+end

data/lib/axlsx/util/simple_typed_list.rb

@@ -0,0 +1,160 @@
+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
+    # 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
+
+    # Creats a new typed list
+    # @param [Array, Class] type An array of Class objects or a single Class object
+    # @param [String] serialize 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
+
+    # Lock this list at the current size
+    # @return [self]
+    def lock
+      @locked_at = @list.size
+      self
+    end
+    
+    def to_ary
+      @list
+    end
+
+    # Unlock the list
+    # @return [self]
+    def unlock
+      @locked_at = nil
+      self
+    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
+
+    # alternate of << method
+    # @see <<
+    def push(v)
+      self.<< v
+    end
+
+    # 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
+
+    # 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
+    def method_missing(meth, *args, &block)
+      raise ArgumentError, "#{meth} not supported" if [:replace, :insert, :collect!, :map!, :pop, :delete_if, :reverse!, :shift, :shuffle!, :slice!, :sort!, :uniq!, :unshift, :zip, :flatten!, :fill, :drop, :drop_while, :delete_if, :clear].include? meth.to_sym        
+      if @list.respond_to? meth
+        @list.send(meth, *args, &block)      
+      else
+        puts "method:#{meth.inspect}"
+        super
+      end
+    end
+
+    # Serializes the list
+    # If the serialize_as property is set, it is used as the parent node name. 
+    # If the serialize_as property is nil, the first item in the list of allowed_types will be used, having the first letter of the class changed to lower case.
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      classname = @allowed_types[0].name.split('::').last
+      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1]).pluralize
+      xml.send(el_name, :count=>@list.size) {
+        @list.each { |item| item.to_xml(xml) }
+      }
+    end
+  end
+
+
+end

data/lib/axlsx/util/validators.rb

@@ -0,0 +1,132 @@
+module Axlsx
+  # Validate a value against a specific list of allowed values.
+  class RestrictionValidator
+    # Perform validation
+    # @param [String] name The name of what is being validatied. This is included in the error message
+    # @param [Array] choices The list of choices to validate against
+    # @param [Any] v The value to be validated  
+    # @raise [ArgumentError] Raised if the value provided is not in the list of choices.
+    # @return [Boolean] true if validation succeeds.
+    def self.validate(name, choices, v)
+      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)      
+      true
+    end
+  end
+
+  # Validates the value against the regular expression provided.
+  class RegexValidator
+    # @param [String] name The name of what is being validated. This is included in the output when the value is invalid
+    # @param [Regexp] regex The regular expression to evaluate
+    # @param [Any] v The value to validate.
+    def self.validate(name, regex, v)
+      raise ArgumentError, (ERR_REGEX % [v.inspect, regex.to_s]) unless (v.respond_to?(:=~) && v =~ regex)
+    end
+  end
+  # Validate that the class of the value provided is either an instance or the class of the allowed types and that any specified additional validation returns true.
+  class DataTypeValidator
+    # Perform validation
+    # @param [String] name The name of what is being validated. This is included in the error message
+    # @param [Array, Class] types A single class or array of classes that the value is validated against.
+    # @param [Block] other Any block that must evaluate to true for the value to be valid
+    # @raise [ArugumentError] Raised if the class of the value provided is not in the specified array of types or the block passed returns false
+    # @return [Boolean] true if validation succeeds.
+    # @see validate_boolean
+    def self.validate(name, types, v, other= lambda{|arg| true })
+      types = [types] unless types.is_a? Array
+      valid_type = false
+      if v.class == Class
+        types.each { |t| valid_type = true if v.ancestors.include?(t) }
+      else
+        types.each { |t| valid_type = true if v.is_a?(t) }
+      end
+      raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless (other.call(v) && valid_type)
+    end
+    true
+  end
+
+  # Requires that the value is a Fixnum or Integer and is greater or equal to 0
+  # @param [Any] v The value validated
+  # @raise [ArgumentError] raised if the value is not a Fixnum or Integer value greater or equal to 0
+  # @return [Boolean] true if the data is valid
+  def self.validate_unsigned_int(v)
+    DataTypeValidator.validate(:unsigned_int, [Fixnum, Integer], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
+  end
+
+  # Requires that the value is a Fixnum or Integer
+  # @param [Any] v The value validated
+  def self.validate_int(v)
+    DataTypeValidator.validate :unsigned_int, [Fixnum, Integer], v
+  end
+
+  # Requires that the value is a form that can be evaluated as a boolean in an xml document.
+  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and 
+  # it must be one of 0, 1, "true", "false", :true, :false, true, false, "0", or "1"
+  # @param [Any] v The value validated
+  def self.validate_boolean(v)
+    DataTypeValidator.validate(:boolean, [Fixnum, String, Integer, Symbol, TrueClass, FalseClass], v, lambda { |arg| [0, 1, "true", "false", :true, :false, true, false, "0", "1"].include?(arg) })
+  end
+
+  # Requires that the value is a String
+  # @param [Any] v The value validated
+  def self.validate_string(v)
+    DataTypeValidator.validate :string, String, v
+  end   
+
+  # Requires that the value is a Float
+  # @param [Any] v The value validated
+  def self.validate_float(v)
+    DataTypeValidator.validate :float, Float, v
+  end   
+
+  # Requires that the value is valid pattern type.
+  # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
+  # :darkUp, :darkGrid, :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, or :gray0625.
+  # @param [Any] v The value validated
+  def self.validate_pattern_type(v)
+    RestrictionValidator.validate :pattern_type, [:none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown, :darkUp, :darkGrid,
+       :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625], v
+  end
+
+  # Requires that the value is a gradient_type.
+  # valid types are :linear and :path
+  # @param [Any] v The value validated
+  def self.validate_gradient_type(v)
+    RestrictionValidator.validate :gradient_type, [:linear, :path], v
+  end
+
+  # Requires that the value is a valid horizontal_alignment
+  # :general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed are allowed
+  # @param [Any] v The value validated
+  def self.validate_horizontal_alignment(v)
+    RestrictionValidator.validate :horizontal_alignment, [:general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed], v
+  end
+
+  # Requires that the value is a valid vertical_alignment
+  # :top, :center, :bottom, :justify, :distributed are allowed
+  # @param [Any] v The value validated
+  def self.validate_vertical_alignment(v)
+    RestrictionValidator.validate :vertical_alignment, [:top, :center, :bottom, :justify, :distributed], v
+  end
+
+  # Requires that the value is a valid content_type
+  # TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, DRAWING_CT are allowed
+  # @param [Any] v The value validated
+  def self.validate_content_type(v)
+    RestrictionValidator.validate :content_type, [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, JPEG_CT, GIF_CT, PNG_CT, DRAWING_CT], v
+  end
+
+  # Requires that the value is a valid relationship_type
+  # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R are allowed
+  # @param [Any] v The value validated
+  def self.validate_relationship_type(v)
+    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R, IMAGE_R], v
+  end
+
+  # Requires that the value is a valid table element type
+  # :wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues are allowed
+  # @param [Any] v The value validated
+  def self.validate_table_element_type(v)
+    RestrictionValidator.validate :table_element_type, [:wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues], v
+  end
+
+end

data/lib/axlsx/version.rb

@@ -0,0 +1,4 @@
+module Axlsx
+  # version
+  VERSION="1.0.13"
+end

data/lib/axlsx/workbook/#workbook.rb#

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+module Axlsx 
+
+require 'axlsx/workbook/worksheet/cell.rb'
+require 'axlsx/workbook/worksheet/row.rb'
+require 'axlsx/workbook/worksheet/worksheet.rb'
+
+  # The Workbook class is an xlsx workbook that manages worksheets, charts, drawings and styles.
+  # The following parts of the Office Open XML spreadsheet specification are not implimented in this version.
+  # 
+  #   bookViews
+  #   calcPr
+  #   customWorkbookViews
+  #   definedNames
+  #   externalReferences
+  #   extLst
+  #   fileRecoveryPr
+  #   fileSharing
+  #   fileVersion
+  #   functionGroups
+  #   oleSize
+  #   pivotCaches
+  #   smartTagPr
+  #   smartTagTypes
+  #   webPublishing
+  #   webPublishObjects
+  #   workbookProtection
+  #   workbookPr*
+  #
+  #   *workbookPr is only supported to the extend of date1904
+  class Workbook
+
+    # A collection of worksheets associated with this workbook. 
+    # @note The recommended way to manage worksheets is add_worksheet
+    # @see Workbook#add_worksheet
+    # @see Worksheet
+    # @return [SimpleTypedList]
+    attr_reader :worksheets
+
+    # A colllection of charts associated with this workbook
+    # @note The recommended way to manage charts is Worksheet#add_chart
+    # @see Worksheet#add_chart
+    # @see Chart
+    # @return [SimpleTypedList]
+    attr_reader :charts
+
+    # A colllection of images associated with this workbook
+    # @note The recommended way to manage images is Worksheet#add_image
+    # @see Worksheet#add_image
+    # @see Pic
+    # @return [SimpleTypedList]
+    attr_reader :images
+
+    # A colllection of drawings associated with this workbook
+    # @note The recommended way to manage drawings is Worksheet#add_chart
+    # @see Worksheet#add_chart
+    # @see Drawing
+    # @return [SimpleTypedList]
+    attr_reader :drawings
+
+    # The styles associated with this workbook
+    # @note The recommended way to manage styles is Styles#add_style
+    # @see Style#add_style
+    # @see Style
+    # @return [Styles]
+    def styles
+      yield @styles if block_given?
+      @styles
+    end
+
+
+    # Indicates if the epoc date for serialization should be 1904. If false, 1900 is used.
+    @@date1904 = false
+
+    # lets come back to this later when we are ready for parsing. 
+    #def self.parse entry
+    #  io = entry.get_input_stream
+    #  w = self.new
+    #  w.parser_xml = Nokogiri::XML(io.read)
+    #  w.parse_string :date1904, "//xmlns:workbookPr/@date1904"      
+    #  w
+    #end
+
+    # Creates a new Workbook
+    # @option options [Boolean] date1904
+    def initialize(options={})
+      @styles = Styles.new
+      @worksheets = SimpleTypedList.new Worksheet
+      @drawings = SimpleTypedList.new Drawing
+      @charts = SimpleTypedList.new Chart
+      @images = SimpleTypedList.new Pic
+      self.date1904= options[:date1904] unless options[:date1904].nil?
+      yield self if block_given?      
+    end
+
+    # Instance level access to the class variable 1904
+    # @return [Boolean]
+    def date1904() @@date1904; end    
+
+    # see @date1904
+    def date1904=(v) Axlsx::validate_boolean v; @@date1904 = v; end
+
+    # Sets the date1904 attribute to the provided boolean
+    # @return [Boolean]
+    def self.date1904=(v) Axlsx::validate_boolean v; @@date1904 = v; end
+
+    # retrieves the date1904 attribute
+    # @return [Boolean]
+    def self.date1904() @@date1904; end
+
+    # Adds a worksheet to this workbook
+    # @return [Worksheet]
+    # @option options [String] name The name of the worksheet.
+    # @see Worksheet#initialize
+    def add_worksheet(options={})
+      worksheet = Worksheet.new(self, options)
+      yield worksheet if block_given?
+      worksheet
+    end
+
+    # The workbook relationships. This is managed automatically by the workbook
+    # @return [Relationships]
+    def relationships
+      r = Relationships.new
+      @worksheets.each do |sheet|
+        r << Relationship.new(WORKSHEET_R, WORKSHEET_PN % (r.size+1))
+      end 
+      r << Relationship.new(STYLES_R,  STYLES_PN)
+      r
+    end
+
+    # returns a range of cells in a worksheet
+    # @param [String] cell_def The excel style reference defining the worksheet and cells. The range must specify the sheet to 
+    # retrieve the cells from. e.g. range('Sheet1!A1:B2') will return an array of four cells [A1, A2, B1, B2] while range('Sheet1!A1') will return a single Cell.
+    # @return [Cell, Array]
+    def [](cell_def)
+      sheet_name = cell_def.split('!')[0] if cell_def.match('!')
+      worksheet =  self.worksheets.select { |s| s.name == sheet_name }.first
+      raise ArgumentError, 'Unknown Sheet' unless sheet_name && worksheet.is_a?(Worksheet) 
+      worksheet[cell_def.gsub(/.+!/,"")]
+    end
+
+    # Serializes the workbook document
+    # @return [String]
+    def to_xml()
+      add_worksheet unless worksheets.size > 0
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.workbook(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
+          xml.workbookPr(:date1904=>@@date1904, :defaultThemeVersion=>"124226")
+          xml.bookViews {
+            xml.workbookView(:xWindow=>"420", :yWindow=>"405", :windowWidth=>"24480", :windowHeight=>"9885")
+          }
+          xml.sheets {
+            @worksheets.each_with_index do |sheet, index|              
+              xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)
+            end
+          }
+          xml.calcPr(:calcId=>"124519")
+          xml.fileRecoveryPr(:repairLoad=>"1")
+        }
+      end      
+      builder.to_xml
+    end
+  end
+end