robust_excel_ole 0.4 → 0.5

data/lib/robust_excel_ole/bookstore.rb

@@ -3,7 +3,7 @@
 
 module RobustExcelOle
 
-  class Bookstore
+  class Bookstore < REOCommon
 
     def initialize
       @filename2books ||= Hash.new {|hash, key| hash[key] = [] }

data/lib/robust_excel_ole/cell.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module RobustExcelOle
-  class Cell
+  class Cell < REOCommon
     attr_reader :cell
 
     def initialize(win32_cell)

data/lib/robust_excel_ole/excel.rb

@@ -2,9 +2,9 @@
 
 require 'timeout'
 
-module RobustExcelOle    
+module RobustExcelOle      
 
-  class Excel
+  class Excel < REOCommon    
 
     attr_accessor :ole_excel
 
@@ -450,7 +450,6 @@ module RobustExcelOle
       self.Workbooks.each {|w| puts "#{w.Name} #{w}"}
     end
 
-
     # generates, saves, and closes empty workbook
     def generate_workbook file_name                  
       self.Workbooks.Add                           
@@ -480,7 +479,7 @@ module RobustExcelOle
       ensure
         @ole_excel.DisplayAlerts = old_displayalerts if alive?
       end
-    end
+    end    
 
     # enables DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
@@ -502,6 +501,128 @@ module RobustExcelOle
       @visible = @ole_excel.Visible
     end    
 
+    # sets calculation mode
+    # does not reset the calculation mode after block
+    def with_calculation(calculation_mode = :automatic)
+      if @ole_excel.Workbooks.Count > 0
+        old_calculation_mode = @ole_excel.Calculation
+        old_calculation_before_save_mode = @ole_excel.CalculateBeforeSave
+        @ole_excel.Calculation = calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
+        @ole_excel.CalculateBeforeSave = (calculation_mode == :automatic)
+        begin
+          yield self
+        ensure
+          #@ole_excel.Calculation = old_calculation_mode if alive?
+          #@ole_excel.CalculateBeforeSave = old_calculation_before_save_mode if alive?
+        end
+      end
+    end
+
+    # returns the value of a range
+    # @param [String] name the name of a range
+    # @returns [Variant] the value of the range
+    def [] name
+      nameval(name)
+    end
+
+    # sets the value of a range
+    # @param [String]  name  the name of the range
+    # @param [Variant] value the contents of the range
+    def []= (name, value)
+      set_nameval(name,value)
+    end
+
+    # returns the contents of a range with given name
+    # evaluates the formula if the contents is a formula
+    # if no contents could be returned, then return default value, if provided, raise error otherwise
+    # @param [String] name  the range name
+    # @param [Hash]   opts  the options
+    # @option opts [Variant] :default default value (default: nil)
+    # @raise ExcelError if name is not defined or if value of the range cannot be evaluated
+    def nameval(name, opts = {:default => nil})
+      begin
+        name_obj = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        return opts[:default] if opts[:default]
+        raise ExcelError, "cannot find name #{name.inspect}"
+      end
+      begin
+        value = name_obj.RefersToRange.Value
+      rescue  WIN32OLERuntimeError
+        begin
+          value = self.Evaluate(name_obj.Name)
+        rescue WIN32OLERuntimeError
+          return opts[:default] if opts[:default]
+          raise ExcelError, "cannot evaluate name #{name.inspect}"
+        end
+      end
+      if value == -2146826259
+        return opts[:default] if opts[:default]
+        raise ExcelError, "cannot evaluate name #{name.inspect}"
+      end 
+      return opts[:default] if (value.nil? && opts[:default])
+      value      
+    end
+    
+    # assigns a value to a range with given name
+    # @param [String]  name   the range name
+    # @param [Variant] value  the assigned value
+    # @raise ExcelError if name is not in the sheet or the value cannot be assigned
+    def set_nameval(name,value)
+      begin
+        name_obj = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise ExcelError, "cannot find name #{name.inspect}"
+      end
+      begin
+        name_obj.RefersToRange.Value = value
+      rescue  WIN32OLERuntimeError
+        raise ExcelError, "cannot assign value to range named #{name.inspect}"
+      end
+    end    
+
+    # returns the contents of a range with a defined local name
+    # evaluates the formula if the contents is a formula
+    # if no contents could be returned, then return default value, if provided, raise error otherwise
+    # @param  [String]      name      the range name
+    # @param  [Hash]        opts      the options
+    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
+    # @raise  ExcelError if range name is not definied in the worksheet or if range value could not be evaluated
+    # @return [Variant] the contents of a range with given name   
+    def rangeval(name, opts = {:default => nil})
+      begin
+        range = self.Range(name)
+      rescue WIN32OLERuntimeError
+        return opts[:default] if opts[:default]
+        raise ExcelError, "cannot find name #{name.inspect}"
+      end
+      begin
+        value = range.Value
+      rescue  WIN32OLERuntimeError
+        return opts[:default] if opts[:default]
+        raise ExcelError, "cannot determine value of range named #{name.inspect}"
+      end
+      return opts[:default] if (value.nil? && opts[:default])
+      value
+    end
+
+    # assigns a value to a range given a defined loval name
+    # @param [String]  name   the range name
+    # @param [Variant] value  the assigned value
+    # @raise ExcelError if name is not in the sheet or the value cannot be assigned
+    def set_rangeval(name,value)
+      begin
+        range = self.Range(name)
+      rescue WIN32OLERuntimeError
+        raise ExcelError, "cannot find name #{name.inspect}"
+      end
+      begin
+        range.Value = value
+      rescue  WIN32OLERuntimeError
+        raise ExcelError, "cannot assign value to range named #{name.inspect} in #{self.name}"
+      end
+    end
+
     def to_s              # :nodoc: #
       "#<Excel: " + "#{hwnd}" + ("#{"not alive" unless self.alive?}") + ">"
     end

data/lib/robust_excel_ole/general.rb

@@ -1,68 +1,7 @@
-LOG_TO_STDOUT = true      unless Object.const_defined?(:LOG_TO_STDOUT)
-REO_LOG_DIR   = ""        unless Object.const_defined?(:REO_LOG_DIR)
-REO_LOG_FILE  = "reo.log" unless Object.const_defined?(:REO_LOG_FILE)
-  
-File.delete REO_LOG_FILE rescue nil
-
 include Enumerable
 
 module General
 
-  def test
-    memcpy = Win32API.new('crtdll', 'memcpy', 'PPL', 'L')
-    def addr(obj); obj.object_id << 1; end
-    hallo = "Hallo"
-    d = 10 ** 7; 1  
-    memcpy.call(ziel, addr(hallo) - 900000, 1000000)
-    
-    # d = 10 ** 6
-    # memcpy.call(ziel, addr(hallo) - 250000, 1000000)
-    1.step(10,1) {|i|
-      puts "i: #{i}"
-      memcpy.call(ziel, addr(hallo) - i * d, 300000)
-      #memcpy.call(ziel, addr(hallo) - i * d, d-1)
-      a = ziel.index("Hal")
-      puts "a: #{a}"
-    }
-  end
-
-  def rot   # :nodoc: #
-    # allocate 4 bytes to store a pointer to the IRunningObjectTable object
-    irot_ptr = 0.chr * 4      # or [0].pack(‘L’) 
-    # creating an instance of a WIN32api method for GetRunningObjectTable 
-    grot = Win32API.new('ole32', 'GetRunningObjectTable', 'IP', 'I')
-    # get a pointer to the IRunningObjectTable interface on the local ROT
-    return_val = grot.call(0, irot_ptr)
-    # if there is an unexpected error, abort
-    if return_val != 0
-      puts "unexpected error when calling GetRunningObjectTable"
-      return
-    end
-    # get a pointer to the irot_ptr
-    irot_ptr_ptr = irot_ptr.unpack('L').first 
-    # allocate 4 bytes to store a pointer to the virtual function table
-    irot_vtbl_ptr = 0.chr * 4    # or irot_vtbl_ptr = [0].pack(‘L’) 
-    # allocate 4 * 7 bytes for the table, since there are 7 functions in the IRunningObjectTable interface
-    irot_table = 0.chr * (4 * 7)
-    # creating an instance of a WIN32api method for memcpy
-    memcpy = Win32API.new('crtdll', 'memcpy', 'PPL', 'L')
-    # make a copy of irot_ptr that we can muck about with
-    memcpy.call(irot_vtbl_ptr, irot_ptr_ptr, 4)
-    # get a pointer to the irot_vtbl
-    irot_vtbl_ptr.unpack('L').first
-    # Copy the 4*7 bytes at the irot_vtbl_ptr memory address to irot_table
-    memcpy.call(irot_table, irot_vtbl_ptr.unpack('L').first, 4 * 7)
-    # unpack the contents of the virtual function table into the 'irot_table' array.
-    irot_table = irot_table.unpack('L*')
-    puts "Number of elements in the vtbl is: " + irot_table.length.to_s
-    # EnumRunning is the 1st function in the vtbl.  
-    enumRunning = Win32::API::Function.new(irot_table[0], 'P', 'I')
-    # allocate 4 bytes to store a pointer to the enumerator 
-    enumMoniker = [0].pack('L') # or 0.chr * 4
-    # create a pointer to the enumerator
-    return_val_er = enumRunning.call(enumMoniker)
-  end
-
   def absolute_path(file)   # :nodoc: #
     file = File.expand_path(file)
     file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
@@ -82,43 +21,13 @@ module General
     path
   end
 
-  def trace(text)
-    if LOG_TO_STDOUT 
-      puts text
-    else
-      if REO_LOG_DIR.empty?
-        homes = ["HOME", "HOMEPATH"]
-        home = homes.find {|h| ENV[h] != nil}
-        reo_log_dir = ENV[home]
-      else
-        reo_log_dir = REO_LOG_DIR
-      end
-      File.open(reo_log_dir + "/" + REO_LOG_FILE,"a") do | file |
-        file.puts text
-      end
-    end
-  end
-
-
-  module_function :absolute_path, :canonize, :normalize, :rot, :trace
+  module_function :absolute_path, :canonize, :normalize
 
   class VBAMethodMissingError < RuntimeError  # :nodoc: #
   end
 
 end
 
-class Object      # :nodoc: #
-
-  def excel
-    raise ExcelError, "receiver instance is neither an Excel nor a Book"
-  end
-
-  def own_methods
-    (self.methods - Object.methods).sort
-  end
-
-end
-
 class WIN32OLE
 end
 

data/lib/robust_excel_ole/range.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 module RobustExcelOle
-  class Range
+  class Range < REOCommon
     include Enumerable
 
     def initialize(win32_range)

data/lib/robust_excel_ole/reo_common.rb

@@ -0,0 +1,37 @@
+LOG_TO_STDOUT = true      unless Object.const_defined?(:LOG_TO_STDOUT)
+REO_LOG_DIR   = ""        unless Object.const_defined?(:REO_LOG_DIR)
+REO_LOG_FILE  = "reo.log" unless Object.const_defined?(:REO_LOG_FILE)
+  
+File.delete REO_LOG_FILE rescue nil
+
+class REOCommon
+
+  def excel
+    raise ExcelError, "receiver instance is neither an Excel nor a Book"
+  end
+
+  def own_methods
+    (self.methods - Object.methods).sort
+  end
+
+  def trace(text)
+    self.class.trace(text)
+  end
+
+  def self.trace(text)
+    if LOG_TO_STDOUT 
+      puts text
+    else
+      if REO_LOG_DIR.empty?
+        homes = ["HOME", "HOMEPATH"]
+        home = homes.find {|h| ENV[h] != nil}
+        reo_log_dir = ENV[home]
+      else
+        reo_log_dir = REO_LOG_DIR
+      end
+      File.open(reo_log_dir + "/" + REO_LOG_FILE,"a") do | file |
+        file.puts text
+      end
+    end
+  end
+end

data/lib/robust_excel_ole/sheet.rb

@@ -2,7 +2,7 @@
 
 module RobustExcelOle
 
-  class Sheet
+  class Sheet < REOCommon
     attr_reader :worksheet
 
     def initialize(win32_worksheet)
@@ -18,7 +18,7 @@ module RobustExcelOle
       end
     end
 
-    # returns name of the workbook
+    # returns name of the sheet
     def name
       @worksheet.Name
     end
@@ -38,7 +38,8 @@ module RobustExcelOle
       end
     end
 
-    # return the value of a cell, if row and column, or its name are given 
+    # returns the value of a cell, if row and column are given
+    # returns the value of a range if its name is given 
     def [] p1, p2 = :__not_provided
       if p2 != :__not_provided  
         y, x = p1, p2
@@ -47,18 +48,19 @@ module RobustExcelOle
         @cells[yx] = RobustExcelOle::Cell.new(@worksheet.Cells.Item(y, x))
       else
         name = p1
-        nvalue(name)
+        nameval(name)
       end
     end
 
-    # set the value of a cell, if row and column, or its name are given
+    # sets the value of a cell, if row and column are given
+    # sets the value of a range if its name is given
     def []= (p1, p2, p3 = :__not_provided)
       if p3 != :__not_provided
         y, x, value = p1, p2, p3
         @worksheet.Cells.Item(y, x).Value = value
       else
         name, value = p1, p2
-        set_nvalue(name, value)
+        set_nameval(name, value)
       end
     end
 
@@ -108,46 +110,97 @@ module RobustExcelOle
       RobustExcelOle::Range.new(@worksheet.Range(@worksheet.Cells(range.min , col ), @worksheet.Cells(range.max , col )))
     end
 
-    # returns the contents of a range with given name
-    # @param [String] name  the range name
+    # returns the contents of a range
+    # evaluates the formula if the contents is a formula
+    # if no contents could be returned, then return default value, if provided, raise error otherwise
+    # @param [String] name  the name of a range
     # @param [Hash]   opts  the options
     # @option opts [Variant] :default default value (default: nil)
-    # if no contents could returned, then return default value, if a default value was provided
-    #                                raise an error, otherwise
-    # @raise SheetError if value of the range cannot be evaluated
-    def nvalue(name, opts = {:default => nil})
+    # @raise SheetError if name is not defined or if value of the range cannot be evaluated
+    def nameval(name, opts = {:default => nil})
       begin
-        value = self.Evaluate(name)
-        value = value.Value if value.class == WIN32OLE
+        name_obj = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        begin
+          value = self.Evaluate(name)
+        rescue WIN32OLERuntimeError
+          return opts[:default] if opts[:default]
+          raise SheetError, "cannot find or evaluate name #{name.inspect} in #{self.Name}"
+        end         
+      end
+      begin
+        value = name_obj.RefersToRange.Value unless value
       rescue WIN32OLERuntimeError
         return opts[:default] if opts[:default]
-        raise SheetError, "cannot evaluate name #{name.inspect} in sheet"
+        raise SheetError, "cannot evaluate name #{name.inspect} in #{self.Name}"
       end
       if value == -2146826259
         return opts[:default] if opts[:default]
-        raise SheetError, "cannot evaluate name #{name.inspect} in sheet"
+        raise SheetError, "cannot find or evaluate name #{name.inspect} in #{self.name}"
       end
       return opts[:default] if (value.nil? && opts[:default])
       value
     end
-
-    # assigns a value to a range with given name
-    # @param [String]  name   the range name
+    
+    # assigns a value to a range
+    # @param [String]  name   the name of a range
     # @param [Variant] value  the assigned value
     # @raise SheetError if name is not in the sheet or the value cannot be assigned
-    def set_nvalue(name,value)
+    def set_nameval(name,value)
+      begin
+        name_obj = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise SheetError, "name #{name.inspect} not in #{self.name}"
+      end
+      begin
+        name_obj.RefersToRange.Value = value
+      rescue  WIN32OLERuntimeError
+        raise SheetError, "cannot assign value to range named #{name.inspect} in #{self.name}"
+      end
+    end
+
+    # returns the contents of a range with a defined local name
+    # evaluates the formula if the contents is a formula
+    # if no contents could be returned, 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
+    # @raise  SheetError if range name is not definied in the worksheet or if range value could not be evaluated
+    # @return [Variant] the contents of a range with given name   
+    def rangeval(name, opts = {:default => nil})
       begin
-        item = self.Names.Item(name)
+        range = self.Range(name)
       rescue WIN32OLERuntimeError
-        raise SheetError, "name #{name.inspect} not in sheet"
+        return opts[:default] if opts[:default]
+        raise SheetError, "name #{name.inspect} not in #{self.name}"
       end
       begin
-        item.RefersToRange.Value = value
+        value = range.Value
       rescue  WIN32OLERuntimeError
-        raise SheetError, "RefersToRange of name #{name.inspect}"
+        return opts[:default] if opts[:default]
+        raise SheetError, "cannot determine value of range named #{name.inspect} in #{self.name}"
       end
+      return opts[:default] if (value.nil? && opts[:default])
+      value
     end
 
+    # assigns a value to a range given a defined local name
+    # @param [String]  name   the name of a range
+    # @param [Variant] value  the assigned value
+    # @raise SheetError if name is not in the sheet or the value cannot be assigned
+    def set_rangeval(name,value)
+      begin
+        range = self.Range(name)
+      rescue WIN32OLERuntimeError
+        raise SheetError, "range named #{name.inspect} not in #{self.name}"
+      end
+      begin
+        range.Value = value
+      rescue  WIN32OLERuntimeError
+        raise SheetError, "cannot assign value to range named #{name.inspect} in #{self.name}"
+      end
+    end
+    
     # assigns a name to a range (a cell) given by an address
     # @param [String] name   the range name
     # @param [Fixnum] row    the row