dbus 0.1.5

data/lib/dbus/binding.rb

@@ -0,0 +1,259 @@
+#-----------------------------------------------------
+# D-BUS bindings for Ruby
+# (C) Copyright 2004 Leon Breedt
+# (C) Copyright 2004 Provenco Group Ltd
+#
+# Licensed under the same terms as the D-BUS library
+#-----------------------------------------------------
+
+#-----------------------------------------------------------------
+# Native classes
+#
+#   The classes below provide any additional implementation for 
+#   the corresponding classes defined in dbus.so. Things which
+#   belong in here are string munging, convenience methods,
+#   to_string implementations, etc. 
+#
+#   Basically, anything which would be too much of a pain to
+#   implement in C.
+# 
+#-----------------------------------------------------------------
+module DBus
+module Binding
+
+  class DBusConnection
+    #--
+    # TODO
+    #++
+    def set_watch_functions(add_func, remove_func, data) # :nodoc:
+    end
+    def set_timeout_functions(add_func, remove_func, data) # :nodoc:
+    end
+    def set_wakeup_main_function(add_func, remove_func, data) # :nodoc:
+    end
+    def set_data(slot, data) # :nodoc:
+    end
+    def get_data(slot, data) # :nodoc:
+    end
+  end
+
+  class DBusMessage
+    include Enumerable
+
+    # Yields each message argument value that was appended to the message to
+    # the given block, in sequence
+    def each
+      raise DBusError, "block expected" unless block_given?
+      iter = get_iter
+      begin
+        value = iter.value
+      rescue
+        return nil
+      end
+      yield value
+      have_value = iter.next
+      while have_value
+        yield iter.value
+        have_value = iter.next
+      end
+      nil
+    end
+
+    # Returns the message argument value at the given offset
+    def [](offset)
+      entries[offset]
+    end
+
+    # Appends each item in the given Array to the message
+    def append(ary)
+      iter = get_append_iter
+      ary.each{|value| iter.append(value)}
+      nil
+    end
+
+    # Appends the given value to the message. If you want to append more than
+    # one value, use DBusMessage#append instead, it will be more efficient.
+    def <<(value)
+      iter = get_append_iter
+      iter.append(value)
+      nil
+    end
+
+    # Returns an array containing the path segments of the message path
+    def get_path_decomposed
+      get_path.split("/")
+    end
+
+    def to_s
+      "#<#{self.class.to_s} path=\"#{get_path}\" interface=\"#{get_interface}\" member=\"#{get_member}\" sender=\"#{get_sender}\">"
+    end
+  end
+
+  class DBusMessageIter
+    # Appends the given value to the message this iterator is associated with.
+    # Ruby types are automatically converted to the closest matching D-BUS
+    # message argument type.
+    def append(value)
+      case
+      when value.nil?
+        append_nil
+      when value.is_a?(ObjectPath)
+        append_object_path(value)
+      when value.is_a?(String)
+        append_string(value)
+      when value.is_a?(Fixnum)
+        append_int32(value)
+      when value.is_a?(Bignum)
+        append_int64(value)
+      when value.is_a?(Float)
+        append_double(value)
+      when value.is_a?(TrueClass)
+        append_boolean(true)
+      when value.is_a?(FalseClass)
+        append_boolean(false)
+      when value.is_a?(Hash)
+        di = append_dict
+        value.each{|k,v| di.append_dict_key(k); di.append(v); }
+        true
+      when value.is_a?(Array)
+        raise ArgumentError, "empty arrays are not supported" if value.empty?
+        dtype = ruby_to_dbus_type(value[0])
+        ai = append_array(dtype)
+        value.each{|v| ai.append(v) if ruby_to_dbus_type(v) == dtype}
+        true
+      else
+        raise ArgumentError, "unsupported argument type #{value.class}"
+      end
+    end
+
+    # Returns the message argument value at the current position of the
+    # iterator. The value is converted from the D-BUS type to the closest
+    # matching Ruby type.
+    def value
+      case get_arg_type
+      when TYPE_NIL
+        nil
+      when TYPE_BYTE
+        get_byte
+      when TYPE_BOOLEAN
+        get_boolean
+      when TYPE_INT32
+        get_int32
+      when TYPE_UINT32
+        get_uint32
+      when TYPE_INT64
+        get_int64
+      when TYPE_UINT64
+        get_uint64
+      when TYPE_DOUBLE
+        get_double
+      when TYPE_STRING
+        get_string
+      when TYPE_ARRAY
+        get_array
+      when TYPE_DICT
+        get_dict
+      when TYPE_OBJECT_PATH
+        ObjectPath.new(get_object_path)
+      else
+        raise DBusError, "unsupported iter arg type '#{type_as_string(get_arg_type)}'"
+      end
+    end
+
+    # For compatibility with the other bindings
+    alias :get :value
+
+    # Returns the message argument value at the current position of the
+    # iterator as a Hash. For this to work, the argument value has to be
+    # of the D-BUS type TYPE_DICT.
+    def get_dict
+      iter = dict_iter
+      ret = {}
+      loop do
+        ret[iter.get_dict_key] = iter.value
+        break if !iter.has_next
+        iter.next
+      end
+      ret
+    end
+
+    # Returns the message argument value at the current position of the
+    # iterator as an Array.  For this to work, the argument value has to be
+    # of the D-BUS type TYPE_ARRAY.
+    def get_array
+      iter = array_iter
+      ret = []
+      loop do
+        ret << iter.value
+        break if !iter.has_next
+        iter.next
+      end
+      ret
+    end
+
+    private
+    def type_as_string(arg_type)
+      case arg_type
+      when TYPE_INVALID
+        'invalid'
+      when TYPE_NIL
+        'nil'
+      when TYPE_BYTE
+        'byte'
+      when TYPE_BOOLEAN
+        'boolean'
+      when TYPE_INT32
+        'int32'
+      when TYPE_UINT32
+        'uint32'
+      when TYPE_INT64
+        'int64'
+      when TYPE_UINT64
+        'uint64'
+      when TYPE_DOUBLE
+        'double'
+      when TYPE_STRING
+        'string'
+      when TYPE_CUSTOM
+        'custom'
+      when TYPE_ARRAY
+        'array'
+      when TYPE_DICT
+        'dict'
+      when TYPE_OBJECT_PATH
+        'objectpath'
+      else
+        'unknown'
+      end
+    end
+
+    def ruby_to_dbus_type(value)
+      case
+      when value.nil?
+        TYPE_NIL
+      when value.is_a?(ObjectPath)
+        TYPE_OBJECT_PATH
+      when value.is_a?(String)
+        TYPE_STRING
+      when value.is_a?(Fixnum)
+        TYPE_INT32
+      when value.is_a?(Bignum)
+        TYPE_INT64
+      when value.is_a?(Float)
+        TYPE_DOUBLE
+      when value.is_a?(TrueClass)
+        TYPE_BOOLEAN
+      when value.is_a?(FalseClass)
+        TYPE_BOOLEAN
+      when value.is_a?(Hash)
+        TYPE_DICT
+      when value.is_a?(Array)
+        TYPE_ARRAY
+      else
+        raise ArgumentError, "unsupported Ruby type #{value.class}"
+      end
+    end
+  end
+
+end # Binding
+end # DBus

data/lib/dbus/version.rb

@@ -0,0 +1,21 @@
+#---------------------------------------------------
+# D-BUS bindings for Ruby
+# (C) Copyright 2004 Leon Breedt
+# (C) Copyright 2004 Provenco Group Ltd
+#
+# Licensed under the same terms as the D-BUS library
+#---------------------------------------------------
+
+module DBus
+
+  # Contains the version of the D-BUS bindings. This version is
+  # completely different from the D-BUS library itself.
+  module BindingVersion
+    VERSION_MAJOR = 0
+    VERSION_MINOR = 1
+    VERSION_PATCH = 4
+  end
+  
+  # Contains the string version of the D-BUS bindings
+  BINDING_VERSION = "#{BindingVersion::VERSION_MAJOR}.#{BindingVersion::VERSION_MINOR}.#{BindingVersion::VERSION_PATCH}"
+end

data/test/tc_all.rb

@@ -0,0 +1,10 @@
+require 'pathname'
+require 'test/unit'
+basedir = Pathname.new($0).realpath.dirname.dirname.to_s
+$:.unshift(File.join(basedir, 'ext'))
+$:.unshift(File.join(basedir, 'lib'))
+testdir = File.join(basedir, 'test') 
+$:.unshift(testdir)
+Dir[File.join(testdir, '**', 'tc_*.rb')].each do |t|
+  require t
+end

data/test/tc_connection.rb

@@ -0,0 +1,49 @@
+require 'dbus'
+require 'test/unit'
+
+class TC_DBusConnection < Test::Unit::TestCase
+  def setup
+    @server = DBus::Binding::DBusServer::listen("unix:tmpdir=#{Dir.getwd}")
+    @conn = DBus::Binding::DBusConnection.new(@server.get_address)
+    @server.setup_with_g_main
+    @conn.setup_with_g_main
+  end
+
+  def teardown
+    @server.disconnect
+    @conn.disconnect
+    @server = @conn = nil
+  end
+
+  def test_bus_get
+    conn = DBus::Binding::bus_get(DBus::BUS_SYSTEM)
+    assert(!conn.nil?)
+    assert(conn.is_a?(DBus::Binding::DBusConnection))
+  end
+
+  def test_conn_open_new
+    assert_raises(DBus::DBusError) do
+      DBus::Binding::DBusConnection.new("invalid dbus address")
+    end
+    assert_raises(DBus::DBusError) do 
+      DBus::Binding::DBusConnection.new("unix:path=/nonexistent/socket/path")
+    end
+  end
+
+  def test_attr
+    conn = DBus::Binding::bus_get(DBus::BUS_SYSTEM)
+    assert(conn.get_max_message_size.is_a?(Numeric))
+    conn.set_max_message_size(5)
+    assert(conn.get_max_message_size == 5)
+    assert(conn.get_max_received_size.is_a?(Numeric))
+    conn.set_max_received_size(5)
+    assert(conn.get_max_received_size == 5)
+    assert(conn.get_outgoing_size.is_a?(Numeric))
+  end
+
+  def test_send
+    msg = DBus::Binding::DBusMessage.new_signal("/com/provenco/sync/FS", "com.provenco.sync.FS", "MediaChanged")
+    msg.get_iter.append_boolean(true)
+    ret, call = @conn.send_with_reply(msg, 5)
+  end
+end

data/test/tc_message.rb

@@ -0,0 +1,82 @@
+require 'dbus'
+require 'test/unit'
+
+class TC_DBusMessage < Test::Unit::TestCase
+  def test_new_variants
+    msg = DBus::Binding::DBusMessage.new_method_call("dummy", "fake", "fake", "fake")
+    assert(msg.get_type == DBus::MESSAGE_TYPE_METHOD_CALL)
+    msg = DBus::Binding::DBusMessage.new_method_return(msg)
+    assert(msg.get_type == DBus::MESSAGE_TYPE_METHOD_RETURN)
+    msg = DBus::Binding::DBusMessage.new_signal("path", "interface", "name")
+    assert(msg.get_type == DBus::MESSAGE_TYPE_SIGNAL)
+    msg = DBus::Binding::DBusMessage.new_error(msg, "com.provenco.Error", "default msg")
+    assert(msg.get_type == DBus::MESSAGE_TYPE_ERROR)
+  end
+
+  def test_attribute_getters_and_setters
+    msg = DBus::Binding::DBusMessage.new(DBus::MESSAGE_TYPE_SIGNAL)
+    str_attrs = %w[path interface member error_name destination sender]
+    str_attrs.each do |name|
+      assert(msg.send("get_#{name}").nil?)
+      value = name == 'path' ? "org/freedesktop/Fake/Value" : "org.freedesktop.Fake.Value"
+      assert(msg.send("set_#{name}", value) == true)
+      assert(msg.send("get_#{name}") == value)
+    end
+    assert(msg.get_no_reply == false)
+    msg.set_no_reply(true)
+    assert(msg.get_no_reply == true)
+    assert(msg.is_method_call("org.freedesktop.Fake.Interface", "FakeMethod") == false)
+    assert(msg.is_error("org.freedesktop.Fake.Error") == false)
+    assert(msg.has_destination("org.freedesktop.Fake.Destination") == false)
+    assert(msg.has_sender("org.freedesktop.Fake.Sender") == false)
+    assert(msg.has_signature("org.freedesktop.Fake.Signature") == false)
+    assert(msg.get_serial == 0) # XXX crap, what should this be?
+    assert(msg.get_signature == '') # XXX crap, what should this be?
+    msg.set_reply_serial(590232)
+    msg.get_reply_serial == 590232
+    assert(msg.get_auto_activation == false)
+    msg.set_auto_activation(true)
+    assert(msg.get_auto_activation == true)
+    assert(msg.get_path_decomposed == ["org", "freedesktop", "Fake", "Value"])
+  end
+
+  def test_iter
+    msg = DBus::Binding::DBusMessage.new(DBus::MESSAGE_TYPE_SIGNAL)
+    iter = msg.get_iter
+    iter.append_byte(0xfa)
+    iter.append_nil
+    iter.append_boolean(true)
+    iter.append_int32(0xfffff)
+    iter.append({'hello' => 5, 'bye' => 6})
+    iter.append([1, 2, 3, 4])
+    iter = msg.get_iter
+    assert(iter.has_next == true)
+    assert(iter.value == 0xfa)
+    iter.next
+    assert(iter.value.nil?)
+    iter.next
+    assert(iter.value == true)
+    assert(iter.next == true)
+    assert(iter.value == 0xfffff)
+    iter.next
+    assert(iter.value['hello'] == 5)
+    assert(iter.value['bye'] == 6)
+    iter.next
+    assert(iter.value[0] == 1)
+    assert(iter.value[1] == 2)
+    assert(iter.value[2] == 3)
+    assert(iter.value[3] == 4)
+    assert(iter.has_next == false)
+    assert(iter.next == false)
+  end
+
+  def test_enumerable
+    msg = DBus::Binding::DBusMessage.new(DBus::MESSAGE_TYPE_SIGNAL)
+    msg << "test"
+    msg << 0
+    msg.append([5, nil, false, 39932039, "test2"])
+    assert(msg[0] == "test")
+    assert(msg.collect {|x| x == 5} == [false, false, true, false, false, false, false])
+    assert(msg.entries.length == 7)
+  end
+end

data/test/tc_server.rb

@@ -0,0 +1,10 @@
+require 'dbus'
+require 'test/unit'
+
+class TC_Server < Test::Unit::TestCase
+  def test_server_listen
+    server = DBus::Binding::DBusServer::listen("unix:tmpdir=#{Dir.getwd}")
+    assert(server.get_is_connected == true)
+    assert(!server.get_address.nil?)
+  end
+end

data/tools/genrdoc

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+# ugly, but rdoc doesn't maintain state between .c files.
+cat ext/*.c >ruby-dbus.c
+rdoc -t DBus/Ruby --line-numbers --inline-source -p -m DBus -x ext ruby-dbus.c lib
+rm -f ruby-dbus.c

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: dbus
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+date: 2004-11-25
+summary: Ruby bindings for D-BUS.
+require_paths: 
+  - lib
+author: Leon Breedt
+email: bitserf@gmail.com
+homepage: http://rubyforge.org/projects/dbus-ruby
+rubyforge_project: dbus-ruby
+description: Ruby bindings for D-BUS.  This module allows Ruby programs to interface with the D-BUS message bus installed on newer Unix operating systems.
+autorequire: dbus
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - examples/example-signal-emitter.rb
+  - examples/list-session-services.rb
+  - examples/example-signal-recipient.rb
+  - examples/list-system-services.rb
+  - examples/gconf-proxy-client.rb
+  - examples/example-client.rb
+  - examples/gconf-proxy-service.rb
+  - examples/example-service.rb
+  - examples/volumed.rb
+  - ext/ruby-dbus-message-iter.c
+  - ext/ruby-dbus-message.c
+  - ext/ruby-dbus-pending-call.c
+  - ext/ruby-dbus-server.c
+  - ext/ruby-dbus.h
+  - ext/ruby-dbus-common.c
+  - ext/ruby-dbus-bus.c
+  - ext/MANIFEST
+  - ext/extconf.rb
+  - ext/ruby-dbus-connection.c
+  - lib/dbus
+  - lib/dbus.rb
+  - lib/dbus/version.rb
+  - lib/dbus/binding.rb
+  - test/tc_connection.rb
+  - test/tc_all.rb
+  - test/tc_message.rb
+  - test/tc_server.rb
+  - tools/genrdoc
+test_files: 
+  - test/tc_all.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: 
+  - ext/extconf.rb
+requirements: 
+  - The D-BUS library
+  - Ruby Glib2 bindings
+dependencies: []