ruby-dbus 0.14.0 → 0.17.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# copied from activesupport/core_ext from Rails, MIT license
+# https://github.com/rails/rails/tree/a713fdae4eb4f7ccd34932edc61561a96b8d9f35/activesupport/lib/active_support/core_ext/module
+
+class Module
+  if RUBY_VERSION >= "2.3"
+    # Marks the named method as intended to be redefined, if it exists.
+    # Suppresses the Ruby method redefinition warning. Prefer
+    # #redefine_method where possible.
+    def silence_redefinition_of_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        # This suppresses the "method redefined" warning; the self-alias
+        # looks odd, but means we don't need to generate a unique name
+        alias_method method, method
+      end
+    end
+  else
+    def silence_redefinition_of_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        alias_method :__rails_redefine, method
+        remove_method :__rails_redefine
+      end
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    visibility = method_visibility(method)
+    silence_redefinition_of_method(method)
+    define_method(method, &block)
+    send(visibility, method)
+  end
+
+  # Replaces the existing singleton method definition, if there is one, with
+  # the passed block as its body.
+  def redefine_singleton_method(method, &block)
+    singleton_class.redefine_method(method, &block)
+  end
+
+  def method_visibility(method) # :nodoc:
+    case
+    when private_method_defined?(method)
+      :private
+    when protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+  end
+end

data/lib/dbus/introspect.rb

@@ -14,10 +14,6 @@ module DBus
   # Regular expressions that should match all interface names.
   INTERFACE_ELEMENT_RE = /^[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
@@ -30,19 +26,23 @@ module DBus
   # 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
+    # @return [String] The name of the interface.
     attr_reader :name
-    # The methods that are part of the interface. Hash: Symbol => DBus::Method
+    # @return [Hash{Symbol => DBus::Method}] The methods that are part of the interface.
     attr_reader :methods
-    # The signals that are part of the interface. Hash: Symbol => Signal
+    # @return [Hash{Symbol => Signal}] The signals that are part of the interface.
     attr_reader :signals
 
+    # @return [Hash{Symbol => Property}]
+    attr_reader :properties
+
     # Creates a new interface with a given _name_.
     def initialize(name)
       validate_name(name)
       @name = name
       @methods = {}
       @signals = {}
+      @properties = {}
     end
 
     # Validates a service _name_.
@@ -50,29 +50,37 @@ module DBus
       raise InvalidIntrospectionData if name.bytesize > 255
       raise InvalidIntrospectionData if name =~ /^\./ || name =~ /\.$/
       raise InvalidIntrospectionData if name =~ /\.\./
-      raise InvalidIntrospectionData if !(name =~ /\./)
+      raise InvalidIntrospectionData if name !~ /\./
       name.split(".").each do |element|
-        raise InvalidIntrospectionData if !(element =~ INTERFACE_ELEMENT_RE)
+        raise InvalidIntrospectionData if element !~ INTERFACE_ELEMENT_RE
       end
     end
 
-    # Helper method for defining a method _m_.
-    def define(m)
-      if m.is_a?(Method)
-        @methods[m.name.to_sym] = m
-      elsif m.is_a?(Signal)
-        @signals[m.name.to_sym] = m
-      end
+    # Add _ie_ as a known {Method}, {Signal} or {Property}
+    # @param ie [InterfaceElement]
+    def define(ie)
+      name = ie.name.to_sym
+      category = if ie.is_a?(Method)
+                   @methods
+                 elsif ie.is_a?(Signal)
+                   @signals
+                 elsif ie.is_a?(Property)
+                   @properties
+                 end
+      category[name] = ie
     end
+    alias declare define
     alias << define
 
     # Defines a method with name _id_ and a given _prototype_ in the
     # interface.
+    # Better name: declare_method
     def define_method(id, prototype)
       m = Method.new(id)
       m.from_prototype(prototype)
       define(m)
     end
+    alias declare_method define_method
   end # class Interface
 
   # = A formal parameter has a name and a type
@@ -148,6 +156,7 @@ module DBus
     end
 
     # Add parameter types by parsing the given _prototype_.
+    # @param prototype [Prototype]
     def from_prototype(prototype)
       prototype.split(/, */).each do |arg|
         arg = arg.split(" ")
@@ -171,16 +180,16 @@ module DBus
 
     # Return an XML string representation of the method interface elment.
     def to_xml
-      xml = %(<method name="#{@name}">\n)
+      xml = "    <method name=\"#{@name}\">\n"
       @params.each do |param|
-        name = param.name ? %(name="#{param.name}" ) : ""
-        xml += %(<arg #{name}direction="in" type="#{param.type}"/>\n)
+        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)
+        name = param.name ? "name=\"#{param.name}\" " : ""
+        xml += "      <arg #{name}direction=\"out\" type=\"#{param.type}\"/>\n"
       end
-      xml += %(</method>\n)
+      xml += "    </method>\n"
       xml
     end
   end # class Method
@@ -205,13 +214,49 @@ module DBus
 
     # Return an XML string representation of the signal interface elment.
     def to_xml
-      xml = %(<signal name="#{@name}">\n)
+      xml = "    <signal name=\"#{@name}\">\n"
       @params.each do |param|
-        name = param.name ? %(name="#{param.name}" ) : ""
-        xml += %(<arg #{name}type="#{param.type}"/>\n)
+        name = param.name ? "name=\"#{param.name}\" " : ""
+        xml += "      <arg #{name}type=\"#{param.type}\"/>\n"
       end
-      xml += %(</signal>\n)
+      xml += "    </signal>\n"
       xml
     end
   end # class Signal
+
+  # An (exported) property
+  # https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties
+  class Property
+    # @return [String] The name of the property, for example FooBar.
+    attr_reader :name
+    attr_reader :type
+    # @return [Symbol] :read :write or :readwrite
+    attr_reader :access
+
+    # @return [Symbol] What to call at Ruby side.
+    #   (Always without the trailing `=`)
+    attr_reader :ruby_name
+
+    def initialize(name, type, access, ruby_name:)
+      @name = name
+      @type = type
+      @access = access
+      @ruby_name = ruby_name
+    end
+
+    # @return [Boolean]
+    def readable?
+      access == :read || access == :readwrite
+    end
+
+    # @return [Boolean]
+    def writable?
+      access == :write || access == :readwrite
+    end
+
+    # Return introspection XML string representation of the property.
+    def to_xml
+      "    <property type=\"#{@type}\" name=\"#{@name}\" access=\"#{@access}\"/>\n"
+    end
+  end
 end # module DBus

data/lib/dbus/marshall.rb

@@ -69,6 +69,7 @@ module DBus
     def align(a)
       case a
       when 1
+        nil
       when 2, 4, 8
         bits = a - 1
         @idx = @idx + bits & ~bits
@@ -421,7 +422,7 @@ module DBus
         ["s", value.to_str]
       elsif value.respond_to? :to_int
         i = value.to_int
-        if -2_147_483_648 <= i && i < 2_147_483_648
+        if (-2_147_483_648...2_147_483_648).cover?(i)
           ["i", i]
         else
           ["x", i]

data/lib/dbus/message_queue.rb

@@ -11,6 +11,7 @@ require "fcntl"
 require "socket"
 
 module DBus
+  # Encapsulates a socket so that we can {#push} and {#pop} {Message}s.
   class MessageQueue
     # The socket that is used to connect with the bus.
     attr_reader :socket
@@ -22,10 +23,10 @@ module DBus
       connect
     end
 
-    # TODO: failure modes
-    #
-    # If _non_block_ is true, return nil instead of waiting
-    # EOFError may be raised
+    # @param non_block [Boolean] if true, return nil instead of waiting
+    # @return [Message,nil] one message or nil if unavailable
+    # @raise EOFError
+    # @todo failure modes
     def pop(non_block = false)
       buffer_from_socket_nonblock
       message = message_from_buffer_nonblock
@@ -80,22 +81,23 @@ module DBus
 
     # Connect to a bus over tcp and initialize the connection.
     def connect_to_tcp(params)
-      # check if the path is sufficient
-      if params.key?("host") && params.key?("port")
+      host = params["host"]
+      port = params["port"]
+      if host && port
         begin
           # initialize the tcp socket
-          @socket = TCPSocket.new(params["host"], params["port"].to_i)
+          @socket = TCPSocket.new(host, port.to_i)
           @socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
           init_connection
           @is_tcp = true
         rescue Exception => e
           puts "Oops:", e
-          puts "Error: Could not establish connection to: #{@path}, will now exit."
+          puts "Error: Could not establish connection to: #{host}:#{port}, will now exit."
           exit(1) # a little harsh
         end
       else
         # Danger, Will Robinson: the specified "path" is not usable
-        puts "Error: supplied path: #{@path}, unusable! sorry."
+        puts "Error: supplied params: #{@params}, unusable! sorry."
       end
     end
 
@@ -124,14 +126,14 @@ module DBus
 
     # Initialize the connection to the bus.
     def init_connection
-      @client = Client.new(@socket)
-      @client.authenticate
+      client = Client.new(@socket)
+      client.authenticate
     end
 
     public # FIXME: fix Main loop instead
 
     # Get and remove one message from the buffer.
-    # Return the message or nil.
+    # @return [Message,nil] the message or nil if unavailable
     def message_from_buffer_nonblock
       return nil if @buffer.empty?
       ret = nil
@@ -139,7 +141,7 @@ module DBus
         ret, size = Message.new.unmarshall_buffer(@buffer)
         @buffer.slice!(0, size)
       rescue IncompleteBufferException
-        # fall through, let ret be null
+        # fall through, let ret remain nil
       end
       ret
     end
@@ -149,7 +151,8 @@ module DBus
 
     # Fill (append) the buffer from data that might be available on the
     # socket.
-    # EOFError may be raised
+    # @return [void]
+    # @raise EOFError
     def buffer_from_socket_nonblock
       @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
     rescue EOFError