em-ruby-dbus 0.11.0

data/lib/dbus/xml.rb

@@ -0,0 +1,161 @@
+# dbus/xml.rb - introspection parser, rexml/nokogiri abstraction
+#
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2012 Geoff Youngs
+#
+# 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.
+
+# TODO check if it is slow, make replaceable
+require 'rexml/document'
+begin
+require 'nokogiri'
+rescue LoadError
+end
+
+module DBus
+  # = D-Bus introspect XML parser class
+  #
+  # This class parses introspection XML of an object and constructs a tree
+  # of Node, Interface, Method, Signal instances.
+  class IntrospectXMLParser
+    class << self
+      attr_accessor :backend
+    end
+    # Creates a new parser for XML data in string _xml_.
+    def initialize(xml)
+      @xml = xml
+    end
+
+    class AbstractXML
+      def self.have_nokogiri?
+        Object.const_defined?('Nokogiri')
+      end
+      class Node
+        def initialize(node)
+          @node = node
+        end
+        # required methods
+        # returns node attribute value
+        def [](key)
+        end
+        # yields child nodes which match xpath of type AbstractXML::Node
+        def each(xpath)
+        end
+      end
+      # required methods
+      # initialize parser with xml string
+      def initialize(xml)
+      end
+      # yields nodes which match xpath of type AbstractXML::Node
+      def each(xpath)
+      end
+    end
+
+    class NokogiriParser < AbstractXML
+      class NokogiriNode < AbstractXML::Node
+        def [](key)
+          @node[key]
+        end
+        def each(path, &block)
+          @node.search(path).each { |node| block.call NokogiriNode.new(node) }
+        end
+      end
+      def initialize(xml)
+        @doc = Nokogiri.XML(xml)
+      end
+      def each(path, &block)
+        @doc.search("//#{path}").each { |node| block.call NokogiriNode.new(node) }
+      end
+    end
+
+    class REXMLParser < AbstractXML
+      class REXMLNode < AbstractXML::Node
+        def [](key)
+          @node.attributes[key]
+        end
+        def each(path, &block)
+          @node.elements.each(path) { |node| block.call REXMLNode.new(node) }
+        end
+      end
+      def initialize(xml)
+        @doc = REXML::Document.new(xml)
+      end
+      def each(path, &block)
+        @doc.elements.each(path) { |node| block.call REXMLNode.new(node) }
+      end
+    end
+
+    if AbstractXML.have_nokogiri?
+      @backend = NokogiriParser
+    else
+      @backend = REXMLParser
+    end
+
+    # return a pair: [list of Interfaces, list of direct subnode names]
+    def parse
+      # Using a Hash instead of a list helps merge split-up interfaces,
+      # a quirk observed in ModemManager (I#41).
+      interfaces = Hash.new do |hash, missing_key|
+        hash[missing_key] = Interface.new(missing_key)
+      end
+      subnodes = []
+      t = Time.now
+
+
+      d = IntrospectXMLParser.backend.new(@xml)
+      d.each("node/node") do |e|
+        subnodes << e["name"]
+      end
+      d.each("node/interface") do |e|
+        i = interfaces[e["name"]]
+        e.each("method") do |me|
+          m = Method.new(me["name"])
+          parse_methsig(me, m)
+          i << m
+        end
+        e.each("signal") do |se|
+          s = Signal.new(se["name"])
+          parse_methsig(se, s)
+          i << s
+        end
+      end
+      d = Time.now - t
+      if d > 2
+        DBus.logger.debug "Some XML took more that two secs to parse. Optimize me!"
+      end
+      [interfaces.values, subnodes]
+    end
+
+    ######################################################################
+    private
+
+    # Parses a method signature XML element _e_ and initialises
+    # method/signal _m_.
+    def parse_methsig(e, m)
+      e.each("arg") do |ae|
+        name = ae["name"]
+        dir = ae["direction"]
+        sig = ae["type"]
+	if m.is_a?(DBus::Signal)
+          # Direction can only be "out", ignore it
+          m.add_fparam(name, sig)
+	elsif m.is_a?(DBus::Method)
+          case dir
+          # This is a method, so dir defaults to "in"
+          when "in", nil
+            m.add_fparam(name, sig)
+          when "out"
+	    m.add_return(name, sig)
+	  end
+        else
+          raise NotImplementedError, dir
+        end
+      end
+    end
+  end # class IntrospectXMLParser
+end # module DBus
+

data/test/async_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env rspec
+# Test the binding of dbus concepts to ruby concepts
+require_relative "spec_helper"
+require "dbus"
+
+describe "AsyncTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+    @obj = @svc.object "/org/ruby/MyInstance"
+    @obj.introspect
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+  # https://github.com/mvidner/ruby-dbus/issues/13
+  it "tests async_call_to_default_interface" do
+    loop = DBus::Main.new
+    loop << @bus
+
+    immediate_answer = @obj.the_answer do |msg, retval|
+      expect(retval).to eq(42)
+      loop.quit
+    end
+
+    expect(immediate_answer).to be_nil
+
+    # wait for the async reply
+    loop.run
+  end
+
+  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|
+      expect(retval).to eq("dcba")
+      loop.quit
+    end
+
+    expect(immediate_answer).to be_nil
+
+    # wait for the async reply
+    loop.run
+  end
+
+end

data/test/binding_spec.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env rspec
+# Test the binding of dbus concepts to ruby concepts
+require_relative "spec_helper"
+
+require "dbus"
+
+describe "BindingTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+    @base = @svc.object "/org/ruby/MyInstance"
+    @base.introspect
+    @base.default_iface = "org.ruby.SampleInterface"
+  end
+
+  # https://trac.luon.net/ruby-dbus/ticket/36#comment:3
+  it "tests class inheritance" do
+    derived = @svc.object "/org/ruby/MyDerivedInstance"
+    derived.introspect
+
+    # it should inherit from the parent
+    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
+  it "tests separation of classes" do
+    test2 = @svc.object "/org/ruby/MyInstance2"
+    test2.introspect
+
+    # 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
+
+    # and the parent should not get polluted by the child
+    expect(@base["org.ruby.Test2"]).to be_nil
+  end
+
+  it "tests translating errors into exceptions" do
+    # this is a generic call that will reply with the specified error
+    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
+
+  it "tests generic dbus error" do
+    # this is a generic call that will reply with the specified error
+    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
+  
+  it "tests dynamic interface definition" do
+    # interfaces can be defined dynamicaly
+    derived = DBus::Object.new "/org/ruby/MyDerivedInstance"
+    
+    #define a new interface
+    derived.singleton_class.instance_eval do
+      dbus_interface "org.ruby.DynamicInterface" do
+        dbus_method :hello2, "in name:s, in name2:s" do |name, name2|
+          puts "hello(#{name}, #{name2})"
+        end
+      end
+    end
+    
+    # the object should have the new iface
+    ifaces = derived.intfs
+    expect(ifaces && ifaces.include?("org.ruby.DynamicInterface")).to be_true
+  end
+    
+end

data/test/bus_and_xml_backend_spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env rspec
+# Test the bus class
+require_relative "spec_helper"
+
+require 'rubygems'
+require 'nokogiri'
+require "dbus"
+
+describe "BusAndXmlBackendTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+  end
+
+  it "tests introspection reading rexml" do
+    DBus::IntrospectXMLParser.backend = DBus::IntrospectXMLParser::REXMLParser
+    @svc = @bus.service("org.ruby.service")
+    obj = @svc.object("/org/ruby/MyInstance")
+    obj.default_iface = 'org.ruby.SampleInterface'
+    obj.introspect
+    # "should respond to :the_answer"
+    expect(obj.the_answer[0]).to eq(42)
+    # "should work with multiple interfaces"
+    expect(obj["org.ruby.AnotherInterface"].Reverse('foo')[0]).to eq("oof")
+  end
+
+  it "tests introspection reading nokogiri" do
+    # peek inside the object to see if a cleanup step worked or not
+    DBus::IntrospectXMLParser.backend = DBus::IntrospectXMLParser::NokogiriParser
+    @svc = @bus.service("org.ruby.service")
+    obj = @svc.object("/org/ruby/MyInstance")
+    obj.default_iface = 'org.ruby.SampleInterface'
+    obj.introspect
+    # "should respond to :the_answer"
+    expect(obj.the_answer[0]).to eq(42)
+    # "should work with multiple interfaces"
+    expect(obj["org.ruby.AnotherInterface"].Reverse('foo')[0]).to eq("oof")
+  end
+
+end

data/test/bus_driver_spec.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::Service do
+  let(:bus) { DBus::ASessionBus.new }
+
+  describe "#exists?" do
+    it "is true for an existing service" do
+      svc = bus.service("org.ruby.service")
+      svc.object("/").introspect # must activate the service first :-/
+      expect(svc.exists?).to be_true
+    end
+
+    it "is false for a nonexisting service" do
+      svc = bus.service("org.ruby.nosuchservice")
+      expect(svc.exists?).to be_false
+    end
+  end
+end

data/test/bus_spec.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env rspec
+# Test the bus class
+require_relative "spec_helper"
+
+require "dbus"
+
+describe "BusTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+    @svc.object("/").introspect
+  end
+
+  it "tests introspection not leaking" do
+    # peek inside the object to see if a cleanup step worked or not
+    some_hash = @bus.instance_eval { @method_call_replies || Hash.new }
+    # fail: "there are leftover method handlers"
+    expect(some_hash.size).to eq(0)
+  end
+end

data/test/byte_array_spec.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+
+require "dbus"
+
+describe "ByteArrayTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+    @obj = @svc.object("/org/ruby/MyInstance")
+    @obj.introspect
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+
+  it "tests passing byte array" do
+    data = [0, 77, 255]
+    result = @obj.mirror_byte_array(data).first
+    expect(result).to eq(data)
+  end
+
+  it "tests passing byte array from string" do
+    data = "AAA"
+    result = @obj.mirror_byte_array(data).first
+    expect(result).to eq([65, 65, 65])
+  end
+
+  it "tests passing byte array from hash" do
+    # Hash is an Enumerable, but is caught earlier
+    data = { "this will" => "fail" }
+    expect { @obj.mirror_byte_array(data).first }.to raise_error(DBus::TypeException)
+  end
+
+  it "tests passing byte array from nonenumerable" do
+    data = Time.now
+    expect { @obj.mirror_byte_array(data).first }.to raise_error(DBus::TypeException)
+  end
+end

data/test/err_msg_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env rspec
+# should report it missing on org.ruby.SampleInterface
+# (on object...) instead of on DBus::Proxy::ObjectInterface
+require_relative "spec_helper"
+require "dbus"
+
+describe "ErrMsgTest" do
+  before(:each) do
+    session_bus = DBus::ASessionBus.new
+    svc = session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect                  # necessary
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+  it "tests report dbus interface" do
+    # a specific exception...
+    # mentioning DBus and the interface
+    expect { @obj.NoSuchMethod }.to raise_error(NameError, /DBus interface.*#{@obj.default_iface}/)
+  end
+
+  it "tests report short struct" do
+    expect { @obj.test_variant ["(ss)", ["too few"] ] }.to raise_error(DBus::TypeException, /1 elements but type info for 2/)
+  end
+
+  it "tests report long struct" do
+    expect { @obj.test_variant ["(ss)", ["a", "b", "too many"] ] }.to raise_error(DBus::TypeException, /3 elements but type info for 2/)
+  end
+
+  it "tests report nil" do
+    nils = [
+            ["(s)", [nil] ],    # would get disconnected
+            ["i", nil ],
+            ["a{ss}", {"foo" => nil} ],
+           ]
+    nils.each do |has_nil|
+      # TODO want backtrace from the perspective of the caller:
+      # rescue/reraise in send_sync?
+      expect { @obj.test_variant has_nil }.to raise_error(DBus::TypeException, /Cannot send nil/)
+    end
+  end
+end