com 0.3.0

data/lib/com/methodinvocationerror.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+# Represents an COM method invocation error.
+class COM::MethodInvocationError < COM::Error
+  extend COM::PatternError
+
+  pattern %r{^\s*([^\n]*)\n
+              \s*OLE\serror\scode:([0-9a-fA-F]+)
+              \s+in\s+([^\n]+)\n
+              \s*([^\n]+)\n
+              \s*HRESULT\serror\scode:0x([0-9a-fA-F]+)[^\n]*\n
+              \s*(.+)$}xu
+
+  class << self
+    # This is an internal method used by COM::Error.
+    def replace(error)
+      m = pattern.match(error.message)
+      new(m[4], m[1], m[3], m[2].to_i(16), m[5].to_i(16), m[6])
+    end
+  end
+
+  # Creates a new COM::MethodInvocationError with _message_.
+  #
+  # @param [#to_str] message Error message
+  # @param [String] method Method error occurred in
+  # @param [String] server Server error occurred in
+  # @param [Integer] code COM error code
+  # @param [Integer] hresult_code HRESULT error code
+  # @param [String] hresult_message HRESULT error message
+  def initialize(message, method = '', server = '', code = -1,
+                 hresult_code = -1, hresult_message = '')
+    super message
+    @method, @server, @code, @hresult_code, @hresult_message =
+      method, server, code, hresult_code, hresult_message
+  end
+
+  attr_reader :method, :server, :code, :hresult_code, :hresult_message
+end

data/lib/com/object.rb

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+
+class COM::Object
+  # Creates a new instance based on _com_.  It is important that subclasses
+  # call `super` if they override this method.
+  #
+  # @param [WIN32OLE] com A WIN32OLE Com object
+  def initialize(com)
+    self.com = com
+  end
+
+  # Queries whether this COM object responds to _method_.
+  #
+  # @param [Symbol] method Method name to query for response
+  # @return [Boolean] Whether or not this COM object responds to _method_
+  def respond_to?(method)
+    super or com.respond_to? method
+  end
+
+  # Sets a bunch of properties, yield, and then restore them.  If an exception
+  # is raised, any set properties are restored.
+  #
+  # @param [#to_hash] properties properties with values to set
+  # @return [COM::Object] `self` */
+  def with_properties(properties)
+    saved_properties = []
+    begin
+      properties.to_hash.each do |property, value|
+        saved_properties << [property, com[property]]
+        com.set_property property, value
+      end
+      yield
+    ensure
+      previous_error = $!
+      begin
+        saved_properties.reverse.each do |property, value|
+          begin com.set_property property, value; rescue COM::Error; end
+        end
+      rescue
+        raise if not previous_error
+      end
+    end
+  end
+
+  def observe(event, observer = COM::Events::ArgumentMissing, &block)
+    com.observe event, observer, &block
+    self
+  end
+
+  def unobserve(event, observer = nil)
+    com.unobserve event, observer
+    self
+  end
+
+  def to_com
+    com.to_com
+  end
+
+  protected
+
+  attr_reader :com
+
+  def com=(com)
+    @com = WIN32OLE === com ? COM::Wrapper.new(com) : com
+  end
+
+  private
+
+  def method_missing(method, *args)
+    case method.to_s
+    when /=\z/
+      com.set_property($`.encode(COM.charset), *args)
+    else
+      com.invoke(method.to_s.encode(COM.charset), *args)
+    end
+  rescue NoMethodError => e
+    raise e, "undefined method `%s' for %p" % [method, self], e.backtrace
+  end
+end

data/lib/com/pathname.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+class Pathname
+  # Returns a String representation of this Pathname in the COM character set.
+  #
+  # @see COM.charset
+  def to_com
+    to_path.encode(COM.charset)
+  end
+end

data/lib/com/patternerror.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+module COM::PatternError
+  # @private method used by {COM::Error.find}.
+  def replaces?(error)
+    pattern =~ error.message
+  end
+
+protected
+
+  def replace(error)
+    new(*pattern.match(error.message).captures)
+  end
+
+private
+
+  def pattern(pattern = nil)
+    (pattern or not defined? @pattern) ? @pattern = pattern : @pattern
+  end
+end

data/lib/com/standarderror.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+# Sets up mappings between COM errors and Ruby errors.
+#
+# @private
+module COM::StandardError
+  class << self
+  private
+    def define(code, errorclass, message = nil, &block)
+      block = proc{ |m| m[1] } unless message or block
+      Class.new(COM::Error) do
+        extend COM::PatternError
+
+        pattern %r{^\s*(.*)\n\s*HRESULT\serror\scode:(0x(?i:#{code.to_s(16)}))}xu
+
+        (class << self; self; end).class_eval do
+          define_method :replace do |error|
+            m = pattern.match(error.message)
+            errorclass.new(*Array(message ? message : block.call(m)))
+          end
+        end
+      end
+    end
+  end
+
+  define(0x80004001, ::NotImplementedError){ |m| '%s: not implemented' % m[1] }
+  define 0x80020005, ::TypeError
+  define 0x80020006, ::NoMethodError
+  define 0x8002000e, ::ArgumentError, 'wrong number of arguments'
+  define 0x800401e4, ::ArgumentError
+  define 0x800401f3, ::NameError do |m|
+    name = m[1].sub(/.*`(.*)'\z/, '\\1')
+    ['unknown COM server: %s' % name, name]
+  end
+end
+
+# Sets up mappings between HRESULT errors and COM errors.
+#
+# @private
+module COM::HResultError
+  class << self
+    def define(code, error, message = nil, &block)
+      block = proc{ |m| m[1] } unless message or block
+      COM.const_set error, Class.new(COM::Error){
+        extend COM::PatternError
+
+        pattern %r{^\s*(.*)\n\s*HRESULT\serror\scode:(0x(?i:#{code.to_s(16)}))}xu
+
+        (class << self; self; end).class_eval do
+          define_method :replace do |e|
+            m = pattern.match(e.message)
+            new(message ? message : block.call(m))
+          end
+        end
+      }
+    end
+  end
+
+  define 0x80020003, :MemberNotFoundError
+  define 0x800401e3, :OperationUnavailableError
+end

data/lib/com/version.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module COM
+  Version = '0.3.0'
+end

data/lib/com/win32ole.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+class WIN32OLE_TYPE
+  class << self
+    def enums(id)
+      ole_classes(id).select{ |c| c.visible? and c.ole_type == 'Enum' }
+    end
+  end
+
+  def constants
+    variables.select{ |v| v.visible? and v.variable_kind == 'CONSTANT' }
+  end
+end
+
+class WIN32OLE_VARIABLE
+  def const_name
+    name.sub(/^./){ |l| l.upcase }
+  end
+end

data/lib/com/wrapper.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+# This module provides a wrapper around WIN32OLE’s instance methods.  This
+# wrapper deals with converting errors to the appropriate type.
+#
+# @private
+class COM::Wrapper
+  BacktraceFilter = File.dirname(File.dirname(__FILE__)) + File::SEPARATOR
+
+  class << self
+    def raise_in(method, e)
+      clean = e.backtrace.reject{ |s| s.start_with? BacktraceFilter }
+      raise COM::Error.from(e, clean.unshift(clean.first.sub(/:in `.*'$/, ":in `#{method}'")))
+    end
+  end
+
+  def initialize(ole)
+    @ole = ole
+  end
+
+  def invoke(method, *args)
+    @ole.invoke(method, *args.map{ |e| e.respond_to?(:to_com) ? e.to_com : e })
+  rescue NoMethodError => e
+    error = NoMethodError.new("undefined method `%s' for %p" % [method, self],
+                              method,
+                              args)
+    error.set_backtrace e.backtrace.reject{ |s| s.start_with? BacktraceFilter }
+    raise error
+  rescue WIN32OLERuntimeError => e
+    raise COM::Wrapper.raise_in(method, e)
+  end
+
+  def set_property(property, *args)
+    @ole.setproperty(property, *args.map{ |e| e.respond_to?(:to_com) ? e.to_com : e })
+  rescue NoMethodError => e
+    error = NoMethodError.new("undefined property `%s' for %p" % [property, self],
+                              property,
+                              args)
+    error.set_backtrace e.backtrace.reject{ |s| s.start_with? BacktraceFilter }
+    raise error
+  rescue WIN32OLERuntimeError => e
+    raise COM::Wrapper.raise_in('%s=' % property, e)
+  end
+
+  def load_constants(into)
+    saved_verbose, $VERBOSE = $VERBOSE, nil
+    begin
+      begin
+        WIN32OLE.const_load @ole, into
+      rescue RuntimeError
+        WIN32OLE_TYPE.enums(program_id).each do |enum|
+          enum.constants.each do |constant|
+            into.const_set constant.const_name, constant.value
+          end
+        end
+      end
+    ensure
+      $VERBOSE = saved_verbose
+    end
+  end
+
+  def observe(event, observer = COM::Events::ArgumentMissing, &block)
+    events.observe event, observer, &block
+    self
+  end
+
+  def unobserve(event, observer = nil)
+    events.unobserve event, observer
+    self
+  end
+
+  def to_com
+    @ole
+  end
+
+  protected
+
+  def events
+    @events ||= COM::Events.new(@ole)
+  end
+
+  private
+
+  def method_missing(method, *args)
+    case method.to_s
+    when /=\z/
+      begin
+        set_property($`.encode(COM.charset), *args)
+      rescue NoMethodError => e
+        raise e, "undefined method `%s' for %p" % [method, self], e.backtrace
+      end
+    else
+      invoke(method.to_s.encode(COM.charset), *args)
+    end
+  end
+end

data/test/unit/com.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'UTF-8' do
+    stub(WIN32OLE).codepage{ WIN32OLE::CP_UTF8 }
+    COM.charset
+  end
+
+  expect RuntimeError do
+    stub(WIN32OLE).codepage{ :unknown_encoding }
+    COM.charset
+  end
+
+  expect COM::Error do
+    stub(WIN32OLE).connect{ raise WIN32OLERuntimeError }
+    COM.connect(stub)
+  end
+
+  expect COM::Error do
+    stub(WIN32OLE).new{ raise WIN32OLERuntimeError }
+    COM.new(stub)
+  end
+end

data/test/unit/com/error.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect COM::Error do
+    COM::Error.from(stub(:message => '<some random message>'))
+  end
+
+  expect '<some random message>' do
+    COM::Error.from(stub(:message => '<some random message>')).message
+  end
+end

data/test/unit/com/events.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect WIN32OLE_EVENT.to.receive.new(:com, :interface) do
+    COM::Events.new(:com, :interface)
+  end
+
+  expect mock.to.receive.on_event(:on_something) do |o|
+    stub(WIN32OLE_EVENT).new{ o }
+    COM::Events.new(:ole, :interface).observe :on_something do end
+  end
+
+  expect mock.to.receive.call do |o|
+    events = stub
+    class << events
+      def on_event(event, &block)
+        @block = block
+      end
+
+      def trigger
+        @block.call
+      end
+    end
+    stub(WIN32OLE_EVENT).new{ events }
+    e = COM::Events.new(:ole, :interface)
+    e.observe(:on_something, proc{ events.trigger }){ o.call }
+  end
+end

data/test/unit/com/instantiable.rb

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'Program.Class' do
+    Class.new(COM::Instantiable).program_id('Program.Class')
+  end
+
+  expect 'Program.Class' do
+    Class.new(COM::Instantiable){
+      program_id 'Program.Class'
+    }.program_id
+  end
+
+  expect ArgumentError do
+    Class.new(COM::Instantiable).tap{ |c| stub(c).name{ 'Class' } }.program_id
+  end
+
+  expect 'Program.Class' do
+    Class.new(COM::Instantiable).tap{ |c| stub(c).name{ 'Program::Class' } }.program_id
+  end
+
+  expect 'Program.Class' do
+    Class.new(COM::Instantiable).tap{ |c| stub(c).name{ 'Vendor::Program::Class' } }.program_id
+  end
+
+  expect false do
+    Class.new(COM::Instantiable).connect?
+  end
+
+  expect true do
+    Class.new(COM::Instantiable).connect
+  end
+
+  expect true do
+    Class.new(COM::Instantiable){ connect }.connect?
+  end
+
+  expect true do
+    Class.new(COM::Instantiable).constants?
+  end
+
+  expect true do
+    Class.new(COM::Instantiable).constants(true)
+  end
+
+  expect true do
+    Class.new(COM::Instantiable){ constants true }.constants?
+  end
+
+  expect COM.to.receive.connect('A.B'){ stub } do
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:connect => true, :constants => false)
+  end
+
+  expect COM.not.to.receive.new do
+    stub(COM).connect{ stub }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:connect => true, :constants => false)
+  end
+
+  expect COM.to.receive.new('A.B'){ stub } do
+    stub(COM).connect{ raise COM::OperationUnavailableError }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:connect => true, :constants => false)
+  end
+
+  expect COM.to.receive.new('A.B'){ stub } do
+    stub(COM).connect{ raise COM::OperationUnavailableError }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:constants => false)
+  end
+
+  expect true do
+    stub(COM).connect{ stub }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:connect => true, :constants => false).connected?
+  end
+
+  expect false do
+    stub(COM).connect{ raise COM::OperationUnavailableError }
+    stub(COM).new{ stub }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:connect => true, :constants => false).connected?
+  end
+
+  expect false do
+    stub(COM).new{ stub }
+    Class.new(COM::Instantiable){ program_id 'A.B' }.new(:constants => false).connected?
+  end
+
+  expect(Class.new(COM::Instantiable){ program_id 'A.B' }.to.receive.load_constants) do |o|
+    stub(COM).new{ stub }
+    o.new
+  end
+
+  expect(Class.new(COM::Instantiable){ program_id 'A.B' }.not.to.receive.load_constants) do |o|
+    stub(COM).new{ stub }
+    o.new(:constants => false)
+  end
+end