em-ruby-dbus 0.11.0

data/lib/dbus/core_ext/array/extract_options.rb

@@ -0,0 +1,31 @@
+# copied from activesupport/core_ext from Rails, MIT license
+# https://github.com/rails/rails/tree/5aa869861c192daceafe3a3ee50eb93f5a2b7bd2/activesupport/lib/active_support/core_ext
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# copied from activesupport/core_ext from Rails, MIT license
+# https://github.com/rails/rails/tree/5aa869861c192daceafe3a3ee50eb93f5a2b7bd2/activesupport/lib/active_support/core_ext
+require 'dbus/core_ext/kernel/singleton_class'
+require 'dbus/core_ext/module/remove_method'
+require 'dbus/core_ext/array/extract_options'
+
+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, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   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 reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def class_attribute(*attrs)
+    options = attrs.extract_options!
+    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
+
+    attrs.each do |name|
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+
+    unless respond_to?(:singleton_class?)
+      def singleton_class?
+        ancestors.first != self
+      end
+    end
+end

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

@@ -0,0 +1,8 @@
+# copied from activesupport/core_ext from Rails, MIT license
+# https://github.com/rails/rails/tree/5aa869861c192daceafe3a3ee50eb93f5a2b7bd2/activesupport/lib/active_support/core_ext
+module Kernel
+  # 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,14 @@
+# copied from activesupport/core_ext from Rails, MIT license
+# https://github.com/rails/rails/tree/5aa869861c192daceafe3a3ee50eb93f5a2b7bd2/activesupport/lib/active_support/core_ext
+class Module
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end

data/lib/dbus/error.rb

@@ -0,0 +1,46 @@
+# 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
+
+  # @example raise a generic error
+  #   raise DBus.error, "message"
+  # @example raise a specific error
+  #   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,128 @@
+# 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. 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
+    class_attribute :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
+
+    # 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_ to call exported methods
+    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
+          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
+        unless @@cur_intf = (self.intfs && self.intfs[s])
+          @@cur_intf = Interface.new(s)
+          self.intfs = (self.intfs || {}).merge({s => @@cur_intf})
+        end
+        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

data/lib/dbus/introspect.rb

@@ -0,0 +1,219 @@
+# 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.
+
+module DBus
+  # Regular expressions that should match all method names.
+  MethodSignalRE = /^[A-Za-z][A-Za-z0-9_]*$/
+  # Regular expressions that should match all interface names.
+  InterfaceElementRE = /^[A-Za-z][A-Za-z0-9_]*$/
+
+  # Exception raised when an unknown signal is used.
+  class UnknownSignal < Exception
+  end
+
+  # Exception raised when an invalid class definition is encountered.
+  class InvalidClassDefinition < Exception
+  end
+
+  # = D-Bus interface class
+  #
+  # This class is the interface descriptor.  In most cases, the Introspect()
+  # method call instantiates and configures this class for us.
+  #
+  # It also is the local definition of interface exported by the program.
+  # At the client side, see ProxyObjectInterface
+  class Interface
+    # The name of the interface. String
+    attr_reader :name
+    # The methods that are part of the interface. Hash: Symbol => DBus::Method
+    attr_reader :methods
+    # The signals that are part of the interface. Hash: Symbol => Signal
+    attr_reader :signals
+
+    # Creates a new interface with a given _name_.
+    def initialize(name)
+      validate_name(name)
+      @name = name
+      @methods, @signals = Hash.new, Hash.new
+    end
+
+    # Validates a service _name_.
+    def validate_name(name)
+      raise InvalidIntrospectionData if name.bytesize > 255
+      raise InvalidIntrospectionData if name =~ /^\./ or name =~ /\.$/
+      raise InvalidIntrospectionData if name =~ /\.\./
+      raise InvalidIntrospectionData if not name =~ /\./
+      name.split(".").each do |element|
+        raise InvalidIntrospectionData if not element =~ InterfaceElementRE
+      end
+    end
+
+    # Helper method for defining a method _m_.
+    def define(m)
+      if m.kind_of?(Method)
+        @methods[m.name.to_sym] = m
+      elsif m.kind_of?(Signal)
+        @signals[m.name.to_sym] = m
+      end
+    end
+    alias :<< :define
+
+    # Defines a method with name _id_ and a given _prototype_ in the
+    # interface.
+    def define_method(id, prototype)
+      m = Method.new(id)
+      m.from_prototype(prototype)
+      define(m)
+    end
+  end # class Interface
+
+  # = A formal parameter has a name and a type
+  class FormalParameter
+    attr_reader :name
+    attr_reader :type
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+
+    # backward compatibility, deprecated
+    def [](index)
+      case index
+        when 0 then name
+        when 1 then type
+        else nil
+      end
+    end
+  end
+
+  # = D-Bus interface element class
+  #
+  # This is a generic class for entities that are part of the interface
+  # such as methods and signals.
+  class InterfaceElement
+    # The name of the interface element. Symbol
+    attr_reader :name
+    # The parameters of the interface element. Array: FormalParameter
+    attr_reader :params
+
+    # Validates element _name_.
+    def validate_name(name)
+      if (not name =~ MethodSignalRE) or (name.bytesize > 255)
+        raise InvalidMethodName, name
+      end
+    end
+
+    # Creates a new element with the given _name_.
+    def initialize(name)
+      validate_name(name.to_s)
+      @name = name
+      @params = Array.new
+    end
+
+    # Adds a formal parameter with _name_ and _signature_
+    # (See also Message#add_param which takes signature+value)
+    def add_fparam(name, signature)
+      @params << FormalParameter.new(name, signature)
+    end
+
+    # Deprecated, for backward compatibility
+    def add_param(name_signature_pair)
+      add_fparam(*name_signature_pair)
+    end
+  end # class InterfaceElement
+
+  # = D-Bus interface method class
+  #
+  # This is a class representing methods that are part of an interface.
+  class Method < InterfaceElement
+    # The list of return values for the method. Array: FormalParameter
+    attr_reader :rets
+
+    # Creates a new method interface element with the given _name_.
+    def initialize(name)
+      super(name)
+      @rets = Array.new
+    end
+
+    # Add a return value _name_ and _signature_.
+    def add_return(name, signature)
+      @rets << FormalParameter.new(name, signature)
+    end
+
+    # Add parameter types by parsing the given _prototype_.
+    def from_prototype(prototype)
+      prototype.split(/, */).each do |arg|
+        arg = arg.split(" ")
+        raise InvalidClassDefinition if arg.size != 2
+        dir, arg = arg
+        if arg =~ /:/
+          arg = arg.split(":")
+          name, sig = arg
+        else
+          sig = arg
+        end
+        case dir
+        when "in"
+          add_fparam(name, sig)
+        when "out"
+          add_return(name, sig)
+        end
+      end
+      self
+    end
+
+    # Return an XML string representation of the method interface elment.
+    def to_xml
+      xml = %{<method name="#{@name}">\n}
+      @params.each do |param|
+        name = param.name ? %{name="#{param.name}" } : ""
+        xml += %{<arg #{name}direction="in" type="#{param.type}"/>\n}
+      end
+      @rets.each do |param|
+        name = param.name ? %{name="#{param.name}" } : ""
+        xml += %{<arg #{name}direction="out" type="#{param.type}"/>\n}
+      end
+      xml += %{</method>\n}
+      xml
+    end
+  end # class Method
+
+  # = D-Bus interface signal class
+  #
+  # This is a class representing signals that are part of an interface.
+  class Signal < InterfaceElement
+    # Add parameter types based on the given _prototype_.
+    def from_prototype(prototype)
+      prototype.split(/, */).each do |arg|
+        if arg =~ /:/
+          arg = arg.split(":")
+          name, sig = arg
+        else
+          sig = arg
+        end
+        add_fparam(name, sig)
+      end
+      self
+    end
+
+    # Return an XML string representation of the signal interface elment.
+    def to_xml
+      xml = %{<signal name="#{@name}">\n}
+      @params.each do |param|
+        name = param.name ? %{name="#{param.name}" } : ""
+        xml += %{<arg #{name}type="#{param.type}"/>\n}
+      end
+      xml += %{</signal>\n}
+      xml
+    end
+  end # class Signal
+end # module DBus
+