caxlsx 2.0.2 → 3.0.4

data/lib/axlsx/util/mime_type_utils.rb

@@ -0,0 +1,11 @@
+module Axlsx
+  # This module defines some utils related with mime type detection
+  module MimeTypeUtils
+    # Detect a file mime type
+    # @param [String] v File path
+    # @return [String] File mime type
+    def self.get_mime_type(v)
+      MimeMagic.by_magic(File.open(v)).to_s
+    end
+  end
+end

data/lib/axlsx/util/options_parser.rb

@@ -8,7 +8,8 @@ module Axlsx
     # @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
+        key = :"#{key}="
+        self.send(key, value) if !value.nil? && self.respond_to?(key)
       end
     end
   end

data/lib/axlsx/util/serialized_attributes.rb

@@ -18,9 +18,7 @@ module Axlsx
       end
 
       # a reader for those attributes
-      def xml_attributes
-        @xml_attributes
-      end
+      attr_reader :xml_attributes
 
       # This helper registers the attributes that will be formatted as elements.
       def serializable_element_attributes(*symbols)
@@ -28,8 +26,20 @@ module Axlsx
       end
 
       # attr reader for element attributes
-      def xml_element_attributes
-        @xml_element_attributes
+      attr_reader :xml_element_attributes
+    end
+
+    # creates a XML tag with serialized attributes
+    # @see SerializedAttributes#serialized_attributes
+    def serialized_tag(tagname, str, additional_attributes = {}, &block)
+      str << "<#{tagname} "
+      serialized_attributes(str, additional_attributes)
+      if block_given?
+        str << '>'
+        yield
+        str << "</#{tagname}>"
+      else
+        str << '/>'
       end
     end
 
@@ -42,7 +52,7 @@ module Axlsx
     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)}\" "
+        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.camel(Axlsx.booleanize(value), false)}\" "
       end
       str
     end

data/lib/axlsx/util/simple_typed_list.rb

@@ -8,7 +8,7 @@ module Axlsx
     # @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
+    def initialize type, serialize_as=nil, start_size = 0
       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
@@ -16,9 +16,8 @@ module Axlsx
         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
+      @serialize_as = serialize_as unless serialize_as.nil?
+      @list = Array.new(start_size)
     end
 
     # The class constants of allowed types
@@ -27,7 +26,9 @@ module Axlsx
 
     # The index below which items cannot be removed
     # @return [Integer]
-    attr_reader :locked_at
+    def locked_at
+      defined?(@locked_at) ? @locked_at : nil
+    end
 
     # 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.
@@ -54,6 +55,7 @@ module Axlsx
       end
       result
     end
+    
     # Lock this list at the current size
     # @return [self]
     def lock
@@ -61,18 +63,18 @@ module Axlsx
       self
     end
 
-    def to_ary
-      @list
-    end
-
-    alias :to_a :to_ary
-
     # Unlock the list
     # @return [self]
     def unlock
       @locked_at = nil
       self
     end
+    
+    def to_ary
+      @list
+    end
+
+    alias :to_a :to_ary
 
     # join operator
     # @param [Array] v the array to join
@@ -81,7 +83,7 @@ module Axlsx
     # @return [SimpleTypedList]
     def +(v)
       v.each do |item| 
-        DataTypeValidator.validate "SimpleTypedList.+", @allowed_types, item
+        DataTypeValidator.validate :SimpleTypedList_plus, @allowed_types, item
         @list << item 
       end
     end
@@ -91,19 +93,21 @@ module Axlsx
     # @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
+      DataTypeValidator.validate :SimpleTypedList_push, @allowed_types, v
       @list << v
       @list.size - 1
-    end
+    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)
+      return unless include? v
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
       @list.delete v
     end
 
@@ -122,7 +126,7 @@ module Axlsx
     # @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
+      DataTypeValidator.validate :SimpleTypedList_insert, @allowed_types, v
       raise ArgumentError, "Item is protected and cannot be changed" if protected? index
       @list[index] = v
       v
@@ -134,7 +138,7 @@ module Axlsx
     # @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
+      DataTypeValidator.validate :SimpleTypedList_insert, @allowed_types, v
       raise ArgumentError, "Item is protected and cannot be changed" if protected? index
       @list.insert(index, v)
       v
@@ -143,38 +147,10 @@ module Axlsx
     # determines if the index is protected
     # @param [Integer] index
     def protected? index
-      return false unless @locked_at.is_a? Fixnum
-      index < @locked_at
+      return false unless locked_at.is_a? Integer
+      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',
@@ -188,13 +164,13 @@ module Axlsx
         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 << '>'
+      str << ('<' << el_name << ' count="' << size.to_s << '">')
+      each { |item| item.to_xml_string(str) }
+      str << ('</' << el_name << '>')
     end
 
   end

data/lib/axlsx/util/storage.rb

@@ -6,14 +6,14 @@ module Axlsx
 
     # 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"
+    PACKING = "s32 s1 c2 l3 x16 x4 q2 l q".freeze
 
     # storage types
     TYPES = {
       :root=>5,
       :stream=>2,
       :storage=>1
-    }
+    }.freeze
 
     # Creates a byte string for this storage
     # @return [String] 
@@ -45,7 +45,7 @@ module Axlsx
     # 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      
+      RestrictionValidator.validate :storage_color, COLORS.values, v      
       @color = v
     end
 
@@ -116,7 +116,7 @@ module Axlsx
     # 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      
+      RestrictionValidator.validate :storage_type, TYPES.values, v      
       @type = v
     end
 

data/lib/axlsx/util/validators.rb

@@ -52,14 +52,12 @@ module Axlsx
     # @return [Boolean] true if validation succeeds.
     # @see validate_boolean
     def self.validate(name, types, v, other=false)
-      types = [types] unless types.is_a? Array
       if other.is_a?(Proc)
          raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless other.call(v)
       end
-      if v.class == Class
-        types.each { |t| return if v.ancestors.include?(t) }
-      else
-        types.each { |t| return if v.is_a?(t) }
+      v_class = v.is_a?(Class) ? v : v.class
+      Array(types).each do |t|
+        return if v_class <= t
       end
       raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect])
     end
@@ -80,34 +78,38 @@ module Axlsx
   def self.validate_angle(v)
     raise ArgumentError, (ERR_ANGLE % v.inspect) unless (v.to_i >= -5400000 && v.to_i <= 5400000)
   end
-  # Requires that the value is a Fixnum or Integer and is greater or equal to 0
+
+  # Validates an unsigned intger
+  UINT_VALIDATOR = lambda { |arg| arg.respond_to?(:>=) && arg >= 0 }
+
+  # Requires that the value is a 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
+  # @raise [ArgumentError] raised if the value is not a 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 })
+    DataTypeValidator.validate(:unsigned_int, Integer, v, UINT_VALIDATOR)
   end
 
-  # Requires that the value is a Fixnum Integer or Float and is greater or equal to 0
+  # Requires that the value is a Integer or Float and is greater or equal to 0
   # @param [Any] v The value validated
-  # @raise [ArgumentError] raised if the value is not a Fixnun, Integer, Float value greater or equal to 0
+  # @raise [ArgumentError] raised if the value is not a Integer, Float value greater or equal to 0
   # @return [Boolean] true if the data is valid
   def self.validate_unsigned_numeric(v)
-    DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg.to_i >= 0 })
+    DataTypeValidator.validate(:unsigned_numeric, Numeric, v, UINT_VALIDATOR)
   end
 
-  # Requires that the value is a Fixnum or Integer
+  # Requires that the value is a Integer
   # @param [Any] v The value validated
   def self.validate_int(v)
-    DataTypeValidator.validate :unsigned_int, [Fixnum, Integer], v
+    DataTypeValidator.validate :signed_int, 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
+  # The value must be an instance of 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) })
+    DataTypeValidator.validate(:boolean, [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
@@ -130,12 +132,12 @@ module Axlsx
 
   # Requires that the value is an integer ranging from 10 to 400.
   def self.validate_scale_10_400(v)
-    DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg >= 10 && arg <= 400 }
+    DataTypeValidator.validate "page_scale", Integer, v, lambda { |arg| arg >= 10 && arg <= 400 }
   end
 
   # Requires that the value is an integer ranging from 10 to 400 or 0.
   def self.validate_scale_0_10_400(v)
-    DataTypeValidator.validate "page_scale", [Fixnum, Integer], v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
+    DataTypeValidator.validate "page_scale", Integer, v, lambda { |arg| arg == 0 || (arg >= 10 && arg <= 400) }
   end
 
   # Requires that the value is one of :default, :landscape, or :portrait.
@@ -147,7 +149,7 @@ module Axlsx
     RestrictionValidator.validate "cell run style u", [:none, :single, :double, :singleAccounting, :doubleAccounting], v
   end
 
-  # validates cell style family which must be between 1 and 5 
+  # validates cell style family which must be between 1 and 5
   def self.validate_family(v)
     RestrictionValidator.validate "cell run style family", 1..5, v
   end
@@ -267,7 +269,7 @@ module Axlsx
   # valid types must be one of custom, data, decimal, list, none, textLength, time, whole
   # @param [Any] v The value validated
   def self.validate_data_validation_type(v)
-    RestrictionValidator.validate :data_validation_type, [:custom, :data, :decimal, :list, :none, :textLength, :time, :whole], v
+    RestrictionValidator.validate :data_validation_type, [:custom, :data, :decimal, :list, :none, :textLength, :date, :time, :whole], v
   end
 
   # Requires that the value is a valid sheet view type.
@@ -297,4 +299,14 @@ module Axlsx
   def self.validate_display_blanks_as(v)
     RestrictionValidator.validate :display_blanks_as, [:gap, :span, :zero], v
   end
+
+  # Requires that the value is one of :visible, :hidden, :very_hidden
+  def self.validate_view_visibility(v)
+    RestrictionValidator.validate :visibility, [:visible, :hidden, :very_hidden], v
+  end
+
+  # Requires that the value is one of :default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x
+  def self.validate_marker_symbol(v)
+    RestrictionValidator.validate :marker_symbol, [:default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x], v
+  end
 end

data/lib/axlsx/util/zip_command.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+require 'open3'
+require 'shellwords'
+
+module Axlsx
+
+  # The ZipCommand class supports zipping the Excel file contents using
+  # a binary zip program instead of RubyZip's `Zip::OutputStream`.
+  #
+  # The methods provided here mimic `Zip::OutputStream` so that `ZipCommand` can
+  # be used as a drop-in replacement. Note that method signatures are not
+  # identical to `Zip::OutputStream`, they are only sufficiently close so that
+  # `ZipCommand` and `Zip::OutputStream` can be interchangeably used within
+  # `caxlsx`.
+  class ZipCommand
+    # Raised when the zip command exits with a non-zero status.
+    class ZipError < StandardError; end
+
+    def initialize(zip_command)
+      @current_file = nil
+      @files = []
+      @zip_command = zip_command
+    end
+
+    # Create a temporary directory for writing files to.
+    #
+    # The directory and its contents are removed at the end of the block.
+    def open(output, &block)
+      Dir.mktmpdir do |dir|
+        @dir = dir
+        block.call(self)
+        write_file
+        zip_parts(output)
+      end
+    end
+
+    # Closes the current entry and opens a new for writing.
+    def put_next_entry(entry)
+      write_file
+      @current_file = "#{@dir}/#{entry.name}"
+      @files << entry.name
+      FileUtils.mkdir_p(File.dirname(@current_file))
+    end
+
+    # Write to a buffer that will be written to the current entry
+    def write(content)
+      @buffer << content
+    end
+    alias << write
+
+    private
+
+    def write_file
+      if @current_file
+        @buffer.rewind
+        File.open(@current_file, "wb") { |f| f.write @buffer.read }
+      end
+      @current_file = nil
+      @buffer = StringIO.new
+    end
+
+    def zip_parts(output)
+      output = Shellwords.shellescape(File.absolute_path(output))
+      inputs = Shellwords.shelljoin(@files)
+      escaped_dir = Shellwords.shellescape(@dir)
+      command = "cd #{escaped_dir} && #{@zip_command} #{output} #{inputs}"
+      stdout_and_stderr, status = Open3.capture2e(command)
+      if !status.success?
+        raise(ZipError.new(stdout_and_stderr))
+      end
+    end
+  end
+end