ruby-dbus 0.12.0 → 0.13.0

data/lib/dbus/error.rb

@@ -30,7 +30,7 @@ module DBus
         @name = name
         super(msg)
       end
-      # TODO validate error name
+      # TODO: validate error name
     end
   end # class Error
 

data/lib/dbus/export.rb

@@ -8,7 +8,7 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
-require 'thread'
+require "thread"
 
 module DBus
   # Exported object type
@@ -21,10 +21,12 @@ module DBus
     attr_reader :path
     # The interfaces that the object supports. Hash: String => Interface
     class_attribute :intfs
+    self.intfs = {}
+
     # The service that the object is exported by.
     attr_writer :service
 
-    @@cur_intf = nil            # Interface
+    @@cur_intf = nil # Interface
     @@intfs_mutex = Mutex.new
 
     # Create a new object with a given _path_.
@@ -34,30 +36,24 @@ module DBus
       @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]
+          if !intfs[msg.interface]
             raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
-            "Interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
+                  "Interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
           end
-          meth = self.intfs[msg.interface].methods[msg.member.to_sym]
-          if not meth
+          meth = intfs[msg.interface].methods[msg.member.to_sym]
+          if !meth
             raise DBus.error("org.freedesktop.DBus.Error.UnknownMethod"),
-            "Method \"#{msg.member}\" on interface \"#{msg.interface}\" of object \"#{msg.path}\" doesn't exist"
+                  "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]
+          retdata = [*retdata]
 
           reply = Message.method_return(msg)
           meth.rets.zip(retdata).each do |rsig, rdata|
@@ -75,9 +71,15 @@ module DBus
     # belong to.
     def self.dbus_interface(s)
       @@intfs_mutex.synchronize do
-        unless @@cur_intf = (self.intfs && self.intfs[s])
+        @@cur_intf = intfs[s]
+        if !@@cur_intf
           @@cur_intf = Interface.new(s)
-          self.intfs = (self.intfs || {}).merge({s => @@cur_intf})
+          # As this is a mutable class_attr, we cannot use
+          #   self.intfs[s] = @@cur_intf                      # Hash#[]=
+          # as that would modify parent class attr in place.
+          # Using the setter lets a subclass have the new value
+          # while the superclass keeps the old one.
+          self.intfs = intfs.merge(s => @@cur_intf)
         end
         yield
         @@cur_intf = nil
@@ -96,7 +98,7 @@ module DBus
     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) 
+      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
@@ -117,10 +119,10 @@ module DBus
     end
 
     ####################################################################
-    private
 
     # Helper method that returns a method name generated from the interface
     # name _intfname_ and method name _methname_.
+    # @api private
     def self.make_method_name(intfname, methname)
       "#{intfname}%%#{methname}"
     end

data/lib/dbus/introspect.rb

@@ -10,9 +10,9 @@
 
 module DBus
   # Regular expressions that should match all method names.
-  MethodSignalRE = /^[A-Za-z][A-Za-z0-9_]*$/
+  METHOD_SIGNAL_RE = /^[A-Za-z][A-Za-z0-9_]*$/
   # Regular expressions that should match all interface names.
-  InterfaceElementRE = /^[A-Za-z][A-Za-z0-9_]*$/
+  INTERFACE_ELEMENT_RE = /^[A-Za-z][A-Za-z0-9_]*$/
 
   # Exception raised when an unknown signal is used.
   class UnknownSignal < Exception
@@ -41,29 +41,30 @@ module DBus
     def initialize(name)
       validate_name(name)
       @name = name
-      @methods, @signals = Hash.new, Hash.new
+      @methods = {}
+      @signals = {}
     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 =~ /^\./ || name =~ /\.$/
       raise InvalidIntrospectionData if name =~ /\.\./
-      raise InvalidIntrospectionData if not name =~ /\./
+      raise InvalidIntrospectionData if !(name =~ /\./)
       name.split(".").each do |element|
-        raise InvalidIntrospectionData if not element =~ InterfaceElementRE
+        raise InvalidIntrospectionData if !(element =~ INTERFACE_ELEMENT_RE)
       end
     end
 
     # Helper method for defining a method _m_.
     def define(m)
-      if m.kind_of?(Method)
+      if m.is_a?(Method)
         @methods[m.name.to_sym] = m
-      elsif m.kind_of?(Signal)
+      elsif m.is_a?(Signal)
         @signals[m.name.to_sym] = m
       end
     end
-    alias :<< :define
+    alias << define
 
     # Defines a method with name _id_ and a given _prototype_ in the
     # interface.
@@ -87,9 +88,8 @@ module DBus
     # backward compatibility, deprecated
     def [](index)
       case index
-        when 0 then name
-        when 1 then type
-        else nil
+      when 0 then name
+      when 1 then type
       end
     end
   end
@@ -106,16 +106,15 @@ module DBus
 
     # Validates element _name_.
     def validate_name(name)
-      if (not name =~ MethodSignalRE) or (name.bytesize > 255)
-        raise InvalidMethodName, name
-      end
+      return if (name =~ METHOD_SIGNAL_RE) && (name.bytesize <= 255)
+      raise InvalidMethodName, name
     end
 
     # Creates a new element with the given _name_.
     def initialize(name)
       validate_name(name.to_s)
       @name = name
-      @params = Array.new
+      @params = []
     end
 
     # Adds a formal parameter with _name_ and _signature_
@@ -140,7 +139,7 @@ module DBus
     # Creates a new method interface element with the given _name_.
     def initialize(name)
       super(name)
-      @rets = Array.new
+      @rets = []
     end
 
     # Add a return value _name_ and _signature_.
@@ -172,16 +171,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
@@ -206,14 +205,13 @@ 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
 end # module DBus
-

data/lib/dbus/logger.rb

@@ -8,7 +8,7 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
-require 'logger'
+require "logger"
 
 module DBus
   # Get the logger for the DBus module.

data/lib/dbus/marshall.rb

@@ -8,7 +8,7 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
-require 'socket'
+require "socket"
 
 # = D-Bus main module
 #
@@ -23,7 +23,7 @@ module DBus
   # Class that handles the conversion (unmarshalling) of payload data
   # to Array.
   class PacketUnmarshaller
-    # Index pointer that points to the byte in the data that is 
+    # Index pointer that points to the byte in the data that is
     # currently being processed.
     #
     # Used to kown what part of the buffer has been consumed by unmarshalling.
@@ -32,7 +32,8 @@ module DBus
 
     # Create a new unmarshaller for the given data _buffer_ and _endianness_.
     def initialize(buffer, endianness)
-      @buffy, @endianness = buffer.dup, endianness
+      @buffy = buffer.dup
+      @endianness = endianness
       if @endianness == BIG_END
         @uint32 = "N"
         @uint16 = "n"
@@ -50,13 +51,13 @@ module DBus
     # Unmarshall the buffer for a given _signature_ and length _len_.
     # Return an array of unmarshalled objects
     def unmarshall(signature, len = nil)
-      if len != nil
+      if !len.nil?
         if @buffy.bytesize < @idx + len
           raise IncompleteBufferException
         end
       end
       sigtree = Type::Parser.new(signature).parse
-      ret = Array.new
+      ret = []
       sigtree.each do |elem|
         ret << do_parse(elem)
       end
@@ -83,18 +84,18 @@ module DBus
     private
 
     # Retrieve the next _nbytes_ number of bytes from the buffer.
-    def get(nbytes)
+    def read(nbytes)
       raise IncompleteBufferException if @idx + nbytes > @buffy.bytesize
       ret = @buffy.slice(@idx, nbytes)
       @idx += nbytes
       ret
     end
 
-    # Get the string length and string itself from the buffer.
+    # Read the string length and string itself from the buffer.
     # Return the string.
-    def get_string
+    def read_string
       align(4)
-      str_sz = get(4).unpack(@uint32)[0]
+      str_sz = read(4).unpack(@uint32)[0]
       ret = @buffy.slice(@idx, str_sz)
       raise IncompleteBufferException if @idx + str_sz + 1 > @buffy.bytesize
       @idx += str_sz
@@ -106,10 +107,10 @@ module DBus
       ret
     end
 
-    # Get the signature length and signature itself from the buffer.
+    # Read the signature length and signature itself from the buffer.
     # Return the signature.
-    def get_signature
-      str_sz = get(1).unpack('C')[0]
+    def read_signature
+      str_sz = read(1).unpack("C")[0]
       ret = @buffy.slice(@idx, str_sz)
       raise IncompleteBufferException if @idx + str_sz + 1 >= @buffy.bytesize
       @idx += str_sz
@@ -127,94 +128,91 @@ module DBus
       packet = nil
       case signature.sigtype
       when Type::BYTE
-        packet = get(1).unpack("C")[0]
+        packet = read(1).unpack("C")[0]
       when Type::UINT16
         align(2)
-        packet = get(2).unpack(@uint16)[0]
+        packet = read(2).unpack(@uint16)[0]
       when Type::INT16
         align(4)
-        packet = get(4).unpack(@uint16)[0]
+        packet = read(4).unpack(@uint16)[0]
         if (packet & 0x8000) != 0
           packet -= 0x10000
         end
       when Type::UINT32, Type::UNIX_FD
         align(4)
-        packet = get(4).unpack(@uint32)[0]
+        packet = read(4).unpack(@uint32)[0]
       when Type::INT32
         align(4)
-        packet = get(4).unpack(@uint32)[0]
+        packet = read(4).unpack(@uint32)[0]
         if (packet & 0x80000000) != 0
           packet -= 0x100000000
         end
       when Type::UINT64
         align(8)
-        packet_l = get(4).unpack(@uint32)[0]
-        packet_h = get(4).unpack(@uint32)[0]
-        if @endianness == LIL_END
-          packet = packet_l + packet_h * 2**32
-        else
-          packet = packet_l * 2**32 + packet_h
-        end
+        packet_l = read(4).unpack(@uint32)[0]
+        packet_h = read(4).unpack(@uint32)[0]
+        packet = if @endianness == LIL_END
+                   packet_l + packet_h * 2**32
+                 else
+                   packet_l * 2**32 + packet_h
+                 end
       when Type::INT64
         align(8)
-        packet_l = get(4).unpack(@uint32)[0]
-        packet_h = get(4).unpack(@uint32)[0]
-        if @endianness == LIL_END
-          packet = packet_l + packet_h * 2**32
-        else
-          packet = packet_l * 2**32 + packet_h
-        end
+        packet_l = read(4).unpack(@uint32)[0]
+        packet_h = read(4).unpack(@uint32)[0]
+        packet = if @endianness == LIL_END
+                   packet_l + packet_h * 2**32
+                 else
+                   packet_l * 2**32 + packet_h
+                 end
         if (packet & 0x8000000000000000) != 0
           packet -= 0x10000000000000000
         end
       when Type::DOUBLE
         align(8)
-        packet = get(8).unpack(@double)[0]
+        packet = read(8).unpack(@double)[0]
       when Type::BOOLEAN
         align(4)
-        v = get(4).unpack(@uint32)[0]
-        raise InvalidPacketException if not [0, 1].member?(v)
+        v = read(4).unpack(@uint32)[0]
+        raise InvalidPacketException if ![0, 1].member?(v)
         packet = (v == 1)
       when Type::ARRAY
         align(4)
         # checks please
-        array_sz = get(4).unpack(@uint32)[0]
-        raise InvalidPacketException if array_sz > 67108864
+        array_sz = read(4).unpack(@uint32)[0]
+        raise InvalidPacketException if array_sz > 67_108_864
 
         align(signature.child.alignment)
         raise IncompleteBufferException if @idx + array_sz > @buffy.bytesize
 
-        packet = Array.new
+        packet = []
         start_idx = @idx
         while @idx - start_idx < array_sz
           packet << do_parse(signature.child)
         end
 
-        if signature.child.sigtype == Type::DICT_ENTRY then
-          packet = packet.inject(Hash.new) do |hash, pair|
-            hash[pair[0]] = pair[1]
-            hash
-	  end
+        if signature.child.sigtype == Type::DICT_ENTRY
+          packet = Hash[packet]
         end
       when Type::STRUCT
         align(8)
-        packet = Array.new
+        packet = []
         signature.members.each do |elem|
           packet << do_parse(elem)
         end
       when Type::VARIANT
-        string = get_signature
+        string = read_signature
         # error checking please
         sig = Type::Parser.new(string).parse[0]
         align(sig.alignment)
         packet = do_parse(sig)
       when Type::OBJECT_PATH
-        packet = get_string
+        packet = read_string
       when Type::STRING
-        packet = get_string
-        packet.force_encoding('UTF-8')
+        packet = read_string
+        packet.force_encoding("UTF-8")
       when Type::SIGNATURE
-        packet = get_signature
+        packet = read_signature
       when Type::DICT_ENTRY
         align(8)
         key = do_parse(signature.members[0])
@@ -222,7 +220,7 @@ module DBus
         packet = [key, value]
       else
         raise NotImplementedError,
-	  "sigtype: #{signature.sigtype} (#{signature.sigtype.chr})"
+              "sigtype: #{signature.sigtype} (#{signature.sigtype.chr})"
       end
       packet
     end # def do_parse
@@ -241,7 +239,7 @@ module DBus
     # empty packet.
     def initialize(offset = 0)
       @packet = ""
-      @offset = offset          # for correct alignment of nested marshallers
+      @offset = offset # for correct alignment of nested marshallers
     end
 
     # Round _n_ up to the specified power of two, _a_
@@ -282,7 +280,7 @@ module DBus
       contentidx = @packet.bytesize
       yield
       sz = @packet.bytesize - contentidx
-      raise InvalidPacketException if sz > 67108864
+      raise InvalidPacketException if sz > 67_108_864
       @packet[sizeidx...sizeidx + 4] = [sz].pack("L")
     end
 
@@ -298,8 +296,8 @@ module DBus
     def append(type, val)
       raise TypeException, "Cannot send nil" if val.nil?
 
-      type = type.chr if type.kind_of?(Fixnum)
-      type = Type::Parser.new(type).parse[0] if type.kind_of?(String)
+      type = type.chr if type.is_a?(Fixnum)
+      type = Type::Parser.new(type).parse[0] if type.is_a?(String)
       case type.sigtype
       when Type::BYTE
         @packet += val.chr
@@ -307,11 +305,11 @@ module DBus
         align(4)
         @packet += [val].pack("L")
       when Type::UINT64
-	align(8)
-	@packet += [val].pack("Q")
+        align(8)
+        @packet += [val].pack("Q")
       when Type::INT64
-	align(8)
-	@packet += [val].pack("q")
+        align(8)
+        @packet += [val].pack("q")
       when Type::INT32
         align(4)
         @packet += [val].pack("l")
@@ -323,14 +321,14 @@ module DBus
         @packet += [val].pack("s")
       when Type::DOUBLE
         align(8)
-	@packet += [val].pack("d")
+        @packet += [val].pack("d")
       when Type::BOOLEAN
         align(4)
-        if val
-          @packet += [1].pack("L")
-        else
-          @packet += [0].pack("L")
-        end
+        @packet += if val
+                     [1].pack("L")
+                   else
+                     [0].pack("L")
+                   end
       when Type::OBJECT_PATH
         append_string(val)
       when Type::STRING
@@ -339,7 +337,7 @@ module DBus
         append_signature(val)
       when Type::VARIANT
         vartype = nil
-        if val.is_a?(Array) and val.size == 2
+        if val.is_a?(Array) && val.size == 2
           if val[0].is_a?(DBus::Type::Type)
             vartype, vardata = val
           elsif val[0].is_a?(String)
@@ -363,16 +361,16 @@ module DBus
         sub.append(vartype, vardata)
         @packet += sub.packet
       when Type::ARRAY
-        if val.kind_of?(Hash)
+        if val.is_a?(Hash)
           raise TypeException, "Expected an Array but got a Hash" if type.child.sigtype != Type::DICT_ENTRY
           # Damn ruby rocks here
           val = val.to_a
         end
         # If string is recieved and ay is expected, explode the string
-        if val.kind_of?(String) && type.child.sigtype == Type::BYTE
+        if val.is_a?(String) && type.child.sigtype == Type::BYTE
           val = val.bytes
         end
-        if not val.kind_of?(Enumerable)
+        if !val.is_a?(Enumerable)
           raise TypeException, "Expected an Enumerable of #{type.child.inspect} but got a #{val.class}"
         end
         array(type.child) do
@@ -381,9 +379,9 @@ module DBus
           end
         end
       when Type::STRUCT, Type::DICT_ENTRY
-        # TODO use duck typing, val.respond_to?
-        raise TypeException, "Struct/DE expects an Array" if not val.kind_of?(Array)
-        if type.sigtype == Type::DICT_ENTRY and val.size != 2
+        # TODO: use duck typing, val.respond_to?
+        raise TypeException, "Struct/DE expects an Array" if !val.is_a?(Array)
+        if type.sigtype == Type::DICT_ENTRY && val.size != 2
           raise TypeException, "Dict entry expects a pair"
         end
         if type.members.size != val.size
@@ -396,7 +394,7 @@ module DBus
         end
       else
         raise NotImplementedError,
-	  "sigtype: #{type.sigtype} (#{type.sigtype.chr})"     
+              "sigtype: #{type.sigtype} (#{type.sigtype.chr})"
       end
     end # def append
 
@@ -414,10 +412,10 @@ module DBus
       elsif value.is_a? Symbol
         ["s", value.to_s]
       elsif value.is_a? Array
-        ["av", value.map {|i| make_variant(i) }]
+        ["av", value.map { |i| make_variant(i) }]
       elsif value.is_a? Hash
         h = {}
-        value.each_key {|k| h[k] = make_variant(value[k]) }
+        value.each_key { |k| h[k] = make_variant(value[k]) }
         ["a{sv}", h]
       elsif value.respond_to? :to_str
         ["s", value.to_str]
@@ -429,6 +427,6 @@ module DBus
           ["x", i]
         end
       end
-    end    
+    end
   end # class PacketMarshaller
 end # module DBus