ruby-dbus 0.16.0 → 0.18.1

data/lib/dbus/proxy_object_interface.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
@@ -13,13 +15,16 @@ module DBus
   # A class similar to the normal Interface used as a proxy for remote
   # object interfaces.
   class ProxyObjectInterface
-    # The proxied methods contained in the interface.
-    attr_accessor :methods
-    # The proxied signals contained in the interface.
-    attr_accessor :signals
-    # The proxy object to which this interface belongs.
+    # @return [Hash{String => DBus::Method}]
+    attr_reader :methods
+    # @return [Hash{String => Signal}]
+    attr_reader :signals
+    # @return [Hash{Symbol => Property}]
+    attr_reader :properties
+
+    # @return [ProxyObject] The proxy object to which this interface belongs.
     attr_reader :object
-    # The name of the interface.
+    # @return [String] The name of the interface.
     attr_reader :name
 
     # Creates a new proxy interface for the given proxy _object_
@@ -29,6 +34,7 @@ module DBus
       @name = name
       @methods = {}
       @signals = {}
+      @properties = {}
     end
 
     # Returns the string representation of the interface (the name).
@@ -36,27 +42,28 @@ module DBus
       @name
     end
 
-    # Defines a method on the interface from the Method descriptor _m_.
-    def define_method_from_descriptor(m)
-      m.params.each do |fpar|
+    # Defines a method on the interface from the Method descriptor _method_.
+    # @param method [Method]
+    def define_method_from_descriptor(method)
+      method.params.each do |fpar|
         par = fpar.type
         # This is the signature validity check
         Type::Parser.new(par).parse
       end
 
       singleton_class.class_eval do
-        define_method m.name do |*args, &reply_handler|
-          if m.params.size != args.size
-            raise ArgumentError, "wrong number of arguments (#{args.size} for #{m.params.size})"
+        define_method method.name do |*args, &reply_handler|
+          if method.params.size != args.size
+            raise ArgumentError, "wrong number of arguments (#{args.size} for #{method.params.size})"
           end
 
           msg = Message.new(Message::METHOD_CALL)
           msg.path = @object.path
           msg.interface = @name
           msg.destination = @object.destination
-          msg.member = m.name
+          msg.member = method.name
           msg.sender = @object.bus.unique_name
-          m.params.each do |fpar|
+          method.params.each do |fpar|
             par = fpar.type
             msg.add_param(par, args.shift)
           end
@@ -64,25 +71,35 @@ module DBus
           if ret.nil? || @object.api.proxy_method_returns_array
             ret
           else
-            m.rets.size == 1 ? ret.first : ret
+            method.rets.size == 1 ? ret.first : ret
           end
         end
       end
 
-      @methods[m.name] = m
+      @methods[method.name] = method
     end
 
-    # Defines a signal from the descriptor _s_.
-    def define_signal_from_descriptor(s)
-      @signals[s.name] = s
+    # Defines a signal from the descriptor _sig_.
+    # @param sig [Signal]
+    def define_signal_from_descriptor(sig)
+      @signals[sig.name] = sig
     end
 
-    # Defines a signal or method based on the descriptor _m_.
-    def define(m)
-      if m.is_a?(Method)
-        define_method_from_descriptor(m)
-      elsif m.is_a?(Signal)
-        define_signal_from_descriptor(m)
+    # @param prop [Property]
+    def define_property_from_descriptor(prop)
+      @properties[prop.name] = prop
+    end
+
+    # Defines a signal or method based on the descriptor _ifc_el_.
+    # @param ifc_el [DBus::Method,Signal,Property]
+    def define(ifc_el)
+      case ifc_el
+      when Method
+        define_method_from_descriptor(ifc_el)
+      when Signal
+        define_signal_from_descriptor(ifc_el)
+      when Property
+        define_property_from_descriptor(ifc_el)
       end
     end
 
@@ -109,7 +126,7 @@ module DBus
       end
     end
 
-    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties".freeze
+    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
 
     # Read a property.
     # @param propname [String]
@@ -124,10 +141,26 @@ module DBus
     end
 
     # Write a property.
-    # @param propname [String]
+    # @param property_name [String]
     # @param value [Object]
-    def []=(propname, value)
-      object[PROPERTY_INTERFACE].Set(name, propname, value)
+    def []=(property_name, value)
+      property = properties[property_name.to_sym]
+      if !property
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+              "Property '#{name}.#{property_name}' (on object '#{object.path}') not found"
+      end
+
+      case value
+      # accommodate former need to explicitly make a variant with the right type
+      when Data::Variant
+        variant = value
+      else
+        type = property.type
+        typed_value = Data.make_typed(type, value)
+        variant = Data::Variant.new(typed_value, member_type: type)
+      end
+
+      object[PROPERTY_INTERFACE].Set(name, property_name, variant)
     end
 
     # Read all properties at once, as a hash.
@@ -141,5 +174,5 @@ module DBus
         ret
       end
     end
-  end # class ProxyObjectInterface
+  end
 end

data/lib/dbus/raw_message.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# This file is part of the ruby-dbus project
+# Copyright (C) 2022 Martin Vidner
+#
+# 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
+  # A message while it is being parsed: a binary string,
+  # with a position cursor (*pos*), and an *endianness* tag.
+  class RawMessage
+    # @return [String]
+    # attr_reader :bytes
+
+    # @return [Integer] position in the byte buffer
+    attr_reader :pos
+
+    # @return [:little,:big]
+    attr_reader :endianness
+
+    # @param bytes [String]
+    # @param endianness [:little,:big,nil]
+    #    if not given, read the 1st byte of *bytes*
+    def initialize(bytes, endianness = nil)
+      @bytes = bytes
+      @pos = 0
+      @endianness = endianness || self.class.endianness(@bytes[0])
+    end
+
+    # Get the endiannes switch as a Symbol,
+    # which will make using it slightly more efficient
+    # @param tag_char [String]
+    # @return [:little,:big]
+    def self.endianness(tag_char)
+      case tag_char
+      when LIL_END
+        :little
+      when BIG_END
+        :big
+      else
+        raise InvalidPacketException, "Incorrect endianness #{tag_char.inspect}"
+      end
+    end
+
+    # @return [void]
+    # @raise IncompleteBufferException if there are not enough bytes remaining
+    def want!(size)
+      raise IncompleteBufferException if @pos + size > @bytes.bytesize
+    end
+
+    # @return [String]
+    # @raise IncompleteBufferException if there are not enough bytes remaining
+    # TODO: stress test this with encodings. always binary?
+    def read(size)
+      want!(size)
+      ret = @bytes.slice(@pos, size)
+      @pos += size
+      ret
+    end
+
+    # @return [String]
+    # @api private
+    def remaining_bytes
+      # This returns "" if pos is just past the end of the string,
+      # and nil if it is further.
+      @bytes[@pos..-1]
+    end
+
+    # Align the *pos* index on a multiple of *alignment*
+    # @param alignment [Integer] must be 1, 2, 4 or 8
+    # @return [void]
+    def align(alignment)
+      case alignment
+      when 1
+        nil
+      when 2, 4, 8
+        bits = alignment - 1
+        pad_size = ((@pos + bits) & ~bits) - @pos
+        pad = read(pad_size)
+        unless pad.bytes.all?(&:zero?)
+          raise InvalidPacketException, "Alignment bytes are not NUL"
+        end
+      else
+        raise ArgumentError, "Unsupported alignment #{alignment}"
+      end
+    end
+  end
+end