ruby-dbus-openplacos 0.6.0

data/lib/dbus/core_ext/class/attribute.rb

@@ -0,0 +1,91 @@
+# copied from activesupport/core_ext from Rails, MIT license
+require 'dbus/core_ext/kernel/singleton_class'
+require 'dbus/core_ext/module/remove_method'
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, a query method is defined as well:
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance writer method, pass :instance_writer => false.
+  #
+  #   object.setting = false  # => NoMethodError
+  def class_attribute(*attrs)
+    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
+
+    attrs.each do |name|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{name}() nil end
+        def self.#{name}?() !!#{name} end
+
+        def self.#{name}=(val)
+          singleton_class.class_eval do
+            remove_possible_method(:#{name})
+            define_method(:#{name}) { val }
+          end
+          val
+        end
+
+        def #{name}
+          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+        end
+
+        def #{name}?
+          !!#{name}
+        end
+      RUBY
+
+      attr_writer name if instance_writer
+    end
+  end
+end

data/lib/dbus/core_ext/kernel/singleton_class.rb

@@ -0,0 +1,14 @@
+# copied from activesupport/core_ext from Rails, MIT license
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
+
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end

data/lib/dbus/core_ext/module/remove_method.rb

@@ -0,0 +1,12 @@
+# copied from activesupport/core_ext from Rails, MIT license
+class Module
+  def remove_possible_method(method)
+    remove_method(method)
+  rescue NameError
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end

data/lib/dbus/error.rb

@@ -0,0 +1,44 @@
+# error.rb
+#
+# 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.
+
+module DBus
+  # Represents a D-Bus Error, both on the client and server side.
+  class Error < StandardError
+    # error_name. +message+ is inherited from +Exception+
+    attr_reader :name
+    # for received errors, the raw D-Bus message
+    attr_reader :dbus_message
+
+    # If +msg+ is a +DBus::Message+, its contents is used for initialization.
+    # Otherwise, +msg+ is taken as a string and +name+ is used.
+    def initialize(msg, name = "org.freedesktop.DBus.Error.Failed")
+      if msg.is_a? DBus::Message
+        @dbus_message = msg
+        @name = msg.error_name
+        super(msg.params[0]) # or nil
+        if msg.params[1].is_a? Array
+          set_backtrace msg.params[1]
+        end
+      else
+        @name = name
+        super(msg)
+      end
+      # TODO validate error name
+    end
+  end # class Error
+
+  # raise DBus.error, "message"
+  # raise DBus.error("org.example.Error.SeatOccupied"), "Seat #{n} is occupied"
+  def error(name = "org.freedesktop.DBus.Error.Failed")
+    # message will be set by Kernel.raise
+    DBus::Error.new(nil, name)
+  end
+  module_function :error
+end # module DBus

data/lib/dbus/export.rb

@@ -0,0 +1,124 @@
+# dbus/introspection.rb - module containing a low-level D-Bus introspection implementation
+#
+# 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'
+
+module DBus
+  # 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.
+  class Object
+    # The path of the object.
+    attr_reader :path
+    # The interfaces that the object supports.
+    class_attribute :intfs
+    # The service that the object is exported by.
+    attr_writer :service
+
+    @@cur_intf = nil
+    @@intfs_mutex = Mutex.new
+
+    # Create a new object with a given _path_.
+    def initialize(path)
+      @path = path
+      @service = nil
+    end
+
+    # State that the object implements the given _intf_.
+    def implements(intf)
+      # use a setter
+      self.intfs = (self.intfs || {}).merge({intf.name => intf})
+    end
+
+    # Dispatch a message _msg_.
+    def dispatch(msg)
+      case msg.message_type
+      when Message::METHOD_CALL
+        reply = nil
+        begin
+          if not self.intfs[msg.interface]
+            raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
+            "Interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
+          end
+          meth = self.intfs[msg.interface].methods[msg.member.to_sym]
+          if not 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 => ex
+          reply = ErrorMessage.from_exception(ex).reply_to(msg)
+        end
+        @service.bus.send(reply.marshall)
+      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 = Interface.new(s)
+        self.intfs = (self.intfs || {}).merge({s => @@cur_intf})
+        yield
+        @@cur_intf = nil
+      end
+    end
+
+    # Dummy undefined interface class.
+    class UndefinedInterface < ScriptError
+      def initialize(sym)
+        super "No interface specified for #{sym}"
+      end
+    end
+
+    # Defines an exportable method on the object with the given name _sym_,
+    # _prototype_ and the code in a block.
+    def self.dbus_method(sym, protoype = "", &block)
+      raise UndefinedInterface, sym if @@cur_intf.nil?
+      @@cur_intf.define(Method.new(sym.to_s).from_prototype(protoype))
+      define_method(Object.make_method_name(@@cur_intf.name, sym.to_s), &block) 
+    end
+
+    # Emits a signal from the object with the given _interface_, signal
+    # _sig_ and arguments _args_.
+    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, protoype = "")
+      raise UndefinedInterface, sym if @@cur_intf.nil?
+      cur_intf = @@cur_intf
+      signal = Signal.new(sym.to_s).from_prototype(protoype)
+      cur_intf.define(Signal.new(sym.to_s).from_prototype(protoype))
+      define_method(sym.to_s) do |*args|
+        emit(cur_intf, signal, *args)
+      end
+    end
+
+    ####################################################################
+    private
+
+    # Helper method that returns a method name generated from the interface
+    # name _intfname_ and method name _methname_.
+    def self.make_method_name(intfname, methname)
+      "#{intfname}%%#{methname}"
+    end
+  end # class Object
+end # module DBus