ruby-dbus 0.10.0 → 0.11.0

data/lib/dbus/proxy_object.rb

@@ -0,0 +1,149 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # D-Bus proxy object class
+  #
+  # Class representing a remote object in an external application.
+  # Typically, calling a method on an instance of a ProxyObject sends a message
+  # over the bus so that the method is executed remotely on the correctponding
+  # object.
+  class ProxyObject
+    # The names of direct subnodes of the object in the tree.
+    attr_accessor :subnodes
+    # Flag determining whether the object has been introspected.
+    attr_accessor :introspected
+    # The (remote) destination of the object.
+    attr_reader :destination
+    # The path to the object.
+    attr_reader :path
+    # The bus the object is reachable via.
+    attr_reader :bus
+    # @return [String] The name of the default interface of the object.
+    attr_accessor :default_iface
+
+    # Creates a new proxy object living on the given _bus_ at destination _dest_
+    # on the given _path_.
+    def initialize(bus, dest, path)
+      @bus, @destination, @path = bus, dest, path
+      @interfaces = Hash.new
+      @subnodes = Array.new
+    end
+
+    # Returns the interfaces of the object.
+    def interfaces
+      @interfaces.keys
+    end
+
+    # Retrieves an interface of the proxy object
+    # @param [String] intfname
+    # @return [ProxyObjectInterface]
+    def [](intfname)
+      @interfaces[intfname]
+    end
+
+    # Maps the given interface name _intfname_ to the given interface _intf.
+    # @param [String] intfname
+    # @param [ProxyObjectInterface] intf
+    # @return [ProxyObjectInterface]
+    def []=(intfname, intf)
+      @interfaces[intfname] = intf
+    end
+
+    # Introspects the remote object. Allows you to find and select
+    # interfaces on the object.
+    def introspect
+      # Synchronous call here.
+      xml = @bus.introspect_data(@destination, @path)
+      ProxyObjectFactory.introspect_into(self, xml)
+      define_shortcut_methods()
+      xml
+    end
+
+    # For each non duplicated method name in any interface present on the
+    # caller, defines a shortcut method dynamically.
+    # This function is automatically called when a {ProxyObject} is
+    # introspected.
+    def define_shortcut_methods
+      # builds a list of duplicated methods
+      dup_meths, univocal_meths = [],{}
+      @interfaces.each_value do |intf|
+        intf.methods.each_value do |meth|
+          name = meth.name.to_sym
+          # don't overwrite instance methods!
+          if dup_meths.include? name or self.class.instance_methods.include? name
+            next
+          elsif univocal_meths.include? name
+            univocal_meths.delete name
+            dup_meths << name
+          else
+            univocal_meths[name] = intf
+          end
+        end
+      end
+      univocal_meths.each do |name, intf|
+        # creates a shortcut function that forwards each call to the method on
+        # the appropriate intf
+        singleton_class.class_eval do
+          define_method name do |*args, &reply_handler|
+            intf.method(name).call(*args, &reply_handler)
+          end
+        end
+      end
+    end
+
+    # Returns whether the object has an interface with the given _name_.
+    def has_iface?(name)
+      raise "Cannot call has_iface? if not introspected" if not @introspected
+      @interfaces.member?(name)
+    end
+
+    # Registers a handler, the code block, for a signal with the given _name_.
+    # It uses _default_iface_ which must have been set.
+    # @return [void]
+    def on_signal(name, &block)
+      if @default_iface and has_iface?(@default_iface)
+        @interfaces[@default_iface].on_signal(name, &block)
+      else
+        # TODO improve
+        raise NoMethodError
+      end
+    end
+
+    ####################################################
+    private
+
+    # Handles all unkown methods, mostly to route method calls to the
+    # default interface.
+    def method_missing(name, *args, &reply_handler)
+      if @default_iface and has_iface?(@default_iface)
+        begin
+          @interfaces[@default_iface].method(name).call(*args, &reply_handler)
+        rescue NameError => e
+          # interesting, foo.method("unknown")
+          # raises NameError, not NoMethodError
+          raise unless e.to_s =~ /undefined method `#{name}'/
+          # BTW e.exception("...") would preserve the class.
+          raise NoMethodError,"undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
+        end
+      else
+        # TODO distinguish:
+        # - di not specified
+        #TODO
+        # - di is specified but not found in introspection data
+        raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
+      end
+    end
+
+    # Returns the singleton class of the object.
+    def singleton_class
+      (class << self ; self ; end)
+    end
+  end # class ProxyObject
+end

data/lib/dbus/proxy_object_factory.rb

@@ -0,0 +1,41 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # = D-Bus proxy object factory class
+  #
+  # Class that generates and sets up a proxy object based on introspection data.
+  class ProxyObjectFactory
+    # Creates a new proxy object factory for the given introspection XML _xml_,
+    # _bus_, destination _dest_, and _path_.
+    def initialize(xml, bus, dest, path)
+      @xml, @bus, @path, @dest = xml, bus, path, dest
+    end
+
+    # Investigates the sub-nodes of the proxy object _po_ based on the
+    # introspection XML data _xml_ and sets them up recursively.
+    def ProxyObjectFactory.introspect_into(po, xml)
+      intfs, po.subnodes = IntrospectXMLParser.new(xml).parse
+      intfs.each do |i|
+        poi = ProxyObjectInterface.new(po, i.name)
+        i.methods.each_value { |m| poi.define(m) }
+        i.signals.each_value { |s| poi.define(s) }
+        po[i.name] = poi
+      end
+      po.introspected = true
+    end
+
+    # Generates, sets up and returns the proxy object.
+    def build
+      po = ProxyObject.new(@bus, @dest, @path)
+      ProxyObjectFactory.introspect_into(po, @xml)
+      po
+    end
+  end # class ProxyObjectFactory
+end

data/lib/dbus/proxy_object_interface.rb

@@ -0,0 +1,128 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+module DBus
+  # = D-Bus proxy object interface class
+  #
+  # A class similar to the normal Interface used as a proxy for remote
+  # object interfaces.
+  class ProxyObjectInterface
+    # The proxied methods contained in the interface.
+    attr_accessor :methods
+    # The proxied signals contained in the interface.
+    attr_accessor :signals
+    # The proxy object to which this interface belongs.
+    attr_reader :object
+    # The name of the interface.
+    attr_reader :name
+
+    # Creates a new proxy interface for the given proxy _object_
+    # and the given _name_.
+    def initialize(object, name)
+      @object, @name = object, name
+      @methods, @signals = Hash.new, Hash.new
+    end
+
+    # Returns the string representation of the interface (the name).
+    def to_str
+      @name
+    end
+
+    # Returns the singleton class of the interface.
+    def singleton_class
+      (class << self ; self ; end)
+    end
+
+    # Defines a method on the interface from the Method descriptor _m_.
+    def define_method_from_descriptor(m)
+      m.params.each do |fpar|
+        par = fpar.type
+        # This is the signature validity check
+        Type::Parser.new(par).parse
+      end
+
+      singleton_class.class_eval do
+        define_method m.name do |*args, &reply_handler|
+          if m.params.size != args.size
+            raise ArgumentError, "wrong number of arguments (#{args.size} for #{m.params.size})"
+          end
+
+          msg = Message.new(Message::METHOD_CALL)
+          msg.path = @object.path
+          msg.interface = @name
+          msg.destination = @object.destination
+          msg.member = m.name
+          msg.sender = @object.bus.unique_name
+          m.params.each do |fpar|
+            par = fpar.type
+            msg.add_param(par, args.shift)
+          end
+          @object.bus.send_sync_or_async(msg, &reply_handler)
+        end
+      end
+
+      @methods[m.name] = m
+    end
+
+    # Defines a signal from the descriptor _s_.
+    def define_signal_from_descriptor(s)
+      @signals[s.name] = s
+    end
+
+    # Defines a signal or method based on the descriptor _m_.
+    def define(m)
+      if m.kind_of?(Method)
+        define_method_from_descriptor(m)
+      elsif m.kind_of?(Signal)
+        define_signal_from_descriptor(m)
+      end
+    end
+
+    # Defines a proxied method on the interface.
+    def define_method(methodname, prototype)
+      m = Method.new(methodname)
+      m.from_prototype(prototype)
+      define(m)
+    end
+
+    # @overload on_signal(name, &block)
+    # @overload on_signal(bus, name, &block)
+    # Registers a handler (code block) for a signal with _name_ arriving
+    # over the given _bus_. If no block is given, the signal is unregistered.
+    # Note that specifying _bus_ is discouraged and the option is kept only for
+    # backward compatibility.
+    # @return [void]
+    def on_signal(bus = @object.bus, name, &block)
+      mr = DBus::MatchRule.new.from_signal(self, name)
+      if block.nil?
+        bus.remove_match(mr)
+      else
+        bus.add_match(mr) { |msg| block.call(*msg.params) }
+      end
+    end
+
+    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
+
+    # Read a property.
+    def [](propname)
+      self.object[PROPERTY_INTERFACE].Get(self.name, propname)[0]
+    end
+
+    # Write a property.
+    def []=(propname, value)
+      self.object[PROPERTY_INTERFACE].Set(self.name, propname, value)
+    end
+
+    # Read all properties at once, as a hash.
+    # @return [Hash{String}]
+    def all_properties
+      self.object[PROPERTY_INTERFACE].GetAll(self.name)[0]
+    end
+  end # class ProxyObjectInterface
+end

data/ruby-dbus.gemspec

@@ -16,4 +16,5 @@ GEMSPEC = Gem::Specification.new do |s|
   s.require_path = "lib"
   s.required_ruby_version = ">= 1.9.3"
   s.add_development_dependency("packaging_rake_tasks")
+  s.add_development_dependency("rspec")
 end

data/test/{async_test.rb → async_spec.rb}

@@ -1,11 +1,10 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 # Test the binding of dbus concepts to ruby concepts
-require File.expand_path("../test_helper", __FILE__)
-require "test/unit"
+require_relative "spec_helper"
 require "dbus"
 
-class AsyncTest < Test::Unit::TestCase
-  def setup
+describe "AsyncTest" do
+  before(:each) do
     @bus = DBus::ASessionBus.new
     @svc = @bus.service("org.ruby.service")
     @obj = @svc.object "/org/ruby/MyInstance"
@@ -14,32 +13,32 @@ class AsyncTest < Test::Unit::TestCase
   end
 
   # https://github.com/mvidner/ruby-dbus/issues/13
-  def test_async_call_to_default_interface
+  it "tests async_call_to_default_interface" do
     loop = DBus::Main.new
     loop << @bus
 
     immediate_answer = @obj.the_answer do |msg, retval|
-      assert_equal 42, retval
+      expect(retval).to eq(42)
       loop.quit
     end
 
-    assert_nil immediate_answer
+    expect(immediate_answer).to be_nil
 
     # wait for the async reply
     loop.run
   end
 
-  def test_async_call_to_explicit_interface
+  it "tests async_call_to_explicit_interface" do
     loop = DBus::Main.new
     loop << @bus
 
     ifc = @obj["org.ruby.AnotherInterface"]
     immediate_answer = ifc.Reverse("abcd") do |msg, retval|
-      assert_equal "dcba", retval
+      expect(retval).to eq("dcba")
       loop.quit
     end
 
-    assert_nil immediate_answer
+    expect(immediate_answer).to be_nil
 
     # wait for the async reply
     loop.run

data/test/{binding_test.rb → binding_spec.rb}

@@ -1,11 +1,11 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 # Test the binding of dbus concepts to ruby concepts
-require File.expand_path("../test_helper", __FILE__)
-require "test/unit"
+require_relative "spec_helper"
+
 require "dbus"
 
-class BindingTest < Test::Unit::TestCase
-  def setup
+describe "BindingTest" do
+  before(:each) do
     @bus = DBus::ASessionBus.new
     @svc = @bus.service("org.ruby.service")
     @base = @svc.object "/org/ruby/MyInstance"
@@ -14,48 +14,46 @@ class BindingTest < Test::Unit::TestCase
   end
 
   # https://trac.luon.net/ruby-dbus/ticket/36#comment:3
-  def test_class_inheritance
+  it "tests class inheritance" do
     derived = @svc.object "/org/ruby/MyDerivedInstance"
     derived.introspect
 
     # it should inherit from the parent
-    assert_not_nil derived["org.ruby.SampleInterface"]
+    expect(derived["org.ruby.SampleInterface"]).not_to be_nil
   end
 
   # https://trac.luon.net/ruby-dbus/ticket/36
   # Interfaces and methods/signals appeared on all classes
-  def test_separation_of_classes
+  it "tests separation of classes" do
     test2 = @svc.object "/org/ruby/MyInstance2"
     test2.introspect
 
     # it should have its own interface
-    assert_not_nil test2["org.ruby.Test2"]
+    expect(test2["org.ruby.Test2"]).not_to be_nil
     # but not an interface of the Test class
-    assert_nil test2["org.ruby.SampleInterface"]
+    expect(test2["org.ruby.SampleInterface"]).to be_nil
 
     # and the parent should not get polluted by the child
-    assert_nil @base["org.ruby.Test2"]
+    expect(@base["org.ruby.Test2"]).to be_nil
   end
 
-  def test_translating_errors_into_exceptions
+  it "tests translating errors into exceptions" do
     # this is a generic call that will reply with the specified error
-    @base.Error "org.example.Fail", "as you wish"
-    assert false, "should have raised"
-  rescue DBus::Error => e
-    assert_equal "org.example.Fail", e.name
-    assert_equal "as you wish", e.message
+    expect { @base.Error "org.example.Fail", "as you wish" }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to eq("org.example.Fail")
+      expect(e.message).to match(/as you wish/)
+    end
   end
 
-  def test_generic_dbus_error
+  it "tests generic dbus error" do
     # this is a generic call that will reply with the specified error
-    @base.will_raise_error_failed
-    assert false, "should have raised"
-  rescue DBus::Error => e
-    assert_equal "org.freedesktop.DBus.Error.Failed", e.name
-    assert_equal "failed as designed", e.message
+    expect { @base.will_raise_error_failed }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to eq("org.freedesktop.DBus.Error.Failed")
+      expect(e.message).to match(/failed as designed/)
+    end
   end
   
-  def test_dynamic_interface_definition
+  it "tests dynamic interface definition" do
     # interfaces can be defined dynamicaly
     derived = DBus::Object.new "/org/ruby/MyDerivedInstance"
     
@@ -70,7 +68,7 @@ class BindingTest < Test::Unit::TestCase
     
     # the object should have the new iface
     ifaces = derived.intfs
-    assert ifaces and ifaces.include?("org.ruby.DynamicInterface")
+    expect(ifaces && ifaces.include?("org.ruby.DynamicInterface")).to be_true
   end
     
 end