ruby-dbus 0.18.0.beta6 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54a45385340217271e3fb445cddf6afcddb9892c4bf75b503e7859390f4d2ed7
-  data.tar.gz: 3c4f71745992c5afece87e34909e67f451717c9398ac6efb6235cc64ad1d1b0c
+  metadata.gz: 07f1f2fd26d13923b2601c9c3f29ccf57afd42c0348b937bceea0804eece6d66
+  data.tar.gz: 5ad80792234951e7ed422b6eba16e7f6e55b41f24a116ef40afaa7f32cdeef74
 SHA512:
-  metadata.gz: 864aaaaa867ea04247515d875d836560a558b7a3d780712a41dcd52214d95e47e857d640d66a3573eaf4df778a0320f89ad2c59918c005a2fc80adb8a63074cb
-  data.tar.gz: cabd9d699d8b7aad7c5f77a83aa07389b59c11b34b1219822909a031774b078d0bf001a1bce9bb5912be42caa4adba7608906ebc76dde57ff9f06d13afd7850f
+  metadata.gz: acbe18b2d9695f8959ef6d51a3871e989600291076d6eef870a9215768ed6c7afd599d3af2741e13a733fe2f5cc9f75fdf075a130cafd0a9144b4ca00bd80dc9
+  data.tar.gz: 0363375dd8c4465aa2650649d0bd62a4f95431b78178edb624a84f5326e395476e0c54e4755b27fedc86caf94b7c059abbdc15af28832417ec1d3e4770ea9ae0

data/NEWS.md

@@ -2,6 +2,74 @@
 
 ## Unreleased
 
+## Ruby D-Bus 0.18.1 - 2022-07-13
+
+No changes since 0.18.0.beta8.
+Repeating the most important changes since 0.17.0:
+
+API:
+ * Introduced DBus::Data classes, use them in Properties.Get,
+   Properties.GetAll to return correct types as declared ([#97][]).
+ * Introduced Object#dbus_properties_changed to send correctly typed property
+   values ([#115][]). Avoid calling PropertiesChanged directly as it will
+   guess the types.
+ * Service side `emits_changed_signal` to control emission of
+   PropertiesChanged: can be assigned within `dbus_interface` or as an option
+   when declaring properties ([#117][]).
+ * DBus.variant(type, value) is deprecated in favor of
+   Data::Variant.new(value, member_type:)
+ * Added type factories
+   * Type::Array[type]
+   * Type::Hash[key_type, value_type]
+   * Type::Struct[type1, type2...]
+
+Bug fixes:
+ * Fix Object.dbus_reader to work with attr_accessor and automatically produce
+   dbus_properties_changed for properties that are read-write at
+   implementation side and read-only at D-Bus side ([#96][])
+ * Service-side properties: Fix Properties.Get, Properties.GetAll
+   to use the specific property signature, not the generic
+   Variant ([#97][], [#105][], [#109][]).
+ * Client-side properties: When calling Properties.Set in
+   ProxyObjectInterface#[]=, use the correct type ([#108][]).
+ * Added thorough tests (`spec/data/marshall.yaml`) to detect nearly all
+   invalid data at unmarshalling time.
+
+Requirements:
+ * Require Ruby 2.4, because of RuboCop 1.0.
+
+## Ruby D-Bus 0.18.0.beta8 - 2022-06-21
+
+Bug fixes:
+ * Introduced Object#dbus_properties_changed to send correctly typed property
+   values ([#115][]). Avoid calling PropertiesChanged directly as it will
+   guess the types.
+ * Fix Object.dbus_reader to work with attr_accessor and automatically produce
+   dbus_properties_changed for properties that are read-write at
+   implementation side and read-only at D-Bus side ([#96][])
+
+[#96]: https://github.com/mvidner/ruby-dbus/issues/96
+
+API:
+ * Service side `emits_changed_signal` to control emission of
+   PropertiesChanged: can be assigned within `dbus_interface` or as an option
+   when declaring properties ([#117][]).
+
+[#115]: https://github.com/mvidner/ruby-dbus/issues/115
+[#117]: https://github.com/mvidner/ruby-dbus/pulls/117
+
+## Ruby D-Bus 0.18.0.beta7 - 2022-05-29
+
+API:
+ * DBus.variant(type, value) is deprecated in favor of
+   Data::Variant.new(value, member_type:)
+
+Bug fixes:
+ * Client-side properties: When calling Properties.Set in
+   ProxyObjectInterface#[]=, use the correct type ([#108][]).
+
+[#108]: https://github.com/mvidner/ruby-dbus/issues/108
+
 ## Ruby D-Bus 0.18.0.beta6 - 2022-05-25
 
 API:

data/VERSION

@@ -1 +1 @@
-0.18.0.beta6
+0.18.1

data/doc/Reference.md

@@ -166,12 +166,21 @@ D-Bus has stricter typing than Ruby, so the library must decide
 which D-Bus type to choose. Most of the time the choice is dictated
 by the D-Bus signature.
 
+For exact representation of D-Bus data types, use subclasses
+of {DBus::Data::Base}, such as {DBus::Data::Int16} or {DBus::Data::UInt64}.
+
 ##### Variants
 
 If the signature expects a Variant
 (which is the case for all Properties!) then an explicit mechanism is needed.
 
-1. A pair [{DBus::Type}, value] specifies to marshall *value* as
+1. Any {DBus::Data::Base}.
+
+2. A {DBus::Data::Variant} made by {DBus.variant}(signature, value).
+   (Formerly this produced the type+value pair below, now it is just an alias
+   to the Variant constructor.)
+
+3. A pair [{DBus::Type}, value] specifies to marshall *value* as
    that specified type.
    The pair can be produced by {DBus.variant}(signature, value) which
    gives the  same result as [{DBus.type}(signature), value].
@@ -181,13 +190,13 @@ If the signature expects a Variant
 
    `foo_i["Bar"] = DBus.variant("au", [0, 1, 1, 2, 3, 5, 8])`
 
-2. Other values are tried to fit one of these:
+4. Other values are tried to fit one of these:
    Boolean, Double, Array of Variants, Hash of String keyed Variants,
    String, Int32, Int64.
 
-3. **Deprecated:** A pair [String, value], where String is a valid
+5. **Deprecated:** A pair [String, value], where String is a valid
    signature of a single complete type, marshalls value as that
-   type. This will hit you when you rely on method (2) but happen to have
+   type. This will hit you when you rely on method (4) but happen to have
    a particular string value in an array.
 
 ##### Structs

data/lib/dbus/bus.rb

@@ -171,15 +171,11 @@ module DBus
 "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 '
       xml += "<node name=\"#{node_opath}\">\n"
-      each_pair do |k, _v|
+      each_key do |k|
         xml += "  <node name=\"#{k}\" />\n"
       end
-      @object&.intfs&.each_pair do |_k, v|
-        xml += "  <interface name=\"#{v.name}\">\n"
-        v.methods.each_value { |m| xml += m.to_xml }
-        v.signals.each_value { |m| xml += m.to_xml }
-        v.properties.each_value { |m| xml += m.to_xml }
-        xml += "  </interface>\n"
+      @object&.intfs&.each_value do |v|
+        xml += v.to_xml
       end
       xml += "</node>"
       xml

data/lib/dbus/data.rb

@@ -601,8 +601,10 @@ module DBus
 
         typed_value = case value
                       when Data::Array
-                        raise ArgumentError, "Specified type is #{type} but value type is #{value.type}" \
-                          unless value.type == type
+                        unless value.type == type
+                          raise ArgumentError,
+                                "Specified type is #{type.inspect} but value type is #{value.type.inspect}"
+                        end
 
                         value.exact_value
                       else
@@ -651,8 +653,10 @@ module DBus
 
         typed_value = case value
                       when self.class
-                        raise ArgumentError, "Specified type is #{type} but value type is #{value.type}" \
-                          unless value.type == type
+                        unless value.type == type
+                          raise ArgumentError,
+                                "Specified type is #{type.inspect} but value type is #{value.type.inspect}"
+                        end
 
                         value.exact_value
                       else
@@ -751,13 +755,19 @@ module DBus
       # @return [Type]
       attr_reader :member_type
 
+      # Determine the type of *value*
+      # @param value [::Object]
+      # @return [Type]
+      # @api private
+      # See also {PacketMarshaller.make_variant}
       def self.guess_type(value)
         sct, = PacketMarshaller.make_variant(value)
         DBus.type(sct)
       end
 
-      # @param member_type [Type,nil]
+      # @param member_type [SingleCompleteType,Type,nil]
       def initialize(value, member_type:)
+        member_type = Type::Factory.make_type(member_type) if member_type
         # TODO: validate that the given *member_type* matches *value*
         case value
         when Data::Variant
@@ -775,6 +785,30 @@ module DBus
         end
         super(value)
       end
+
+      # Internal helpers to keep the {DBus.variant} method working.
+      # Formerly it returned just a pair of [DBus.type(string_type), value]
+      # so let's provide [0], [1], .first, .last
+      def [](index)
+        case index
+        when 0
+          member_type
+        when 1
+          value
+        else
+          raise ArgumentError, "DBus.variant can only be indexed with 0 or 1, seen #{index.inspect}"
+        end
+      end
+
+      # @see #[]
+      def first
+        self[0]
+      end
+
+      # @see #[]
+      def last
+        self[1]
+      end
     end
 
     consts = constants.map { |c_sym| const_get(c_sym) }

data/lib/dbus/emits_changed_signal.rb

@@ -0,0 +1,83 @@
+# 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
+  # Describes the behavior of PropertiesChanged signal, for a single property
+  # or for an entire interface.
+  #
+  # The possible values are:
+  #
+  # - *true*: the signal is emitted with the value included.
+  # - *:invalidates*: the signal is emitted but the value is not included
+  #   in the signal.
+  # - *:const*: the property never changes value during the lifetime
+  #   of the object it belongs to, and hence the signal
+  #   is never emitted for it (but clients can cache the value)
+  # - *false*: the signal won't be emitted (clients should re-Get the property value)
+  #
+  # The default is:
+  # - for an interface: *true*
+  # - for a property: what the parent interface specifies
+  #
+  # @see DBus::Object.emits_changed_signal
+  # @see DBus::Object.dbus_attr_accessor
+  # @see https://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format
+  #
+  # Immutable once constructed.
+  class EmitsChangedSignal
+    # @return [true,false,:const,:invalidates]
+    attr_reader :value
+
+    # @param value [true,false,:const,:invalidates,nil]
+    #   See class-level description above, {EmitsChangedSignal}.
+    # @param interface [Interface,nil]
+    #   If the (property-level) *value* is unspecified (nil), this is the
+    #   containing {Interface} to get the value from.
+    def initialize(value, interface: nil)
+      if value.nil?
+        raise ArgumentError, "Both arguments are nil" if interface.nil?
+
+        @value = interface.emits_changed_signal.value
+      else
+        expecting = [true, false, :const, :invalidates]
+        unless expecting.include?(value)
+          raise ArgumentError, "Expecting one of #{expecting.inspect}. Seen #{value.inspect}"
+        end
+
+        @value = value
+      end
+
+      freeze
+    end
+
+    # Return introspection XML string representation
+    # @return [String]
+    def to_xml
+      return "" if @value == true
+
+      "    <annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"#{@value}\"/>\n"
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def ==(other)
+      if other.is_a?(self.class)
+        other.value == @value
+      else
+        other == value
+      end
+    end
+    alias eql? ==
+
+    DEFAULT_ECS = EmitsChangedSignal.new(true)
+  end
+end

data/lib/dbus/introspect.rb

@@ -26,7 +26,7 @@ module DBus
   # method call instantiates and configures this class for us.
   #
   # It also is the local definition of interface exported by the program.
-  # At the client side, see ProxyObjectInterface
+  # At the client side, see {ProxyObjectInterface}.
   class Interface
     # @return [String] The name of the interface.
     attr_reader :name
@@ -38,6 +38,9 @@ module DBus
     # @return [Hash{Symbol => Property}]
     attr_reader :properties
 
+    # @return [EmitsChangedSignal]
+    attr_reader :emits_changed_signal
+
     # Creates a new interface with a given _name_.
     def initialize(name)
       validate_name(name)
@@ -45,6 +48,20 @@ module DBus
       @methods = {}
       @signals = {}
       @properties = {}
+      @emits_changed_signal = EmitsChangedSignal::DEFAULT_ECS
+    end
+
+    # Helper for {Object.emits_changed_signal=}.
+    # @api private
+    def emits_changed_signal=(ecs)
+      raise TypeError unless ecs.is_a? EmitsChangedSignal
+      # equal?: object identity
+      unless @emits_changed_signal.equal?(EmitsChangedSignal::DEFAULT_ECS) ||
+             @emits_changed_signal.value == ecs.value
+        raise "emits_change_signal was assigned more than once"
+      end
+
+      @emits_changed_signal = ecs
     end
 
     # Validates a service _name_.
@@ -85,6 +102,18 @@ module DBus
       define(m)
     end
     alias declare_method define_method
+
+    # Return introspection XML string representation of the property.
+    # @return [String]
+    def to_xml
+      xml = "  <interface name=\"#{name}\">\n"
+      xml += emits_changed_signal.to_xml
+      methods.each_value { |m| xml += m.to_xml }
+      signals.each_value { |m| xml += m.to_xml }
+      properties.each_value { |m| xml += m.to_xml }
+      xml += "  </interface>\n"
+      xml
+    end
   end
 
   # = A formal parameter has a name and a type
@@ -190,6 +219,7 @@ module DBus
     end
 
     # Return an XML string representation of the method interface elment.
+    # @return [String]
     def to_xml
       xml = "    <method name=\"#{@name}\">\n"
       @params.each do |param|
@@ -238,19 +268,20 @@ module DBus
   # 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.
+    # @return [Symbol] The name of the property, for example FooBar.
     attr_reader :name
     # @return [SingleCompleteType]
     attr_reader :type
     # @return [Symbol] :read :write or :readwrite
     attr_reader :access
 
-    # @return [Symbol] What to call at Ruby side.
+    # @return [Symbol,nil] What to call at Ruby side.
     #   (Always without the trailing `=`)
+    #   It is `nil` IFF representing a client-side proxy.
     attr_reader :ruby_name
 
     def initialize(name, type, access, ruby_name:)
-      @name = name
+      @name = name.to_sym
       @type = type
       @access = access
       @ruby_name = ruby_name
@@ -270,5 +301,14 @@ module DBus
     def to_xml
       "    <property type=\"#{@type}\" name=\"#{@name}\" access=\"#{@access}\"/>\n"
     end
+
+    # @param xml_node [AbstractXML::Node]
+    # @return [Property]
+    def self.from_xml(xml_node)
+      name = xml_node["name"].to_sym
+      type = xml_node["type"]
+      access = xml_node["access"].to_sym
+      new(name, type, access, ruby_name: nil)
+    end
   end
 end

data/lib/dbus/object.rb

@@ -102,6 +102,18 @@ module DBus
       end
     end
 
+    # Declare the behavior of PropertiesChanged signal,
+    # common for all properties in this interface
+    # (individual properties may override it)
+    # @example
+    #   self.emits_changed_signal = :invalidates
+    # @param [true,false,:const,:invalidates] value
+    def self.emits_changed_signal=(value)
+      raise UndefinedInterface, :emits_changed_signal if @@cur_intf.nil?
+
+      @@cur_intf.emits_changed_signal = EmitsChangedSignal.new(value)
+    end
+
     # A read-write property accessing an instance variable.
     # A combination of `attr_accessor` and {.dbus_accessor}.
     #
@@ -114,11 +126,13 @@ module DBus
     # @param dbus_name [String] if not given it is made
     #   by CamelCasing the ruby_name. foo_bar becomes FooBar
     #   to convert the Ruby convention to the DBus convention.
+    # @param emits_changed_signal [true,false,:const,:invalidates]
+    #   see {EmitsChangedSignal}; if unspecified, ask the interface.
     # @return [void]
-    def self.dbus_attr_accessor(ruby_name, type, dbus_name: nil)
+    def self.dbus_attr_accessor(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       attr_accessor(ruby_name)
 
-      dbus_accessor(ruby_name, type, dbus_name: dbus_name)
+      dbus_accessor(ruby_name, type, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # A read-only property accessing an instance variable.
@@ -126,19 +140,20 @@ module DBus
     #
     # Whenever the property value gets changed from "inside" the object,
     # you should emit the `PropertiesChanged` signal by calling
+    # {#dbus_properties_changed}.
     #
-    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #   dbus_properties_changed(interface_name, {dbus_name.to_s => value}, [])
     #
     # or, omitting the value in the signal,
     #
-    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #   dbus_properties_changed(interface_name, {}, [dbus_name.to_s])
     #
     # @param  (see .dbus_attr_accessor)
     # @return (see .dbus_attr_accessor)
-    def self.dbus_attr_reader(ruby_name, type, dbus_name: nil)
+    def self.dbus_attr_reader(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       attr_reader(ruby_name)
 
-      dbus_reader(ruby_name, type, dbus_name: dbus_name)
+      dbus_reader(ruby_name, type, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # A write-only property accessing an instance variable.
@@ -146,10 +161,10 @@ module DBus
     #
     # @param  (see .dbus_attr_accessor)
     # @return (see .dbus_attr_accessor)
-    def self.dbus_attr_writer(ruby_name, type, dbus_name: nil)
+    def self.dbus_attr_writer(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       attr_writer(ruby_name)
 
-      dbus_writer(ruby_name, type, dbus_name: dbus_name)
+      dbus_writer(ruby_name, type, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # A read-write property using a pair of reader/writer methods
@@ -160,36 +175,49 @@ module DBus
     #
     # @param  (see .dbus_attr_accessor)
     # @return (see .dbus_attr_accessor)
-    def self.dbus_accessor(ruby_name, type, dbus_name: nil)
+    def self.dbus_accessor(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       raise UndefinedInterface, ruby_name if @@cur_intf.nil?
 
       dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
       property = Property.new(dbus_name, type, :readwrite, ruby_name: ruby_name)
       @@cur_intf.define(property)
 
-      dbus_watcher(ruby_name, dbus_name: dbus_name)
+      dbus_watcher(ruby_name, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # A read-only property accessing a reader method (which must already exist).
     # (To directly access an instance variable, use {.dbus_attr_reader} instead)
     #
-    # Whenever the property value gets changed from "inside" the object,
+    # At the D-Bus side the property is read only but it makes perfect sense to
+    # implement it with a read-write attr_accessor. In that case this method
+    # uses {.dbus_watcher} to set up the PropertiesChanged signal.
+    #
+    #   attr_accessor :foo_bar
+    #   dbus_reader :foo_bar, "s"
+    #
+    # If the property value should change by other means than its attr_writer,
     # you should emit the `PropertiesChanged` signal by calling
+    # {#dbus_properties_changed}.
     #
-    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #   dbus_properties_changed(interface_name, {dbus_name.to_s => value}, [])
     #
     # or, omitting the value in the signal,
     #
-    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #   dbus_properties_changed(interface_name, {}, [dbus_name.to_s])
     #
     # @param  (see .dbus_attr_accessor)
     # @return (see .dbus_attr_accessor)
-    def self.dbus_reader(ruby_name, type, dbus_name: nil)
+    def self.dbus_reader(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       raise UndefinedInterface, ruby_name if @@cur_intf.nil?
 
       dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
       property = Property.new(dbus_name, type, :read, ruby_name: ruby_name)
       @@cur_intf.define(property)
+
+      ruby_name_eq = "#{ruby_name}=".to_sym
+      return unless method_defined?(ruby_name_eq)
+
+      dbus_watcher(ruby_name, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # A write-only property accessing a writer method (which must already exist).
@@ -199,14 +227,14 @@ module DBus
     #
     # @param  (see .dbus_attr_accessor)
     # @return (see .dbus_attr_accessor)
-    def self.dbus_writer(ruby_name, type, dbus_name: nil)
+    def self.dbus_writer(ruby_name, type, dbus_name: nil, emits_changed_signal: nil)
       raise UndefinedInterface, ruby_name if @@cur_intf.nil?
 
       dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
       property = Property.new(dbus_name, type, :write, ruby_name: ruby_name)
       @@cur_intf.define(property)
 
-      dbus_watcher(ruby_name, dbus_name: dbus_name)
+      dbus_watcher(ruby_name, dbus_name: dbus_name, emits_changed_signal: emits_changed_signal)
     end
 
     # Enables automatic sending of the PropertiesChanged signal.
@@ -218,11 +246,13 @@ module DBus
     # @param dbus_name [String] if not given it is made
     #   by CamelCasing the ruby_name. foo_bar becomes FooBar
     #   to convert the Ruby convention to the DBus convention.
+    # @param emits_changed_signal [true,false,:const,:invalidates]
+    #   see {EmitsChangedSignal}; if unspecified, ask the interface.
     # @return [void]
-    def self.dbus_watcher(ruby_name, dbus_name: nil)
+    def self.dbus_watcher(ruby_name, dbus_name: nil, emits_changed_signal: nil)
       raise UndefinedInterface, ruby_name if @@cur_intf.nil?
 
-      cur_intf = @@cur_intf
+      interface_name = @@cur_intf.name
 
       ruby_name = ruby_name.to_s.sub(/=$/, "").to_sym
       ruby_name_eq = "#{ruby_name}=".to_sym
@@ -230,14 +260,27 @@ module DBus
 
       dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
 
+      emits_changed_signal = EmitsChangedSignal.new(emits_changed_signal, interface: @@cur_intf)
+
       # the argument order is alias_method(new_name, existing_name)
       alias_method original_ruby_name_eq, ruby_name_eq
       define_method ruby_name_eq do |value|
-        public_send(original_ruby_name_eq, value)
+        result = public_send(original_ruby_name_eq, value)
+
+        case emits_changed_signal.value
+        when true
+          # signature: "interface:s, changed_props:a{sv}, invalidated_props:as"
+          dbus_properties_changed(interface_name, { dbus_name.to_s => value }, [])
+        when :invalidates
+          dbus_properties_changed(interface_name, {}, [dbus_name.to_s])
+        when :const
+          # Oh my, seeing a value change of a supposedly constant property.
+          # Maybe should have raised at declaration time, don't make a fuss now.
+        when false
+          # Do nothing
+        end
 
-        # TODO: respect EmitsChangedSignal to use invalidated_properties instead
-        # PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
-        PropertiesChanged(cur_intf.name, { dbus_name.to_s => value }, [])
+        result
       end
     end
 
@@ -301,6 +344,25 @@ module DBus
       dbus_name.to_sym
     end
 
+    # Use this instead of calling PropertiesChanged directly. This one
+    # considers not only the PC signature (which says that all property values
+    # are variants) but also the specific property type.
+    # @param interface_name [String] interface name like "org.example.ManagerManager"
+    # @param changed_props [Hash{String => ::Object}]
+    #   changed properties (D-Bus names) and their values.
+    # @param invalidated_props [Array<String>]
+    #   names of properties whose changed value is not specified
+    def dbus_properties_changed(interface_name, changed_props, invalidated_props)
+      typed_changed_props = changed_props.map do |dbus_name, value|
+        property = dbus_lookup_property(interface_name, dbus_name)
+        type = property.type
+        typed_value = Data.make_typed(type, value)
+        variant = Data::Variant.new(typed_value, member_type: type)
+        [dbus_name, variant]
+      end.to_h
+      PropertiesChanged(interface_name, typed_changed_props, invalidated_props)
+    end
+
     # @param interface_name [String]
     # @param property_name [String]
     # @return [Property]

data/lib/dbus/proxy_object_factory.rb

@@ -29,11 +29,13 @@ module DBus
     # @param pobj [ProxyObject]
     # @param xml [String]
     def self.introspect_into(pobj, xml)
+      # intfs [Array<Interface>], subnodes [Array<String>]
       intfs, pobj.subnodes = IntrospectXMLParser.new(xml).parse
       intfs.each do |i|
         poi = ProxyObjectInterface.new(pobj, i.name)
         i.methods.each_value { |m| poi.define(m) }
         i.signals.each_value { |s| poi.define(s) }
+        i.properties.each_value { |p| poi.define(p) }
         pobj[i.name] = poi
       end
       pobj.introspected = true

data/lib/dbus/proxy_object_interface.rb

@@ -15,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_
@@ -31,6 +34,7 @@ module DBus
       @name = name
       @methods = {}
       @signals = {}
+      @properties = {}
     end
 
     # Returns the string representation of the interface (the name).
@@ -81,13 +85,21 @@ module DBus
       @signals[sig.name] = sig
     end
 
+    # @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
 
@@ -129,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.

data/lib/dbus/type.rb

@@ -415,8 +415,9 @@ module DBus
   # @param string_type [SingleCompleteType]
   # @param value [::Object]
   # @return [Array(DBus::Type::Type,::Object)]
+  # @deprecated Use {Data::Variant#initialize} instead
   def variant(string_type, value)
-    [type(string_type), value]
+    Data::Variant.new(value, member_type: string_type)
   end
   module_function :variant
 end

data/lib/dbus/xml.rb

@@ -134,6 +134,10 @@ module DBus
           parse_methsig(se, s)
           i << s
         end
+        e.each("property") do |pe|
+          p = Property.from_xml(pe)
+          i << p
+        end
       end
       d = Time.now - t
       if d > 2

data/lib/dbus.rb

@@ -15,6 +15,7 @@ require_relative "dbus/auth"
 require_relative "dbus/bus"
 require_relative "dbus/bus_name"
 require_relative "dbus/data"
+require_relative "dbus/emits_changed_signal"
 require_relative "dbus/error"
 require_relative "dbus/introspect"
 require_relative "dbus/logger"

data/spec/data_spec.rb

@@ -193,7 +193,7 @@ RSpec.shared_examples "constructor rejects values from this list" do |bad_list|
   describe "#initialize" do
     bad_list.each do |(value, exc_class, msg_substr)|
       it "rejects #{value.inspect} with #{exc_class}: #{msg_substr}" do
-        msg_re = Regexp.new(Regexp.quote(msg_substr))
+        msg_re = Regexp.try_convert(msg_substr) || Regexp.new(Regexp.quote(msg_substr))
         expect { described_class.new(value) }.to raise_error(exc_class, msg_re)
       end
     end
@@ -204,7 +204,7 @@ RSpec.shared_examples "constructor (kwargs) rejects values" do |bad_list|
   describe "#initialize" do
     bad_list.each do |(value, kwargs_hash, exc_class, msg_substr)|
       it "rejects #{value.inspect}, #{kwargs_hash.inspect} with #{exc_class}: #{msg_substr}" do
-        msg_re = Regexp.new(Regexp.quote(msg_substr))
+        msg_re = Regexp.try_convert(msg_substr) || Regexp.new(Regexp.quote(msg_substr))
         expect { described_class.new(value, **kwargs_hash) }.to raise_error(exc_class, msg_re)
       end
     end
@@ -387,8 +387,9 @@ describe DBus::Data do
 
   describe "containers" do
     describe DBus::Data::Array do
+      aq = DBus::Data::Array.new([1, 2, 3], type: "aq")
+
       good = [
-        # [[1, 2, 3], type: nil],
         [[1, 2, 3], { type: "aq" }],
         [[1, 2, 3], { type: T::Array[T::UINT16] }],
         [[1, 2, 3], { type: T::Array["q"] }],
@@ -398,9 +399,14 @@ describe DBus::Data do
 
       bad = [
         # undesirable type guessing
-        ## [[1, 2, 3], { type: nil }, DBus::InvalidPacketException, "Unknown type code"],
-        ## [[1, 2, 3], { type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
-        # TODO: others
+        [[1, 2, 3], { type: nil }, ArgumentError, /Expecting DBus::Type.*got nil/],
+        [[1, 2, 3], { type: "!" }, DBus::Type::SignatureException, "Unknown type code"],
+        [aq, { type: "q" }, ArgumentError, "Expecting \"a\""],
+        [aq, { type: "ao" }, ArgumentError,
+         "Specified type is ARRAY: [OBJECT_PATH] but value type is ARRAY: [UINT16]"]
+        # TODO: how to handle these?
+        # [{1 => 2, 3 => 4}, { type: "aq" }, ArgumentError, "?"],
+        # [/i am not an array/, { type: "aq" }, ArgumentError, "?"],
       ]
 
       include_examples "#== and #eql? work for container types (inequal)",
@@ -506,7 +512,7 @@ describe DBus::Data do
           value2 = result1
           type2 = "(xxx)"
           expect { described_class.new(value2, type: type2) }
-            .to raise_error(ArgumentError, /value type is .uuu./)
+            .to raise_error(ArgumentError, /value type is STRUCT.*UINT32/)
         end
 
         it "checks that size of type and value match" do
@@ -553,7 +559,7 @@ describe DBus::Data do
           value2 = result1
           type2 = T::Hash[T::UINT64, T::UINT64].child
           expect { described_class.new(value2, type: type2) }
-            .to raise_error(ArgumentError, /value type is .uu./)
+            .to raise_error(ArgumentError, /value type is DICT_ENTRY.*UINT32/)
         end
 
         it "checks that size of type and value match" do
@@ -632,6 +638,36 @@ describe DBus::Data do
 
       include_examples "#== and #eql? work for container types (1 value)",
                        "/foo", { member_type: DBus.type(T::STRING) }
+
+      describe "DBus.variant compatibility" do
+        let(:v) { DBus.variant("o", "/foo") }
+
+        describe "#[]" do
+          it "returns the type for 0" do
+            expect(v[0]).to eq DBus.type(DBus::Type::OBJECT_PATH)
+          end
+
+          it "returns the value for 1" do
+            expect(v[1]).to eq DBus::ObjectPath.new("/foo")
+          end
+
+          it "returns an error for other indices" do
+            expect { v[2] }.to raise_error(ArgumentError, /DBus.variant can only be indexed with 0 or 1/)
+          end
+        end
+
+        describe "#first" do
+          it "returns the type" do
+            expect(v.first).to eq DBus.type(DBus::Type::OBJECT_PATH)
+          end
+        end
+
+        describe "#last" do
+          it "returns the value" do
+            expect(v.last).to eq DBus::ObjectPath.new("/foo")
+          end
+        end
+      end
     end
   end
 end

data/spec/emits_changed_signal_spec.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::EmitsChangedSignal do
+  describe "#initialize" do
+    it "accepts a simple value" do
+      expect(described_class.new(:const).value).to eq :const
+    end
+
+    it "avoids nil by asking the interface" do
+      ifc = DBus::Interface.new("org.example.Foo")
+      ifc.emits_changed_signal = described_class.new(:invalidates)
+
+      expect(described_class.new(nil, interface: ifc).value).to eq :invalidates
+    end
+
+    it "fails for unknown value" do
+      expect { described_class.new(:huh) }.to raise_error(ArgumentError, /Seen :huh/)
+    end
+
+    it "fails for 2 nils" do
+      expect { described_class.new(nil, interface: nil) }.to raise_error(ArgumentError, /Both/)
+    end
+  end
+
+  describe "#==" do
+    it "is true for two different objects with the same value" do
+      const_a = described_class.new(:const)
+      const_b = described_class.new(:const)
+      expect(const_a == const_b).to be true
+    end
+  end
+
+  describe "#to_xml" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_xml)
+        .to eq "    <annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"const\"/>\n"
+    end
+  end
+
+  describe "#to_s" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_s).to eq "const"
+    end
+  end
+end
+
+describe DBus::Interface do
+  describe ".emits_changed_signal=" do
+    it "only allows an EmitsChangedSignal as argument" do
+      ifc = described_class.new("org.ruby.Interface")
+      expect { ifc.emits_changed_signal = :const }.to raise_error(TypeError)
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+class ObjectTest < DBus::Object
+  T = DBus::Type unless const_defined? "T"
+
+  dbus_interface "org.ruby.ServerTest" do
+    dbus_attr_writer :write_me, T::Struct[String, String]
+
+    attr_accessor :read_only_for_dbus
+
+    dbus_reader :read_only_for_dbus, T::STRING, emits_changed_signal: :invalidates
+  end
+end
+
+describe DBus::Object do
+  describe ".dbus_attr_writer" do
+    describe "the declared assignment method" do
+      # Slightly advanced RSpec:
+      # https://rspec.info/documentation/3.9/rspec-expectations/RSpec/Matchers.html#satisfy-instance_method
+      let(:a_struct_in_a_variant) do
+        satisfying { |x| x.is_a?(DBus::Data::Variant) && x.member_type.to_s == "(ss)" }
+        # ^ This formatting keeps the matcher on a single line
+        # which enables RSpec to cite it if it fails, instead of saying "block".
+      end
+
+      it "emits PropertyChanged with correctly typed argument" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {
+            "WriteMe" => a_struct_in_a_variant
+          },
+          []
+        )
+        # bug: call PC with simply the assigned value,
+        # which will need type guessing
+        obj.write_me = ["two", "strings"]
+      end
+    end
+  end
+
+  describe ".dbus_accessor" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_accessor :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_reader" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_reader :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_reader, when paired with attr_accessor" do
+    describe "the declared assignment method" do
+      it "emits PropertyChanged" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {},
+          ["ReadOnlyForDbus"]
+        )
+        obj.read_only_for_dbus = "myvalue"
+      end
+    end
+  end
+
+  describe ".dbus_writer" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_writer :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_watcher" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_watcher :foo
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_method" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_method :foo do
+          end
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".emits_changed_signal" do
+    it "raises UndefinedInterface when so" do
+      expect { ObjectTest.emits_changed_signal = false }
+        .to raise_error DBus::Object::UndefinedInterface
+    end
+
+    it "assigns to the current interface" do
+      ObjectTest.instance_exec do
+        dbus_interface "org.ruby.Interface" do
+          self.emits_changed_signal = false
+        end
+      end
+      ecs = ObjectTest.intfs["org.ruby.Interface"].emits_changed_signal
+      expect(ecs).to eq false
+    end
+
+    it "only can be assigned once" do
+      expect do
+        Class.new(DBus::Object) do
+          dbus_interface "org.ruby.Interface" do
+            self.emits_changed_signal = false
+            self.emits_changed_signal = :invalidates
+          end
+        end
+      end.to raise_error(RuntimeError, /assigned more than once/)
+    end
+  end
+end

data/spec/property_spec.rb

@@ -60,7 +60,7 @@ describe "PropertyTest" do
 
   it "tests get all" do
     all = @iface.all_properties
-    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyByte", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests get all on a V1 object" do
@@ -68,7 +68,7 @@ describe "PropertyTest" do
     iface = obj["org.ruby.SampleInterface"]
 
     all = iface.all_properties
-    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyByte", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests unknown property reading" do
@@ -110,6 +110,7 @@ describe "PropertyTest" do
     end
 
     @iface["ReadOrWriteMe"] = "VALUE"
+    @iface.SetTwoProperties("REAMDE", 255)
 
     # loop to process the signal. complicated :-( see signal_spec.rb
     loop = DBus::Main.new
@@ -123,6 +124,8 @@ describe "PropertyTest" do
     quitter.join
 
     expect(received["ReadOrWriteMe"]).to eq("VALUE")
+    expect(received["ReadMe"]).to eq("REAMDE")
+    expect(received["MyByte"]).to eq(255)
   end
 
   context "a struct-typed property" do
@@ -200,6 +203,36 @@ describe "PropertyTest" do
     end
   end
 
+  context "a byte-typed property" do
+    # Slightly advanced RSpec:
+    # https://rspec.info/documentation/3.9/rspec-expectations/RSpec/Matchers.html#satisfy-instance_method
+    let(:a_byte_in_a_variant) do
+      satisfying { |x| x.is_a?(DBus::Data::Variant) && x.member_type.to_s == DBus::Type::BYTE }
+      # ^ This formatting keeps the matcher on a single line
+      # which enables RSpec to cite it if it fails, instead of saying "block".
+    end
+
+    let(:prop_iface) { @obj[DBus::PROPERTY_INTERFACE] }
+
+    it "gets set with a correct type (#108)" do
+      expect(prop_iface).to receive(:Set).with(
+        "org.ruby.SampleInterface",
+        "MyByte",
+        a_byte_in_a_variant
+      )
+      @iface["MyByte"] = 1
+    end
+
+    it "gets set with a correct type (#108), when using the DBus.variant workaround" do
+      expect(prop_iface).to receive(:Set).with(
+        "org.ruby.SampleInterface",
+        "MyByte",
+        a_byte_in_a_variant
+      )
+      @iface["MyByte"] = DBus.variant("y", 1)
+    end
+  end
+
   context "marshall.yaml round-trip via a VARIANT property" do
     marshall_yaml.each do |test|
       t = OpenStruct.new(test)

data/spec/service_newapi.rb

@@ -28,6 +28,8 @@ class Test < DBus::Object
       "three" => [3, 3, 3]
     }
     @my_variant = @my_array.dup
+    # 201 is a RET instruction for ZX Spectrum which has turned 40 recently
+    @my_byte = 201
     @main_loop = nil
   end
 
@@ -111,6 +113,17 @@ class Test < DBus::Object
     dbus_attr_accessor :my_array, "aq"
     dbus_attr_accessor :my_dict, "a{sv}"
     dbus_attr_accessor :my_variant, "v"
+
+    dbus_attr_accessor :my_byte, "y"
+
+    # to test dbus_properties_changed
+    dbus_method :SetTwoProperties, "in read_me:s, in byte:y" do |read_me, byte|
+      @read_me = read_me
+      @my_byte = byte
+      dbus_properties_changed(INTERFACE,
+                              { "ReadMe" => read_me, "MyByte" => byte },
+                              [])
+    end
   end
 
   # closing and reopening the same interface

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dbus
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta6
+  version: 0.18.1
 platform: ruby
 authors:
 - Ruby DBus Team
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-25 00:00:00.000000000 Z
+date: 2022-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -146,6 +146,7 @@ files:
 - lib/dbus/core_ext/class/attribute.rb
 - lib/dbus/core_ext/module/redefine_method.rb
 - lib/dbus/data.rb
+- lib/dbus/emits_changed_signal.rb
 - lib/dbus/error.rb
 - lib/dbus/introspect.rb
 - lib/dbus/logger.rb
@@ -172,12 +173,14 @@ files:
 - spec/client_robustness_spec.rb
 - spec/data/marshall.yaml
 - spec/data_spec.rb
+- spec/emits_changed_signal_spec.rb
 - spec/err_msg_spec.rb
 - spec/introspect_xml_parser_spec.rb
 - spec/introspection_spec.rb
 - spec/main_loop_spec.rb
 - spec/node_spec.rb
 - spec/object_path_spec.rb
+- spec/object_spec.rb
 - spec/packet_marshaller_spec.rb
 - spec/packet_unmarshaller_spec.rb
 - spec/property_spec.rb
@@ -202,7 +205,7 @@ homepage: https://github.com/mvidner/ruby-dbus
 licenses:
 - LGPL-2.1
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -213,12 +216,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.7.6.3
+signing_key: 
 specification_version: 4
 summary: Ruby module for interaction with D-Bus
 test_files: []