axlsx 1.0.13 → 1.0.14

data/lib/axlsx/drawing/series_title.rb

@@ -6,13 +6,13 @@ module Axlsx
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
-      xml.send('c:tx') {
-        xml.send('c:strRef') {
-          xml.send('c:f', Axlsx::cell_range([@cell]))
-          xml.send('c:strCache') {
-            xml.send('c:ptCount', :val=>1)
-            xml.send('c:pt', :idx=>0) {
-              xml.send('c:v', @text)
+      xml[:c].tx {
+        xml[:c].strRef {
+          xml[:c].f Axlsx::cell_range([@cell])
+          xml[:c].strCache {
+            xml[:c].ptCount :val=>1
+            xml[:c].pt(:idx=>0) {
+              xml[:c].v @text
             }
           }
         }

data/lib/axlsx/drawing/title.rb

@@ -42,18 +42,22 @@ module Axlsx
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
-      xml.send('c:title') {
-        xml.send('c:tx') {
-          xml.send('c:strRef') {
-            xml.send('c:f', Axlsx::cell_range([@cell]))
-            xml.send('c:strCache') {
-              xml.send('c:ptCount', :val=>1)
-              xml.send('c:pt', :idx=>0) {
-                xml.send('c:v', @text)
+      xml[:c].title {
+        unless @text.empty?
+          xml[:c].tx {
+            xml[:c].strRef {
+              xml[:c].f Axlsx::cell_range([@cell])
+              xml[:c].strCache {
+                xml[:c].ptCount :val=>1
+                xml[:c].pt(:idx=>0) {
+                  xml[:c].v @text
+                }
               }
             }
           }
-        }
+        end
+        xml[:c].layout
+        xml[:c].overlay :val=>0
       }      
     end
     

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -58,15 +58,15 @@ module Axlsx
     # @return [String]
     def to_xml(xml)
       #build it for now, break it down later!
-      xml.send('xdr:twoCellAnchor') {
-        xml.send('xdr:from') {
+      xml[:xdr].twoCellAnchor {
+        xml.from {
           from.to_xml(xml)
         }
-        xml.send('xdr:to') {
+        xml.to {
           to.to_xml(xml)
         }
         @object.to_xml(xml)
-        xml.send('xdr:clientData')
+        xml.clientData
       }
     end    
 

data/lib/axlsx/drawing/val_axis.rb

@@ -25,9 +25,9 @@ module Axlsx
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
-      xml.send('c:valAx') {
+      xml.valAx {
         super(xml)
-        xml.send('c:crossBetween', :val=>@crossBetween)
+        xml.crossBetween :val=>@crossBetween
       }
     end
   end

data/lib/axlsx/drawing/val_axis_data.rb

@@ -6,17 +6,15 @@ module Axlsx
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
-      xml.send('c:val') {
-        xml.send('c:numRef') {
-          xml.send('c:f', Axlsx::cell_range(@list))
-          xml.send('c:numCache') {
-            xml.send('c:formatCode', 'General')
-            xml.send('c:ptCount', :val=>size)
+      xml.val {
+        xml.numRef {
+          xml.f Axlsx::cell_range(@list)
+          xml.numCache {
+            xml.formatCode 'General'
+            xml.ptCount :val=>size
             each_with_index do |item, index|
               v = item.is_a?(Cell) ? item.value : item
-              xml.send('c:pt', :idx=>index) {
-                xml.send('c:v', v) 
-              }
+              xml.pt(:idx=>index) { xml.v v }
             end
           }                        
         }

data/lib/axlsx/drawing/view_3D.rb

@@ -72,13 +72,13 @@ module Axlsx
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
     def to_xml(xml)
-      xml.send('c:view3D') {
-        xml.send('c:rotX', :val=>@rotX) unless @rotX.nil?
-        xml.send('c:hPercent', :val=>@hPercent) unless @hPercent.nil?
-        xml.send('c:rotY', :val=>@rotY) unless @rotY.nil?
-        xml.send('c:depthPercent', :val=>@depthPercent) unless @depthPercent.nil?
-        xml.send('c:rAngAx', :val=>@rAngAx) unless @rAngAx.nil?
-        xml.send('c:perspective', :val=>@perspective) unless @perspective.nil?
+      xml[:c].view3D {
+        xml[:c].rotX :val=>@rotX unless @rotX.nil?
+        xml[:c].hPercent :val=>@hPercent unless @hPercent.nil?
+        xml[:c].rotY :val=>@rotY unless @rotY.nil?
+        xml[:c].depthPercent :val=>@depthPercent unless @depthPercent.nil?
+        xml[:c].rAngAx :val=>@rAngAx unless @rAngAx.nil?
+        xml[:c].perspective :val=>@perspective unless @perspective.nil?
       }
     end
   end

data/lib/axlsx/package.rb

@@ -4,6 +4,14 @@ module Axlsx
   # xlsx document including valdation and serialization.
   class Package
 
+    # provides access to the app doc properties for this package
+    # see App
+    attr_reader :app
+
+    # provides access to the core doc properties for the package
+    # see Core
+    attr_reader :core
+
     # Initializes your package
     #
     # @param [Hash] options A hash that you can use to specify the author and workbook for this package.

data/lib/axlsx/util/constants.rb

@@ -12,10 +12,6 @@ module Axlsx
   # extended-properties namespace
   APP_NS = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
 
-  XML_NS_MC="http://schemas.openxmlformats.org/markup-compatibility/2006" 
-
-  XML_NS_X14AC = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac"
-
   # doc props namespace
   APP_NS_VT = "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
 

data/lib/axlsx/util/ms_off_crypto.rb

@@ -0,0 +1,88 @@
+require 'digest'
+require 'base64'
+require 'openssl'
+module Axlsx
+  class MsOffCrypto
+
+    attr_reader :verifier
+    attr_reader :key
+
+    def initialize(password = "passowrd")
+      @password = password
+      @salt_size = 0x10
+      @key_size = 0x100
+      @verifier = rand(16**16).to_s 
+
+      #fixed salt for testing
+      @salt = [0x90,0xAC,0x68,0x0E,0x76,0xF9,0x43,0x2B,0x8D,0x13,0xB7,0x1D,0xB7,0xC0,0xFC,0x0D].join
+      # @salt =Digest::SHA1.digest(rand(16**16).to_s)
+    end
+
+    def encryption_info
+      #         v.major v.minor flags           header length   flags           size            # AES 128 bit
+      header = [3, 0, 2, 0, 0x24, 0, 0, 0, 0xA4, 0, 0, 0, 0x24, 0, 0, 0, 0, 0, 0, 0, 0x0E, 0x66, 0, 0]
+      header.concat [0x04, 0x80, 0, 0, 0x80, 0, 0, 0, 0x18, 0, 0, 0, 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]
+      header.concat [0x10, 0, 0, 0]
+      header.concat [0x90,0xAC,0x68,0x0E,0x76,0xF9,0x43,0x2B,0x8D,0x13,0xB7,0x1D,0xB7,0xC0,0xFC,0x0D]
+      header.concat encrypted_verifier.bytes.to_a.pack('c*').bytes.to_a
+      header.concat [20, 0,0,0]
+      header.concat encrypted_verifier_hash.bytes.to_a.pack('c*').bytes.to_a
+      header.flatten!
+      header.pack('c*')
+    end
+
+    def encryption_verifier
+      {:salt_size => @salt_size, 
+       :salt => @salt, 
+       :encrypted_verifier => encrypted_verifier,
+       :varifier_hash_size => 0x14,
+        :encrypted_verifier_hash =>  encrypted_verifier_hash}
+    end
+
+    # 2.3.3
+    def encrypted_verifier
+      @encrypted_verifier ||= encrypt(@verifier)
+    end
+
+    # 2.3.3
+    def encrypted_verifier_hash
+      verifier_hash = Digest::SHA1.digest(@verifier)
+      verifier_hash << Array.new(32 - verifier_hash.size, 0).join('')
+      @encrypted_verifier_hash ||= encrypt(verifier_hash)
+    end
+
+    # 2.3.4.7 ECMA-376 Document Encryption Key Generation (Standard Encryption)
+    def 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
+      @key ||= x3.bytes.to_a[(0..31)].pack('c*')
+    end
+
+    def verify_password
+      puts decrypt(@encrypted_verifier)
+    end
+
+    def encrypt(data)
+      aes = OpenSSL::Cipher.new("AES-128-ECB")     
+      aes.encrypt
+      aes.key = key
+      aes.update(data)
+    end
+
+    def decrypt(data)
+      aes = OpenSSL::Cipher.new("AES-128-ECB")     
+      aes.decrypt
+      aes.key = key
+      aes.update(data)
+    end
+
+  end
+end

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

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

data/lib/axlsx/version.rb

@@ -1,4 +1,4 @@
 module Axlsx
   # version
-  VERSION="1.0.13"
+  VERSION="1.0.14"
 end

data/lib/axlsx/workbook/workbook.rb

@@ -147,6 +147,7 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
       builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
         xml.workbook(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
           xml.workbookPr(:date1904=>@@date1904)
+          #<x:workbookProtection workbookPassword="xsd:hexBinary data" lockStructure="1" lockWindows="1" />
           xml.sheets {
             @worksheets.each_with_index do |sheet, index|              
               xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -219,6 +219,18 @@ module Axlsx
       [index, row.index]
     end
 
+    # Merges all the cells in a range created between this cell and the cell or string name for a cell  provided
+    # @see worksheet.merge_cells
+    # @param [Cell, String] target The last cell, or str ref for the cell in the merge range
+    def merge(target)
+      range_end = if target.is_a?(String)
+                    target
+                  elsif(target.is_a?(Cell))
+                    target.r
+                  end
+      self.row.worksheet.merge_cells "#{self.r}:#{range_end}" unless range_end.nil?
+    end              
+
     # Serializes the cell
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String] xml text for the cell
@@ -266,6 +278,14 @@ module Axlsx
             }
           }
         end
+      elsif @type == :time
+        # Using hardcoded offsets here as some operating systems will not except a 'negative' offset from the ruby epoc.
+        # (1970)
+        epoc1900 = -2209021200 #Time.local(1900, 1, 1) 
+        epoc1904 = -2082877200 #Time.local(1904, 1, 1) 
+        epoc = Workbook.date1904 ? epoc1904 : epoc1900
+        v = ((@value.localtime.to_f - epoc) /60.0/60.0/24.0).to_f
+        xml.c(:r => r, :s => style) { xml.v v }
       else
         xml.c(:r => r, :s => style) { xml.v value }
       end
@@ -315,15 +335,8 @@ module Axlsx
     # @see Axlsx#date1904
     def cast_value(v)
       if (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
-        v = v.respond_to?(:to_time) ? v.to_time : v
         self.style = STYLE_DATE if self.style == 0
-        # Using hardcoded offsets here as some operating systems will not except a 'negative' offset from the ruby epoc.
-        # (1970)
-        epoc1900 = -2209021200 #Time.local(1900, 1, 1) 
-        epoc1904 = -2082877200 #Time.local(1904, 1, 1) 
-        epoc = Workbook.date1904 ? epoc1904 : epoc1900
-        v = ((v.localtime.to_f - epoc) /60.0/60.0/24.0).to_f
-        ((v * 10**11).round.to_f / 10**11)
+        v.respond_to?(:to_time) ? v.to_time : v
       elsif @type == :float
         v.to_f
       elsif @type == :integer

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

@@ -24,8 +24,16 @@ module Axlsx
     # @return [Array] of Hash 
     attr_reader :auto_fit_data
 
-    # TODO Merge Cells
-    # attr_reader :merge_cells
+    # An array of merged cell ranges e.d "A1:B3"
+    # Content and formatting is read from the first cell.
+    # @return Array
+    attr_reader :merged_cells
+
+    # An range that excel will apply an autfilter to "A1:B3"
+    # This will turn filtering on for the cells in the range.
+    # The first row is considered the header, while subsequent rows are considerd to be data.
+    # @return Array
+    attr_reader :auto_filter
     
     # Creates a new worksheet.
     # @note the recommended way to manage worksheets is Workbook#add_worksheet
@@ -40,8 +48,28 @@ module Axlsx
       self.name = options[:name] || "Sheet" + (index+1).to_s
       @magick_draw = Magick::Draw.new
       @cols = SimpleTypedList.new Cell
+      @merged_cells = []
+    end
+
+    # Creates merge information for this worksheet. 
+    # Cells can be merged by calling the merge_cells method on a worksheet.
+    # @example This would merge the three cells C1..E1    #  
+    #        worksheet.merge_cells "C1:E1"
+    #        # you can also provide an array of cells to be merged
+    #        worksheet.merge_cells worksheet.rows.first.cells[(2..4)]
+    #        #alternatively you can do it from a single cell
+    #        worksheet["C1"].merge worksheet["E1"]
+    # @param [Array, string]    
+    def merge_cells(cells)
+      @merged_cells << if cells.is_a?(String)
+                         cells
+                       elsif cells.is_a?(Array)
+                         cells = cells.sort { |x, y| x.r <=> y.r }
+                         "#{cells.first.r}:#{cells.last.r}"
+                       end 
     end
 
+
     # Returns the cell or cells defined using excel style A1:B3 references.
     # @param [String] cell_def the string defining the cell or range of cells
     # @return [Cell, Array]
@@ -81,6 +109,14 @@ module Axlsx
       @name=v 
     end
 
+    # The auto filter range for the worksheet
+    # @param [String] v
+    # @see auto_filter
+    def auto_filter=(v) 
+      DataTypeValidator.validate "Worksheet.auto_filter", String, v
+      @auto_filter = v
+    end
+
     # The part name of this worksheet
     # @return [String]
     def pn
@@ -214,6 +250,8 @@ module Axlsx
               row.to_xml(xml)
             end
           }
+          xml.autoFilter :ref=>@auto_filter if @auto_filter
+          xml.mergeCells(:count=>@merged_cells.size) { @merged_cells.each { | mc | xml.mergeCell(:ref=>mc) } } unless @merged_cells.empty?
           xml.drawing :"r:id"=>"rId1" if @drawing          
         }
       end
@@ -234,15 +272,21 @@ module Axlsx
     def workbook=(v) DataTypeValidator.validate "Worksheet.workbook", Workbook, v; @workbook = v; end
 
     # Updates auto fit data. 
-    # Autofit data attempts to determine the cell in a column that has the greatest width by comparing the length of the text multiplied by the size of the font.
+    # We store an auto_fit_data item for each column. when a row is added we multiple the font size by the length of the text to 
+    # attempt to identify the longest cell in the column. This is not 100% accurate as it needs to take into account
+    # any formatting that will be applied to the data, as well as the actual rendering size when the length and size is equal 
+    # for two cells.
     # @return [Array] of Cell objects
     # @param [Array] cells an array of cells
     def update_auto_fit_data(cells)
+      # TODO delay this until rendering. too much work when we dont know what they are going to do to the sheet.
       styles = self.workbook.styles
       cellXfs, fonts = styles.cellXfs, styles.fonts
-      sz = fonts[0].sz
+      sz = 11
       cells.each_with_index do |item, index|
+        # ignore formula - there is no way for us to know the result
         next if item.value.is_a?(String) && item.value.start_with?('=')
+
         col = @auto_fit_data[index] || {:longest=>"", :sz=>sz} 
         cell_xf = cellXfs[item.style]
         font = fonts[cell_xf.fontId || 0]
@@ -255,25 +299,37 @@ module Axlsx
       end
       cells
     end
-
+    
     # Determines the proper width for a column based on content.
     # @note 
-    #  From ECMA docs
-    #   Column width measured as the number of characters of the maximum digit width of the numbers 0 .. 9 as 
-    #   rendered in the normal style's font. There are 4 pixels of margin padding (two on each side), plus 1 pixel padding for the gridlines.
-    #   width = Truncate([!{Number of Characters} * !{Maximum Digit Width} + !{5 pixel padding}]/{Maximum Digit Width}*256)/256
+    #   width = Truncate([!{Number of Characters} * !{Maximum Digit Width} + !{5 pixel padding}]/!{Maximum Digit Width}*256)/256
     # @return [Float]
     # @param [Hash] A hash of auto_fit_data 
     def auto_width(col)
-      mdw = 6.0 # maximum digit with is always 6.0 with RMagick's default font
-      mdw_count = 0 
-      best_guess = 1.5  #direct testing shows the results of the documented formula to be a bit too small. This is a best guess scaling
-      font_scale = col[:sz].to_f / (self.workbook.styles.fonts[0].sz.to_f || 11.0)
-      
-      col[:longest].scan(/./mu).each do |i|
-        mdw_count +=1 if @magick_draw.get_type_metrics(i).width >= mdw 
+      mdw_count, font_scale, mdw = 0, col[:sz]/11.0, 6.0
+      mdw_count = col[:longest].scan(/./mu).reduce(0) do | count, char |
+        count +=1 if @magick_draw.get_type_metrics(char).max_advance >= mdw
+        count
       end
-      ((mdw_count * mdw + 5) / mdw * 256) / 256.0 * best_guess * font_scale      
-    end   
+      ((mdw_count * mdw + 5) / mdw * 256) / 256.0 * font_scale
+    end
+
+    # Something to look into:
+    #  width calculation actually needs to be done agains the formatted value for items that apply a 
+    # format
+    # def excel_format(cell)
+    #   # The most common case.
+    #   return time.value.to_s if cell.style == 0
+    #
+    #   # The second most common case   
+    #   num_fmt = workbook.styles.cellXfs[items.style].numFmtId
+    #   return value.to_s if num_fmt == 0
+    #   
+    #   format_code = workbook.styles.numFmts[num_fmt]
+    #   # need to find some exceptionally fast way of parsing value according to
+    #   # an excel format_code
+    #   item.value.to_s
+    # end      
+
   end
 end