ruby-dbus 0.14.0 → 0.17.0

data/lib/dbus/object.rb

@@ -0,0 +1,380 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+#
+# 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.
+
+require "thread"
+require_relative "core_ext/class/attribute"
+
+module DBus
+  PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties".freeze
+
+  # Exported object type
+  # = Exportable D-Bus object class
+  #
+  # Objects that are going to be exported by a D-Bus service
+  # should inherit from this class. At the client side, use {ProxyObject}.
+  class Object
+    # The path of the object.
+    attr_reader :path
+    # The interfaces that the object supports. Hash: String => Interface
+    my_class_attribute :intfs
+    self.intfs = {}
+
+    # The service that the object is exported by.
+    attr_writer :service
+
+    @@cur_intf = nil # Interface
+    @@intfs_mutex = Mutex.new
+
+    # Create a new object with a given _path_.
+    # Use Service#export to export it.
+    def initialize(path)
+      @path = path
+      @service = nil
+    end
+
+    # Dispatch a message _msg_ to call exported methods
+    def dispatch(msg)
+      case msg.message_type
+      when Message::METHOD_CALL
+        reply = nil
+        begin
+          if !intfs[msg.interface]
+            raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
+                  "Interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
+          end
+          meth = intfs[msg.interface].methods[msg.member.to_sym]
+          if !meth
+            raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
+                  "Method \"#{msg.member}\" on interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
+          end
+          methname = Object.make_method_name(msg.interface, msg.member)
+          retdata = method(methname).call(*msg.params)
+          retdata = [*retdata]
+
+          reply = Message.method_return(msg)
+          meth.rets.zip(retdata).each do |rsig, rdata|
+            reply.add_param(rsig.type, rdata)
+          end
+        rescue StandardError => ex
+          dbus_msg_exc = msg.annotate_exception(ex)
+          reply = ErrorMessage.from_exception(dbus_msg_exc).reply_to(msg)
+        end
+        @service.bus.message_queue.push(reply)
+      end
+    end
+
+    # Select (and create) the interface that the following defined methods
+    # belong to.
+    def self.dbus_interface(s)
+      @@intfs_mutex.synchronize do
+        @@cur_intf = intfs[s]
+        if !@@cur_intf
+          @@cur_intf = Interface.new(s)
+          # As this is a mutable class_attr, we cannot use
+          #   self.intfs[s] = @@cur_intf                      # Hash#[]=
+          # as that would modify parent class attr in place.
+          # Using the setter lets a subclass have the new value
+          # while the superclass keeps the old one.
+          self.intfs = intfs.merge(s => @@cur_intf)
+        end
+        yield
+        @@cur_intf = nil
+      end
+    end
+
+    # Forgetting to declare the interface for a method/signal/property
+    # is a ScriptError.
+    class UndefinedInterface < ScriptError # rubocop:disable Lint/InheritException
+      def initialize(sym)
+        super "No interface specified for #{sym}. Enclose it in dbus_interface."
+      end
+    end
+
+    # A read-write property accessing an instance variable.
+    # A combination of `attr_accessor` and {.dbus_accessor}.
+    #
+    # PropertiesChanged signal will be emitted whenever `foo_bar=` is used
+    # but not when @foo_bar is written directly.
+    #
+    # @param ruby_name [Symbol] :foo_bar is exposed as FooBar;
+    #   use dbus_name to override
+    # @param type a signature like "s" or "a(uus)" or Type::STRING
+    # @param dbus_name [String] if not given it is made
+    #   by CamelCasing the ruby_name. foo_bar becomes FooBar
+    #   to convert the Ruby convention to the DBus convention.
+    # @return [void]
+    def self.dbus_attr_accessor(ruby_name, type, dbus_name: nil)
+      attr_accessor(ruby_name)
+      dbus_accessor(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A read-only property accessing an instance variable.
+    # A combination of `attr_reader` and {.dbus_reader}.
+    #
+    # Whenever the property value gets changed from "inside" the object,
+    # you should emit the `PropertiesChanged` signal by calling
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #
+    # or, omitting the value in the signal,
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_attr_reader(ruby_name, type, dbus_name: nil)
+      attr_reader(ruby_name)
+      dbus_reader(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A write-only property accessing an instance variable.
+    # A combination of `attr_writer` and {.dbus_writer}.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_attr_writer(ruby_name, type, dbus_name: nil)
+      attr_writer(ruby_name)
+      dbus_writer(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A read-write property using a pair of reader/writer methods
+    # (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_accessor} instead)
+    #
+    # Uses {.dbus_watcher} to set up the PropertiesChanged signal.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_accessor(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :readwrite, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+
+      dbus_watcher(ruby_name, dbus_name: dbus_name)
+    end
+
+    # A read-only property accessing a reader method (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_reader} instead)
+    #
+    # Whenever the property value gets changed from "inside" the object,
+    # you should emit the `PropertiesChanged` signal by calling
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #
+    # or, omitting the value in the signal,
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_reader(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :read, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+    end
+
+    # A write-only property accessing a writer method (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_writer} instead)
+    #
+    # Uses {.dbus_watcher} to set up the PropertiesChanged signal.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_writer(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :write, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+
+      dbus_watcher(ruby_name, dbus_name: dbus_name)
+    end
+
+    # Enables automatic sending of the PropertiesChanged signal.
+    # For *ruby_name* `foo_bar`, wrap `foo_bar=` so that it sends
+    # the signal for FooBar.
+    # The original version remains as `_original_foo_bar=`.
+    #
+    # @param ruby_name [Symbol] :foo_bar and :foo_bar= both mean the same thing
+    # @param dbus_name [String] if not given it is made
+    #   by CamelCasing the ruby_name. foo_bar becomes FooBar
+    #   to convert the Ruby convention to the DBus convention.
+    # @return [void]
+    def self.dbus_watcher(ruby_name, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+      cur_intf = @@cur_intf
+
+      ruby_name = ruby_name.to_s.sub(/=$/, "").to_sym
+      ruby_name_eq = "#{ruby_name}=".to_sym
+      original_ruby_name_eq = "_original_#{ruby_name_eq}"
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+
+      # the argument order is alias_method(new_name, existing_name)
+      alias_method original_ruby_name_eq, ruby_name_eq
+      define_method ruby_name_eq do |value|
+        public_send(original_ruby_name_eq, value)
+
+        # TODO: respect EmitsChangedSignal to use invalidated_properties instead
+        # PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
+        PropertiesChanged(cur_intf.name, { dbus_name.to_s => value }, [])
+      end
+    end
+
+    # Defines an exportable method on the object with the given name _sym_,
+    # _prototype_ and the code in a block.
+    # @param prototype [Prototype]
+    def self.dbus_method(sym, prototype = "", &block)
+      raise UndefinedInterface, sym if @@cur_intf.nil?
+      @@cur_intf.define(Method.new(sym.to_s).from_prototype(prototype))
+
+      ruby_name = Object.make_method_name(@@cur_intf.name, sym.to_s)
+      # ::Module#define_method(name) { body }
+      define_method(ruby_name, &block)
+    end
+
+    # Emits a signal from the object with the given _interface_, signal
+    # _sig_ and arguments _args_.
+    # @param intf [Interface]
+    # @param sig [Signal]
+    # @param args arguments for the signal
+    def emit(intf, sig, *args)
+      @service.bus.emit(@service, self, intf, sig, *args)
+    end
+
+    # Defines a signal for the object with a given name _sym_ and _prototype_.
+    def self.dbus_signal(sym, prototype = "")
+      raise UndefinedInterface, sym if @@cur_intf.nil?
+      cur_intf = @@cur_intf
+      signal = Signal.new(sym.to_s).from_prototype(prototype)
+      cur_intf.define(Signal.new(sym.to_s).from_prototype(prototype))
+
+      # ::Module#define_method(name) { body }
+      define_method(sym.to_s) do |*args|
+        emit(cur_intf, signal, *args)
+      end
+    end
+
+    # Helper method that returns a method name generated from the interface
+    # name _intfname_ and method name _methname_.
+    # @api private
+    def self.make_method_name(intfname, methname)
+      "#{intfname}%%#{methname}"
+    end
+
+    # TODO: borrow a proven implementation
+    # @param str [String]
+    # @return [String]
+    # @api private
+    def self.camelize(str)
+      str.split(/_/).map(&:capitalize).join("")
+    end
+
+    # Make a D-Bus conventional name, CamelCased.
+    # @param ruby_name [String,Symbol] eg :do_something
+    # @param dbus_name [String,Symbol,nil] use this if given
+    # @return [Symbol] eg DoSomething
+    def self.make_dbus_name(ruby_name, dbus_name: nil)
+      dbus_name ||= camelize(ruby_name.to_s)
+      dbus_name.to_sym
+    end
+
+    # @param interface_name [String]
+    # @param property_name [String]
+    # @return [Property]
+    # @raise [DBus::Error]
+    # @api private
+    def dbus_lookup_property(interface_name, property_name)
+      # what should happen for unknown properties
+      # plasma: InvalidArgs (propname), UnknownInterface (interface)
+      # systemd: UnknownProperty
+      interface = intfs[interface_name]
+      if !interface
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+              "Property '#{interface_name}.#{property_name}' (on object '#{@path}') not found: no such interface"
+      end
+
+      property = interface.properties[property_name.to_sym]
+      if !property
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+              "Property '#{interface_name}.#{property_name}' (on object '#{@path}') not found"
+      end
+
+      property
+    end
+
+    ####################################################################
+
+    # use the above defined methods to declare the property-handling
+    # interfaces and methods
+
+    dbus_interface PROPERTY_INTERFACE do
+      dbus_method :Get, "in interface_name:s, in property_name:s, out value:v" do |interface_name, property_name|
+        property = dbus_lookup_property(interface_name, property_name)
+
+        if property.readable?
+          ruby_name = property.ruby_name
+          value = public_send(ruby_name)
+          [value]
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.PropertyWriteOnly"),
+                "Property '#{interface_name}.#{property_name}' (on object '#{@path}') is not readable"
+        end
+      end
+
+      dbus_method :Set, "in interface_name:s, in property_name:s, in val:v" do |interface_name, property_name, value|
+        property = dbus_lookup_property(interface_name, property_name)
+
+        if property.writable?
+          ruby_name_eq = "#{property.ruby_name}="
+          public_send(ruby_name_eq, value)
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.PropertyReadOnly"),
+                "Property '#{interface_name}.#{property_name}' (on object '#{@path}') is not writable"
+        end
+      end
+
+      dbus_method :GetAll, "in interface_name:s, out value:a{sv}" do |interface_name|
+        interface = intfs[interface_name]
+        if !interface
+          raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+                "Properties '#{interface_name}.*' (on object '#{@path}') not found: no such interface"
+        end
+
+        p_hash = {}
+        interface.properties.each do |p_name, property|
+          next unless property.readable?
+
+          ruby_name = property.ruby_name
+          begin
+            # D-Bus spec says:
+            # > If GetAll is called with a valid interface name for which some
+            # > properties are not accessible to the caller (for example, due
+            # > to per-property access control implemented in the service),
+            # > those properties should be silently omitted from the result
+            # > array.
+            # so we will silently omit properties that fail to read.
+            # Get'ting them individually will send DBus.Error
+            p_hash[p_name.to_s] = public_send(ruby_name)
+          rescue StandardError
+            DBus.logger.debug "Property '#{interface_name}.#{p_name}' (on object '#{@path}')" \
+                              " has raised during GetAll, omitting it"
+          end
+        end
+
+        [p_hash]
+      end
+
+      dbus_signal :PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
+    end
+  end
+end

data/lib/dbus/object_path.rb

@@ -0,0 +1,24 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2019 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
+  # A {::String} that validates at initialization time
+  class ObjectPath < String
+    # @raise Error if not a valid object path
+    def initialize(s)
+      unless self.class.valid?(s)
+        raise DBus::Error, "Invalid object path #{s.inspect}"
+      end
+      super
+    end
+
+    def self.valid?(s)
+      s == "/" || s =~ %r{\A(/[A-Za-z0-9_]+)+\z}
+    end
+  end
+end

data/lib/dbus/proxy_object.rb

@@ -36,7 +36,7 @@ module DBus
     def initialize(bus, dest, path, api: ApiOptions::CURRENT)
       @bus = bus
       @destination = dest
-      @path = path
+      @path = ObjectPath.new(path)
       @introspected = false
       @interfaces = {}
       @subnodes = []
@@ -44,6 +44,7 @@ module DBus
     end
 
     # Returns the interfaces of the object.
+    # @return [Array<String>] names of the interfaces
     def interfaces
       introspect unless introspected
       @interfaces.keys
@@ -54,7 +55,9 @@ module DBus
     # @return [ProxyObjectInterface]
     def [](intfname)
       introspect unless introspected
-      @interfaces[intfname]
+      ifc = @interfaces[intfname]
+      raise DBus::Error, "no such interface `#{intfname}' on object `#{@path}'" unless ifc
+      ifc
     end
 
     # Maps the given interface name _intfname_ to the given interface _intf.
@@ -127,6 +130,11 @@ module DBus
     ####################################################
     private
 
+    # rubocop:disable Style/MethodMissing
+    # but https://github.com/rubocop-hq/ruby-style-guide#no-method-missing
+    # and http://blog.marc-andre.ca/2010/11/15/methodmissing-politely/
+    # have a point to be investigated
+
     # Handles all unkown methods, mostly to route method calls to the
     # default interface.
     def method_missing(name, *args, &reply_handler)
@@ -148,5 +156,6 @@ module DBus
         raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
       end
     end
+    # rubocop:enable Style/MethodMissing
   end # class ProxyObject
 end

data/lib/dbus/proxy_object_interface.rb

@@ -87,6 +87,7 @@ module DBus
     end
 
     # Defines a proxied method on the interface.
+    # Better name: declare_method
     def define_method(methodname, prototype)
       m = Method.new(methodname)
       m.from_prototype(prototype)

data/lib/dbus/type.rb

@@ -9,6 +9,24 @@
 # See the file "COPYING" for the exact licensing terms.
 
 module DBus
+  # Like a {Signature} but containing only a single complete type.
+  #
+  # For documentation purposes only.
+  class SingleCompleteType < String; end
+
+  # Zero or more {SingleCompleteType}s; its own type code is "g".
+  # For example "ssv" for a method taking two Strings and a Variant/
+  #
+  # For documentation purposes only.
+  class Signature < String; end
+
+  # Similar to {Signature} but for {DBus::Object.define_method},
+  # contains names and direction of the parameters.
+  # For example "in query:s, in case_sensitive:b, out results:ao".
+  #
+  # For documentation purposes only.
+  class Prototype < String; end
+
   # = D-Bus type module
   #
   # This module containts the constants of the types specified in the D-Bus

data/lib/dbus/xml.rb

@@ -41,21 +41,17 @@ module DBus
 
         # required methods
         # returns node attribute value
-        def [](key)
-        end
+        def [](key); end
 
         # yields child nodes which match xpath of type AbstractXML::Node
-        def each(xpath)
-        end
+        def each(xpath); end
       end
       # required methods
       # initialize parser with xml string
-      def initialize(xml)
-      end
+      def initialize(xml); end
 
       # yields nodes which match xpath of type AbstractXML::Node
-      def each(xpath)
-      end
+      def each(xpath); end
     end
 
     class NokogiriParser < AbstractXML

data/lib/dbus.rb

@@ -11,15 +11,16 @@
 require_relative "dbus/api_options"
 require_relative "dbus/auth"
 require_relative "dbus/bus"
-require_relative "dbus/core_ext/class/attribute"
+require_relative "dbus/bus_name"
 require_relative "dbus/error"
-require_relative "dbus/export"
 require_relative "dbus/introspect"
 require_relative "dbus/logger"
 require_relative "dbus/marshall"
 require_relative "dbus/matchrule"
 require_relative "dbus/message"
 require_relative "dbus/message_queue"
+require_relative "dbus/object"
+require_relative "dbus/object_path"
 require_relative "dbus/proxy_object"
 require_relative "dbus/proxy_object_factory"
 require_relative "dbus/proxy_object_interface"

data/ruby-dbus.gemspec

@@ -1,6 +1,5 @@
 # -*- ruby -*-
 require "rubygems"
-require "rake"
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "ruby-dbus"
@@ -8,25 +7,28 @@ GEMSPEC = Gem::Specification.new do |s|
   s.summary = "Ruby module for interaction with D-Bus"
   s.description = "Pure Ruby module for interaction with D-Bus IPC system"
   s.version = File.read("VERSION").strip
-  s.license = "LGPL v2.1"
+  s.license = "LGPL-2.1"
   s.author = "Ruby DBus Team"
-  s.email = "ruby-dbus-devel@lists.luon.net"
-  s.homepage = "https://trac.luon.net/ruby-dbus"
-  s.files = FileList[
+  s.email = "martin.github@vidner.net"
+  s.homepage = "https://github.com/mvidner/ruby-dbus"
+  s.files = Dir[
     "{doc,examples,lib,spec}/**/*",
     "COPYING", "NEWS.md", "Rakefile", "README.md",
-    "ruby-dbus.gemspec", "VERSION", ".rspec"].to_a.sort
+    "ruby-dbus.gemspec", "VERSION", ".rspec"
+  ]
   s.require_path = "lib"
 
-  s.required_ruby_version = ">= 2.0.0"
+  s.required_ruby_version = ">= 2.1.0"
+
+  s.add_dependency "rexml"
 
   # This is optional
   # s.add_runtime_dependency "nokogiri"
 
-  s.add_development_dependency "coveralls"
   s.add_development_dependency "packaging_rake_tasks"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 3"
-  s.add_development_dependency "rubocop", "= 0.41.2"
+  s.add_development_dependency "rubocop", "= 0.50.0"
   s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-lcov"
 end

data/spec/binding_spec.rb

@@ -28,10 +28,14 @@ describe "BindingTest" do
     # it should have its own interface
     expect(test2["org.ruby.Test2"]).not_to be_nil
     # but not an interface of the Test class
-    expect(test2["org.ruby.SampleInterface"]).to be_nil
+    expect { test2["org.ruby.SampleInterface"] }.to raise_error(DBus::Error) do |e|
+      expect(e.message).to match(/no such interface/)
+    end
 
     # and the parent should not get polluted by the child
-    expect(@base["org.ruby.Test2"]).to be_nil
+    expect { @base["org.ruby.Test2"] }.to raise_error(DBus::Error) do |e|
+      expect(e.message).to match(/no such interface/)
+    end
   end
 
   it "tests translating errors into exceptions" do

data/spec/bus_name_spec.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::BusName do
+  describe ".valid?" do
+    it "recognizes valid bus names" do
+      expect(described_class.valid?("org.freedesktop.DBus")).to be_truthy
+      expect(described_class.valid?(":1.42")).to be_truthy
+      expect(described_class.valid?("org._7_zip.Archiver")).to be_truthy
+    end
+
+    it "recognizes invalid bus names" do
+      expect(described_class.valid?("")).to be_falsey
+      expect(described_class.valid?("Empty..Component")).to be_falsey
+      expect(described_class.valid?(".Empty.First.Component")).to be_falsey
+      expect(described_class.valid?("Empty.Last.Component.")).to be_falsey
+      expect(described_class.valid?("Invalid.Ch@r@cter")).to be_falsey
+      expect(described_class.valid?("/Invalid-Character")).to be_falsey
+      long_name = "a." + ("long." * 100) + "name"
+      expect(described_class.valid?(long_name)).to be_falsey
+      expect(described_class.valid?("org.7_zip.Archiver")).to be_falsey
+    end
+  end
+end

data/spec/client_robustness_spec.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env rspec
+# Test that a client survives various error cases
+require_relative "spec_helper"
+require "dbus"
+
+describe "ClientRobustnessTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  context "when the bus name is invalid" do
+    it "tells the user the bus name is invalid" do
+      # user mistake, should be "org.ruby.service"
+      expect { @bus.service(".org.ruby.service") }.to raise_error(DBus::Error)
+    end
+  end
+
+  context "when the object path is invalid" do
+    it "tells the user the path is invalid" do
+      # user mistake, should be "/org/ruby/MyInstance"
+      expect { @svc.object("org.ruby.MyInstance") }.to raise_error(DBus::Error)
+    end
+  end
+end

data/spec/introspect_xml_parser_spec.rb

@@ -4,19 +4,19 @@ require "dbus"
 
 describe "IntrospectXMLParserTest" do
   it "tests split interfaces" do
-    xml = <<EOS
-<node>
-   <interface name="org.example.Foo">
-     <method name="Dwim"/>
-   </interface>
-   <interface name="org.example.Bar">
-     <method name="Drink"/>
-   </interface>
-   <interface name="org.example.Foo">
-     <method name="Smurf"/>
-   </interface>
-</node>
-EOS
+    xml = <<-XML
+      <node>
+        <interface name="org.example.Foo">
+          <method name="Dwim"/>
+        </interface>
+        <interface name="org.example.Bar">
+          <method name="Drink"/>
+        </interface>
+        <interface name="org.example.Foo">
+          <method name="Smurf"/>
+        </interface>
+      </node>
+    XML
 
     interfaces, _subnodes = DBus::IntrospectXMLParser.new(xml).parse