axlsx 1.1.3 → 1.2.0

data/lib/axlsx/drawing/cat_axis_data.rb

@@ -1,34 +0,0 @@
-# encoding: UTF-8
-module Axlsx
-  # The CatAxisData class serializes the category axis data for a chart
-  class CatAxisData < SimpleTypedList
-
-    # Create a new CatAxisData object
-    # @param [Array, SimpleTypedList] data the data for this category axis. This can be a simple array or a simple typed list of cells.
-    def initialize(data=[])
-      super Object
-      @list.concat data if data.is_a?(Array)
-      data.each { |i| @list << i } if data.is_a?(SimpleTypedList)
-    end
-
-    # Serializes the object
-    # @param [String] str
-    # @return [String]
-    def to_xml_string(str = '')
-      str << '<c:cat>'
-      str << '<c:strRef>'
-      str << '<c:f>' << Axlsx::cell_range(@list) << '</c:f>'
-      str << '<c:strCache>'
-      str << '<c:ptCount val="' << size.to_s << '"/>'
-      each_with_index do |item, index|
-        v = item.is_a?(Cell) ?  item.value.to_s : item
-        str << '<c:pt idx="' << index.to_s << '"><c:v>' << v << '</c:v></c:pt>'
-      end
-      str << '</c:strCache>'
-      str << '</c:strRef>'
-      str << '</c:cat>'
-    end
-
-  end
-
-end

data/lib/axlsx/drawing/hyperlink.rb~

@@ -1,64 +0,0 @@
-# -*- coding: utf-8 -*-
-module Axlsx
-  # a hlinkClick object adds a click behaviour to a drawing object.
-  # using the hlink_click method on a drawing object is the recommended way to manage hlinks
-  # @see Pic#link_to
-  class Hyperlink
-
-    # the type of hyper link defines the onclick or mouseover trigger.
-    # type must be one of :hlinkClick or :hlinkMouse
-    def type
-      @type ||= :hlinkClick
-    end
-
-    # sets the type of the object. 
-    # @param [Symbol] type one of :hlinkClick or hlinkMouse
-    def type(v) RestrictionValidator.validate "Hyperlink.type", [:hlinkClick, :hlinkMouse], v; @type = v end
-
-    # The destination of the hyperlink
-    # This value is actually stored in the drawings .rels. doc as a relationship.
-    attr_accessor :href
-
-    # The docs say:
-    #      Specifies the URL when it has been determined by the generating application that the URL is invalid. That is the generating application can still store the URL but it is known that this URL is not correct.
-    attr_accessor :invalidUrl
-
-    # Specifies the target frame that is to be used when opening this hyperlink. When the hyperlink is activated this attribute is used to determine if a new window is launched for viewing or if an existing one can be used. If this attribute is omitted, than a new window is opened.
-    attr_accessor :tgtFrame
-
-    # Specifies the tooltip that should be displayed when the hyperlink text is hovered over with the mouse. If this attribute is omitted, than the hyperlink text itself can be displayed.
-    attr_accessor :tooltip
-
-    #Creates a hyperlink object 
-    # parent must be a Pic for now, although I expect that other object support this tag and its cNvPr parent
-    # @param [Pic] parent
-    # @option [String] tooltip message shown when hyperlinked object is hovered over with mouse.
-    # @option [String] tgtFrame Target frame for opening hyperlink
-    # @option [String] invalidUrl supposedly use to store the href when we know it is an invalid resource. 
-    # @option [String] href the target resource this hyperlink links to.
-    def initialize(parent, options=>{})
-      DataTypeValidator.validate "Hyperlink.parent", [Pic], parent
-      @parent = parent
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
-
-    # The index of this hyperlink in the owning document's hyperlinks collection
-    # @returns [Integer]
-    def index
-      self.parent.anchor.drawing.hyperlinks.index(self)
-    end
-
-    # The relational ID for this hyperlink    
-    # @returns [String]
-    def r:id
-      reference_count = self.parent.anchor.drawing.charts.size + self.parent.anchor.drawing.images.size + index
-      
-    end
-
-    def to_xml(xml) 
-      xml.send(type, 
-    end
-  end
-end

data/lib/axlsx/drawing/named_axis_data.rb

@@ -1,36 +0,0 @@
-# encoding: UTF-8
-# TODO: review cat, val and named access data to extend this and reduce replicated code.
-module Axlsx
-  # The ValAxisData class manages the values for a chart value series.
-  class NamedAxisData < CatAxisData
-
-    # creates a new NamedAxisData Object
-    # @param [String] name The serialized node name for the axis data object
-    # @param [Array] The data to associate with the axis data object
-    def initialize(name, data=[])
-      super(data)
-      @name = name
-    end
-
-    # Serializes the object
-    # @param [String] str
-    # @return [String]
-    def to_xml_string(str = '')
-      str << '<c:' << @name.to_s << '>'
-      str << '<c:numRef>'
-      str << '<c:f>' << Axlsx::cell_range(@list) << '</c:f>'
-      str << '<c:numCache>'
-      str << '<c:formatCode>General</c:formatCode>'
-      str << '<c:ptCount val="' << size.to_s << '"/>'
-      each_with_index do |item, index|
-        v = item.is_a?(Cell) ?  item.value.to_s : item
-        str << '<c:pt idx="' << index.to_s << '"><c:v>' << v << '</c:v></c:pt>'
-      end
-      str << '</c:numCache>'
-      str << '</c:numRef>'
-      str << '</c:' << @name.to_s << '>'
-    end
-
-  end
-
-end

data/lib/axlsx/drawing/picture_locking.rb~

@@ -1,36 +0,0 @@
-module Axlsx
-  # The picture locking class defines the locking properties for pictures in your workbook. 
-  class PictureLocking
-    
-    
-    attr_reader :noGrp
-    attr_reader :noSelect
-    attr_reader :noRot
-    attr_reader :noChangeAspect
-    attr_reader :noMove
-    attr_reader :noResize
-    attr_reader :noEditPoints
-    attr_reader :noAdjustHandles
-    attr_reader :noChangeArrowheads
-    attr_reader :noChangeShapeType
-
-    # Creates a new PictureLocking object
-    # @option options [Boolean] noGrp
-    # @option options [Boolean] noSelect
-    # @option options [Boolean] noRot
-    # @option options [Boolean] noChangeAspect
-    # @option options [Boolean] noMove
-    # @option options [Boolean] noResize
-    # @option options [Boolean] noEditPoints
-    # @option options [Boolean] noAdjustHandles
-    # @option options [Boolean] noChangeArrowheads
-    # @option options [Boolean] noChangeShapeType
-    def initialize(options={})
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end        
-
-
-  end
-end

data/lib/axlsx/drawing/val_axis_data.rb

@@ -1,27 +0,0 @@
-# encoding: UTF-8
-module Axlsx
-  # The ValAxisData class manages the values for a chart value series.
-  class ValAxisData < CatAxisData
-
-    # Serializes the object
-    # @param [String] str
-    # @return [String]
-    def to_xml_string(str = '')
-      str << '<c:val>'
-      str << '<c:numRef>'
-      str << '<c:f>' << Axlsx::cell_range(@list) << '</c:f>'
-      str << '<c:numCache>'
-      str << '<c:formatCode>General</c:formatCode>'
-      str << '<c:ptCount val="' << size.to_s << '"/>'
-      each_with_index do |item, index|
-        v = item.is_a?(Cell) ?  item.value.to_s : item
-        str << '<c:pt idx="' << index.to_s << '"><c:v>' << v << '</c:v></c:pt>'
-      end
-      str << '</c:numCache>'
-      str << '</c:numRef>'
-      str << '</c:val>'
-    end
-
-  end
-
-end

data/lib/axlsx/util/cbf.rb

@@ -1,333 +0,0 @@
-# encoding: UTF-8
-module Axlsx
-
-  # The Cfb class is a MS-OFF-CRYPTOGRAPHY specific OLE (MS-CBF) writer implementation. No attempt is made to re-invent the wheel for read/write of compound binary files.
-  class Cbf
-
-    # the serialization for the CBF FAT
-    FAT_PACKING  = "s128"
-
-    # the serialization for the MS-OFF-CRYPTO version stream
-    VERSION_PACKING = 'l s30 l3'
-
-    # The serialization for the MS-OFF-CRYPTO dataspace map stream
-    DATA_SPACE_MAP_PACKING = 'l6 s16 l s25 x2'
-
-    # The serialization for the MS-OFF-CRYPTO strong encrytion data space stream
-    STRONG_ENCRYPTION_DATA_SPACE_PACKING = 'l3 s26'
-
-    # The serialization for the MS-OFF-CRYPTO primary stream
-    PRIMARY_PACKING = 'l3 s38 l s40 l3 x12 l'
-
-    # The cutoff size that determines if a stream should be in the mini-fat or the fat
-    MINI_CUTOFF = 4096
-
-    # The serialization for CBF header
-    HEADER_PACKING = "q x16 l s3 x10 l l x4 l*"
-
-    # Creates a new Cbf object based on the ms_off_crypto object provided.
-    # @param [MsOffCrypto] ms_off_crypto
-    def initialize(ms_off_crypto)
-      @file_name = ms_off_crypto.file_name  
-      @ms_off_crypto = ms_off_crypto
-      create_storages
-      mini_fat_stream
-      mini_fat
-      fat
-      header
-    end
-
-    # creates or returns the version storage
-    # @return [Storage]
-    def version
-      @version ||= create_version
-    end
-
-    # returns the data space map storage
-    # @return [Storage]
-    def data_space_map
-      @data_space_map ||= create_data_space_map
-    end
-
-    # returns the primary storage
-    # @return [Storgae]
-    def primary
-      @primary ||= create_primary
-    end
-
-    # returns the summary information storage
-    # @return [Storage]
-    def summary_information
-      @summary_information ||= create_summary_information
-    end
-
-    # returns the document summary information 
-    # @return [Storage]
-    def document_summary_information
-      @document_summary_information ||= create_document_summary_information
-    end
-
-    # returns the stream of data allocated in the fat
-    # @return [String]
-    def fat_stream 
-      @fat_stream ||= create_fat_stream
-    end
-
-    # returns the stream allocated in the mini fat.
-    # return [String]
-    def mini_fat_stream
-      @mini_fat_stream ||= create_mini_fat_stream
-    end
-    
-    # returns the mini fat
-    # return [String]
-    def mini_fat
-      @mini_fat ||= create_mini_fat
-    end
-
-    # returns the fat
-    # @return [String]
-    def fat
-      @fat ||= create_fat
-    end
-    
-    # returns the CFB header
-    # @return [String]
-    def header
-      @header ||= create_header
-    end
-
-    # returns the encryption info from the ms_off_crypt object provided during intialization
-    # @return [String] encryption info
-    def encryption_info
-      @ms_off_crypto.encryption_info
-    end
-
-    # returns the encrypted package from the ms_off_crypt object provided during initalization
-    # @return [String] encrypted package
-    def encrypted_package
-      @ms_off_crypto.encrypted_package
-    end
-
-    # writes the compound binary file to disk
-    def save
-      ole = File.open(@file_name, 'w')
-      ole << header
-      ole << fat
-      @storages.each { |s| ole << s.to_s }
-      ole << Array.new((512-(ole.pos % 512)), 0).pack('c*')
-      ole << mini_fat
-      ole << mini_fat_stream
-      ole << fat_stream
-      ole.close
-    end
-    
-    private
-
-    # Generates the storages required for ms-office-cryptography cfb
-    def create_storages
-      @storages = []
-      @encryption_info = @ms_off_crypto.encryption_info
-      @encrypted_package = @ms_off_crypto.encrypted_package
-
-      @storages << Storage.new('EncryptionInfo', :data=>encryption_info, :left=>3, :right=>11) # example shows right child. do we need the summary info????
-      @storages << Storage.new('EncryptedPackage', :data=>encrypted_package, :color=>Storage::COLORS[:red])
-      @storages << Storage.new([6].pack("c")+"DataSpaces", :child=>5, :modified =>129685612740945580, :created=>129685612740819979)
-      @storages << version
-      @storages << data_space_map
-      @storages << Storage.new('DataSpaceInfo', :right=>8, :child=>7, :created=>129685612740828880,:modified=>129685612740831800)
-      @storages << strong_encryption_data_space
-      @storages << Storage.new('TransformInfo', :color => Storage::COLORS[:red],  :child=>9, :created=>129685612740834130, :modified=>129685612740943959)
-      @storages << Storage.new('StrongEncryptionTransform', :child=>10, :created=>129685612740834169, :modified=>129685612740942280)
-      @storages << primary      
-      # @storages << summary_information
-      # @storages << document_summary_information
-
-      # we do this at the end as we need to build the minifat stream to determine the size. #HOWEVER - it looks like the size should not include the padding?
-      @storages.unshift Storage.new('Root Entry', :type=>Storage::TYPES[:root], :color=>Storage::COLORS[:red], :child=>1, :data => mini_fat_stream)
-
-    end
-
-    # generates the mini fat stream
-    # @return [String]
-    def create_mini_fat_stream
-      mfs = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each_with_index do |stream, index|
-        puts "#{stream.name.pack('c*')}: #{stream.data.size}"        
-        mfs.concat stream.data
-        mfs.concat Array.new(64 - (mfs.size % 64), 0) if mfs.size % 64 > 0        
-        puts "mini fat stream size: #{mfs.size}"
-      end
-      mfs.concat(Array.new(512 - (mfs.size % 512), 0))
-      mfs.pack 'c*'
-    end
-
-    # generates the fat stream.
-    # @return [String]
-    def create_fat_stream
-      mfs = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size >= MINI_CUTOFF}.each_with_index do |stream, index|
-        mfs.concat stream.data
-        mfs.concat Array.new(512 - (mfs.size % 512), 0) if mfs.size % 512 > 0     
-      end
-      mfs.pack 'c*'
-    end
-
-    # creates the mini fat
-    # @return [String]
-    def create_mini_fat
-      v_mf = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each do |stream|
-        allocate_stream(v_mf, stream, 64)
-      end
-      v_mf.concat Array.new(128 - v_mf.size, -1)
-      v_mf.pack 'l*'
-    end
-
-    # creates the fat
-    # @return [String]
-    def create_fat
-      v_fat = [-3]
-      # storages four per sector, allocation forces directories to start at sector ID 0
-      allocate_stream(v_fat, @storages, 4)
-      # fat entry for minifat
-      allocate_stream(v_fat, 0, 512)
-      # fat entry for minifat stream
-      @storages[0].sector = v_fat.size
-      allocate_stream(v_fat, mini_fat_stream, 512)
-      # fat entries for encrypted package storage
-      # what to do about DIFAT for larger packages...
-      if @encrypted_package.size > (109 - v_fat.size) * 512
-        raise ArgumentError, "Your package is too big!"
-      end
-
-      if @encrypted_package.size >= MINI_CUTOFF
-        allocate_stream(v_fat, @encrypted_package, 512)
-      end
-
-      v_fat.concat Array.new(128 - v_fat.size, -1) if v_fat.size < 128 #pack in unused sectors
-      v_fat.pack 'l*'
-    end
-    
-    # Creates the version storage
-    # @return [Storage]
-    def create_version
-      v_stream= [60, "Microsoft.Container.DataSpaces".bytes.to_a, 1, 1, 1].flatten!.pack VERSION_PACKING
-      Storage.new('Version', :data=>v_stream, :size=>v_stream.size)
-    end
-
-    # returns the strong encryption data space storage
-    # @return [Storgae]
-    def strong_encryption_data_space
-      @strong_encryption_data_space ||= create_strong_encryption_data_space
-    end
-
-    # Creates the data space map storage
-    # @return [Storgae]
-    def create_data_space_map
-      v_stream = [8,1,104, 1,0, 32, "EncryptedPackage".bytes.to_a, 50, "StrongEncryptionDataSpace".bytes.to_a].flatten!.pack DATA_SPACE_MAP_PACKING      
-      Storage.new('DataSpaceMap', :data=>v_stream, :left => 4, :right => 6, :size=>v_stream.size)
-    end
-
-
-    # creates the stron encryption data space storage
-    # @return [Storgae]
-    def create_strong_encryption_data_space
-      v_stream = [8,1,50,"StrongEncryptionTransform".bytes.to_a,0].flatten.pack STRONG_ENCRYPTION_DATA_SPACE_PACKING
-      Storage.new("StrongEncryptionDataSpace", :data=>v_stream, :size => v_stream.size)
-    end
-    
-    # creates the primary storage
-    # @return [Storgae]
-    def create_primary
-      v_stream = [88,1,76,"{FF9A3F03-56EF-4613-BDD5-5A41C1D07246}".bytes.to_a].flatten
-      v_stream.concat [78, "Microsoft.Container.EncryptionTransform".bytes.to_a,0,1,1,1,4].flatten
-      v_stream = v_stream.pack PRIMARY_PACKING
-      Storage.new([6].pack("c")+"Primary", :data=>v_stream)
-    end
-
-
-    # creates the summary information storage
-    # @return [Storage]
-    def create_summary_information
-      v_stream = []
-      v_stream.concat [0xFEFF, 0x0000, 0x030A, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000]
-      v_stream.concat [0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0000, 0xE085, 0x9FF2]
-      v_stream.concat [0xF94F, 0x6810, 0xAB91, 0x0800, 0x2B27, 0xB3D9, 0x3000, 0x0000]
-      v_stream.concat [0xAC00, 0x0000, 0x0700, 0x0000, 0x0100, 0x0000, 0x4000, 0x0000]
-      v_stream.concat [0x0400, 0x0000, 0x4800, 0x0000, 0x0800, 0x0000, 0x5800, 0x0000]
-      v_stream.concat [0x1200, 0x0000, 0x6800, 0x0000, 0x0C00, 0x0000, 0x8C00, 0x0000]
-      v_stream.concat [0x0D00, 0x0000, 0x9800, 0x0000, 0x1300, 0x0000, 0xA400, 0x0000]
-      v_stream.concat [0x0200, 0x0000, 0xE9FD, 0x0000, 0x1E00, 0x0000, 0x0800, 0x0000]
-      v_stream.concat [0x7261, 0x6E64, 0x796D, 0x0000, 0x1E00, 0x0000, 0x0800, 0x0000]
-      v_stream.concat [0x7261, 0x6E64, 0x796D, 0x0000, 0x1E00, 0x0000, 0x1C00, 0x0000]
-      v_stream.concat [0x4D69, 0x6372, 0x6F73, 0x6F66, 0x7420, 0x4D61, 0x6369, 0x6E74]
-      v_stream.concat [0x6F73, 0x6820, 0x4578, 0x6365, 0x6C00, 0x0000, 0x4000, 0x0000]
-      v_stream.concat [0x10AC, 0x5396, 0x60BC, 0xCC01, 0x4000, 0x0000, 0x40F4, 0xFDAF]
-      v_stream.concat [0x60BC, 0xCC01, 0x0300, 0x0000, 0x0100, 0x0000]
-
-      v_stream = v_stream.pack "s*"
-
-      Storage.new([5].pack('c')+"SummaryInformation", :data=>v_stream, :left => 2)
-    end
-
-
-    # creates the document summary information storage
-    # @return [Storage]
-    def create_document_summary_information
-      v_stream = []
-      v_stream.concat [0xFEFF, 0x0000, 0x030A, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000]
-      v_stream.concat [0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0000, 0x02D5, 0xCDD5]
-      v_stream.concat [0x9C2E, 0x1B10, 0x9397, 0x0800, 0x2B2C, 0xF9AE, 0x3000, 0x0000]
-      v_stream.concat [0xCC00, 0x0000, 0x0900, 0x0000, 0x0100, 0x0000, 0x5000, 0x0000]
-      v_stream.concat [0x0F00, 0x0000, 0x5800, 0x0000, 0x1700, 0x0000, 0x6400, 0x0000]
-      v_stream.concat [0x0B00, 0x0000, 0x6C00, 0x0000, 0x1000, 0x0000, 0x7400, 0x0000]
-      v_stream.concat [0x1300, 0x0000, 0x7C00, 0x0000, 0x1600, 0x0000, 0x8400, 0x0000]
-      v_stream.concat [0x0D00, 0x0000, 0x8C00, 0x0000, 0x0C00, 0x0000, 0x9F00, 0x0000]
-      v_stream.concat [0x0200, 0x0000, 0xE9FD, 0x0000, 0x1E00, 0x0000, 0x0400, 0x0000]
-      v_stream.concat [0x0000, 0x0000, 0x0300, 0x0000, 0x0000, 0x0C00, 0x0B00, 0x0000]
-      v_stream.concat [0x0000, 0x0000, 0x0B00, 0x0000, 0x0000, 0x0000, 0x0B00, 0x0000]
-      v_stream.concat [0x0000, 0x0000, 0x0B00, 0x0000, 0x0000, 0x0000, 0x1E10, 0x0000]
-      v_stream.concat [0x0100, 0x0000, 0x0700, 0x0000, 0x5368, 0x6565, 0x7431, 0x000C]
-      v_stream.concat [0x1000, 0x0002, 0x0000, 0x001E, 0x0000, 0x0013, 0x0000, 0x00E3]
-      v_stream.concat [0x83AF, 0xE383, 0xBCE3, 0x82AF, 0xE382, 0xB7E3, 0x83BC, 0xE383]
-      v_stream.concat [0x8800, 0x0300, 0x0000, 0x0100, 0x0000, 0x0000]
-      v_stream = v_stream.pack 'c*'
-      Storage.new([5].pack('c')+"DocumentSummaryInformation", :data=>v_stream)
-    end
-
-    # Creates the header 
-    # @return [String]
-    def create_header
-      header = []
-      header << -2226271756974174256 # identifier pack as q
-      header << 196670 # version pack as L
-      header << 65534 # byte order pack as s
-      header << 9 # sector shift
-      header << 6 # mini-sector shift
-      header << (fat.size/512.0).ceil # this is the number of FAT sectors in the file at index 6 pack as L
-      header << header.last # this is the first directory sector, index of 7 pack as L
-      header << MINI_CUTOFF # minfat cutoff pack as L
-      # MiniFat starts after directories
-      header << (fat.size/512.0).ceil + (@storages.size/4.0).ceil # this is the sector id for the first minifat index 10 pack as L
-      header << (mini_fat.size/512.0).ceil # minifat sector count index 11 pack as L
-      header << -2 # the first DIFAT - set to end of chain until we exceed a single FAT pack as L
-      header << 0 # number of DIFAT sectors, unless we go beyond 109 FAT sectors this will always be 0 pack as L
-      header << 0 # first FAT sector defined in the DIFAT pack as L
-      header.concat Array.new(108, -1) # Difat sectors pack as L108
-      header.pack(HEADER_PACKING)
-    end
-
-    # Allocates sector chains in a allocation table based on the sector size and stream provided
-    # If a storage obeject is provided, the starting sector value for the storage is updated based on the allocation performed here.
-    # @param [Array] table Allocation table array
-    # @param [Storage | String] stream
-    # @param [Integer] size The cutoff size for the stream. 
-    def allocate_stream(table, stream, size)
-      stream.sector = table.size if stream.respond_to?(:sector)
-      ((stream.size / size.to_f).ceil).times { table << table.size }
-      table[table.size-1] = -2 # this is the CBF chain terminator
-    end
-
-  end
-end