ruby-dbus 0.12.0 → 0.13.0

data/lib/dbus/proxy_object_factory.rb

@@ -15,13 +15,16 @@ module DBus
     # Creates a new proxy object factory for the given introspection XML _xml_,
     # _bus_, destination _dest_, and _path_.
     def initialize(xml, bus, dest, path, api: ApiOptions::CURRENT)
-      @xml, @bus, @path, @dest = xml, bus, path, dest
+      @xml = xml
+      @bus = bus
+      @path = path
+      @dest = dest
       @api = api
     end
 
     # Investigates the sub-nodes of the proxy object _po_ based on the
     # introspection XML data _xml_ and sets them up recursively.
-    def ProxyObjectFactory.introspect_into(po, xml)
+    def self.introspect_into(po, xml)
       intfs, po.subnodes = IntrospectXMLParser.new(xml).parse
       intfs.each do |i|
         poi = ProxyObjectInterface.new(po, i.name)

data/lib/dbus/proxy_object_interface.rb

@@ -25,8 +25,10 @@ module DBus
     # Creates a new proxy interface for the given proxy _object_
     # and the given _name_.
     def initialize(object, name)
-      @object, @name = object, name
-      @methods, @signals = Hash.new, Hash.new
+      @object = object
+      @name = name
+      @methods = {}
+      @signals = {}
     end
 
     # Returns the string representation of the interface (the name).
@@ -77,9 +79,9 @@ module DBus
 
     # Defines a signal or method based on the descriptor _m_.
     def define(m)
-      if m.kind_of?(Method)
+      if m.is_a?(Method)
         define_method_from_descriptor(m)
-      elsif m.kind_of?(Signal)
+      elsif m.is_a?(Signal)
         define_signal_from_descriptor(m)
       end
     end
@@ -107,12 +109,12 @@ module DBus
       end
     end
 
-    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
+    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties".freeze
 
     # Read a property.
     # @param propname [String]
     def [](propname)
-      ret = self.object[PROPERTY_INTERFACE].Get(self.name, propname)
+      ret = object[PROPERTY_INTERFACE].Get(name, propname)
       # this method always returns the single property
       if @object.api.proxy_method_returns_array
         ret[0]
@@ -125,13 +127,13 @@ module DBus
     # @param propname [String]
     # @param value [Object]
     def []=(propname, value)
-      self.object[PROPERTY_INTERFACE].Set(self.name, propname, value)
+      object[PROPERTY_INTERFACE].Set(name, propname, value)
     end
 
     # Read all properties at once, as a hash.
     # @return [Hash{String}]
     def all_properties
-      ret = self.object[PROPERTY_INTERFACE].GetAll(self.name)
+      ret = object[PROPERTY_INTERFACE].GetAll(name)
       # this method always returns the single property
       if @object.api.proxy_method_returns_array
         ret[0]

data/lib/dbus/type.rb

@@ -9,185 +9,183 @@
 # See the file "COPYING" for the exact licensing terms.
 
 module DBus
-
-# = D-Bus type module
-#
-# This module containts the constants of the types specified in the D-Bus
-# protocol.
-module Type
-  # Mapping from type number to name and alignment.
-  TypeMapping = {
-    0 => ["INVALID", nil],
-    ?y => ["BYTE", 1],
-    ?b => ["BOOLEAN", 4],
-    ?n => ["INT16", 2],
-    ?q => ["UINT16", 2],
-    ?i => ["INT32", 4],
-    ?u => ["UINT32", 4],
-    ?x => ["INT64", 8],
-    ?t => ["UINT64", 8],
-    ?d => ["DOUBLE", 8],
-    ?r => ["STRUCT", 8],
-    ?a => ["ARRAY", 4],
-    ?v => ["VARIANT", 1],
-    ?o => ["OBJECT_PATH", 4],
-    ?s => ["STRING", 4],
-    ?g => ["SIGNATURE", 1],
-    ?e => ["DICT_ENTRY", 8],
-    ?h => ["UNIX_FD", 4],
-  }
-  # Defines the set of constants
-  TypeMapping.each_pair do |key, value|
-    Type.const_set(value.first, key)
-  end
-
-  # Exception raised when an unknown/incorrect type is encountered.
-  class SignatureException < Exception
-  end
-
-  # = D-Bus type conversion class
+  # = D-Bus type module
   #
-  # Helper class for representing a D-Bus type.
-  class Type
-    # Returns the signature type number.
-    attr_reader :sigtype
-    # Return contained member types.
-    attr_reader :members
-
-    # Create a new type instance for type number _sigtype_.
-    def initialize(sigtype)
-      if not TypeMapping.keys.member?(sigtype)
-        raise SignatureException, "Unknown key in signature: #{sigtype.chr}"
-      end
-      @sigtype = sigtype
-      @members = Array.new
+  # This module containts the constants of the types specified in the D-Bus
+  # protocol.
+  module Type
+    # Mapping from type number to name and alignment.
+    TypeMapping = {
+      0 => ["INVALID", nil],
+      "y" => ["BYTE", 1],
+      "b" => ["BOOLEAN", 4],
+      "n" => ["INT16", 2],
+      "q" => ["UINT16", 2],
+      "i" => ["INT32", 4],
+      "u" => ["UINT32", 4],
+      "x" => ["INT64", 8],
+      "t" => ["UINT64", 8],
+      "d" => ["DOUBLE", 8],
+      "r" => ["STRUCT", 8],
+      "a" => ["ARRAY", 4],
+      "v" => ["VARIANT", 1],
+      "o" => ["OBJECT_PATH", 4],
+      "s" => ["STRING", 4],
+      "g" => ["SIGNATURE", 1],
+      "e" => ["DICT_ENTRY", 8],
+      "h" => ["UNIX_FD", 4]
+    }.freeze
+    # Defines the set of constants
+    TypeMapping.each_pair do |key, value|
+      Type.const_set(value.first, key)
     end
 
-    # Return the required alignment for the type.
-    def alignment
-      TypeMapping[@sigtype].last
+    # Exception raised when an unknown/incorrect type is encountered.
+    class SignatureException < Exception
     end
 
-    # Return a string representation of the type according to the
-    # D-Bus specification.
-    def to_s
-      case @sigtype
-      when STRUCT
-        "(" + @members.collect { |t| t.to_s }.join + ")"
-      when ARRAY
-        "a" + child.to_s
-      when DICT_ENTRY
-        "{" + @members.collect { |t| t.to_s }.join + "}"
-      else
-        if not TypeMapping.keys.member?(@sigtype)
-          raise NotImplementedError
+    # = D-Bus type conversion class
+    #
+    # Helper class for representing a D-Bus type.
+    class Type
+      # Returns the signature type number.
+      attr_reader :sigtype
+      # Return contained member types.
+      attr_reader :members
+
+      # Create a new type instance for type number _sigtype_.
+      def initialize(sigtype)
+        if !TypeMapping.keys.member?(sigtype)
+          raise SignatureException, "Unknown key in signature: #{sigtype.chr}"
         end
-        @sigtype.chr
+        @sigtype = sigtype
+        @members = []
       end
-    end
 
-    # Add a new member type _a_.
-    def <<(a)
-      if not [STRUCT, ARRAY, DICT_ENTRY].member?(@sigtype)
-        raise SignatureException
+      # Return the required alignment for the type.
+      def alignment
+        TypeMapping[@sigtype].last
       end
-      raise SignatureException if @sigtype == ARRAY and @members.size > 0
-      if @sigtype == DICT_ENTRY
-        if @members.size == 2
-          raise SignatureException, "Dict entries have exactly two members"
-        end
-        if @members.size == 0
-          if [STRUCT, ARRAY, DICT_ENTRY].member?(a.sigtype)
-            raise SignatureException, "Dict entry keys must be basic types"
+
+      # Return a string representation of the type according to the
+      # D-Bus specification.
+      def to_s
+        case @sigtype
+        when STRUCT
+          "(" + @members.collect(&:to_s).join + ")"
+        when ARRAY
+          "a" + child.to_s
+        when DICT_ENTRY
+          "{" + @members.collect(&:to_s).join + "}"
+        else
+          if !TypeMapping.keys.member?(@sigtype)
+            raise NotImplementedError
           end
+          @sigtype.chr
         end
       end
-      @members << a
-    end
 
-    # Return the first contained member type.
-    def child
-      @members[0]
-    end
+      # Add a new member type _a_.
+      def <<(a)
+        if ![STRUCT, ARRAY, DICT_ENTRY].member?(@sigtype)
+          raise SignatureException
+        end
+        raise SignatureException if @sigtype == ARRAY && !@members.empty?
+        if @sigtype == DICT_ENTRY
+          if @members.size == 2
+            raise SignatureException, "Dict entries have exactly two members"
+          end
+          if @members.empty?
+            if [STRUCT, ARRAY, DICT_ENTRY].member?(a.sigtype)
+              raise SignatureException, "Dict entry keys must be basic types"
+            end
+          end
+        end
+        @members << a
+      end
 
-    def inspect
-      s = TypeMapping[@sigtype].first
-      if [STRUCT, ARRAY].member?(@sigtype)
-        s += ": " + @members.inspect
+      # Return the first contained member type.
+      def child
+        @members[0]
       end
-      s
-    end
-  end # class Type
 
-  # = D-Bus type parser class
-  #
-  # Helper class to parse a type signature in the protocol.
-  class Parser
-    # Create a new parser for the given _signature_.
-    def initialize(signature)
-      @signature = signature
-      @idx = 0
-    end
+      def inspect
+        s = TypeMapping[@sigtype].first
+        if [STRUCT, ARRAY].member?(@sigtype)
+          s += ": " + @members.inspect
+        end
+        s
+      end
+    end # class Type
+
+    # = D-Bus type parser class
+    #
+    # Helper class to parse a type signature in the protocol.
+    class Parser
+      # Create a new parser for the given _signature_.
+      def initialize(signature)
+        @signature = signature
+        @idx = 0
+      end
 
-    # Returns the next character from the signature.
-    def nextchar
-      c = @signature[@idx]
-      @idx += 1
-      c
-    end
+      # Returns the next character from the signature.
+      def nextchar
+        c = @signature[@idx]
+        @idx += 1
+        c
+      end
 
-    # Parse one character _c_ of the signature.
-    def parse_one(c)
-      res = nil
-      case c
-      when ?a
-        res = Type.new(ARRAY)
-        c = nextchar
-        raise SignatureException, "Parse error in #{@signature}" if c == nil
-        child = parse_one(c)
-        res << child
-      when ?(
-        res = Type.new(STRUCT)
-        while (c = nextchar) != nil and c != ?)
-          res << parse_one(c)
-        end
-        raise SignatureException, "Parse error in #{@signature}" if c == nil
-      when ?{
-        res = Type.new(DICT_ENTRY)
-        while (c = nextchar) != nil and c != ?}
-          res << parse_one(c)
+      # Parse one character _c_ of the signature.
+      def parse_one(c)
+        res = nil
+        case c
+        when "a"
+          res = Type.new(ARRAY)
+          c = nextchar
+          raise SignatureException, "Parse error in #{@signature}" if c.nil?
+          child = parse_one(c)
+          res << child
+        when "("
+          res = Type.new(STRUCT)
+          while (c = nextchar) && c != ")"
+            res << parse_one(c)
+          end
+          raise SignatureException, "Parse error in #{@signature}" if c.nil?
+        when "{"
+          res = Type.new(DICT_ENTRY)
+          while (c = nextchar) && c != "}"
+            res << parse_one(c)
+          end
+          raise SignatureException, "Parse error in #{@signature}" if c.nil?
+        else
+          res = Type.new(c)
         end
-        raise SignatureException, "Parse error in #{@signature}" if c == nil
-      else
-        res = Type.new(c)
+        res
       end
-      res
-    end
 
-    # Parse the entire signature, return a DBus::Type object.
-    def parse
-      @idx = 0
-      ret = Array.new
-      while (c = nextchar)
-        ret << parse_one(c)
+      # Parse the entire signature, return a DBus::Type object.
+      def parse
+        @idx = 0
+        ret = []
+        while (c = nextchar)
+          ret << parse_one(c)
+        end
+        ret
       end
-      ret
-    end
-  end # class Parser
-end # module Type
-
-# shortcuts
+    end # class Parser
+  end # module Type
 
-# Parse a String to a DBus::Type::Type
-def type(string_type)
-  Type::Parser.new(string_type).parse[0]
-end
-module_function :type
+  # shortcuts
 
-# Make an explicit [Type, value] pair
-def variant(string_type, value)
-  [type(string_type), value]
-end
-module_function :variant
+  # Parse a String to a DBus::Type::Type
+  def type(string_type)
+    Type::Parser.new(string_type).parse[0]
+  end
+  module_function :type
 
+  # Make an explicit [Type, value] pair
+  def variant(string_type, value)
+    [type(string_type), value]
+  end
+  module_function :variant
 end # module DBus

data/lib/dbus/xml.rb

@@ -9,10 +9,10 @@
 # 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'
+# TODO: check if it is slow, make replaceable
+require "rexml/document"
 begin
-require 'nokogiri'
+  require "nokogiri"
 rescue LoadError
 end
 
@@ -32,16 +32,18 @@ module DBus
 
     class AbstractXML
       def self.have_nokogiri?
-        Object.const_defined?('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
@@ -50,6 +52,7 @@ module DBus
       # initialize parser with xml string
       def initialize(xml)
       end
+
       # yields nodes which match xpath of type AbstractXML::Node
       def each(xpath)
       end
@@ -60,6 +63,7 @@ module DBus
         def [](key)
           @node[key]
         end
+
         def each(path, &block)
           @node.search(path).each { |node| block.call NokogiriNode.new(node) }
         end
@@ -67,6 +71,7 @@ module DBus
       def initialize(xml)
         @doc = Nokogiri.XML(xml)
       end
+
       def each(path, &block)
         @doc.search("//#{path}").each { |node| block.call NokogiriNode.new(node) }
       end
@@ -77,6 +82,7 @@ module DBus
         def [](key)
           @node.attributes[key]
         end
+
         def each(path, &block)
           @node.elements.each(path) { |node| block.call REXMLNode.new(node) }
         end
@@ -84,18 +90,20 @@ module DBus
       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
+    @backend = if AbstractXML.have_nokogiri?
+                 NokogiriParser
+               else
+                 REXMLParser
+               end
 
-    # return a pair: [list of Interfaces, list of direct subnode names]
+    # @return [Array(Array<Interface>,Array<String>)]
+    #   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).
@@ -105,7 +113,6 @@ module DBus
       subnodes = []
       t = Time.now
 
-
       d = IntrospectXMLParser.backend.new(@xml)
       d.each("node/node") do |e|
         subnodes << e["name"]
@@ -140,17 +147,17 @@ module DBus
         name = ae["name"]
         dir = ae["direction"]
         sig = ae["type"]
-	if m.is_a?(DBus::Signal)
+        if m.is_a?(DBus::Signal)
           # Direction can only be "out", ignore it
           m.add_fparam(name, sig)
-	elsif m.is_a?(DBus::Method)
+        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
+            m.add_return(name, sig)
+          end
         else
           raise NotImplementedError, dir
         end
@@ -158,4 +165,3 @@ module DBus
     end
   end # class IntrospectXMLParser
 end # module DBus
-