ruby-dbus 0.17.0 → 0.18.0.beta1

data/lib/dbus/marshall.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # dbus.rb - Module containing the low-level D-Bus implementation
 #
 # This file is part of the ruby-dbus project
@@ -34,11 +36,12 @@ module DBus
     def initialize(buffer, endianness)
       @buffy = buffer.dup
       @endianness = endianness
-      if @endianness == BIG_END
+      case @endianness
+      when BIG_END
         @uint32 = "N"
         @uint16 = "n"
         @double = "G"
-      elsif @endianness == LIL_END
+      when LIL_END
         @uint32 = "V"
         @uint16 = "v"
         @double = "E"
@@ -50,12 +53,14 @@ module DBus
 
     # Unmarshall the buffer for a given _signature_ and length _len_.
     # Return an array of unmarshalled objects
+    # @param signature [Signature]
+    # @param len [Integer,nil] if given, and there is not enough data
+    #   in the buffer, raise {IncompleteBufferException}
+    # @return [Array<::Object>]
+    # @raise IncompleteBufferException
     def unmarshall(signature, len = nil)
-      if !len.nil?
-        if @buffy.bytesize < @idx + len
-          raise IncompleteBufferException
-        end
-      end
+      raise IncompleteBufferException if len && @buffy.bytesize < @idx + len
+
       sigtree = Type::Parser.new(signature).parse
       ret = []
       sigtree.each do |elem|
@@ -64,18 +69,18 @@ module DBus
       ret
     end
 
-    # Align the pointer index on a byte index of _a_, where a
+    # Align the pointer index on a byte index of _alignment_, which
     # must be 1, 2, 4 or 8.
-    def align(a)
-      case a
+    def align(alignment)
+      case alignment
       when 1
         nil
       when 2, 4, 8
-        bits = a - 1
+        bits = alignment - 1
         @idx = @idx + bits & ~bits
         raise IncompleteBufferException if @idx > @buffy.bytesize
       else
-        raise "Unsupported alignment #{a}"
+        raise ArgumentError, "Unsupported alignment #{alignment}"
       end
     end
 
@@ -87,6 +92,7 @@ module DBus
     # Retrieve the next _nbytes_ number of bytes from the buffer.
     def read(nbytes)
       raise IncompleteBufferException if @idx + nbytes > @buffy.bytesize
+
       ret = @buffy.slice(@idx, nbytes)
       @idx += nbytes
       ret
@@ -96,13 +102,15 @@ module DBus
     # Return the string.
     def read_string
       align(4)
-      str_sz = read(4).unpack(@uint32)[0]
+      str_sz = read(4).unpack1(@uint32)
       ret = @buffy.slice(@idx, str_sz)
       raise IncompleteBufferException if @idx + str_sz + 1 > @buffy.bytesize
+
       @idx += str_sz
       if @buffy[@idx].ord != 0
         raise InvalidPacketException, "String is not nul-terminated"
       end
+
       @idx += 1
       # no exception, see check above
       ret
@@ -111,13 +119,15 @@ module DBus
     # Read the signature length and signature itself from the buffer.
     # Return the signature.
     def read_signature
-      str_sz = read(1).unpack("C")[0]
+      str_sz = read(1).unpack1("C")
       ret = @buffy.slice(@idx, str_sz)
       raise IncompleteBufferException if @idx + str_sz + 1 >= @buffy.bytesize
+
       @idx += str_sz
       if @buffy[@idx].ord != 0
         raise InvalidPacketException, "Type is not nul-terminated"
       end
+
       @idx += 1
       # no exception, see check above
       ret
@@ -129,29 +139,29 @@ module DBus
       packet = nil
       case signature.sigtype
       when Type::BYTE
-        packet = read(1).unpack("C")[0]
+        packet = read(1).unpack1("C")
       when Type::UINT16
         align(2)
-        packet = read(2).unpack(@uint16)[0]
+        packet = read(2).unpack1(@uint16)
       when Type::INT16
         align(2)
-        packet = read(2).unpack(@uint16)[0]
+        packet = read(2).unpack1(@uint16)
         if (packet & 0x8000) != 0
           packet -= 0x10000
         end
       when Type::UINT32, Type::UNIX_FD
         align(4)
-        packet = read(4).unpack(@uint32)[0]
+        packet = read(4).unpack1(@uint32)
       when Type::INT32
         align(4)
-        packet = read(4).unpack(@uint32)[0]
+        packet = read(4).unpack1(@uint32)
         if (packet & 0x80000000) != 0
           packet -= 0x100000000
         end
       when Type::UINT64
         align(8)
-        packet_l = read(4).unpack(@uint32)[0]
-        packet_h = read(4).unpack(@uint32)[0]
+        packet_l = read(4).unpack1(@uint32)
+        packet_h = read(4).unpack1(@uint32)
         packet = if @endianness == LIL_END
                    packet_l + packet_h * 2**32
                  else
@@ -159,8 +169,8 @@ module DBus
                  end
       when Type::INT64
         align(8)
-        packet_l = read(4).unpack(@uint32)[0]
-        packet_h = read(4).unpack(@uint32)[0]
+        packet_l = read(4).unpack1(@uint32)
+        packet_h = read(4).unpack1(@uint32)
         packet = if @endianness == LIL_END
                    packet_l + packet_h * 2**32
                  else
@@ -171,16 +181,17 @@ module DBus
         end
       when Type::DOUBLE
         align(8)
-        packet = read(8).unpack(@double)[0]
+        packet = read(8).unpack1(@double)
       when Type::BOOLEAN
         align(4)
-        v = read(4).unpack(@uint32)[0]
+        v = read(4).unpack1(@uint32)
         raise InvalidPacketException if ![0, 1].member?(v)
+
         packet = (v == 1)
       when Type::ARRAY
         align(4)
         # checks please
-        array_sz = read(4).unpack(@uint32)[0]
+        array_sz = read(4).unpack1(@uint32)
         raise InvalidPacketException if array_sz > 67_108_864
 
         align(signature.child.alignment)
@@ -201,6 +212,7 @@ module DBus
         signature.members.each do |elem|
           packet << do_parse(elem)
         end
+        packet.freeze
       when Type::VARIANT
         string = read_signature
         # error checking please
@@ -224,8 +236,8 @@ module DBus
               "sigtype: #{signature.sigtype} (#{signature.sigtype.chr})"
       end
       packet
-    end # def do_parse
-  end # class PacketUnmarshaller
+    end
+  end
 
   # D-Bus packet marshaller class
   #
@@ -243,20 +255,21 @@ module DBus
       @offset = offset # for correct alignment of nested marshallers
     end
 
-    # Round _n_ up to the specified power of two, _a_
-    def num_align(n, a)
-      case a
+    # Round _num_ up to the specified power of two, _alignment_
+    def num_align(num, alignment)
+      case alignment
       when 1, 2, 4, 8
-        bits = a - 1
-        n + bits & ~bits
+        bits = alignment - 1
+        num + bits & ~bits
       else
-        raise "Unsupported alignment"
+        raise ArgumentError, "Unsupported alignment #{alignment}"
       end
     end
 
-    # Align the buffer with NULL (\0) bytes on a byte length of _a_.
-    def align(a)
-      @packet = @packet.ljust(num_align(@offset + @packet.bytesize, a) - @offset, 0.chr)
+    # Align the buffer with NULL (\0) bytes on a byte length of _alignment_.
+    def align(alignment)
+      pad_count = num_align(@offset + @packet.bytesize, alignment) - @offset
+      @packet = @packet.ljust(pad_count, 0.chr)
     end
 
     # Append the the string _str_ itself to the packet.
@@ -267,7 +280,7 @@ module DBus
 
     # Append the the signature _signature_ itself to the packet.
     def append_signature(str)
-      @packet += str.bytesize.chr + str + "\0"
+      @packet += "#{str.bytesize.chr}#{str}\u0000"
     end
 
     # Append the array type _type_ to the packet and allow for appending
@@ -282,6 +295,7 @@ module DBus
       yield
       sz = @packet.bytesize - contentidx
       raise InvalidPacketException if sz > 67_108_864
+
       @packet[sizeidx...sizeidx + 4] = [sz].pack("L")
     end
 
@@ -337,57 +351,24 @@ module DBus
       when Type::SIGNATURE
         append_signature(val)
       when Type::VARIANT
-        vartype = nil
-        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)
-            begin
-              parsed = Type::Parser.new(val[0]).parse
-              vartype = parsed[0] if parsed.size == 1
-              vardata = val[1]
-            rescue Type::SignatureException
-              # no assignment
-            end
-          end
-        end
-        if vartype.nil?
-          vartype, vardata = PacketMarshaller.make_variant(val)
-          vartype = Type::Parser.new(vartype).parse[0]
-        end
-
-        append_signature(vartype.to_s)
-        align(vartype.alignment)
-        sub = PacketMarshaller.new(@offset + @packet.bytesize)
-        sub.append(vartype, vardata)
-        @packet += sub.packet
+        append_variant(val)
       when Type::ARRAY
-        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.is_a?(String) && type.child.sigtype == Type::BYTE
-          val = val.bytes
-        end
-        if !val.is_a?(Enumerable)
-          raise TypeException, "Expected an Enumerable of #{type.child.inspect} but got a #{val.class}"
-        end
-        array(type.child) do
-          val.each do |elem|
-            append(type.child, elem)
-          end
-        end
+        append_array(type.child, val)
       when Type::STRUCT, Type::DICT_ENTRY
-        # TODO: use duck typing, val.respond_to?
-        raise TypeException, "Struct/DE expects an Array" if !val.is_a?(Array)
+        unless val.is_a?(Array) || val.is_a?(Struct)
+          type_name = Type::TYPE_MAPPING[type.sigtype].first
+          raise TypeException, "#{type_name} expects an Array or Struct"
+        end
+
         if type.sigtype == Type::DICT_ENTRY && val.size != 2
-          raise TypeException, "Dict entry expects a pair"
+          raise TypeException, "DICT_ENTRY expects a pair"
         end
+
         if type.members.size != val.size
-          raise TypeException, "Struct/DE has #{val.size} elements but type info for #{type.members.size}"
+          type_name = Type::TYPE_MAPPING[type.sigtype].first
+          raise TypeException, "#{type_name} has #{val.size} elements but type info for #{type.members.size}"
         end
+
         struct do
           type.members.zip(val).each do |t, v|
             append(t, v)
@@ -397,7 +378,58 @@ module DBus
         raise NotImplementedError,
               "sigtype: #{type.sigtype} (#{type.sigtype.chr})"
       end
-    end # def append
+    end
+
+    def append_variant(val)
+      vartype = nil
+      if val.is_a?(Array) && val.size == 2
+        case val[0]
+        when DBus::Type::Type
+          vartype, vardata = val
+        when String
+          begin
+            parsed = Type::Parser.new(val[0]).parse
+            vartype = parsed[0] if parsed.size == 1
+            vardata = val[1]
+          rescue Type::SignatureException
+            # no assignment
+          end
+        end
+      end
+      if vartype.nil?
+        vartype, vardata = PacketMarshaller.make_variant(val)
+        vartype = Type::Parser.new(vartype).parse[0]
+      end
+
+      append_signature(vartype.to_s)
+      align(vartype.alignment)
+      sub = PacketMarshaller.new(@offset + @packet.bytesize)
+      sub.append(vartype, vardata)
+      @packet += sub.packet
+    end
+
+    # @param child_type [DBus::Type::Type]
+    def append_array(child_type, val)
+      if val.is_a?(Hash)
+        raise TypeException, "Expected an Array but got a Hash" if child_type.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.is_a?(String) && child_type.sigtype == Type::BYTE
+        val = val.bytes
+      end
+      if !val.is_a?(Enumerable)
+        raise TypeException, "Expected an Enumerable of #{child_type.inspect} but got a #{val.class}"
+      end
+
+      array(child_type) do
+        val.each do |elem|
+          append(child_type, elem)
+        end
+      end
+    end
 
     # Make a [signature, value] pair for a variant
     def self.make_variant(value)
@@ -429,5 +461,5 @@ module DBus
         end
       end
     end
-  end # class PacketMarshaller
-end # module DBus
+  end
+end

data/lib/dbus/matchrule.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file is part of the ruby-dbus project
 # Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
 #
@@ -27,7 +29,7 @@ module DBus
     attr_accessor :path
     # The destination filter.
     attr_accessor :destination
-    # The type type that is matched.
+    # @return [String] The type type that is matched.
     attr_reader :type
 
     # Create a new match rule
@@ -35,13 +37,14 @@ module DBus
       @sender = @interface = @member = @path = @destination = @type = nil
     end
 
-    # Set the message types to filter to type _t_.
+    # Set the message types to filter to type _typ_.
     # Possible message types are: signal, method_call, method_return, and error.
-    def type=(t)
-      if !["signal", "method_call", "method_return", "error"].member?(t)
-        raise MatchRuleException, t
+    def type=(typ)
+      if !["signal", "method_call", "method_return", "error"].member?(typ)
+        raise MatchRuleException, typ
       end
-      @type = t
+
+      @type = typ
     end
 
     # Returns a match rule string version of the object. E.g.:
@@ -58,11 +61,13 @@ module DBus
     def from_s(str)
       str.split(",").each do |eq|
         next unless eq =~ /^(.*)='([^']*)'$/
+
         # "
         name = Regexp.last_match(1)
         val = Regexp.last_match(2)
         raise MatchRuleException, name unless FILTERS.member?(name.to_sym)
-        method(name + "=").call(val)
+
+        method("#{name}=").call(val)
       end
       self
     end
@@ -80,18 +85,13 @@ module DBus
 
     # Determines whether a message _msg_ matches the match rule.
     def match(msg)
-      if @type
-        if { Message::SIGNAL => "signal", Message::METHOD_CALL => "method_call",
-             Message::METHOD_RETURN => "method_return",
-             Message::ERROR => "error" }[msg.message_type] != @type
-          return false
-        end
-      end
+      return false if @type && @type != msg.message_type_s
       return false if @interface && @interface != msg.interface
       return false if @member && @member != msg.member
       return false if @path && @path != msg.path
+
       # FIXME: sender and destination are ignored
       true
     end
-  end # class MatchRule
-end # module D-Bus
+  end
+end

data/lib/dbus/message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # dbus.rb - Module containing the low-level D-Bus implementation
 #
 # This file is part of the ruby-dbus project
@@ -27,7 +29,7 @@ module DBus
     # Mutex that protects updates on the serial number.
     @@serial_mutex = Mutex.new
     # Type of a message (by specification).
-    MESSAGE_SIGNATURE = "yyyyuua(yv)".freeze
+    MESSAGE_SIGNATURE = "yyyyuua(yv)"
 
     # FIXME: following message type constants should be under Message::Type IMO
     # well, yeah sure
@@ -43,6 +45,9 @@ module DBus
     # Signal message type.
     SIGNAL = 4
 
+    # Names used by signal match rules
+    TYPE_NAMES = ["invalid", "method_call", "method_return", "error", "signal"].freeze
+
     # Message flag signyfing that no reply is expected.
     NO_REPLY_EXPECTED = 0x1
     # Message flag signifying that no automatic start is required/must be
@@ -66,11 +71,13 @@ module DBus
     attr_accessor :sender
     # The signature of the message contents.
     attr_accessor :signature
-    # The serial number of the message this message is a reply for.
+    # @return [Integer] (u32)
+    #   The serial number of the message this message is a reply for.
     attr_accessor :reply_serial
     # The protocol.
     attr_reader :protocol
-    # The serial of the message.
+    # @return [Integer] (u32)
+    #   The serial of the message.
     attr_reader :serial
     # The parameters of the message.
     attr_reader :params
@@ -105,22 +112,28 @@ module DBus
       "error_name=#{error_name}"
     end
 
-    # Create a regular reply to a message _m_.
-    def self.method_return(m)
-      MethodReturnMessage.new.reply_to(m)
+    # @return [String] name of message type, as used in match rules:
+    #    "method_call", "method_return", "signal", "error"
+    def message_type_s
+      TYPE_NAMES[message_type] || "unknown_type_#{message_type}"
     end
 
-    # Create an error reply to a message _m_.
-    def self.error(m, error_name, description = nil)
-      ErrorMessage.new(error_name, description).reply_to(m)
+    # Create a regular reply to a message _msg_.
+    def self.method_return(msg)
+      MethodReturnMessage.new.reply_to(msg)
     end
 
-    # Mark this message as a reply to a another message _m_, taking
-    # the serial number of _m_ as reply serial and the sender of _m_ as
+    # Create an error reply to a message _msg_.
+    def self.error(msg, error_name, description = nil)
+      ErrorMessage.new(error_name, description).reply_to(msg)
+    end
+
+    # Mark this message as a reply to a another message _msg_, taking
+    # the serial number of _msg_ as reply serial and the sender of _msg_ as
     # destination.
-    def reply_to(m)
-      @reply_serial = m.serial
-      @destination = m.sender
+    def reply_to(msg)
+      @reply_serial = msg.serial
+      @destination = msg.sender
       self
     end
 
@@ -223,7 +236,7 @@ module DBus
         end
       end
       pu.align(8)
-      if @body_length > 0 && @signature
+      if @body_length.positive? && @signature
         @params = pu.unmarshall(@signature, @body_length)
       end
       [self, pu.idx]
@@ -231,12 +244,12 @@ module DBus
 
     # Make a new exception from ex, mark it as being caused by this message
     # @api private
-    def annotate_exception(ex)
-      new_ex = ex.exception("#{ex}; caused by #{self}")
-      new_ex.set_backtrace(ex.backtrace)
-      new_ex
+    def annotate_exception(exc)
+      new_exc = exc.exception("#{exc}; caused by #{self}")
+      new_exc.set_backtrace(exc.backtrace)
+      new_exc
     end
-  end # class Message
+  end
 
   class MethodReturnMessage < Message
     def initialize
@@ -251,17 +264,17 @@ module DBus
       add_param(Type::STRING, description) unless description.nil?
     end
 
-    def self.from_exception(ex)
-      name = if ex.is_a? DBus::Error
-               ex.name
+    def self.from_exception(exc)
+      name = if exc.is_a? DBus::Error
+               exc.name
              else
                "org.freedesktop.DBus.Error.Failed"
-               # ex.class.to_s # RuntimeError is not a valid name, has no dot
+               # exc.class.to_s # RuntimeError is not a valid name, has no dot
              end
-      description = ex.message
+      description = exc.message
       msg = new(name, description)
-      msg.add_param(DBus.type("as"), ex.backtrace)
+      msg.add_param(DBus.type("as"), exc.backtrace)
       msg
     end
   end
-end # module DBus
+end

data/lib/dbus/message_queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file is part of the ruby-dbus project
 # Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
 # Copyright (C) 2009-2014 Martin Vidner
@@ -23,14 +25,16 @@ module DBus
       connect
     end
 
-    # @param non_block [Boolean] if true, return nil instead of waiting
+    # @param blocking [Boolean]
+    #   true:  wait to return a {Message};
+    #   false: may return `nil`
     # @return [Message,nil] one message or nil if unavailable
     # @raise EOFError
     # @todo failure modes
-    def pop(non_block = false)
+    def pop(blocking: true)
       buffer_from_socket_nonblock
       message = message_from_buffer_nonblock
-      unless non_block
+      if blocking
         # we can block
         while message.nil?
           r, _d, _d = IO.select([@socket])
@@ -54,7 +58,7 @@ module DBus
     def connect
       addresses = @address.split ";"
       # connect to first one that succeeds
-      worked = addresses.find do |a|
+      addresses.find do |a|
         transport, keyvaluestring = a.split ":"
         kv_list = keyvaluestring.split ","
         kv_hash = {}
@@ -74,7 +78,6 @@ module DBus
           # ignore, report?
         end
       end
-      worked
       # returns the address that worked or nil.
       # how to report failure?
     end
@@ -136,6 +139,7 @@ module DBus
     # @return [Message,nil] the message or nil if unavailable
     def message_from_buffer_nonblock
       return nil if @buffer.empty?
+
       ret = nil
       begin
         ret, size = Message.new.unmarshall_buffer(@buffer)
@@ -162,6 +166,7 @@ module DBus
     rescue Exception => e
       puts "Oops:", e
       raise if @is_tcp # why?
+
       puts "WARNING: read_nonblock failed, falling back to .recv"
       @buffer += @socket.recv(MSG_BUF_SIZE)
     end