axlsx 1.1.7 → 1.2.0

data/lib/axlsx/util/ms_off_crypto.rb

@@ -1,189 +0,0 @@
-# encoding: UTF-8
-require 'digest'
-require 'base64'
-require 'openssl'
-
-module Axlsx
-
-  # The MsOffCrypto class implements ECMA-367 encryption based on the MS-OFF-CRYPTO specification
-  class MsOffCrypto
-
-    # Creates a new MsOffCrypto Object
-    # @param [String] file_name the location of the file you want to encrypt
-    # @param [String] pwd the password to use when encrypting the file
-    def initialize(file_name, pwd)
-      self.password = pwd
-      self.file_name = file_name
-    end
-
-    # Generates a new CBF file based on this instance of ms-off-crypto and overwrites the unencrypted file.
-    def save
-      cfb = Cbf.new(self)
-      cfb.save
-    end
-
-    # returns the raw password used in encryption
-    # @return [String]
-    attr_reader :password
-
-    # sets the password to be used for encryption
-    # @param [String] v the password, @default 'password'
-    # @return [String]
-    def password=(v)
-      @password = v || 'password'
-    end
-
-    # retruns the file name of the archive to be encrypted
-    # @return [String]
-    attr_reader :file_name
-
-    # sets the filename
-    # @return [String]
-    def file_name=(v)
-      #TODO verfify that the file specified exists and is an unencrypted xlsx archive
-      @file_name = v
-    end
-
-
-    # encrypts and returns the package specified by the file name 
-    # @return [String]
-    def encrypted_package
-      @encrypted_package ||= encrypt_package(file_name)
-    end
-
-    # returns the encryption info for this instance of ms-off-crypto
-    # @return [String]
-    def encryption_info 
-      @encryption_info ||= create_encryption_info
-    end
-
-    # returns a random salt
-    # @return [String]
-    def salt
-      @salt ||= Digest::SHA1.digest(rand(16**16).to_s)
-    end
-
-    # returns a random verifier
-    # @return [String]
-    def verifier 
-      @verifier ||= rand(16**16).to_s
-    end
-
-    # returns the verifier encrytped
-    # @return [String]
-    def encrypted_verifier
-      @encrypted_verifier ||= encrypt(verifier)
-    end
-
-    # returns the verifier hash encrypted
-    # @return [String]
-    def encrypted_verifier_hash
-      @encrypted_verifier_hash ||= encrypt(verifier_hash)
-    end
-
-    # returns a verifier hash
-    # @return [String]
-    def verifier_hash
-      @verifier_hash ||= create_verifier_hash
-    end
-
-    # returns an encryption key
-    # @return [String]
-    def key 
-      @key ||= create_key
-    end
-    
-    # size of unencrypted package? concated with encrypted package
-    def encrypt_package(file_name)      
-      package = File.open(file_name, 'r')
-      crypt_pack = encrypt(package.read)      
-      [crypt_pack.size].pack('q') + crypt_pack
-    end
-
-    # Generates an encryption info structure
-    # @return [String]
-    def create_encryption_info
-      header = [3, 0, 2, 0] # version
-      # Header flags copy
-      header.concat [0x24, 0, 0, 0] #flags -- VERY UNSURE ABOUT THIS STILL
-      # header.concat [0, 0, 0, 0] #unused
-      header.concat [0xA4, 0, 0, 0] #length
-      # Header
-      header.concat  [0x24, 0, 0, 0] #flags again
-      # header.concat [0, 0, 0, 0] #unused again,
-      header.concat [0x0E, 0x66, 0, 0] #alg id
-      header.concat [0x04, 0x80, 0, 0] #alg hash id
-      header.concat [key.size, 0, 0, 0] #key size
-      header.concat [0x18, 0, 0, 0] #provider type
-      # header.concat [0, 0, 0, 0] #reserved 1
-      # header.concat [0, 0, 0, 0] #reserved 2
-      header.concat [0xA0, 0xC7, 0xDC, 0x2, 0, 0, 0, 0]
-      header.concat "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)".bytes.to_a.pack('s*').bytes.to_a
-      header.concat [0, 0] #null terminator
-
-      #Salt Size
-      header.concat [salt.bytes.to_a.size].pack('l').bytes.to_a
-      #Salt
-      header.concat salt.bytes.to_a.pack('c*').bytes.to_a
-      # encryption verifier
-      header.concat encrypted_verifier.bytes.to_a.pack('c*').bytes.to_a
-
-      # verifier hash size -- MUST BE 32 bytes
-      header.concat [verifier_hash.bytes.to_a.size].pack('l').bytes.to_a
-
-      #encryption verifier hash
-      header.concat encrypted_verifier_hash.bytes.to_a.pack('c*').bytes.to_a
-
-      header.flatten!
-      header.pack('c*')
-    end
-
-    # 2.3.3
-    def create_verifier_hash
-      vh = Digest::SHA1.digest(verifier)
-      vh << Array.new(32 - vh.size, 0).join('')
-    end
-
-    # 2.3.4.7 ECMA-376 Document Encryption Key Generation (Standard Encryption)
-    def create_key
-      sha = Digest::SHA1.new() << (salt + @password)
-      (0..49999).each { |i| sha.update(i.to_s+sha.to_s) }
-      key = sha.update(sha.to_s+'0').digest
-      a = key.bytes.each_with_index.map { |item, i|  0x36 ^ item }
-      x1 = Digest::SHA1.digest((a.concat Array.new(64 - key.size, 0x36)).to_s)
-      a = key.bytes.each_with_index.map { |item, i| 0x5C ^ item }
-      x2 = Digest::SHA1.digest( (a.concat Array.new(64 - key.size, 0x5C) ).to_s)
-      x3 = x1 + x2
-      x3.bytes.to_a[(0..31)].pack('c*')
-    end
-
-    # ensures that the a hashed decryption of the encryption verifier matches the decrypted verifier hash.
-    # @return [Boolean]
-    def verify_password
-      v = Digest::SHA1.digest decrypt(@encrypted_verifier)
-      vh = decrypt(@encrypted_verifier_hash)
-      vh[0..15] == v[0..15]
-    end
-
-    # encrypts the data proved 
-    # @param [String] data
-    # @return [String] the encrypted data
-    def encrypt(data)
-      aes = OpenSSL::Cipher.new("AES-128-ECB")     
-      aes.encrypt
-      aes.key = key
-      aes.update(data) << aes.final
-    end
-
-    # dencrypts the data proved 
-    # @param [String] data
-    # @return [String] the dencrypted data
-    def decrypt(data)
-      aes = OpenSSL::Cipher.new("AES-128-ECB")     
-      aes.decrypt
-      aes.key = key
-      aes.update(data) << aes.final
-    end
-
-  end
-end

data/lib/axlsx/util/ms_off_crypto.rb~

@@ -1,3 +0,0 @@
-module Axlsx
-  class MsOffcrypto
-end

data/lib/axlsx/util/parser.rb~

@@ -1,6 +0,0 @@
-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/workbook/shared_strings_table.rb~

@@ -1,69 +0,0 @@
-# encoding: UTF--8
-module Axlsx
-
-  # The Shared String Table class is responsible for managing and serializing common strings in a workbook.
-  # While the ECMA-376 spec allows for both inline and shared strings it seems that at least some applications like Numbers (Mac)
-  # and Google Docs require that the shared string table is populated in order to interoperate properly. 
-  # As a developer, you should never need to directly work against this class. Simply set 'use_shared_strings'
-  # on the package or workbook to generate a package that uses the shared strings table instead of inline strings.
-  # @note Serialization performance is affected by using this serialization method so if you do not need interoperability
-  # it is recomended that you use the default inline string method of serialization.
-  class SharedStringsTable
-
-    # The total number of strings in the workbook including duplicates
-    # Empty cells are treated as blank strings
-    # @return [Integer]
-    attr_reader :count
-
-    # The total number of unique strings in the workbook. 
-    # @return [Integer]
-    def unique_count
-      @unique_cells.size
-    end
-
-    # An array of unique cells. Multiple attributes of the cell are used in comparison
-    # each of these unique cells is parsed into the shared string table.     
-    # @see Cell#sharable
-    attr_reader :unique_cells
-
-    # Creates a new Shared Strings Table agains an array of cells
-    # @param [Array] cells This is an array of all of the cells in the workbook
-    def initialize(cells)
-      cells = cells.reject { |c| c.type != :string }
-      @count = cells.size
-      @unique_cells = []
-      resolve cells
-    end
-
-    # Interate over all of the cells in the array. 
-    # if our unique cells array does not contain a sharable cell, 
-    # add the cell to our unique cells array and set the ssti attribute on the index of this cell in the shared strings table
-    # if a sharable cell already exists in our unique_cells array, set the ssti attribute of the cell and move on.
-    # @return [Array] unique cells
-    def resolve(cells)
-      cells.each do |cell|
-        index = @unique_cells.index { |item| item.sharable(cell) }
-        if index == nil
-          cell.ssti = @unique_cells.size
-          @unique_cells << cell
-        else
-          cell.ssti = index
-        end
-      end
-    end
-
-    # Generate the xml document for the Shared Strings Table
-    # @return [String]
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.sst(:xmlns => Axlsx::XML_NS, :count => count, :uniqueCount => unique_count) {
-          @unique_cells.each do |cell|
-            xml.si { xml.t cell.value.to_s }
-          end
-        }
-      end
-      builder.to_xml(:save_with => 0)
-    end
-  end
-
-end

data/lib/axlsx/workbook/worksheet/color_scale.rb~

@@ -1,46 +0,0 @@
-module Axlsx
-  # Conditional Format Rule color scale object
-  # Describes a gradated color scale in this conditional formatting rule.
-
-  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
-  # @see Worksheet#add_conditional_formatting
-  # @see ConditionalFormattingRule#initialize
-  class ColorScale
-
-    # A simple typed list of cfvos
-    # @return [SimpleTypedList]
-    # @see cfvo
-    attr_reader :cfvos
-
-    # A simple types list of colors
-    # @return [SimpleTypedList]
-    # @see Color
-    attr_reader :colors
-
-    def initializer
-      initialize_cfvos
-      initialize_colors
-      yield self if block_given?
-    end
-
-    def add
-      @cfvos << Cfvo.new(:type => :min, :val => 0)
-      @colors << Color.new :rgb => "FF000000"
-      {:cfvo => @cfvos.last, :color => @colors.last}
-    end
-
-    protected
-
-    def initialize_cfvos
-      @cfvos = SimpleTypedList.new Cfvo
-      @cfvos.concat [Cfvo.new(:type => :min, :val => 0), Cfvo.new(:type => :max, :val => 0)]
-      @cfvos.lock
-    end
-
-    def initialize_colors
-      @colors = SimpleTypedList.new Color
-      @colors.concat [Color.new(:rgb => "FFFF0000", Color.new(:rgb => "FF0000FF")]
-      @colors.lock
-    end
-
-  end

data/lib/axlsx/workbook/worksheet/comment.rb~

@@ -1,91 +0,0 @@
-module Axlsx
-
-  # A comment is the text data for a comment
-  class Comment
-
-    # The text to render
-    # @return [String]
-    attr_reader :text
-
-    # The index of the the author for this comment in the owning Comments object
-    # @see Comments
-    # @return [Integer]
-    attr_reader :author_index
-
-    # The owning Comments object
-    # @return [Comments]
-    attr_reader :comments
-
-
-    # The string based cell position reference (e.g. 'A1') that determines the positioning of this comment
-    attr_reader :ref
-
-    # TODO
-    # r (Rich Text Run)
-    # rPh (Phonetic Text Run)
-    # phoneticPr (Phonetic Properties)
-
-    def initialize(comments, options={})
-      raise ArgumentError, "A comment needs a parent comments object" unless comments.is_a?(Comments)
-      @comments = comments
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-
-    def pn
-      "#{COMMENT_PN % (index+1)}"
-    end
-
-    def vml_shape
-      @vml_shape ||= initialize_vml_shape
-    end
-
-    def initialize_vml_shape
-      ws = self.comments.worksheet
-      @vml_shape = VmlShape.new(self, :row => ws[ref].row.index, :column => ws[ref].index) do |vml|
-        vml.left_column = vml.row + 1
-        vml.right_column = vml.column + 4
-        vml.top_row = vml.row
-        vml.bottom_row = vml.row + 4
-      end
-    end
-
-    # The index of this comment
-    # @return [Integer]
-    def index
-      @comments.comment_list.index(self)
-    end
-
-    def ref=(v)
-      Axlsx::DataTypeValidator.validate "Comment.ref", [String, Cell], v
-      @ref = v if v.is_a?(String)
-      @ref = v.r if v.is_a?(Cell)
-    end
-
-    def text=(v)
-      Axlsx::validate_string(v)
-      @text = v
-    end
-
-    def author_index=(v)
-      Axlsx::validate_unsigned_int(v)
-      @author_index = v
-    end
-
-    def to_xml_string(str = "")
-      author = @comments.authors[author_index]
-      str << '<comment ref="' << ref << '" authorId="' << author_index.to_s << '">'
-      str << '<text><r>'
-      str << '<rPr> <b/><color indexed="81"/></rPr>'
-      str << '<t>' << author.to_s << ':
-</t></r>'
-      str << '<r>'
-      str << '<rPr><color indexed="81"/></rPr>'
-      str << '<t>' << text << '</t></r></text>'
-      str << '</comment>'
-    end
-
-  end
-end

data/lib/axlsx/workbook/worksheet/comments.rb~

@@ -1,86 +0,0 @@
-module Axlsx
-
-  class Comments
-
-    # a collection of the comment authors
-    # @return [SimpleTypedList]
-    attr_reader :authors
-
-    # a collection of comment objects
-    # @return [SimpleTypedList]
-    attr_reader :comment_list
-
-
-    # The worksheet that these comments belong to
-    # @return [Worksheet]
-    attr_reader :worksheet
-
-    # Creates a new Comments object
-    def initialize(worksheet)
-      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
-      @worksheet = worksheet
-      @authors = SimpleTypedList.new String
-      @comment_list = SimpleTypedList.new Comment
-    end
-
-    def add_comment(options={})
-      raise ArgumentError, "Comment require an author" unless options[:author]
-      raise ArgumentError, "Comment requires text" unless options[:text]
-      options[:author_index] = @authors.index(options[:author]) || @authors << options[:author]
-      @comment_list << Comment.new(self, options)
-      @comment_list.last
-    end
-
-    def to_xml_string(str="")
-    end
-
-  end
-
-  class Comment
-
-    attr_reader :text
-
-    attr_reader :author_index
-
-    attr_reader :comments
-
-    # TODO
-    # r (Rich Text Run)
-    # rPh (Phonetic Text Run)
-    # phoneticPr (Phonetic Properties)
-    def initialize(comments, options={})
-      raise ArgumentError, "A comment needs a parent comments object" unless comments.is_a?(Comments)
-      @comments = comments
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-
-    def pn
-      "#{COMMENT_PN % (index+1)}"
-    end
-
-    # The index of this comment
-    # @return [Integer]
-    def index
-      @comments.comment_list.index(self)
-    end
-
-
-    def text=(v)
-      Axlsx::validate_string(v)
-      @text = v
-    end
-
-    def author_index=(v)
-      Axlsx::validate_unsigned_int(v)
-      @author_index = v
-    end
-
-    def to_xml_string(str = "")
-    end
-
-  end
-
-end

data/lib/axlsx/workbook/worksheet/icon_set.rb~

@@ -1,95 +0,0 @@
-module Axlsx
-  # Conditional Format Rule data bar object
-  # Describes a data bar conditional formatting rule.
-
-  # @note The recommended way to manage these rules is via Worksheet#add_conditional_formatting
-  # @see Worksheet#add_conditional_formatting
-  # @see ConditionalFormattingRule#initialize
-  class DataBar
-    CHILD_ELEMENTS = [:value_objects]
-
-    # minLength attribute
-    # The minimum length of the data bar, as a percentage of the cell width.
-    # The default value is 10
-    # @return [Integer]
-    attr_reader :minLength
-
-    # maxLength attribute
-    # The maximum length of the data bar, as a percentage of the cell width.
-    # The default value is 90
-    # @return [Integer]
-    attr_reader :maxLength
-
-    # maxLength attribute
-    # Indicates whether to show the values of the cells on which this data bar is applied.
-    # The default value is true
-    # @return [Boolean]
-    attr_reader :showValue
-
-    # A simple typed list of cfvos
-    # @return [SimpleTypedList]
-    # @see Cfvo
-    attr_reader :value_objects
-
-    # color
-    # the color object used in the data bar formatting
-    # @return [Color]
-    def color
-      @color ||= Color.new :rgb => "FF0000FF"
-    end
-
-    # Creates a new data bar conditional formatting object
-    # @option options [Integer] minLength
-    # @option options [Integer] maxLength
-    # @option options [Boolean] showValue
-    # @option options [String] color - the rbg value used to color the bars
-    def initialize(options = {})
-      @minLength = 10
-      @maxLength = 90
-      @showValue = true
-      initialize_value_objects
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-
-    # @see minLength
-    def minLength=(v); Axlsx.validate_unsigned_int(v); @minLength = v end
-    # @see maxLength
-    def maxLength=(v); Axlsx.validate_unsigned_int(v); @maxLength = v end
-
-    # @see showValue
-    def showValue=(v); Axlsx.validate_boolean(v); @showValue = v end
-
-    # Sets the color for the data bars.
-    # @param [Color|String] The color object, or rgb string value to apply
-    def color=(v)
-      @color = v if v.is_a? Color
-      self.color.rgb = v if v.is_a? String
-      @color
-    end
-
-    # Serialize this object to an xml string
-    # @param [String] str
-    # @return [String]
-    def to_xml_string(str="")
-      str << '<dataBar '
-      str << instance_values.map { |key, value| '' << key << '="' << value.to_s << '"' unless CHILD_ELEMENTS.include?(key.to_sym) }.join(' ')
-      str << '>'
-      @value_objects.each { |cfvo| cfvo.to_xml_string(str) }
-      self.color.to_xml_string(str)
-      str << '</dataBar>'
-    end
-
-    private
-
-    # Initalize the simple typed list of value objects
-    # I am keeping this private for now as I am not sure what impact changes to the required two cfvo objects will do.
-    def initialize_value_objects
-      @value_objects = SimpleTypedList.new Cfvo
-      @value_objects.concat [Cfvo.new(:type => :min, :val => 0), Cfvo.new(:type => :max, :val => 0)]
-      @value_objects.lock
-    end
-  end
-end

data/lib/axlsx/workbook/worksheet/table.rb~

@@ -1,97 +0,0 @@
-# encoding: UTF-8
-module Axlsx
-  # Table
-  # @note Worksheet#add_table is the recommended way to create charts for your worksheets.
-  # @see README for examples
-  class Table
-
-
-    # The reference to the table data
-    # @return [String]
-    attr_reader :ref
-
-    # The name of the table.
-    # @return [String]
-    attr_reader :name
-
-    # The style for the table. 
-    # @return [TableStyle]
-    attr_reader :style
-   
-    # Creates a new Table object
-    # @param [String] ref The reference to the table data.
-    # @param [Sheet] ref The sheet containing the table data.
-    # @option options [Cell, String] name
-    # @option options [TableStyle] style
-    def initialize(ref, sheet, options={})
-      @ref = ref
-      @sheet = sheet
-      @style = nil
-      @sheet.workbook.tables << self
-      @name = "Table#{index+1}"
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      yield self if block_given?
-    end
-
-    # The index of this chart in the workbooks charts collection
-    # @return [Integer]
-    def index
-      @sheet.workbook.tables.index(self)
-    end
-
-    # The part name for this table
-    # @return [String]
-    def pn
-      "#{TABLE_PN % (index+1)}"
-    end
-    
-    # The relation reference id for this table
-    # @return [String]
-    def rId
-      "rId#{index+1}"
-    end
-
-    # The name of the Table.
-    # @param [String, Cell] v
-    # @return [Title]
-    def name=(v) 
-      DataTypeValidator.validate "#{self.class}.name", [String], v
-      if v.is_a?(String)
-        @name = v
-      end
-    end
-
-    
-    # The style for the table.
-    # TODO 
-    # def style=(v) DataTypeValidator.validate "Chart.style", Integer, v, lambda { |arg| arg >= 1 && arg <= 48 }; @style = v; end
-
-    # Table Serialization
-    # serializes the table
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.table(:xmlns => XML_NS, :id => index+1, :name => @name, :displayName => @name.gsub(/\s/,'_'), :ref => @ref, :totalsRowShown => 0) {
-          xml.autoFilter :ref=>@ref 
-          xml.tableColumns(:count => header_cells.length) {
-            header_cells.each_with_index do |cell,index|
-              xml.tableColumn :id => index+1, :name => cell.value
-            end
-          }
-          xml.tableStyleInfo :showFirstColumn=>"0", :showLastColumn=>"0", :showRowStripes=>"1", :showColumnStripes=>"0", :name=>"TableStyleMedium9"
-          #TODO implement tableStyleInfo
-        }
-      end
-      builder.to_xml(:save_with => 0)
-    end
-
-    private
-    
-    # get the header cells (hackish)
-    def header_cells 
-      header = @ref.gsub(/^(\w+)(\d+)\:(\w+)\d+$/, '\1\2:\3\2')
-      @sheet[header]
-    end
-  end
-end