robust_excel_ole 1.35 → 1.36

data/lib/robust_excel_ole/excel.rb

@@ -1,12 +1,59 @@
 # -*- coding: utf-8 -*-
 
 require 'weakref'
-require 'Win32API'
+require 'fiddle/import'
 
 def ka
   Excel.kill_all
 end
 
+module User32
+  # Extend this module to an importer
+  extend Fiddle::Importer
+  # Load 'user32' dynamic library into this importer
+  dlload 'user32'
+  # Set C aliases to this importer for further understanding of function signatures
+  typealias 'HWND', 'HANDLE'
+  typealias 'HANDLE', 'void*'
+  typealias 'LPCSTR', 'const char*'
+  typealias 'LPCWSTR', 'const wchar_t*'
+  typealias 'UINT', 'unsigned int'
+  typealias 'HANDLE', 'void*'
+  typealias 'ppvObject', 'void**'
+  typealias 'DWORD', 'unsigned long'
+  typealias 'LPDWORD', 'DWORD*'
+  # Import C functions from loaded libraries and set them as module functions
+  extern 'DWORD GetWindowThreadProcessId(HWND, LPDWORD)'
+  extern 'HWND FindWindowExA(HWND, HWND, LPCSTR, LPCSTR)'
+  extern 'DWORD SetForegroundWindow(HWND)'
+end
+
+module Oleacc
+  # Extend this module to an importer
+  extend Fiddle::Importer
+  # Load 'oleacc' dynamic library into this importer
+  dlload 'oleacc'
+  # Set C aliases to this importer for further understanding of function signatures
+  typealias 'HWND', 'HANDLE'
+  typealias 'HANDLE', 'void*'
+  typealias 'ppvObject', 'void**'
+  typealias 'DWORD', 'unsigned long'
+  typealias 'HRESULT', 'long'  
+  Guid = struct [
+  'unsigned long data1',
+  'unsigned short data2',
+  'unsigned short data3',
+  'unsigned char data4[8]'
+  ]
+  # Import C functions from loaded libraries and set them as module functions
+  extern 'HRESULT AccessibleObjectFromWindow(HWND, DWORD, struct guid*, ppvObject)'
+  #typealias 'REFIID', 'struct guid*'
+  #extern 'HRESULT AccessibleObjectFromWindow(HWND, DWORD, REFIID, ppvObject)'
+  #extern 'HRESULT AccessibleObjectFromWindow(HWND, DWORD, struct GUID*, ppvObject)'
+  #extern 'HRESULT AccessibleObjectFromWindow(HWND, DWORD, void*, ppvObject)'
+  #extern 'HRESULT AccessibleObjectFromWindow(HWND, DWORD, struct GUID*, ppvObject)'
+end
+
 module RobustExcelOle
 
   # This class essentially wraps a Win32Ole Application object. 
@@ -114,7 +161,7 @@ module RobustExcelOle
         @ole_excel = WIN32OLE.new('Excel.Application')
         set_options(opts)
         if opts[:reopen_workbooks]
-          workbook_class.books.each{ |book| book.reopen if !book.alive? && book.excel.alive? && book.excel == self }
+          workbook_class.books.each{ |book| book.open if !book.alive? && book.excel.alive? && book.excel == self }
         end
       end
       self
@@ -294,9 +341,8 @@ module RobustExcelOle
       sleep 0.1
       if finishing_living_excel
         if hwnd
-          process_id = Win32API.new('user32', 'GetWindowThreadProcessId', %w[I P], 'I')
           pid_puffer = ' ' * 32
-          process_id.call(hwnd, pid_puffer)
+          User32::GetWindowThreadProcessId(hwnd, pid_puffer)         
           pid = pid_puffer.unpack('L')[0]
           Process.kill('KILL', pid) rescue nil
         end
@@ -354,10 +400,50 @@ module RobustExcelOle
       WIN32OLE.connect('winmgmts:\\\\.').InstancesOf('win32_process').select { |p| p.Name == 'EXCEL.EXE' }.size
     end
 
-    def self.known_instance_count
+    def self.known_instances_count
       @@hwnd2excel.size
     end
 
+    # returns running Excel instances
+    # !!! This is work in progress
+    # the approach is currently restricted to visible Excel instances with at least one workbook
+    def self.running_excel_instances
+      win32ole_excel_instances = []
+      hwnd = 0
+      loop do
+        hwnd = User32::FindWindowExA(0, hwnd, "XLMAIN", nil).to_i
+        break if hwnd == 0
+        hwnd2 = User32::FindWindowExA(hwnd, 0, "XLDESK", nil).to_i
+        hwnd3 = User32::FindWindowExA(hwnd2, 0, "EXCEL7", nil).to_i
+        interface_address_buffer = ' ' * 8
+        guid = Oleacc::Guid.malloc
+        guid.data1 = 0x20400
+        guid.data2 = 0x0
+        guid.data3 = 0x0
+        guid.data4 = [0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x46]
+        status = Oleacc::AccessibleObjectFromWindow(hwnd3, 0xFFFFFFF0, guid, interface_address_buffer)
+        interface_address = nil
+        if status == 0 
+          interface_address = interface_address_buffer.unpack('L')[0]
+        else
+          raise ExcelREOError, "could not determine the addresss of the specified interface of the Excel object"
+        end
+        accessed_object_buffer = ' ' * 8
+        # open issue: is there a dll containing QueryInterface?
+        status = Ole32::QueryInterface(interface_address, guid, accessed_object_buffer)
+        if status == 0
+          accessed_object = accessed_object_buffer.unpack('L')[0]
+          # open issue: a method, similar to create_win32ole in Win32ole creating a win32ole object 
+          # we could use pr-win32ole (seems to be an old ruby gem, needing C to be installed)
+          ole_excel = create_win32ole(accessed_object)
+          win32ole_excel_instances << ole_excel.Application 
+        else
+          raise ExcelREOError, "could not determine the Excel object from window"
+        end
+      end
+      win32ole_excel_instances.map{|w| w.to_reo}
+    end
+
     # returns a running Excel instance opened with RobustExcelOle
     def self.known_running_instance     
       self.known_running_instances.first
@@ -369,9 +455,8 @@ module RobustExcelOle
       @@hwnd2excel.each do |hwnd,wr_excel|
         next unless wr_excel.weakref_alive?
         excel = wr_excel.__getobj__
-        process_id = Win32API.new('user32', 'GetWindowThreadProcessId', %w[I P], 'I')
         pid_puffer = ' ' * 32
-        process_id.call(hwnd, pid_puffer)
+        User32::GetWindowThreadProcessId(hwnd, pid_puffer)
         pid = pid_puffer.unpack('L')[0]
         pid2excel[pid] = excel
       end
@@ -380,10 +465,10 @@ module RobustExcelOle
     end
 
     class << self
-      alias excels_number instance_count                  # :deprecated :#
-      alias known_excels_number known_instance_count      # :deprecated :#
-      alias known_excel_instance known_running_instance   # :deprecated :#
-      alias known_excel_instances known_running_instances # :deprecated :#
+      alias excels_number instance_count                  # :deprecated: #
+      alias known_excels_number known_instances_count     # :deprecated: #
+      alias known_excel_instance known_running_instance   # :deprecated: #
+      alias known_excel_instances known_running_instances # :deprecated: #
     end
 
   private
@@ -627,11 +712,8 @@ module RobustExcelOle
 
     def focus
       self.visible = true
-      # if not Windows10 then
-      Win32API.new('user32','SetForegroundWindow','I','I').call(@ole_excel.Hwnd)
-      # else
-      # Win32API.new("user32","SetForegroundWindow","","I").call
-      # end
+      status = User32::SetForegroundWindow(@ole_excel.Hwnd)
+      raise ExcelREOError, "could not set Excel window as foreground" if status == 0     
     end
     
     # @private

data/lib/robust_excel_ole/general.rb

@@ -224,18 +224,30 @@ module General
       network = WIN32OLE.new('WScript.Network')
       drives = network.enumnetworkdrives
       count = drives.Count
-      (0..(count - 1)).step(2).map{ |i| NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/')) }
+      # (0..(count - 1)).step(2).map{ |i| NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/')) }      
+      result = (0..(count - 1)).step(2).map { |i| 
+        NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/')) unless drives.Item(i).empty?
+      }.compact
+      result
     end
   end
 
   # @private
   def hostnameshare2networkpath(filename)
     return filename unless filename[0,2] == "//"
-    NetworkDrive.get_all_drives.inject(filename) do |fn_modified, d| 
-      fn_modified.sub(/#{(Regexp.escape(d.network_name))}/i,d.drive_letter)
-    end    
-  end  
-
+    hostname = filename[0,filename[3,filename.length].index('/')+3]
+    filename_wo_hostname = filename[hostname.length+1,filename.length]
+    abs_filename = absolute_path(filename_wo_hostname).tr('\\','/').tr('C:/','c$/')
+    adapted_filename = hostname + "/" + abs_filename
+    NetworkDrive.get_all_drives.each do |d|
+      new_filename = filename.sub(/#{(Regexp.escape(d.network_name))}/i,d.drive_letter)
+      return new_filename if new_filename != filename
+      new_filename = adapted_filename.sub(/#{(Regexp.escape(d.network_name))}/i,d.drive_letter)
+      return new_filename if new_filename != filename
+    end
+    filename
+  end
+  
   # @private
   def absolute_path(file)
     file = file.to_path if file.respond_to?(:to_path)

data/lib/robust_excel_ole/list_object.rb

@@ -60,23 +60,6 @@ module RobustExcelOle
         end
       end
 
-=begin
-
-      ole_table = @ole_table
-
-      @row_class = Class.new(ListRow) do
-
-        @@ole_table = ole_table
-
-        def ole_table
-          @@ole_table
-        end
-      
-      end      
-
-    end
-
-=end
 
     ole_table = @ole_table
 
@@ -141,13 +124,18 @@ module RobustExcelOle
 
   private
 
-   def matching_via_traversing(key_hash, opts)      
+    def matching_via_traversing(key_hash, opts) 
       encode_utf8 = ->(val) {val.respond_to?(:gsub) ? val.encode('utf-8') : val}
       cn2i = column_names_to_index
       max_matching_num = opts[:limit] || 65536     
       matching_rows = @ole_table.ListRows.lazy.select { |listrow|
         rowvalues = listrow.Range.Value.first
-        key_hash.all?{ |key,val| encode_utf8.(rowvalues[cn2i[key]])==val}
+        key_hash.all?{|key,val| 
+          rowvalue = encode_utf8.(rowvalues[cn2i[key]])
+          rowvalue == val || 
+          (val == "0" && rowvalue == 0) ||
+          (rowvalue.respond_to?(:abs) && val.to_i != 0 && rowvalue == val.to_i)
+        }
       }.take(max_matching_num).to_a
     rescue
       raise(TableError, "cannot find row with key #{key_hash}")
@@ -386,6 +374,10 @@ module RobustExcelOle
         self.Parent.to_reo == other_table.Parent.to_reo
     end
 
+    # @private
+    def workbook
+      @workbook ||= ole_table.Parent.Parent.to_reo
+    end
 
     # @private
     # returns true, if the list object responds to VBA methods, false otherwise

data/lib/robust_excel_ole/list_row.rb

@@ -27,6 +27,7 @@ module RobustExcelOle
     # @param [Variant]  column number or column name
     # @return [Variant] value of the cell 
     def [] column_number_or_name
+      column_number_or_name = column_number_or_name.to_s if column_number_or_name.is_a?(Symbol)
       ole_cell = ole_table.Application.Intersect(
         @ole_tablerow.Range, ole_table.ListColumns.Item(column_number_or_name).Range)
       value = ole_cell.Value
@@ -40,6 +41,7 @@ module RobustExcelOle
     # @param [Variant] value of the cell
     def []=(column_number_or_name, value)
       begin
+        column_number_or_name = column_number_or_name.to_s if column_number_or_name.is_a?(Symbol)
         ole_cell = ole_table.Application.Intersect(
           @ole_tablerow.Range, ole_table.ListColumns.Item(column_number_or_name).Range)
         ole_cell.Value = value
@@ -96,27 +98,68 @@ module RobustExcelOle
       other_listrow.is_a?(ListRow) && other_listrow.values == self.values
     end
 
-    def method_missing(name, *args)
-      # this should not happen:
-      raise(TableRowError, "internal error: ole_table not defined") unless self.class.method_defined?(:ole_table)
-      name_str = name.to_s
-      core_name = name_str.chomp('=')
-      column_names = ole_table.HeaderRowRange.Value.first
-      column_name = column_names.find do |c|
-        c == core_name ||
-        c.gsub(/\W/,'_') == core_name ||
-        c.underscore == core_name ||
-        c.underscore.gsub(/\W/,'_') == core_name ||
-        c.replace_umlauts.gsub(/\W/,'_') == core_name ||
-        c.replace_umlauts.underscore.gsub(/\W/,'_') == core_name 
-      end         
-      if column_name
-        define_and_call_method(column_name, name, *args)
-      else
-        super(name, *args)
+    # @private
+    def workbook
+      @workbook ||= workbook_class.new(ole_table.Parent.Parent)
+    end
+
+    # @private
+    def self.workbook_class  
+      @workbook_class ||= begin
+        module_name = parent_name
+        "#{module_name}::Workbook".constantize
+      rescue NameError => e
+        Workbook
       end
     end
 
+    # @private
+    def workbook_class       
+      self.class.workbook_class
+    end
+
+    # @private
+    def column_names
+      ole_table.HeaderRowRange.Value.first
+    end
+
+     # returns true, if the listrow reacts to methods, false otherwise
+    def alive?
+      @ole_tablerow.Parent
+      true
+    rescue
+      @ole_tablerow = nil  # dead object won't be alive again
+      false
+    end
+
+  private
+
+    def valid_similar_names meth_name
+      [
+        meth_name,
+        meth_name.gsub(/\W/,'_'),
+        meth_name.underscore,
+        meth_name.underscore.gsub(/\W/,'_'),
+        meth_name.replace_umlauts.gsub(/\W/,'_'),
+        meth_name.replace_umlauts.underscore.gsub(/\W/,'_')
+      ].uniq
+    end
+
+  public
+
+    # @private
+    def methods
+      @methods ||= begin
+        arr = column_names.map{ |c| valid_similar_names(c) }.flatten
+        (arr + arr.map{|m| m + '='}).map(&:to_sym) + super
+      end
+    end
+
+    # @private
+    def respond_to?(meth_name)
+      methods.include?(meth_name.to_sym)
+    end
+
     # @private
     def to_s    
       inspect  
@@ -129,7 +172,19 @@ module RobustExcelOle
 
   private
 
-    def define_and_call_method(column_name,method_name,*args)
+    def method_missing(meth_name, *args)
+      # this should not happen:
+      raise(TableRowError, "internal error: ole_table not defined") unless self.class.method_defined?(:ole_table)
+      if respond_to?(meth_name)
+        core_name = meth_name.to_s.chomp('=')
+        column_name = column_names.find{ |c| valid_similar_names(c).include?(core_name) }
+        define_and_call_method(column_name, meth_name, *args) if column_name
+      else
+        super(meth_name, *args)
+      end
+    end
+
+    def define_and_call_method(column_name, method_name, *args)
       #column_name = column_name.force_encoding('cp850')
       ole_cell = ole_table.Application.Intersect(
           @ole_tablerow.Range, ole_table.ListColumns.Item(column_name).Range)

data/lib/robust_excel_ole/range.rb

@@ -223,6 +223,11 @@ module RobustExcelOle
       @worksheet.workbook.excel
     end
 
+    # @private
+    def workbook
+      @workbook ||= @worksheet.workbook
+    end
+
     # @private
     # returns true, if the Range object responds to VBA methods, false otherwise
     def alive?
@@ -231,7 +236,7 @@ module RobustExcelOle
     rescue
       # trace $!.message
       false
-    end
+    end    
 
     # @private
     def to_s

data/lib/robust_excel_ole/range_owners.rb

@@ -15,22 +15,25 @@ module RobustExcelOle
     # @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_global(name, opts = { default: :__not_provided })
-      name_obj = begin
-        get_name_object(name)
-      rescue NameNotFound => msg
-        raise
-      end
-      ole_range = name_obj.RefersToRange
-      worksheet = self if self.is_a?(Worksheet)
-      value = begin
-        if !::RANGES_JRUBY_BUG       
-          ole_range.Value
-        else
-          values = RobustExcelOle::Range.new(ole_range, worksheet).v
-          (values.size==1 && values.first.size==1) ? values.first.first : values
+      begin
+        name_obj = begin
+          get_name_object(name)
+        rescue NameNotFound
+          raise
         end
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
+        ole_range = name_obj.RefersToRange
+        worksheet = self if self.is_a?(Worksheet)
+        value = begin
+          if !::RANGES_JRUBY_BUG       
+           ole_range.Value
+          else
+            values = RobustExcelOle::Range.new(ole_range, worksheet).v
+            (values.size==1 && values.first.size==1) ? values.first.first : values
+          end
+        end
+      rescue # WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
         sheet = if self.is_a?(Worksheet) then self
+        # chooses simply the 1st worksheet?
         elsif self.is_a?(Workbook) then self.sheet(1)
         end
         begin
@@ -42,16 +45,20 @@ module RobustExcelOle
             values = RobustExcelOle::Range.new(ole_range, worksheet).v
             (values.size==1 && values.first.size==1) ? values.first.first : values
           end
-        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
+        rescue # WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
           return opts[:default] unless opts[:default] == :__not_provided
-          raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{self}"
+          if name_obj.nil?
+            raise NameNotFound, "cannot find name #{name.inspect}"
+          else
+            raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect}"
+          end
         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?
+      return opts[:default] if opts[:default] != :__not_provided && !value.nil?
       value
     end
 

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.35"
+  VERSION = "1.36"
 end