writeexcel 0.4.0 → 0.4.1

data/lib/writeexcel/colors.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+class Colors
+  COLORS = {
+    :aqua    => 0x0F,
+    :cyan    => 0x0F,
+    :black   => 0x08,
+    :blue    => 0x0C,
+    :brown   => 0x10,
+    :magenta => 0x0E,
+    :fuchsia => 0x0E,
+    :gray    => 0x17,
+    :grey    => 0x17,
+    :green   => 0x11,
+    :lime    => 0x0B,
+    :navy    => 0x12,
+    :orange  => 0x35,
+    :pink    => 0x21,
+    :purple  => 0x14,
+    :red     => 0x0A,
+    :silver  => 0x16,
+    :white   => 0x09,
+    :yellow  => 0x0D,
+  }   # :nodoc:
+
+  ###############################################################################
+  #
+  # get_color(colour)
+  #
+  # Used in conjunction with the set_xxx_color methods to convert a color
+  # string into a number. Color range is 0..63 but we will restrict it
+  # to 8..63 to comply with Gnumeric. Colors 0..7 are repeated in 8..15.
+  #
+  def get_color(color = nil) # :nodoc:
+    if color.respond_to?(:to_int) && color.respond_to?(:+)
+      # the default color if arg is outside range,
+      if color < 0 || 63 < color
+        0x7FFF
+      # or an index < 8 mapped into the correct range,
+      elsif color < 8
+        (color + 8).to_i
+      # or an integer in the valid range
+      else
+        color.to_i
+      end
+    elsif color.respond_to?(:to_sym)
+      color = color.downcase.to_sym if color.respond_to?(:to_str)
+      # or the color string converted to an integer,
+      if COLORS.has_key?(color)
+        COLORS[color]
+      # or the default color if string is unrecognised,
+      else
+        0x7FFF
+      end
+    else
+      0x7FFF
+    end
+  end
+end

data/lib/writeexcel/compatibility.rb

@@ -222,7 +222,7 @@ def ord
 
   unless "".respond_to?(:force_encoding)
     def force_encoding(encoding)
-      if encoding.kind_of?(String)
+      if encoding.respond_to?(:to_str)
         @encoding = case encoding
           when /ASCII/i
             Encoding::ASCII

data/lib/writeexcel/debug_info.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+require 'writeexcel/caller_info'
+
+if defined?($debug)
+  class BIFFWriter
+    include CallerInfo
+
+    def append(*args)
+      data = args.collect{ |arg| arg.dup.force_encoding('ASCII-8BIT') }.join
+      print_caller_info(data, :method => 'append')
+      super
+    end
+
+    def prepend(*args)
+      data = args.collect{ |arg| arg.dup.force_encoding('ASCII-8BIT') }.join
+      print_caller_info(data, :method => 'prepend')
+      super
+    end
+
+    def print_caller_info(data, param = {})
+      infos = caller_info
+
+      print "#{param[:method]}\n" if param[:method]
+      infos.each do |info|
+        print "#{info[:file]}:#{info[:line]}"
+        print " in #{info[:method]}" if info[:method]
+        print "\n"
+      end
+      print data.unpack('C*').map! {|byte| sprintf("%02X", byte) }.join(' ') + "\n\n"
+    end
+  end
+end

data/lib/writeexcel/excelformula.y

@@ -1,139 +1,139 @@
-#
-# copyright (c) 2009, 2010  Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
-
-
-class ExcelFormulaParser
-
-prechigh
-  nonassoc UMINUS
-  right    '^'
-  left     '&'
-  left     '*' '/'
-  left     '+' '-'
-  left     '<' '>' '<=' '>=' '<>'
-  left     '='
-preclow
-
-rule
-
-  formula      : expr_list
-
-  expr_list    :                      { result = [] }
-               | expr_list expr EOL   { result.push val[1], '_arg', '1' }
-               | expr_list EOL
-
-  expr         : expr '+' expr        { result = [ val[0], val[2], 'ptgAdd' ] }
-               | expr '-' expr        { result = [ val[0], val[2], 'ptgSub' ] }
-               | expr '*' expr        { result = [ val[0], val[2], 'ptgMul' ] }
-               | expr '/' expr        { result = [ val[0], val[2], 'ptgDiv' ] }
-               | expr '^' expr        { result = [ val[0], val[2], 'ptgPower' ] }
-               | expr '&' expr        { result = [ val[0], val[2], 'ptgConcat' ] }
-               | expr LT  expr        { result = [ val[0], val[2], 'ptgLT' ] }
-               | expr GT  expr        { result = [ val[0], val[2], 'ptgGT' ] }
-               | expr LE  expr        { result = [ val[0], val[2], 'ptgLE' ] }
-               | expr GE  expr        { result = [ val[0], val[2], 'ptgGE' ] }
-               | expr NE  expr        { result = [ val[0], val[2], 'ptgNE' ] }
-               | expr '=' expr        { result = [ val[0], val[2], 'ptgEQ' ] }
-               | primary
-
-  primary      : '(' expr ')'         { result = [ val[1], '_arg', '1', 'ptgParen'] }
-               | '-' expr  = UMINUS   { result = [ '_num', '-1', val[1], 'ptgMul' ] }
-               | FUNC
-               | NUMBER               { result = [ '_num',     val[0] ] }
-               | STRING               { result = [ '_str',     val[0] ] }
-               | REF2D                { result = [ '_ref2d',   val[0] ] }
-               | REF3D                { result = [ '_ref3d',   val[0] ] }
-               | RANGE2D              { result = [ '_range2d', val[0] ] }
-               | RANGE3D              { result = [ '_range3d', val[0] ] }
-               | NAME                 { result = [ '_name',    val[0] ] }
-               | TRUE                 { result = [ 'ptgBool',  '1'    ] }
-               | FALSE                { result = [ 'ptgBool',  '0'    ] }
-               | funcall
-
-  funcall      : FUNC '(' args ')'    { result = [ '_class', val[0], val[2], '_arg', val[2].size.to_s, '_func', val[0] ] }
-               | FUNC '(' ')'         { result = [ '_func', val[0] ] }
-
-  args         : expr                 { result = val }
-               | args ',' expr        { result.push val[2] }
-
-end
-
-
----- footer
-
-class ExcelFormulaParserError < StandardError; end
-
-class Node
-
-   def exec_list(nodes)
-      v = nil
-      nodes.each { |i| v = i.evaluate }
-      v
-   end
-
-   def excelformulaparser_error(msg)
-      raise ExcelFormulaParserError,
-               "in #{fname}:#{lineno}: #{msg}"
-   end
-
-end
-
-class RootNode < Node
-
-   def initialize(tree)
-      @tree = tree
-   end
-
-   def evaluate
-      exec_list @tree
-   end
-
-end
-
-
-class FuncallNode < Node
-
-   def initialize(func, args)
-      @func = func
-      @args = args
-   end
-
-   def evaluate
-      arg = @args.collect {|i| i.evaluate }
-      out = []
-      arg.each { |i| o.push i }
-      o.push @func
-      p o
-   end
-
-end
-
-class NumberNode < Node
-
-   def initialize(val)
-      @val = val
-   end
-
-   def evaluate
-      p @val
-   end
-
-end
-
-class OperateNode < Node
-
-   def initialize(op, left, right)
-      @op = op
-      @left = left
-      @right = right
-   end
-
-   def evaluate
-      o = []
-      o.push @left
-      o.push @right
-      o.push @op
-      p o
-   end
-end
-
+#
+# copyright (c) 2009, 2010  Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+
+
+class ExcelFormulaParser
+
+prechigh
+  nonassoc UMINUS
+  right    '^'
+  left     '&'
+  left     '*' '/'
+  left     '+' '-'
+  left     '<' '>' '<=' '>=' '<>'
+  left     '='
+preclow
+
+rule
+
+  formula      : expr_list
+
+  expr_list    :                      { result = [] }
+               | expr_list expr EOL   { result.push val[1], '_arg', '1' }
+               | expr_list EOL
+
+  expr         : expr '+' expr        { result = [ val[0], val[2], 'ptgAdd' ] }
+               | expr '-' expr        { result = [ val[0], val[2], 'ptgSub' ] }
+               | expr '*' expr        { result = [ val[0], val[2], 'ptgMul' ] }
+               | expr '/' expr        { result = [ val[0], val[2], 'ptgDiv' ] }
+               | expr '^' expr        { result = [ val[0], val[2], 'ptgPower' ] }
+               | expr '&' expr        { result = [ val[0], val[2], 'ptgConcat' ] }
+               | expr LT  expr        { result = [ val[0], val[2], 'ptgLT' ] }
+               | expr GT  expr        { result = [ val[0], val[2], 'ptgGT' ] }
+               | expr LE  expr        { result = [ val[0], val[2], 'ptgLE' ] }
+               | expr GE  expr        { result = [ val[0], val[2], 'ptgGE' ] }
+               | expr NE  expr        { result = [ val[0], val[2], 'ptgNE' ] }
+               | expr '=' expr        { result = [ val[0], val[2], 'ptgEQ' ] }
+               | primary
+
+  primary      : '(' expr ')'         { result = [ val[1], '_arg', '1', 'ptgParen'] }
+               | '-' expr  = UMINUS   { result = [ '_num', '-1', val[1], 'ptgMul' ] }
+               | FUNC
+               | NUMBER               { result = [ '_num',     val[0] ] }
+               | STRING               { result = [ '_str',     val[0] ] }
+               | REF2D                { result = [ '_ref2d',   val[0] ] }
+               | REF3D                { result = [ '_ref3d',   val[0] ] }
+               | RANGE2D              { result = [ '_range2d', val[0] ] }
+               | RANGE3D              { result = [ '_range3d', val[0] ] }
+               | NAME                 { result = [ '_name',    val[0] ] }
+               | TRUE                 { result = [ 'ptgBool',  '1'    ] }
+               | FALSE                { result = [ 'ptgBool',  '0'    ] }
+               | funcall
+
+  funcall      : FUNC '(' args ')'    { result = [ '_class', val[0], val[2], '_arg', val[2].size.to_s, '_func', val[0] ] }
+               | FUNC '(' ')'         { result = [ '_func', val[0] ] }
+
+  args         : expr                 { result = val }
+               | args ',' expr        { result.push val[2] }
+
+end
+
+
+---- footer
+
+class ExcelFormulaParserError < StandardError; end
+
+class Node
+
+   def exec_list(nodes)
+      v = nil
+      nodes.each { |i| v = i.evaluate }
+      v
+   end
+
+   def excelformulaparser_error(msg)
+      raise ExcelFormulaParserError,
+               "in #{fname}:#{lineno}: #{msg}"
+   end
+
+end
+
+class RootNode < Node
+
+   def initialize(tree)
+      @tree = tree
+   end
+
+   def evaluate
+      exec_list @tree
+   end
+
+end
+
+
+class FuncallNode < Node
+
+   def initialize(func, args)
+      @func = func
+      @args = args
+   end
+
+   def evaluate
+      arg = @args.collect {|i| i.evaluate }
+      out = []
+      arg.each { |i| o.push i }
+      o.push @func
+      p o
+   end
+
+end
+
+class NumberNode < Node
+
+   def initialize(val)
+      @val = val
+   end
+
+   def evaluate
+      p @val
+   end
+
+end
+
+class OperateNode < Node
+
+   def initialize(op, left, right)
+      @op = op
+      @left = left
+      @right = right
+   end
+
+   def evaluate
+      o = []
+      o.push @left
+      o.push @right
+      o.push @op
+      p o
+   end
+end
+

data/lib/writeexcel/format.rb

@@ -17,29 +17,10 @@
 #
 # See CELL FORMATTING, FORMAT METHODS, COLOURS IN EXCEL in WriteExcel's rdoc.
 #
-class Format
-
-  COLORS = {
-    'aqua'    => 0x0F,
-    'cyan'    => 0x0F,
-    'black'   => 0x08,
-    'blue'    => 0x0C,
-    'brown'   => 0x10,
-    'magenta' => 0x0E,
-    'fuchsia' => 0x0E,
-    'gray'    => 0x17,
-    'grey'    => 0x17,
-    'green'   => 0x11,
-    'lime'    => 0x0B,
-    'navy'    => 0x12,
-    'orange'  => 0x35,
-    'pink'    => 0x21,
-    'purple'  => 0x14,
-    'red'     => 0x0A,
-    'silver'  => 0x16,
-    'white'   => 0x09,
-    'yellow'  => 0x0D,
-  }   # :nodoc:
+require 'writeexcel/compatibility'
+require 'writeexcel/colors'
+
+class Format < Colors
 
   ###############################################################################
   #
@@ -139,8 +120,6 @@ def initialize(xf_index = 0, properties = {})   # :nodoc:
   # copying.
   #
   def copy(other)
-    return unless other.kind_of?(Format)
-
     # copy properties except xf, merge_range, used_merge
     # Copy properties
     @type           = other.type
@@ -392,7 +371,7 @@ def get_font  # :nodoc:
 
     # Handle utf8 strings
     if rgch.encoding == Encoding::UTF_8
-      rgch = rgch.encode('UTF-16BE')
+      rgch = utf8_to_16be(rgch)
       encoding = 1
     end
 
@@ -634,48 +613,6 @@ def font_only  # :nodoc:
     @font_only
   end
 
-  ###############################################################################
-  #
-  # get_color(colour)
-  #
-  # Used in conjunction with the set_xxx_color methods to convert a color
-  # string into a number. Color range is 0..63 but we will restrict it
-  # to 8..63 to comply with Gnumeric. Colors 0..7 are repeated in 8..15.
-  #
-  def get_color(colour = nil)  # :nodoc:
-    # Return the default color, 0x7FFF, if undef,
-    return 0x7FFF if colour.nil?
-
-    if colour.kind_of?(Numeric)
-      if colour < 0
-        return 0x7FFF
-
-      # or an index < 8 mapped into the correct range,
-      elsif colour < 8
-        return (colour + 8).to_i
-
-      # or the default color if arg is outside range,
-      elsif colour > 63
-        return 0x7FFF
-
-      # or an integer in the valid range
-      else
-        return colour.to_i
-      end
-    elsif colour.kind_of?(String)
-      # or the color string converted to an integer,
-      if COLORS.has_key?(colour)
-        return COLORS[colour]
-
-      # or the default color if string is unrecognised,
-      else
-        return 0x7FFF
-      end
-    else
-      return 0x7FFF
-    end
-  end
-
   ###############################################################################
   #
   # class method    Format._get_color(colour)
@@ -684,38 +621,8 @@ def get_color(colour = nil)  # :nodoc:
   #
   #  this is cut & copy of get_color().
   #
-  def self._get_color(colour)  # :nodoc:
-    # Return the default color, 0x7FFF, if undef,
-    return 0x7FFF if colour.nil?
-
-    if colour.kind_of?(Numeric)
-      if colour < 0
-        return 0x7FFF
-
-        # or an index < 8 mapped into the correct range,
-      elsif colour < 8
-        return (colour + 8).to_i
-
-        # or the default color if arg is outside range,
-      elsif 63 < colour
-        return 0x7FFF
-
-        # or an integer in the valid range
-      else
-        return colour.to_i
-      end
-    elsif colour.kind_of?(String)
-      # or the color string converted to an integer,
-      if COLORS.has_key?(colour)
-        return COLORS[colour]
-
-        # or the default color if string is unrecognised,
-      else
-        return 0x7FFF
-      end
-    else
-      return 0x7FFF
-    end
+  def self._get_color(color)  # :nodoc:
+    Colors.new.get_color(color)
   end
 
   ###############################################################################
@@ -746,9 +653,9 @@ def set_type(type = nil)  # :nodoc:
   #     format.set_size(30)
   #
   def set_size(size = 1)
-    if size.kind_of?(Numeric) && size >= 1
-      @size = size.to_i
-    end
+   if size.respond_to?(:to_int) && size.respond_to?(:+) && size >= 1 # avoid Symbol
+     @size = size.to_int
+   end
   end
 
   #
@@ -809,17 +716,16 @@ def set_italic(arg = 1)
   # value to 1 and use normal bold.
   #
   def set_bold(weight = nil)
+
     if weight.nil?
       weight = 0x2BC
-    elsif !weight.kind_of?(Numeric)
+    elsif !weight.respond_to?(:to_int) || !weight.respond_to?(:+) # avoid Symbol
       weight = 0x190
-    elsif weight == 1                    # Bold text
+    elsif weight == 1                       # Bold text
       weight = 0x2BC
-    elsif weight == 0                    # Normal text
-      weight = 0x190
-    elsif weight <  0x064                # Lower bound
+    elsif weight == 0                       # Normal text
       weight = 0x190
-    elsif weight >  0x3E8                # Upper bound
+    elsif weight <  0x064 || 0x3E8 < weight # Out bound
       weight = 0x190
     else
       weight = weight.to_i
@@ -1055,12 +961,7 @@ def set_hidden(arg = 1)
   # For further examples see the 'Alignment' worksheet created by formats.rb.
   #
   def set_align(align = 'left')
-
-    return unless align.kind_of?(String)
-
-    location = align.downcase
-
-    case location
+    case align.to_s.downcase
     when 'left'             then set_text_h_align(1)
     when 'centre', 'center' then set_text_h_align(2)
     when 'right'            then set_text_h_align(3)
@@ -1078,6 +979,7 @@ def set_align(align = 'left')
     when 'vjustify'         then set_text_v_align(3)
     when 'vdistributed'     then set_text_v_align(4)
     when 'vequal_space'     then set_text_v_align(4) # ParseExcel
+    else nil
     end
   end
 
@@ -1338,9 +1240,6 @@ def set_right_color(color)
   # from top to bottom.
   #
   def set_rotation(rotation)
-    # Argument should be a number
-    return unless rotation.kind_of?(Numeric)
-
     # The arg type can be a double but the Excel dialog only allows integers.
     rotation = rotation.to_i
 
@@ -1390,11 +1289,11 @@ def set_format_properties(*properties)   # :nodoc:
     return if properties.empty?
     properties.each do |property|
       property.each do |key, value|
-        # Strip leading "-" from Tk style properties e.g. -color => 'red'.
-        key.sub!(/^-/, '') if key.kind_of?(String)
+        # Strip leading "-" from Tk style properties e.g. "-color" => 'red'.
+        key.sub!(/^-/, '') if key.respond_to?(:to_str)
 
         # Create a sub to set the property.
-        if value.kind_of?(String)
+        if value.respond_to?(:to_str) || !value.respond_to?(:+)
           s = "set_#{key}('#{value}')"
         else
           s = "set_#{key}(#{value})"
@@ -1686,10 +1585,10 @@ def method_missing(name, *args)  # :nodoc:
     else                            # for "set_xxx" methods
       value = args[0].nil? ? 1 : args[0]
     end
-    if value.kind_of?(String)
-      s = "#{attribute} = \"#{value.to_s}\""
+    if value.respond_to?(:to_str) || !value.respond_to?(:+)
+      s = %Q!#{attribute} = "#{value.to_s}"!
     else
-      s = "#{attribute} =   #{value.to_s}"
+      s = %Q!#{attribute} =   #{value.to_s}!
     end
     eval s
   end