writeexcel 0.3.5 → 0.4.0

data/lib/writeexcel/format.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 ##############################################################################
 #
 # Format - A class for defining Excel formatting.
@@ -10,7 +11,6 @@
 # original written in Perl by John McNamara
 # converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
 #
-require 'nkf'
 
 #
 # Format - A class for defining Excel formatting.
@@ -40,7 +40,6 @@ class Format
     'white'   => 0x09,
     'yellow'  => 0x0D,
   }   # :nodoc:
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]^` ~\0\n]/  # :nodoc:
 
   ###############################################################################
   #
@@ -196,7 +195,7 @@ def copy(other)
     @diag_border    = other.diag_border
 
     @font_only      = other.font_only
-end
+  end
 
   ###############################################################################
   #
@@ -351,7 +350,7 @@ def get_xf  # :nodoc:
     data   = [ifnt, ifmt, style, align, indent,
               border1, border2, border3, icv].pack("vvvvvvvVv")
 
-    return header + data
+    header + data
   end
 
   ###############################################################################
@@ -389,13 +388,15 @@ def get_font  # :nodoc:
     rgch       = @font
     encoding   = @font_encoding
 
+    rgch = convert_to_ascii_if_ascii(rgch)
+
     # Handle utf8 strings
-    if rgch =~ NonAscii
-      rgch = NKF.nkf('-w16B0 -m0 -W', rgch)
+    if rgch.encoding == Encoding::UTF_8
+      rgch = rgch.encode('UTF-16BE')
       encoding = 1
     end
 
-    cch = rgch.length
+    cch = rgch.bytesize
     #
     # Handle Unicode font names.
     if (encoding == 1)
@@ -405,7 +406,7 @@ def get_font  # :nodoc:
     end
 
     record     = 0x31
-    length     = 0x10 + rgch.length
+    length     = 0x10 + rgch.bytesize
     reserved   = 0x00
 
     grbit      = 0x00
@@ -420,7 +421,7 @@ def get_font  # :nodoc:
               sss, uls, bFamily,
               bCharSet, reserved, cch, encoding].pack('vvvvvCCCCCC')
 
-    return header + data + rgch
+    header + data + rgch
   end
 
   ###############################################################################
@@ -436,9 +437,7 @@ def get_font_key  # :nodoc:
 
     key  = "#{@font}#{@size}#{@font_script}#{@underline}#{@font_strikeout}#{@bold}#{@font_outline}"
     key += "#{@font_family}#{@font_charset}#{@font_shadow}#{@color}#{@italic}#{@font_encoding}"
-    result =  key.gsub(' ', '_') # Convert the key to a single word
-
-    return result
+    key.gsub(' ', '_') # Convert the key to a single word
   end
 
   ###############################################################################
@@ -448,7 +447,7 @@ def get_font_key  # :nodoc:
   # Returns the used by Worksheet->_XF()
   #
   def xf_index  # :nodoc:
-    return @xf_index
+    @xf_index
   end
 
   def used_merge  # :nodoc:

data/lib/writeexcel/formula.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 ###############################################################################
 #
 # Formula - A class for generating Excel formulas.
@@ -10,13 +11,12 @@
 # original written in Perl by John McNamara
 # converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
 #
-require 'nkf'
 require 'strscan'
 require 'writeexcel/excelformulaparser'
 
 class Formula < ExcelFormulaParser       #:nodoc:
-
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]^` ~\0\n]/
+  require 'writeexcel/helper'
+  private :convert_to_ascii_if_ascii
 
   attr_accessor :byte_order, :workbook, :ext_sheets, :ext_refs, :ext_ref_count
 
@@ -151,7 +151,7 @@ def parse_tokens(tokens)
       end
     end
 
-    return parse_str
+    parse_str
   end
 
   def scan(formula)
@@ -239,7 +239,7 @@ def reverse(expression)
   def check_volatile(tokens)
     volatile = 0
 
-    (0..tokens.size-1).each do |i|
+    (0..tokens.size - 1).each do |i|
       # If the next token is a function check if it is volatile.
       if tokens[i] == '_func' and @functions[tokens[i+1]][3] != 0
         volatile = 1
@@ -247,7 +247,7 @@ def check_volatile(tokens)
       end
     end
 
-    return volatile
+    volatile
   end
 
   ###############################################################################
@@ -269,7 +269,7 @@ def convert_volatile
   # Convert a boolean token to ptgBool
   #
   def convert_bool(bool)
-    return [@ptg['ptgBool'], bool.to_i].pack("CC")
+    [@ptg['ptgBool'], bool.to_i].pack("CC")
   end
 
 
@@ -297,23 +297,25 @@ def convert_number(num)
   # Convert a string to a ptg Str.
   #
   def convert_string(str)
+    str = convert_to_ascii_if_ascii(str)
+
     encoding = 0
 
     str.sub!(/^"/,'')   # Remove leading  "
     str.sub!(/"$/,'')   # Remove trailing "
     str.gsub!(/""/,'"') # Substitute Excel's escaped double quote "" for "
 
-    length = str.length
+    length = str.bytesize
 
     # Handle utf8 strings
-    if str =~ NonAscii
-      str = NKF.nkf('-w16L0 -m0 -W', str)
+    if str.encoding == Encoding::UTF_8
+      str = str.encode('UTF-16LE')
       encoding = 1
     end
 
     exit "String in formula has more than 255 chars\n" if length > 255
 
-    return [@ptg['ptgStr'], length, encoding].pack("CCC") + str
+    [@ptg['ptgStr'], length, encoding].pack("CCC") + str.encode('BINARY')
   end
 
   ###############################################################################
@@ -337,7 +339,7 @@ def convert_ref2d(cell, _class)
       exit "Unknown function class in formula\n"
     end
 
-    return ptgref + row + col
+    ptgref + row + col
   end
 
   ###############################################################################
@@ -368,7 +370,7 @@ def convert_ref3d(token, _class)
       exit "Unknown function class in formula\n"
     end
 
-    return ptgref + ext_ref + row + col
+    ptgref + ext_ref + row + col
   end
 
   ###############################################################################
@@ -382,8 +384,8 @@ def convert_range2d(range, _class)
     cell1, cell2 = range.split(':')
 
     # A range such as A:D is equivalent to A1:D65536, so add rows as required
-    cell1 = cell1 + '1'     unless cell1 =~ /\d/
-    cell2 = cell2 + '65536' unless cell2 =~ /\d/
+    cell1 += '1'     unless cell1 =~ /\d/
+    cell2 += '65536' unless cell2 =~ /\d/
 
     # Convert the cell references
     row1, col1 = cell_to_packed_rowcol(cell1)
@@ -400,7 +402,7 @@ def convert_range2d(range, _class)
       exit "Unknown function class in formula\n"
     end
 
-    return ptgarea + row1 + row2 + col1 + col2
+    ptgarea + row1 + row2 + col1 + col2
   end
 
   ###############################################################################
@@ -421,8 +423,8 @@ def convert_range3d(token, _class)
     cell1, cell2 = range.split(':')
 
     # A range such as A:D is equivalent to A1:D65536, so add rows as required
-    cell1 = cell1 + '1'     unless cell1 =~ /\d/
-    cell2 = cell2 + '65536' unless cell2 =~ /\d/
+    cell1 += '1'     unless cell1 =~ /\d/
+    cell2 += '65536' unless cell2 =~ /\d/
 
     # Convert the cell references
     row1, col1 = cell_to_packed_rowcol(cell1)
@@ -439,7 +441,7 @@ def convert_range3d(token, _class)
       exit "Unknown function class in formula\n"
     end
 
-    return ptgarea + ext_ref + row1 + row2 + col1+ col2
+    ptgarea + ext_ref + row1 + row2 + col1+ col2
   end
 
   ###############################################################################
@@ -482,7 +484,7 @@ def pack_ext_ref(ext_ref)
       index = @ext_refs[key]
     end
 
-    return [index].pack("v")
+    [index].pack("v")
   end
 
   ###############################################################################
@@ -493,9 +495,11 @@ def pack_ext_ref(ext_ref)
   # sheet names is updated by the add_worksheet() method of the Workbook class.
   #
   def get_sheet_index(sheet_name)
+    sheet_name = convert_to_ascii_if_ascii(sheet_name)
+
     # Handle utf8 sheetnames
-    if sheet_name =~ NonAscii
-      sheet_name = NKF.nkf('-w16B0 -m0 -W', sheet_name)
+    if sheet_name.encoding == Encoding::UTF_8
+      sheet_name = sheet_name.encode('UTF-16BE')
     end
 
     if @ext_sheets[sheet_name].nil?
@@ -540,7 +544,7 @@ def get_ext_sheets
   # updated by the add_worksheet() method of the Workbook class.
   #
   def get_ext_ref_count
-    return @ext_ref_count
+    @ext_ref_count
   end
 
   ###############################################################################
@@ -645,14 +649,14 @@ def cell_to_rowcol(cell)
 
     while (!chars.empty?)
       char = chars.pop   # LS char first
-      col  = col + (char[0] - "A"[0] + 1) * (26**expn)
+      col  += (char.ord - "A".ord + 1) * (26 ** expn)
       expn += 1
     end
     # Convert 1-index to zero-index
     row -= 1
     col -= 1
 
-    return [row, col, row_rel, col_rel]
+    [row, col, row_rel, col_rel]
   end
 
   ###############################################################################
@@ -674,7 +678,7 @@ def cell_to_packed_rowcol(cell)
     row     = [row].pack('v')
     col     = [col].pack('v')
 
-    return [row, col]
+    [row, col]
   end
 
   ###############################################################################
@@ -1025,8 +1029,6 @@ def initialize_hashes
     }
 
   end
-
-
 end
 
 if $0 ==__FILE__

data/lib/writeexcel/helper.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+#
+# helper.rb
+#
+  # Convert to US_ASCII encoding if ascii characters only.
+  def convert_to_ascii_if_ascii(str)
+    return nil if str.nil?
+    ruby_18 do
+      enc = str.encoding
+      begin
+        str = str.encode('ASCII')
+      rescue
+        str.force_encoding(enc)
+      end
+    end ||
+    ruby_19 do
+      if !str.nil? && str.ascii_only?
+        str = [str].pack('a*')
+      end
+    end
+    str
+  end
+  private :convert_to_ascii_if_ascii

data/lib/writeexcel/olewriter.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 ###############################################################################
 #
 # BIFFwriter - An abstract base class for Excel workbooks and worksheets.
@@ -31,7 +32,7 @@ def initialize(arg)
     else
       @io = arg
     end
-    @io.binmode
+    @io.binmode if @io.respond_to?(:binmode)
 
     @filehandle    = ""
     @fileclosed    = false
@@ -92,13 +93,8 @@ def self.open(arg)
   # Write BIFF data to OLE file.
   #
   def write(data)
-#print "ole write\n"
-#print data.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ') + "\n\n"
     @io.write(data)
   end
-#  def print(data)
-#    @io.print(data)
-#  end
 
   ###############################################################################
   #
@@ -148,11 +144,8 @@ def calculate_sizes
   #
   def close
     if @size_allowed == true
-#print "write_padding"
       write_padding          if @biff_only == 0
-#print "write_property_storage"
       write_property_storage if @biff_only == 0
-#print "write_big_block_depot"
       write_big_block_depot  if @biff_only == 0
     end
     @io.close
@@ -262,7 +255,7 @@ def write_pps(name, type, dir, start, size)
     unless name.empty?
       name = name + "\0"
       ord_name = name.unpack("c*")
-      length = name.length * 2
+      length = name.bytesize * 2
     end
 
     rawname        = ord_name.pack("v*")
@@ -284,17 +277,13 @@ def write_pps(name, type, dir, start, size)
     pps_size       = [size].pack("V")     #0x78
 
     write(rawname)
-    for n in 1..64-length
-      write(zero)
-    end
+    write(zero * (64 - length)) if 64 - length >= 1
     write(pps_sizeofname)
     write(pps_type)
     write(pps_prev)
     write(pps_next)
     write(pps_dir)
-    for n in 1..5
-      write(unknown)
-    end
+    write(unknown * 5)
     write(pps_ts1s)
     write(pps_ts1d)
     write(pps_ts2s)

data/lib/writeexcel/properties.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 ###############################################################################
 #
 # Properties - A module for creating Excel property sets.
@@ -36,25 +37,25 @@ def create_summary_property_set(properties)       #:nodoc:
     property_data, offsets = pack_property_data(properties)
 
     # Create the property type and offsets based on the previous calculation.
-    0.upto(properties.size-1) do |i|
-      property_offsets = property_offsets + [properties[i][0], offsets[i]].pack('VV')
+    0.upto(properties.size - 1) do |i|
+      property_offsets += [properties[i][0], offsets[i]].pack('VV')
     end
 
     # Size of size (4 bytes) +  num_property (4 bytes) + the data structures.
-    size = 8 + (property_offsets).length + property_data.length
+    size = 8 + (property_offsets).bytesize + property_data.bytesize
     size = [size].pack('V')
 
-    return  byte_order         +
-            version            +
-            system_id          +
-            class_id           +
-            num_property_sets  +
-            format_id          +
-            offset             +
-            size               +
-            num_property       +
-            property_offsets   +
-            property_data
+    byte_order         +
+    version            +
+    system_id          +
+    class_id           +
+    num_property_sets  +
+    format_id          +
+    offset             +
+    size               +
+    num_property       +
+    property_offsets   +
+    property_data
 end
 
 
@@ -84,11 +85,11 @@ def create_doc_summary_property_set(properties)       #:nodoc:
 
     # Create the property type and offsets based on the previous calculation.
     0.upto(properties.size-1) do |i|
-      property_offsets_0 = property_offsets_0 + [properties[i][0], offsets[i]].pack('VV')
+      property_offsets_0 += [properties[i][0], offsets[i]].pack('VV')
     end
 
     # Size of size (4 bytes) +  num_property (4 bytes) + the data structures.
-    data_len = 8 + (property_offsets_0).length + property_data_0.length
+    data_len = 8 + (property_offsets_0).bytesize + property_data_0.bytesize
     size_0   = [data_len].pack('V')
 
     # The second property set offset is at the end of the first property set.
@@ -108,22 +109,20 @@ def create_doc_summary_property_set(properties)       #:nodoc:
         7D 00 00 00 00 00 00 00 2D 00 39 00 30 00 33 00
     ).join('')].pack('H*')
 
-    return  byte_order         +
-            version            +
-            system_id          +
-            class_id           +
-            num_property_sets  +
-            format_id_0        +
-            offset_0           +
-            format_id_1        +
-            offset_1           +
-
-            size_0             +
-            num_property_0     +
-            property_offsets_0 +
-            property_data_0    +
-
-            property_data_1
+    byte_order         +
+    version            +
+    system_id          +
+    class_id           +
+    num_property_sets  +
+    format_id_0        +
+    offset_0           +
+    format_id_1        +
+    offset_1           +
+    size_0             +
+    num_property_0     +
+    property_offsets_0 +
+    property_data_0    +
+    property_data_1
 end
 
 
@@ -164,11 +163,11 @@ def pack_property_data(properties, offset = 0)       #:nodoc:
         raise "Unknown property type: '#{property_type}'\n"
       end
 
-      offset += packed_property.length
-      data    = data + packed_property
+      offset += packed_property.bytesize
+      data   += packed_property
     end
 
-    return [data, offsets]
+    [data, offsets]
 end
 
 ###############################################################################
@@ -191,37 +190,27 @@ def pack_VT_I2(value)       #:nodoc:
 #
 def pack_VT_LPSTR(str, codepage)       #:nodoc:
     type        = 0x001E
-    string      = str + "\0"
+    string      = str.force_encoding('BINARY') + "\0".encode('BINARY')
 
     if codepage == 0x04E4
       # Latin1
-      byte_string = string
-      length      = byte_string.length
+      length = string.bytesize
     elsif codepage == 0xFDE9
-      # UTF-8
-      nonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]^` ~\0\n]/
-      if string =~ nonAscii
-#        $KCODE = 'u'
-        require 'jcode'
-        byte_string = string
-        length = byte_string.jlength
-      else
-        byte_string = string
-        length = byte_string.length
-      end
+      # utf8
+      length = string.bytesize
     else
-      raise "Unknown codepage: codepage\n"
+      raise "Unknown codepage: #{codepage}\n"
     end
 
     # Pack the data.
-    data = [type, length].pack('VV')
-    data = data + byte_string
+    data  = [type, length].pack('VV')
+    data += string
 
     # The packed data has to null padded to a 4 byte boundary.
     if (extra = length % 4) != 0
-        data  = data + "\0" * (4 - extra)
+        data += "\0" * (4 - extra)
     end
-    return data
+    data
 end
 
 ###############################################################################