axlsx 1.1.4 → 1.3.1

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/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

data/lib/schema/dc.xsd~

@@ -1,118 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-           xmlns="http://purl.org/dc/elements/1.1/"
-           targetNamespace="http://purl.org/dc/elements/1.1/"
-           elementFormDefault="qualified"
-           attributeFormDefault="unqualified">
-
-  <xs:annotation>
-    <xs:documentation xml:lang="en">
-      DCMES 1.1 XML Schema
-      XML Schema for http://purl.org/dc/elements/1.1/ namespace
-
-      Created 2003-04-02
-
-      Created by 
-
-      Tim Cole (t-cole3@uiuc.edu)
-      Tom Habing (thabing@uiuc.edu)
-      Jane Hunter (jane@dstc.edu.au)
-      Pete Johnston (p.johnston@ukoln.ac.uk),
-      Carl Lagoze (lagoze@cs.cornell.edu)
-
-      This schema declares XML elements for the 15 DC elements from the
-      http://purl.org/dc/elements/1.1/ namespace.
-
-      It defines a complexType SimpleLiteral which permits mixed content 
-      and makes the xml:lang attribute available. It disallows child elements by
-      use of minOcccurs/maxOccurs.
-
-      However, this complexType does permit the derivation of other complexTypes
-      which would permit child elements.
-
-      All elements are declared as substitutable for the abstract element any, 
-      which means that the default type for all elements is dc:SimpleLiteral.
-
-    </xs:documentation>
-
-  </xs:annotation>
-
-
-  <xs:import namespace="http://www.w3.org/XML/1998/namespace"
-             schemaLocation="http://www.w3.org/2001/03/xml.xsd">
-  </xs:import>
-
-  <xs:complexType name="SimpleLiteral">
-        <xs:annotation>
-        <xs:documentation xml:lang="en">
-            This is the default type for all of the DC elements.
-            It permits text content only with optional
-            xml:lang attribute.
-            Text is allowed because mixed="true", but sub-elements
-            are disallowed because minOccurs="0" and maxOccurs="0" 
-            are on the xs:any tag.
-
-    	    This complexType allows for restriction or extension permitting
-            child elements.
-    	</xs:documentation>
-  	</xs:annotation>
-
-   <xs:complexContent mixed="true">
-    <xs:restriction base="xs:anyType">
-     <xs:sequence>
-      <xs:any processContents="lax" minOccurs="0" maxOccurs="0"/>
-     </xs:sequence>
-     <xs:attribute ref="xml:lang" use="optional"/>
-    </xs:restriction>
-   </xs:complexContent>
-  </xs:complexType>
-
-  <xs:element name="any" type="SimpleLiteral" abstract="true"/>
-
-  <xs:element name="title" substitutionGroup="any"/>
-  <xs:element name="creator" substitutionGroup="any"/>
-  <xs:element name="subject" substitutionGroup="any"/>
-  <xs:element name="description" substitutionGroup="any"/>
-  <xs:element name="publisher" substitutionGroup="any"/>
-  <xs:element name="contributor" substitutionGroup="any"/>
-  <xs:element name="date" substitutionGroup="any"/>
-  <xs:element name="type" substitutionGroup="any"/>
-  <xs:element name="format" substitutionGroup="any"/>
-  <xs:element name="identifier" substitutionGroup="any"/>
-  <xs:element name="source" substitutionGroup="any"/>
-  <xs:element name="language" substitutionGroup="any"/>
-  <xs:element name="relation" substitutionGroup="any"/>
-  <xs:element name="coverage" substitutionGroup="any"/>
-  <xs:element name="rights" substitutionGroup="any"/>
-
-  <xs:group name="elementsGroup">
-  	<xs:annotation>
-    	<xs:documentation xml:lang="en">
-    	    This group is included as a convenience for schema authors
-            who need to refer to all the elements in the 
-            http://purl.org/dc/elements/1.1/ namespace.
-    	</xs:documentation>
-  	</xs:annotation>
-
-  <xs:sequence>
-    <xs:choice minOccurs="0" maxOccurs="unbounded">
-      <xs:element ref="any"/>
-    </xs:choice>
-    </xs:sequence>
-  </xs:group>
-
-  <xs:complexType name="elementContainer">
-  	<xs:annotation>
-    	<xs:documentation xml:lang="en">
-    		This complexType is included as a convenience for schema authors who need to define a root
-    		or container element for all of the DC elements.
-    	</xs:documentation>
-  	</xs:annotation>
-
-    <xs:choice>
-      <xs:group ref="elementsGroup"/>
-    </xs:choice>
-  </xs:complexType>
-
-
-</xs:schema>