axlsx 1.0.11 → 1.0.12

data/lib/axlsx/util/parser.rb

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

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

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

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

data/lib/axlsx/workbook/workbook.rb

@@ -1,160 +0,0 @@
-# -*- 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)
-          xml.sheets {
-            @worksheets.each_with_index do |sheet, index|              
-              xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)
-            end
-          }
-        }
-      end      
-      builder.to_xml(:indent=>0)
-    end
-  end
-end