robust_excel_ole 1.8 → 1.9

data/lib/robust_excel_ole/general.rb

@@ -33,15 +33,49 @@ module General
 
 end
 
+# @private
+class Integer
+
+  alias old_spaceship <=>
+
+  def <=> other
+    # p other
+    if other.is_a? Array
+      self <=> other.first
+    else
+      old_spaceship other
+    end
+  end
+
+end
+
+# @private
+class Array
+
+  alias old_spaceship <=>
+
+  def <=> other
+    # p other
+    if other.is_a? Integer
+      self <=> [other]
+    else
+      old_spaceship other
+    end
+  end
+
+end
+
+
 # @private
 class WIN32OLE
+  
   # promoting WIN32OLE objects to RobustExcelOle objects
   def to_reo
     case ole_type.name
     when 'Range' then RobustExcelOle::Range.new(self)
-    when '_Worksheet' then Worksheet.new(self)
-    when '_Workbook' then Workbook.new(self)
-    when '_Application' then Excel.new(self)
+    when '_Worksheet' then RobustExcelOle::Worksheet.new(self)
+    when '_Workbook' then RobustExcelOle::Workbook.new(self)
+    when '_Application' then RobustExcelOle::Excel.new(self)
     else
       self
     end

data/lib/robust_excel_ole/range.rb

@@ -73,18 +73,18 @@ module RobustExcelOle
           { }
         end
       end
-      address = Address.new(dest_address)
+      rows, columns = Address.int_range(dest_address)
       dest_sheet = @worksheet if dest_sheet == :__not_provided
-      dest_address_is_position = (address.rows.min == address.rows.max && address.columns.min == address.columns.max)
+      dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
       dest_range_address = if (not dest_address_is_position) 
-          [address.rows.min..address.rows.max,address.columns.min..address.columns.max]
+          [rows.min..rows.max,columns.min..columns.max]
         else
           if (not options[:transpose])
-            [address.rows.min..address.rows.min+self.Rows.Count-1,
-             address.columns.min..address.columns.min+self.Columns.Count-1]
+            [rows.min..rows.min+self.Rows.Count-1,
+             columns.min..columns.min+self.Columns.Count-1]
           else
-            [address.rows.min..address.rows.min+self.Columns.Count-1,
-             address.columns.min..address.columns.min+self.Rows.Count-1]
+            [rows.min..rows.min+self.Columns.Count-1,
+             columns.min..columns.min+self.Rows.Count-1]
           end
         end
       dest_range = dest_sheet.range(dest_range_address)
@@ -95,9 +95,9 @@ module RobustExcelOle
           if dest_range.worksheet.workbook.excel == @worksheet.workbook.excel 
             if options[:transpose]
               self.Copy
-              dest_range.PasteSpecial(:transpose => true) 
+              dest_range.PasteSpecial('transpose' => true) 
             else
-              self.Copy(:destination => dest_range.ole_range)
+              self.Copy('destination' => dest_range.ole_range)
             end            
           else
             if options[:transpose]
@@ -107,7 +107,7 @@ module RobustExcelOle
               @worksheet.workbook.excel.with_displayalerts(false) {added_sheet.Delete}
             else
               self.Copy
-              dest_sheet.Paste(:destination => dest_range.ole_range)
+              dest_sheet.Paste('destination' => dest_range.ole_range)
             end
           end
         end
@@ -122,18 +122,18 @@ module RobustExcelOle
     # @options [Worksheet] the destination worksheet
     # @options [Hash] options: :transpose, :values_only
     def copy_special(dest_address, dest_sheet = :__not_provided, options = { })
-      address = Address.new(dest_address)
+      rows, columns = Address.int_range(dest_address)
       dest_sheet = @worksheet if dest_sheet == :__not_provided
-      dest_address_is_position = (address.rows.min == address.rows.max && address.columns.min == address.columns.max)
+      dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
       dest_range_address = if (not dest_address_is_position) 
-          [address.rows.min..address.rows.max,address.columns.min..address.columns.max]
+          [rows.min..rows.max,columns.min..columns.max]
         else
           if (not options[:transpose])
-            [address.rows.min..address.rows.min+self.Rows.Count-1,
-             address.columns.min..address.columns.min+self.Columns.Count-1]
+            [rows.min..rows.min+self.Rows.Count-1,
+             columns.min..columns.min+self.Columns.Count-1]
           else
-            [address.rows.min..address.rows.min+self.Columns.Count-1,
-             address.columns.min..address.columns.min+self.Rows.Count-1]
+            [rows.min..rows.min+self.Columns.Count-1,
+             columns.min..columns.min+self.Rows.Count-1]
           end
         end
       dest_range = dest_sheet.range(dest_range_address)
@@ -144,9 +144,9 @@ module RobustExcelOle
           if dest_range.worksheet.workbook.excel == @worksheet.workbook.excel     
             if options[:transpose]
               self.Copy
-              dest_range.PasteSpecial(:transpose => true) 
+              dest_range.PasteSpecial('transpose' => true) 
             else
-              self.Copy(:destination => dest_range.ole_range)
+              self.Copy('destination' => dest_range.ole_range)
             end            
           else
             if options[:transpose]
@@ -156,7 +156,7 @@ module RobustExcelOle
               @worksheet.workbook.excel.with_displayalerts(false) {added_sheet.Delete}
             else
               self.Copy
-              dest_sheet.Paste(:destination => dest_range.ole_range)
+              dest_sheet.Paste('destination' => dest_range.ole_range)
             end
           end
         end

data/lib/robust_excel_ole/range_owners.rb

@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  class RangeOwners < REOCommon
+
+    # returns the contents of a range with given name
+    # if the name could not be found or the value could not be determined,
+    #   then return default value, if provided, raise error otherwise
+    # Excel Bug: if a local name without a qualifier is given,
+    #   then by default Excel takes the first worksheet,
+    #   even if a different worksheet is active
+    # @param  [String]      name      the name of the range
+    # @param  [Hash]        opts      the options
+    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
+    # @return [Variant] the contents of a range with given name
+    def namevalue_glob(name, opts = { :default => :__not_provided })
+      name_obj = begin
+        name_object(name)
+      rescue NameNotFound => msg
+        return opts[:default] unless opts[:default] == :__not_provided
+        raise
+      end
+      value = begin
+        name_obj.RefersToRange.Value
+      rescue WIN32OLERuntimeError
+        sheet = if self.is_a?(Worksheet) then self
+                elsif self.is_a?(Workbook) then self.sheet(1)
+                elsif self.is_a?(Excel) then self.workbook.sheet(1)
+        end
+        begin
+          sheet.Evaluate(name_obj.Name).Value
+        rescue # WIN32OLERuntimeError
+          return opts[:default] unless opts[:default] == :__not_provided
+          raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{self}"
+        end
+      end
+      if value == -2146828288 + RobustExcelOle::XlErrName
+        return opts[:default] unless opts[:default] == :__not_provided
+        raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(workbook.stored_filename).inspect rescue nil}"
+      end
+      return opts[:default] unless (opts[:default] == :__not_provided) || value.nil?
+      value
+    end
+
+    # sets the contents of a range
+    # @param [String]  name  the name of a range
+    # @param [Variant] value the contents of the range
+    # @param [FixNum]  color the color when setting a value
+    # @param [Hash]    opts :color [FixNum]  the color when setting the contents
+    def set_namevalue_glob(name, value, opts = { :color => 0 })
+      cell = name_object(name).RefersToRange
+      cell.Interior.ColorIndex = opts[:color]
+      workbook.modified_cells << cell if workbook # unless cell_modified?(cell)
+      cell.Value = value
+    rescue WIN32OLERuntimeError
+      raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
+    end
+
+    # returns the contents of a range with a locally defined name
+    # evaluates the formula if the contents is a formula
+    # if the name could not be found or the range or value could not be determined,
+    # then return default value, if provided, raise error otherwise
+    # @param  [String]      name      the name of a range
+    # @param  [Hash]        opts      the options
+    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
+    # @return [Variant] the contents of a range with given name
+    def namevalue(name, opts = { :default => :__not_provided })
+      return namevalue_glob(name, opts) if self.is_a?(Workbook)
+      begin
+        range = self.Range(name)
+      rescue WIN32OLERuntimeError
+        return opts[:default] unless opts[:default] == :__not_provided
+        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
+      end
+      begin
+        value = range.Value
+      rescue  WIN32OLERuntimeError
+        return opts[:default] unless opts[:default] == :__not_provided
+        raise RangeNotEvaluatable, "cannot determine value of range named #{name.inspect} in #{self.inspect}"
+      end
+      if value == -2146828288 + RobustExcelOle::XlErrName
+        return opts[:default] unless opts[:default] == __not_provided
+        raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(workbook.stored_filename).inspect rescue nil}"
+      end
+      return opts[:default] unless (opts[:default] == :__not_provided) || value.nil?
+      value
+    end
+
+    # assigns a value to a range given a locally defined name
+    # @param [String]  name   the name of a range
+    # @param [Variant] value  the assigned value
+    # @param [Hash]    opts :color [FixNum]  the color when setting the contents
+    def set_namevalue(name, value, opts = { :color => 0 })
+      begin
+        return set_namevalue_glob(name, value, opts) if self.is_a?(Workbook)
+        range = self.Range(name)
+      rescue WIN32OLERuntimeError
+        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
+      end
+      begin
+        range.Interior.ColorIndex = opts[:color]
+        workbook.modified_cells << range if workbook # unless cell_modified?(range)
+        range.Value = value
+      rescue  WIN32OLERuntimeError
+        raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
+      end
+    end
+
+    # @private
+    def nameval(name, opts = { :default => :__not_provided })   # :deprecated: #
+      namevalue_glob(name, opts)
+    end
+
+    # @private
+    def set_nameval(name, value, opts = { :color => 0 })        # :deprecated: #
+      set_namevalue_glob(name, value, opts)
+    end
+
+    # @private
+    def rangeval(name, opts = { :default => :__not_provided })  # :deprecated: #
+      namevalue(name, opts)
+    end
+
+    # @private
+    def set_rangeval(name, value, opts = { :color => 0 })       # :deprecated: #
+      set_namevalue(name, value, opts)
+    end
+
+    # creates a range from a given defined name or address
+    # range(address) does work for Worksheet objects only
+    # @params [Variant] range name or address
+    # @return [Range] a range
+    def range(name_or_address, address2 = :__not_provided)
+      begin
+        if address2 == :__not_provided
+          range = begin
+            RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange) 
+          rescue NameNotFound
+            nil
+          end
+        end
+        if self.is_a?(Worksheet) && (range.nil? || (address2 != :__not_provided))
+          address = name_or_address
+          address = [name_or_address,address2] unless address2 == :__not_provided
+          self.Names.Add('Name' => '__dummy001', 'RefersToR1C1' => '=' + Address.r1c1(address))
+          range = RobustExcelOle::Range.new(name_object('__dummy001').RefersToRange)
+          self.Names.Item('__dummy001').Delete
+          range          
+          # variant via rows, columns:
+          #rows, columns = Address.int_range(address)
+          #ole_range = if rows.nil?
+          #  self.Range(self.Columns(columns.min), self.Columns(columns.max))
+          #elsif columns.nil?
+          #  self.Range(self.Rows(rows.min), self.Rows(rows.max))
+          #else
+          #  self.Range(self.Cells(rows.min, columns.min), self.Cells(rows.max, columns.max))
+          #end
+          ##range = ole_range.to_reo
+          #range = Range.new(ole_range)
+        end
+      rescue WIN32OLERuntimeError
+        address2_string = address2.nil? ? "" : ", #{address2.inspect}"
+        raise RangeNotCreated, "cannot create range (#{name_or_address.inspect}#{address2_string})"
+      end      
+      range
+    end
+
+    def name2range(name)   # :deprecated: #
+      range(name)
+    end
+
+    # adds a name referring to a range given by the row and column
+    # @param [String] name   the range name
+    # @params [Address] address of the range
+    def add_name(name, addr, addr_deprecated = :__not_provided)
+      addr = [addr,addr_deprecated] unless addr_deprecated == :__not_provided
+      begin
+        self.Names.Add('Name' => name, 'RefersToR1C1' => '=' + Address.r1c1(addr))
+      rescue WIN32OLERuntimeError => msg
+        raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}"
+      end
+      name
+    end
+
+    def set_name(name,row,column)     # :deprecated :#
+      add_name(name,row,column)
+    end
+
+    # renames a range
+    # @param [String] name     the previous range name
+    # @param [String] new_name the new range name
+    def rename_range(name, new_name)
+      begin
+        item = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
+      end
+      begin
+        item.Name = new_name
+      rescue WIN32OLERuntimeError
+        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
+      end
+    end
+
+    # deletes a name of a range
+    # @param [String] name     the previous range name
+    # @param [String] new_name the new range name
+    def delete_name(name)
+      begin
+        item = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
+      end
+      begin
+        item.Delete
+      rescue WIN32OLERuntimeError
+        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
+      end
+    end
+
+  private
+
+    def name_object(name)
+      self.Names.Item(name)
+    rescue WIN32OLERuntimeError
+      begin
+        self.Parent.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise RobustExcelOle::NameNotFound, "name #{name.inspect} not in #{self.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/robust_excel_ole/reo_common.rb

@@ -1,11 +1,21 @@
 # -*- coding: utf-8 -*-
 
-LOG_TO_STDOUT = true      unless Object.const_defined?(:LOG_TO_STDOUT)
+LOG_TO_STDOUT = false            unless Object.const_defined?(:LOG_TO_STDOUT)
 REO_LOG_DIR   = ''.freeze        unless Object.const_defined?(:REO_LOG_DIR)
 REO_LOG_FILE  = 'reo.log'.freeze unless Object.const_defined?(:REO_LOG_FILE)
 
 File.delete REO_LOG_FILE rescue nil
 
+unless "any string".respond_to?(:end_with?)
+  class String 
+    def end_with?(*suffixes)
+      suffixes.any? do |suffix|
+        self[-suffix.size .. -1] == suffix
+      end
+    end
+  end
+end
+
 module RobustExcelOle
 
   # @private
@@ -21,7 +31,7 @@ module RobustExcelOle
   end
 
   # @private
-  class SheetREOError < REOError                   
+  class WorksheetREOError < REOError                   
   end
 
   # @private
@@ -122,18 +132,22 @@ module RobustExcelOle
 
   class REOCommon
 
+    # @private
     def excel
       raise TypeREOError, 'receiver instance is neither an Excel nor a Workbook'
     end
 
+    # @private
     def own_methods
       (self.methods - Object.methods).sort
     end
 
+    # @private
     def self.tr1(_text)
       puts :text
     end
 
+    # @private
     def self.trace(text)
       if LOG_TO_STDOUT
         puts text
@@ -144,6 +158,7 @@ module RobustExcelOle
           reo_log_dir = ENV[home]
         else
           reo_log_dir = REO_LOG_DIR
+          #reo_log_dir = "C:/Users/User"
         end
         File.open(reo_log_dir + '/' + REO_LOG_FILE,'a') do |file|
           file.puts text
@@ -151,6 +166,7 @@ module RobustExcelOle
       end
     end
 
+    # @private
     def self.puts_hash(hash)
       hash.each do |e|
         if e[1].is_a?(Hash)
@@ -166,278 +182,4 @@ module RobustExcelOle
 
   end
 
-  class Address < REOCommon
-
-    attr_reader :rows
-    attr_reader :columns
-
-    def initialize(address)
-      address = [address] unless address.is_a?(Array)
-      raise AddressInvalid, 'more than two components' if address.size > 2
-      begin
-        if address.size == 1
-          comp1, comp2 = address[0].split(':')
-          address_comp1 = comp1.gsub(/[A-Z]/,'')
-          address_comp2 = comp1.gsub(/[0-9]/,'')
-          if comp1 != address_comp2 + address_comp1
-            raise AddressInvalid, "address #{comp1.inspect} not in A1-format"
-          end
-          unless comp2.nil?
-            address_comp3 = comp2.gsub(/[A-Z]/,'')
-            address_comp4 = comp2.gsub(/[0-9]/,'')
-            if comp2 != address_comp4 + address_comp3
-              raise AddressInvalid, "address #{comp2.inspect} not in A1-format"
-            end
-            address_comp1 = address_comp1..address_comp3
-            address_comp2 = address_comp2..address_comp4
-          end
-        else
-          address_comp1, address_comp2 = address
-        end
-        address_comp1 = address_comp1..address_comp1 unless address_comp1.is_a?(Object::Range)
-        address_comp2 = address_comp2..address_comp2 unless address_comp2.is_a?(Object::Range)
-        @rows = address_comp1.min.to_i..address_comp1.max.to_i
-        if address_comp2.min.to_i == 0
-          raise AddressInvalid, "address (#{address_comp1.inspect}, #{address_comp2.inspect}) not in A1-format" if address_comp1.min.to_i == 0
-          @columns = str2num(address_comp2.begin)..str2num(address_comp2.end)
-        else
-          @columns = address_comp2.min.to_i..address_comp2.max.to_i
-        end
-      rescue
-        raise AddressInvalid, "address (#{address.inspect}) not in A1- or R1C1-format"
-      end
-    end
-
-    private
-
-    def str2num(str)
-      str = str.upcase
-      sum = 0
-      (1..str.length).each { |i| sum += (str[i - 1].ord - 64) * 26**(str.length - i) }
-      sum
-    end
-
-  end
-
-  class RangeOwners < REOCommon
-
-    # returns the contents of a range with given name
-    # if the name could not be found or the value could not be determined,
-    #   then return default value, if provided, raise error otherwise
-    # Excel Bug: if a local name without a qualifier is given,
-    #   then by default Excel takes the first worksheet,
-    #   even if a different worksheet is active
-    # @param  [String]      name      the name of the range
-    # @param  [Hash]        opts      the options
-    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
-    # @return [Variant] the contents of a range with given name
-    def namevalue_glob(name, opts = { :default => :__not_provided })
-      name_obj = begin
-        name_object(name)
-      rescue NameNotFound => msg
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise
-      end
-      value = begin
-        name_obj.RefersToRange.Value
-      rescue WIN32OLERuntimeError
-        sheet = if self.is_a?(Worksheet) then self
-                elsif self.is_a?(Workbook) then self.sheet(1)
-                elsif self.is_a?(Excel) then self.workbook.sheet(1)
-        end
-        begin
-          sheet.Evaluate(name_obj.Name).Value
-        rescue # WIN32OLERuntimeError
-          return opts[:default] unless opts[:default] == :__not_provided
-          raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{self}"
-        end
-      end
-      if value == -2146828288 + RobustExcelOle::XlErrName
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(workbook.stored_filename).inspect rescue nil}"
-      end
-      return opts[:default] unless (opts[:default] == :__not_provided) || value.nil?
-      value
-    end
-
-    # sets the contents of a range
-    # @param [String]  name  the name of a range
-    # @param [Variant] value the contents of the range
-    # @param [FixNum]  color the color when setting a value
-    # @param [Hash]    opts :color [FixNum]  the color when setting the contents
-    def set_namevalue_glob(name, value, opts = { :color => 0 })
-      cell = name_object(name).RefersToRange
-      cell.Interior.ColorIndex = opts[:color]
-      workbook.modified_cells << cell if workbook # unless cell_modified?(cell)
-      cell.Value = value
-    rescue WIN32OLERuntimeError
-      raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
-    end
-
-    # returns the contents of a range with a locally defined name
-    # evaluates the formula if the contents is a formula
-    # if the name could not be found or the range or value could not be determined,
-    # then return default value, if provided, raise error otherwise
-    # @param  [String]      name      the name of a range
-    # @param  [Hash]        opts      the options
-    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
-    # @return [Variant] the contents of a range with given name
-    def namevalue(name, opts = { :default => :__not_provided })
-      return namevalue_glob(name, opts) if self.is_a?(Workbook)
-      begin
-        range = self.Range(name)
-      rescue WIN32OLERuntimeError
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
-      end
-      begin
-        value = range.Value
-      rescue  WIN32OLERuntimeError
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise RangeNotEvaluatable, "cannot determine value of range named #{name.inspect} in #{self.inspect}"
-      end
-      if value == -2146828288 + RobustExcelOle::XlErrName
-        return opts[:default] unless opts[:default] == __not_provided
-        raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(workbook.stored_filename).inspect rescue nil}"
-      end
-      return opts[:default] unless (opts[:default] == :__not_provided) || value.nil?
-      value
-    end
-
-    # assigns a value to a range given a locally defined name
-    # @param [String]  name   the name of a range
-    # @param [Variant] value  the assigned value
-    # @param [Hash]    opts :color [FixNum]  the color when setting the contents
-    def set_namevalue(name, value, opts = { :color => 0 })
-      begin
-        return set_namevalue_glob(name, value, opts) if self.is_a?(Workbook)
-        range = self.Range(name)
-      rescue WIN32OLERuntimeError
-        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
-      end
-      begin
-        range.Interior.ColorIndex = opts[:color]
-        workbook.modified_cells << range if workbook # unless cell_modified?(range)
-        range.Value = value
-      rescue  WIN32OLERuntimeError
-        raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
-      end
-    end
-
-    def nameval(name, opts = { :default => :__not_provided })   # :deprecated: #
-      namevalue_glob(name, opts)
-    end
-
-    def set_nameval(name, value, opts = { :color => 0 })        # :deprecated: #
-      set_namevalue_glob(name, value, opts)
-    end
-
-    def rangeval(name, opts = { :default => :__not_provided })  # :deprecated: #
-      namevalue(name, opts)
-    end
-
-    def set_rangeval(name, value, opts = { :color => 0 })       # :deprecated: #
-      set_namevalue(name, value, opts)
-    end
-
-    # creates a range from a given defined name or address
-    # @params [Variant] range name or address
-    # @return [Range] a range
-    def range(name_or_address, address2 = :__not_provided)
-      begin
-        if address2 == :__not_provided
-          range = RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange) rescue nil
-        end
-        if self.is_a?(Worksheet) && (range.nil? || (address2 != :__not_provided))
-          address = name_or_address
-          address = [name_or_address,address2] unless address2 == :__not_provided
-          address = Address.new(address)
-          range = RobustExcelOle::Range.new(@ole_worksheet.Range(
-                                              @ole_worksheet.Cells(address.rows.min, address.columns.min),
-                                              @ole_worksheet.Cells(address.rows.max, address.columns.max)
-                                            ))
-        end
-      rescue WIN32OLERuntimeError
-        address2_string = address2.nil? ? "" : ", #{address2.inspect}"
-        raise RangeNotCreated, "cannot create range (#{name_or_address.inspect}#{address2_string})"
-      end      
-      range
-    end
-
-    def name2range(name)   # :deprecated: #
-      range(name)
-    end
-
-    # adds a name referring to a range given by the row and column
-    # @param [String] name   the range name
-    # @params [Address] address of the range
-    def add_name(name, addr, addr_deprecated = :__not_provided)
-      addr = [addr,addr_deprecated] unless addr_deprecated == :__not_provided
-      address = Address.new(addr)
-      address_string = 'Z' + address.rows.min.to_s + 'S' + address.columns.min.to_s +
-                       ':Z' + address.rows.max.to_s + 'S' + address.columns.max.to_s
-      begin
-        self.Names.Add('Name' => name, 'RefersToR1C1' => '=' + address_string)
-      rescue WIN32OLERuntimeError => msg
-        # trace "WIN32OLERuntimeError: #{msg.message}"
-        raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}"
-      end
-      name
-    end
-
-    def set_name(name,row,column)     # :deprecated :#
-      add_name(name,row,column)
-    end
-
-    # renames a range
-    # @param [String] name     the previous range name
-    # @param [String] new_name the new range name
-    def rename_range(name, new_name)
-      begin
-        item = self.Names.Item(name)
-      rescue WIN32OLERuntimeError
-        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
-      end
-      begin
-        item.Name = new_name
-      rescue WIN32OLERuntimeError
-        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
-      end
-    end
-
-    # deletes a name of a range
-    # @param [String] name     the previous range name
-    # @param [String] new_name the new range name
-    def delete_name(name)
-      begin
-        item = self.Names.Item(name)
-      rescue WIN32OLERuntimeError
-        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
-      end
-      begin
-        item.Delete
-      rescue WIN32OLERuntimeError
-        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
-      end
-    end
-
-    private
-
-    def name_object(name)
-      self.Names.Item(name)
-    rescue WIN32OLERuntimeError
-      begin
-        self.Parent.Names.Item(name)
-      rescue WIN32OLERuntimeError
-        raise RobustExcelOle::NameNotFound, "name #{name.inspect} not in #{self.inspect}"
-      end
-    end
-
-    # def cell_modified?(cell)
-    #  workbook.modified_cells.each{|c| return true if c.Name.Value == cell.Name.Value}
-    #  false
-    # end
-
-  end
-
 end