ruby-dbus 0.18.0.beta2 → 0.18.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c89eebb575c67de57670fdc2e8b70b4c08dcaf7fc3c1bad858f1d23869571c1
-  data.tar.gz: 4a4793ed412ebd25a636bed4dafa5367800658eb5d52d853ef1b2c0df0e3e272
+  metadata.gz: f8b0c43d3f27f0877e52c0adfb8014374829f97bcd38be6b9fabda1d5da8413c
+  data.tar.gz: 000eadf163b0fab2ef4ab39de81a79714b34392cd81b3be68e12587ddfa93372
 SHA512:
-  metadata.gz: c03aa469aebb197943266b9147fba6b55383a22248e0814b0c2f7799c2e95d43b555f80a919c236a437c90805cbd7647498c1f8b1cf901d4a298da0b2d81e50c
-  data.tar.gz: f7906b8c2308909cb8974240f3d8de3bc3e10a481fc15c91acd7af5526f405fd314df8b1a424683009a64dfc52ebfa9fa2c73497f8215cb403d80ab02866d56a
+  metadata.gz: c2206dcd935fed4e3711b88b2c0c265e5a335700f9137d2c3972f419791d9c25198d0acf9ba7aaecdbc6a25e540005c64321e5165c6c644838fb3557355861ac
+  data.tar.gz: 212cb8bdcd75e3f35622843f262cdb80eaa07c1919a7d17ffdf601e05c627556343b7855a014f60a220c8a757c201431d66799a6025a98d084aef6cc12f7d8bb

data/NEWS.md

@@ -2,6 +2,41 @@
 
 ## Unreleased
 
+## Ruby D-Bus 0.18.0.beta5 - 2022-04-27
+
+API:
+ * DBus::Type instances are frozen.
+ * Data::Container classes (Array, Struct, DictEntry, but not Variant)
+   constructors (#initialize, .from_items, .from_typed) changed to have
+   a *type* argument instead of *member_type* or *member_types*.
+ * Added type factories
+   * Type::Array[type]
+   * Type::Hash[key_type, value_type]
+   * Type::Struct[type1, type2...]
+
+Bug fixes:
+ * Properties containing Variants would return them doubly wrapped ([#111][]).
+
+[#111]: https://github.com/mvidner/ruby-dbus/pull/111
+
+## Ruby D-Bus 0.18.0.beta4 - 2022-04-21
+
+Bug fixes:
+ * Service-side properties: Fix Properties.Get, Properties.GetAll for
+   properties that contain arrays, on other than outermost level ([#109][]).
+ * Sending variants: fixed make_variant to correctly guess the signature
+   for UInt64 and number-keyed hashes/dictionaries.
+
+[#109]: https://github.com/mvidner/ruby-dbus/pull/109
+
+## Ruby D-Bus 0.18.0.beta3 - 2022-04-10
+
+Bug fixes:
+ * Service-side properties: Fix Properties.Get, Properties.GetAll for Array,
+   Dict, and Variant types ([#105][]).
+
+[#105]: https://github.com/mvidner/ruby-dbus/pull/105
+
 ## Ruby D-Bus 0.18.0.beta2 - 2022-04-04
 
 API:

data/VERSION

@@ -1 +1 @@
-0.18.0.beta2
+0.18.0.beta5

data/lib/dbus/data.rb

@@ -43,7 +43,7 @@ module DBus
       data_class = Data::BY_TYPE_CODE[type.sigtype]
       # not nil because DBus.type validates
 
-      data_class.from_typed(value, member_types: type.members)
+      data_class.from_typed(value, type: type)
     end
     module_function :make_typed
 
@@ -67,6 +67,15 @@ module DBus
       # for the specific see {Variant#member_type}
       # @return [Type] the exact type of this value
 
+      # @!method self.from_typed(value, type:)
+      # @param value [::Object]
+      # @param type [Type]
+      # @return [Base]
+      # @api private
+      # Use {Data.make_typed} instead.
+      # Construct an instance of the specific subclass, with a type further
+      # specified in the *type* argument.
+
       # Child classes must validate *value*.
       def initialize(value)
         @value = value
@@ -83,6 +92,11 @@ module DBus
       # Hash key equality
       # See https://ruby-doc.org/core-3.0.0/Object.html#method-i-eql-3F
       alias eql? ==
+
+      # @param type [Type]
+      def self.assert_type_matches_class(type)
+        raise ArgumentError unless type.sigtype == type_code
+      end
     end
 
     # A value that is not a {Container}.
@@ -103,10 +117,10 @@ module DBus
       end
 
       # @param value [::Object]
-      # @param member_types [::Array<Type>] (ignored, will be empty)
+      # @param type [Type]
       # @return [Basic]
-      def self.from_typed(value, member_types:) # rubocop:disable Lint/UnusedMethodArgument
-        # assert member_types.empty?
+      def self.from_typed(value, type:)
+        assert_type_matches_class(type)
         new(value)
       end
     end
@@ -132,39 +146,14 @@ module DBus
       end
     end
 
-    # {DBus::Data::String}, {DBus::Data::ObjectPath}, or {DBus::Data::Signature}.
-    class StringLike < Basic
-      def self.fixed?
-        false
-      end
-
-      def initialize(value)
-        if value.is_a?(self.class)
-          value = value.value
-        else
-          self.class.validate_raw!(value)
-        end
-
-        super(value)
-      end
-    end
-
-    # Contains one or more other values.
-    class Container < Base
-      def self.basic?
-        false
-      end
-
-      def self.fixed?
-        false
-      end
-    end
-
     # Format strings for String#unpack, both little- and big-endian.
     Format = ::Struct.new(:little, :big)
 
     # Represents integers
     class Int < Fixed
+      # @!method self.range
+      # @return [Range] the full range of allowed values
+
       # @param value [::Integer,DBus::Data::Int]
       # @raise RangeError
       def initialize(value)
@@ -174,10 +163,6 @@ module DBus
 
         super(value)
       end
-
-      def self.range
-        raise NotImplementedError, "Abstract"
-      end
     end
 
     # Byte.
@@ -399,6 +384,23 @@ module DBus
       end
     end
 
+    # {DBus::Data::String}, {DBus::Data::ObjectPath}, or {DBus::Data::Signature}.
+    class StringLike < Basic
+      def self.fixed?
+        false
+      end
+
+      def initialize(value)
+        if value.is_a?(self.class)
+          value = value.value
+        else
+          self.class.validate_raw!(value)
+        end
+
+        super(value)
+      end
+    end
+
     # UTF-8 encoded string.
     class String < StringLike
       def self.type_code
@@ -495,6 +497,21 @@ module DBus
       end
     end
 
+    # Contains one or more other values.
+    class Container < Base
+      def self.basic?
+        false
+      end
+
+      def self.fixed?
+        false
+      end
+
+      # For containers, the type varies among instances
+      # @see Base#type
+      attr_reader :type
+    end
+
     # An Array, or a Dictionary (Hash).
     class Array < Container
       def self.type_code
@@ -505,44 +522,32 @@ module DBus
         4
       end
 
-      # @return [Type]
-      attr_reader :member_type
-
-      def type
-        return @type if @type
-
-        # TODO: reconstructing the type is cumbersome; have #initialize take *type* instead?
-        # TODO: or rather add Type::Array[t]
-        @type = Type.new("a")
-        @type << member_type
-        @type
-      end
-
       # TODO: check that Hash keys are basic types
       # @param mode [:plain,:exact]
-      # @param member_type [Type]
+      # @param type [Type]
       # @param hash [Boolean] are we unmarshalling an ARRAY of DICT_ENTRY
       # @return [Data::Array]
-      def self.from_items(value, mode:, member_type:, hash: false)
+      def self.from_items(value, mode:, type:, hash: false)
         value = Hash[value] if hash
         return value if mode == :plain
 
-        new(value, member_type: member_type)
+        new(value, type: type)
       end
 
       # @param value [::Object]
-      # @param member_types [::Array<Type>]
+      # @param type [Type]
       # @return [Data::Array]
-      def self.from_typed(value, member_types:)
+      def self.from_typed(value, type:)
+        assert_type_matches_class(type)
         # TODO: validation
-        member_type = member_types.first
+        member_type = type.child
 
         # TODO: Dict??
         items = value.map do |i|
           Data.make_typed(member_type, i)
         end
 
-        new(items) # initialize(::Array<Data::Base>)
+        new(items, type: type) # initialize(::Array<Data::Base>)
       end
 
       # FIXME: should Data::Array be mutable?
@@ -551,12 +556,12 @@ module DBus
       # TODO: specify type or guess type?
       # Data is the exact type, so its constructor should be exact
       # and guesswork should be clearly labeled
-      # @param member_type [SingleCompleteType,Type]
-      def initialize(value, member_type:)
-        member_type = DBus.type(member_type) unless member_type.is_a?(Type)
+      # @param type [SingleCompleteType,Type]
+      def initialize(value, type:)
+        type = DBus.type(type) unless type.is_a?(Type)
+        self.class.assert_type_matches_class(type)
+        @type = type
         # TODO: copy from another Data::Array
-        @member_type = member_type
-        @type = nil
         super(value)
       end
     end
@@ -573,48 +578,32 @@ module DBus
         8
       end
 
-      # @return [::Array<Type>]
-      attr_reader :member_types
-
-      def type
-        return @type if @type
-
-        # TODO: reconstructing the type is cumbersome; have #initialize take *type* instead?
-        # TODO: or rather add Type::Struct[t1, t2, ...]
-        @type = Type.new(self.class.type_code, abstract: true)
-        @member_types.each do |member_type|
-          @type << member_type
-        end
-        @type
-      end
-
       # @param value [::Array]
-      def self.from_items(value, mode:, member_types:)
+      def self.from_items(value, mode:, type:)
         value.freeze
         return value if mode == :plain
 
-        new(value, member_types: member_types)
+        new(value, type: type)
       end
 
       # @param value [::Object] (#size, #each)
-      # @param member_types [::Array<Type>]
+      # @param type [Type]
       # @return [Struct]
-      def self.from_typed(value, member_types:)
+      def self.from_typed(value, type:)
         # TODO: validation
+        member_types = type.members
         raise unless value.size == member_types.size
 
-        @member_types = member_types
-
         items = member_types.zip(value).map do |item_type, item|
           Data.make_typed(item_type, item)
         end
 
-        new(items, member_types: member_types) # initialize(::Array<Data::Base>)
+        new(items, type: type) # initialize(::Array<Data::Base>)
       end
 
-      def initialize(value, member_types:)
-        @member_types = member_types
-        @type = nil
+      def initialize(value, type:)
+        self.class.assert_type_matches_class(type)
+        @type = type
         super(value)
       end
     end
@@ -637,20 +626,26 @@ module DBus
       end
 
       # @param value [::Object]
-      # @param member_types [::Array<Type>]
+      # @param type [Type]
       # @return [Variant]
-      def self.from_typed(value, member_types:) # rubocop:disable Lint/UnusedMethodArgument
-        # assert member_types.empty?
+      def self.from_typed(value, type:)
+        assert_type_matches_class(type)
 
         # decide on type of value
-        new(value)
+        new(value, member_type: nil)
       end
 
-      # Note that for Variants type=="v",
+      # @return [Type]
+      def self.type
+        # memoize
+        @type ||= Type.new(type_code).freeze
+      end
+
+      # Note that for Variants type.to_s=="v",
       # for the specific see {Variant#member_type}
       # @return [Type] the exact type of this value
       def type
-        "v"
+        self.class.type
       end
 
       # @return [Type]
@@ -687,30 +682,34 @@ module DBus
         8
       end
 
-      # @return [::Array<Type>]
-      attr_reader :member_types
-
-      def type
-        return @type if @type
-
-        # TODO: reconstructing the type is cumbersome; have #initialize take *type* instead?
-        @type = Type.new(self.class.type_code, abstract: true)
-        @member_types.each do |member_type|
-          @type << member_type
-        end
-        @type
-      end
-
       # @param value [::Array]
-      def self.from_items(value, mode:, member_types:) # rubocop:disable Lint/UnusedMethodArgument
+      def self.from_items(value, mode:, type:) # rubocop:disable Lint/UnusedMethodArgument
         value.freeze
         # DictEntry ignores the :exact mode
         value
       end
 
-      def initialize(value, member_types:)
-        @member_types = member_types
-        @type = nil
+      # @param value [::Object] (#size, #each)
+      # @param type [Type]
+      # @return [DictEntry]
+      def self.from_typed(value, type:)
+        assert_type_matches_class(type)
+        member_types = type.members
+        # assert member_types.size == 2
+        # TODO: duplicated from Struct. Inherit/delegate?
+        # TODO: validation
+        raise unless value.size == member_types.size
+
+        items = member_types.zip(value).map do |item_type, item|
+          Data.make_typed(item_type, item)
+        end
+
+        new(items, type: type) # initialize(::Array<Data::Base>)
+      end
+
+      def initialize(value, type:)
+        self.class.assert_type_matches_class(type)
+        @type = type
         super(value)
       end
     end

data/lib/dbus/marshall.rb

@@ -102,6 +102,8 @@ module DBus
         packet = data_class.from_raw(value, mode: mode)
       elsif data_class.basic?
         size = aligned_read_value(data_class.size_class)
+        # @raw_msg.align(data_class.alignment)
+        # ^ is not necessary because we've just read a suitably-aligned *size*
         value = @raw_msg.read(size)
         nul = @raw_msg.read(1)
         if nul != "\u0000"
@@ -116,7 +118,7 @@ module DBus
           values = signature.members.map do |child_sig|
             do_parse(child_sig, mode: mode)
           end
-          packet = data_class.from_items(values, mode: mode, member_types: signature.members)
+          packet = data_class.from_items(values, mode: mode, type: signature)
 
         when Type::VARIANT
           data_sig = do_parse(Data::Signature.type, mode: :exact) # -> Data::Signature
@@ -145,7 +147,7 @@ module DBus
             items << item
           end
           is_hash = signature.child.sigtype == Type::DICT_ENTRY
-          packet = data_class.from_items(items, mode: mode, member_type: signature.child, hash: is_hash)
+          packet = data_class.from_items(items, mode: mode, type: signature, hash: is_hash)
         end
       end
       packet
@@ -248,9 +250,10 @@ module DBus
         when Type::VARIANT
           append_variant(val)
         when Type::ARRAY
+          val = val.value if val.is_a?(Data::Array)
           append_array(type.child, val)
         when Type::STRUCT, Type::DICT_ENTRY
-          val = val.value if val.is_a?(Data::Struct)
+          val = val.value if val.is_a?(Data::Struct) || val.is_a?(Data::DictEntry)
           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, seen #{val.class}"
@@ -279,8 +282,11 @@ module DBus
 
     def append_variant(val)
       vartype = nil
-      if val.is_a?(DBus::Data::Base)
-        vartype = val.type # FIXME: box or unbox another variant?
+      if val.is_a?(DBus::Data::Variant)
+        vartype = val.member_type
+        vardata = val.value
+      elsif val.is_a?(DBus::Data::Base)
+        vartype = val.type
         vardata = val.value
       elsif val.is_a?(Array) && val.size == 2
         case val[0]
@@ -351,15 +357,23 @@ module DBus
       elsif value.is_a? Hash
         h = {}
         value.each_key { |k| h[k] = make_variant(value[k]) }
-        ["a{sv}", h]
+        key_type = if value.empty?
+                     "s"
+                   else
+                     t, = make_variant(value.first.first)
+                     t
+                   end
+        ["a{#{key_type}v}", h]
       elsif value.respond_to? :to_str
         ["s", value.to_str]
       elsif value.respond_to? :to_int
         i = value.to_int
-        if (-2_147_483_648...2_147_483_648).cover?(i)
+        if Data::Int32.range.cover?(i)
           ["i", i]
-        else
+        elsif Data::Int64.range.cover?(i)
           ["x", i]
+        else
+          ["t", i]
         end
       end
     end

data/lib/dbus/type.rb

@@ -29,14 +29,12 @@ module DBus
   # For documentation purposes only.
   class Prototype < String; end
 
-  # = D-Bus type module
-  #
-  # This module containts the constants of the types specified in the D-Bus
-  # protocol.
+  # Represents the D-Bus types.
   #
   # Corresponds to {SingleCompleteType}.
+  # Instances are immutable/frozen once fully constructed.
   #
-  # See also {DBus::Data::Signature}
+  # See also {DBus::Data::Signature} which is "type on the wire".
   class Type
     # Mapping from type number to name and alignment.
     TYPE_MAPPING = {
@@ -104,8 +102,9 @@ module DBus
         end
       end
 
-      @sigtype = sigtype
-      @members = []
+      @sigtype = sigtype.freeze
+      @members = [] # not frozen yet, Parser#parse_one or Factory will do it
+      freeze
     end
 
     # Return the required alignment for the type.
@@ -124,16 +123,15 @@ module DBus
       when DICT_ENTRY
         "{#{@members.collect(&:to_s).join}}"
       else
-        if !TYPE_MAPPING.keys.member?(@sigtype)
-          raise NotImplementedError
-        end
-
         @sigtype.chr
       end
     end
 
     # Add a new member type _item_.
+    # @param item [Type]
     def <<(item)
+      raise ArgumentError unless item.is_a?(Type)
+
       if ![STRUCT, ARRAY, DICT_ENTRY].member?(@sigtype)
         raise SignatureException
       end
@@ -232,6 +230,7 @@ module DBus
         else
           res = Type.new(char)
         end
+        res.members.freeze
         res
       end
 
@@ -243,7 +242,7 @@ module DBus
         while (c = nextchar)
           ret << parse_one(c)
         end
-        ret
+        ret.freeze
       end
 
       # Parse one {SingleCompleteType}
@@ -255,9 +254,116 @@ module DBus
         t = parse_one(c)
         raise SignatureException, "Has more than a Single Complete Type: #{@signature}" unless nextchar.nil?
 
+        t.freeze
+      end
+    end
+
+    class Factory
+      # @param type [Type,SingleCompleteType,Class]
+      # @see from_plain_class
+      # @return [Type] (frozen)
+      def self.make_type(type)
+        case type
+        when Type
+          type
+        when String
+          DBus.type(type)
+        when Class
+          from_plain_class(type)
+        else
+          msg = "Expecting DBus::Type, DBus::SingleCompleteType(aka ::String), or Class, got #{type.inspect}"
+          raise ArgumentError, msg
+        end
+      end
+
+      # Make a {Type} corresponding to some plain classes:
+      # - String
+      # - Float
+      # - DBus::ObjectPath
+      # - DBus::Signature, DBus::SingleCompleteType
+      # @param klass [Class]
+      # @return [Type] (frozen)
+      def self.from_plain_class(klass)
+        @signature_type ||= DBus.type(SIGNATURE)
+        @class_to_type ||= {
+          DBus::ObjectPath => DBus.type(OBJECT_PATH),
+          DBus::Signature => @signature_type,
+          DBus::SingleCompleteType => @signature_type,
+          String => DBus.type(STRING),
+          Float => DBus.type(DOUBLE)
+        }
+        t = @class_to_type[klass]
+        raise ArgumentError, "Cannot convert plain class #{klass} to a D-Bus type" if t.nil?
+
+        t
+      end
+    end
+
+    # Syntactic helper for constructing an array Type.
+    # You may be looking for {Data::Array} instead.
+    # @example
+    #   t = Type::Array[Type::INT16]
+    class ArrayFactory < Factory
+      # @param member_type [Type,SingleCompleteType]
+      # @return [Type] (frozen)
+      def self.[](member_type)
+        t = Type.new(ARRAY)
+        t << make_type(member_type)
+        t.members.freeze
+        t
+      end
+    end
+
+    # @example
+    #   t = Type::Array[Type::INT16]
+    Array = ArrayFactory
+
+    # Syntactic helper for constructing a hash Type.
+    # You may be looking for {Data::Array} and {Data::DictEntry} instead.
+    # @example
+    #   t = Type::Hash[Type::STRING, Type::VARIANT]
+    class HashFactory < Factory
+      # @param key_type [Type,SingleCompleteType]
+      # @param value_type [Type,SingleCompleteType]
+      # @return [Type] (frozen)
+      def self.[](key_type, value_type)
+        t = Type.new(ARRAY)
+        de = Type.new(DICT_ENTRY, abstract: true)
+        de << make_type(key_type)
+        de << make_type(value_type)
+        de.members.freeze
+        t << de
+        t.members.freeze
         t
       end
     end
+
+    # @example
+    #   t = Type::Hash[Type::INT16]
+    Hash = HashFactory
+
+    # Syntactic helper for constructing a struct Type.
+    # You may be looking for {Data::Struct} instead.
+    # @example
+    #   t = Type::Struct[Type::INT16, Type::STRING]
+    class StructFactory < Factory
+      # @param member_types [::Array<Type,SingleCompleteType>]
+      # @return [Type] (frozen)
+      def self.[](*member_types)
+        raise ArgumentError if member_types.empty?
+
+        t = Type.new(STRUCT, abstract: true)
+        member_types.each do |mt|
+          t << make_type(mt)
+        end
+        t.members.freeze
+        t
+      end
+    end
+
+    # @example
+    #   t = Type::Struct[Type::INT16, Type::STRING]
+    Struct = StructFactory
   end
 
   # shortcuts
@@ -266,7 +372,7 @@ module DBus
   # This is prefered to {Type#initialize} which allows
   # incomplete or invalid types.
   # @param string_type [SingleCompleteType]
-  # @return [DBus::Type]
+  # @return [DBus::Type] (frozen)
   # @raise SignatureException
   def type(string_type)
     Type::Parser.new(string_type).parse1
@@ -275,7 +381,7 @@ module DBus
 
   # Parse a String to zero or more {DBus::Type}s.
   # @param string_type [Signature]
-  # @return [Array<DBus::Type>]
+  # @return [Array<DBus::Type>] (frozen)
   # @raise SignatureException
   def types(string_type)
     Type::Parser.new(string_type).parse

data/spec/data/marshall.yaml

@@ -1534,6 +1534,34 @@
   - [0xDE, 0xAD, 0xBE, 0xEF]
   exc: DBus::InvalidPacketException
   msg: ''
+- sig: a{oq}
+  end: little
+  buf:
+  # body size
+  - [0, 0, 0, 0]
+  # padding
+  - [0, 0, 0, 0]
+  val: {}
+- sig: a{oq}
+  end: little
+  buf:
+  # body size
+  - [26, 0, 0, 0]
+  # dict_entry padding
+  - [0, 0, 0, 0]
+  # key, padding, value
+  - [2, 0, 0, 0, "/7", 0]
+  - 0
+  - [7, 0]
+  # dict_entry padding
+  - [0, 0, 0, 0, 0, 0]
+  # key, padding, value
+  - [2, 0, 0, 0, "/9", 0]
+  - 0
+  - [9, 0]
+  val:
+    /7: 7
+    /9: 9
 - sig: "(qq)"
   end: little
   buf:

data/spec/data_spec.rb

@@ -85,6 +85,8 @@ end
 # TODO: Look at conversions? to_str, to_int?
 
 describe DBus::Data do
+  T = DBus::Type unless const_defined? "T"
+
   # test initialization, from user code, or from packet (from_raw)
   # remember to unpack if initializing from Data::Base
   # #value should recurse inside so that the user doesnt have to
@@ -183,6 +185,14 @@ describe DBus::Data do
 
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
+
+      describe ".alignment" do
+        # this overly specific test avoids a redundant alignment call
+        # in the production code
+        it "returns the correct value" do
+          expect(described_class.alignment).to eq 4
+        end
+      end
     end
 
     describe DBus::Data::ObjectPath do
@@ -198,6 +208,14 @@ describe DBus::Data do
 
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
+
+      describe ".alignment" do
+        # this overly specific test avoids a redundant alignment call
+        # in the production code
+        it "returns the correct value" do
+          expect(described_class.alignment).to eq 4
+        end
+      end
     end
 
     describe DBus::Data::Signature do
@@ -215,35 +233,50 @@ describe DBus::Data do
 
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
+
+      describe ".alignment" do
+        # this overly specific test avoids a redundant alignment call
+        # in the production code
+        it "returns the correct value" do
+          expect(described_class.alignment).to eq 1
+        end
+      end
     end
   end
 
   describe "containers" do
     describe DBus::Data::Array do
       good = [
-        # [[1, 2, 3], member_type: nil],
-        [[1, 2, 3], { member_type: "q" }],
-        [[1, 2, 3], { member_type: DBus::Type::UINT16 }],
-        [[1, 2, 3], { member_type: DBus.type("q") }],
-        [[DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)], { member_type: "q" }]
+        # [[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"] }],
+        [[DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)], { type: T::Array["q"] }]
         # TODO: others
       ]
 
       bad = [
         # undesirable type guessing
-        ## [[1, 2, 3], { member_type: nil }, DBus::InvalidPacketException, "Unknown type code"],
-        ## [[1, 2, 3], { member_type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
+        ## [[1, 2, 3], { type: nil }, DBus::InvalidPacketException, "Unknown type code"],
+        ## [[1, 2, 3], { type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
         # TODO: others
       ]
 
       include_examples "constructor (kwargs) accepts values", good
       include_examples "constructor (kwargs) rejects values", bad
+
+      describe ".from_typed" do
+        it "creates new instance from given object and type" do
+          type = T::Array[String]
+          expect(described_class.from_typed(["test", "lest"], type: type)).to be_a(described_class)
+        end
+      end
     end
 
     describe DBus::Data::Struct do
       three_words = ::Struct.new(:a, :b, :c)
 
-      qqq = ["q", "q", "q"]
+      qqq = T::Struct[T::UINT16, T::UINT16, T::UINT16]
       integers = [1, 2, 3]
       uints = [DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)]
 
@@ -260,36 +293,50 @@ describe DBus::Data do
       # TODO: also check data ownership: reasonable to own the data?
       # can make it explicit?
       good = [
-        # from plain array; various m_t styles
-        [integers, { member_types: ["q", "q", "q"] }],
-        [integers, { member_types: [DBus::Type::UINT16, DBus::Type::UINT16, DBus::Type::UINT16] }],
-        [integers, { member_types: DBus.types("qqq") }],
+        # from plain array; various *type* styles
+        [integers, { type: DBus.type("(qqq)") }],
+        [integers, { type: T::Struct["q", "q", "q"] }],
+        [integers, { type: T::Struct[T::UINT16, T::UINT16, T::UINT16] }],
+        [integers, { type: T::Struct[*DBus.types("qqq")] }],
         # plain array of data
-        [uints, { member_types: DBus.types("qqq") }],
+        [uints, { type: qqq }],
         # ::Struct
-        [three_words.new(*integers), { member_types: qqq }],
-        [three_words.new(*uints), { member_types: qqq }]
+        [three_words.new(*integers), { type: qqq }],
+        [three_words.new(*uints), { type: qqq }]
         # TODO: others
       ]
 
+      # check these only when canonicalizing @value, because that will
+      # type-check the value deeply
       _bad_but_valid = [
-        # Wrong member_types arg:
-        # hmm this is another reason to pass the type
-        # as the entire struct type, not the members:
-        # empty struct will be caught naturally
-        [integers, { member_types: [] }, ArgumentError, "???"],
-        [integers, { member_types: ["!"] }, DBus::InvalidPacketException, "Unknown type code"],
         # STRUCT specific: member count mismatch
-        [[1, 2], { member_types: DBus.types("qqq") }, ArgumentError, "???"],
-        [[1, 2, 3, 4], { member_types: DBus.types("qqq") }, ArgumentError, "???"]
+        [[1, 2], { type: qqq }, ArgumentError, "???"],
+        [[1, 2, 3, 4], { type: qqq }, ArgumentError, "???"]
         # TODO: others
       ]
 
       include_examples "constructor (kwargs) accepts values", good
       # include_examples "constructor (kwargs) rejects values", bad
+
+      describe ".from_typed" do
+        it "creates new instance from given object and type" do
+          type = T::Struct[T::STRING, T::STRING]
+          expect(described_class.from_typed(["test", "lest"].freeze, type: type))
+            .to be_a(described_class)
+        end
+      end
     end
 
     describe DBus::Data::Variant do
+      describe ".from_typed" do
+        it "creates new instance from given object and type" do
+          type = DBus.type(T::VARIANT)
+          value = described_class.from_typed("test", type: type)
+          expect(value).to be_a(described_class)
+          expect(value.type.to_s).to eq "v"
+          expect(value.member_type.to_s).to eq "s"
+        end
+      end
     end
 
     describe DBus::Data::DictEntry do

data/spec/packet_marshaller_spec.rb

@@ -29,6 +29,13 @@ describe DBus::PacketMarshaller do
         subject.append(signature, t.val)
         expect(subject.packet).to eq(expected)
       end
+
+      it "writes a '#{signature}' with typed value #{t.val.inspect} (#{endianness})" do
+        subject = described_class.new(endianness: endianness)
+        typed_val = DBus::Data.make_typed(signature, t.val)
+        subject.append(signature, typed_val)
+        expect(subject.packet).to eq(expected)
+      end
     end
   end
 end

data/spec/property_spec.rb

@@ -4,6 +4,14 @@
 require_relative "spec_helper"
 require "dbus"
 
+# FIXME: factor out DBus::TestFixtures::Value in spec_helper
+require "ostruct"
+require "yaml"
+
+data_dir = File.expand_path("data", __dir__)
+marshall_yaml_s = File.read("#{data_dir}/marshall.yaml")
+marshall_yaml = YAML.safe_load(marshall_yaml_s)
+
 describe "PropertyTest" do
   before(:each) do
     @session_bus = DBus::ASessionBus.new
@@ -52,7 +60,7 @@ describe "PropertyTest" do
 
   it "tests get all" do
     all = @iface.all_properties
-    expect(all.keys.sort).to eq(["MyStruct", "ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests get all on a V1 object" do
@@ -60,7 +68,7 @@ describe "PropertyTest" do
     iface = obj["org.ruby.SampleInterface"]
 
     all = iface.all_properties
-    expect(all.keys.sort).to eq(["MyStruct", "ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests unknown property reading" do
@@ -147,4 +155,67 @@ describe "PropertyTest" do
       expect(reply).to match(/variant\s+struct {\s+string "three"\s+string "strings"\s+string "in a struct"\s+}/)
     end
   end
+
+  context "an array-typed property" do
+    it "gets read as an array" do
+      val = @iface["MyArray"]
+      expect(val).to eq([42, 43])
+    end
+  end
+
+  context "a dict-typed property" do
+    it "gets read as a hash" do
+      val = @iface["MyDict"]
+      expect(val).to eq({
+                          "one" => 1,
+                          "two" => "dva",
+                          "three" => [3, 3, 3]
+                        })
+    end
+
+    it "Get returns the correctly typed value (check with dbus-send)" do
+      cmd = "dbus-send --print-reply " \
+            "--dest=org.ruby.service " \
+            "/org/ruby/MyInstance " \
+            "org.freedesktop.DBus.Properties.Get " \
+            "string:org.ruby.SampleInterface " \
+            "string:MyDict"
+      reply = `#{cmd}`
+      # a bug about variant nesting lead to a "variant variant int32 1" value
+      match_rx = /variant \s+ array \s \[ \s+
+         dict \s entry\( \s+
+            string \s "one" \s+
+            variant \s+ int32 \s 1 \s+
+         \)/x
+      expect(reply).to match(match_rx)
+    end
+  end
+
+  context "a variant-typed property" do
+    it "gets read at all" do
+      obj = @svc.object("/org/ruby/MyDerivedInstance")
+      iface = obj["org.ruby.SampleInterface"]
+      val = iface["MyVariant"]
+      expect(val).to eq([42, 43])
+    end
+  end
+
+  context "marshall.yaml round-trip via a VARIANT property" do
+    marshall_yaml.each do |test|
+      t = OpenStruct.new(test)
+      next if t.val.nil?
+
+      # Round trips do not work yet because the properties
+      # must present a plain Ruby value so the exact D-Bus type is lost.
+      # Round trips will work once users can declare accepting DBus::Data
+      # in properties and method arguments.
+      it "Sets #{t.sig.inspect}:#{t.val.inspect} and Gets something back" do
+        before = DBus::Data.make_typed(t.sig, t.val)
+        expect { @iface["MyVariant"] = before }.to_not raise_error
+        expect { _after = @iface["MyVariant"] }.to_not raise_error
+        # round-trip:
+        # expect(after).to eq(before.value)
+      end
+    end
+  end
 end

data/spec/service_newapi.rb

@@ -13,16 +13,30 @@ PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
 class Test < DBus::Object
   Point2D = Struct.new(:x, :y)
 
+  attr_writer :main_loop
+
   INTERFACE = "org.ruby.SampleInterface"
   def initialize(path)
     super path
     @read_me = "READ ME"
     @read_or_write_me = "READ OR WRITE ME"
     @my_struct = ["three", "strings", "in a struct"].freeze
+    @my_array = [42, 43]
+    @my_dict = {
+      "one" => 1,
+      "two" => "dva",
+      "three" => [3, 3, 3]
+    }
+    @my_variant = @my_array.dup
+    @main_loop = nil
   end
 
   # Create an interface aggregating all upcoming dbus_method defines.
   dbus_interface INTERFACE do
+    dbus_method :quit, "" do
+      @main_loop&.quit
+    end
+
     dbus_method :hello, "in name:s, in name2:s" do |name, name2|
       puts "hello(#{name}, #{name2})"
     end
@@ -93,7 +107,10 @@ class Test < DBus::Object
     end
     dbus_reader :explosive, "s"
 
-    dbus_attr_reader :my_struct, "(sss)"
+    dbus_attr_accessor :my_struct, "(sss)"
+    dbus_attr_accessor :my_array, "aq"
+    dbus_attr_accessor :my_dict, "a{sv}"
+    dbus_attr_accessor :my_variant, "v"
   end
 
   # closing and reopening the same interface
@@ -193,6 +210,7 @@ end
 puts "listening, with ruby-#{RUBY_VERSION}"
 main = DBus::Main.new
 main << bus
+myobj.main_loop = main
 begin
   main.run
 rescue SystemCallError

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@ if coverage
   SimpleCov.add_filter "_spec.rb"
   # do not cover the activesupport helpers
   SimpleCov.add_filter "/core_ext/"
+  # measure all if/else branches on a line
+  SimpleCov.enable_coverage :branch
 
   SimpleCov.start
 

data/spec/type_spec.rb

@@ -45,6 +45,7 @@ describe DBus do
       ["a{vs}", "DICT_ENTRY key must be basic (non-container)"],
       ["{sv}", "DICT_ENTRY not an immediate child of an ARRAY"],
       ["a({sv})", "DICT_ENTRY not an immediate child of an ARRAY"],
+      ["a{s", "DICT_ENTRY not closed"],
       ["a{sv", "DICT_ENTRY not closed"],
       ["}", "DICT_ENTRY unexpectedly closed"],
 
@@ -79,4 +80,108 @@ describe DBus do
       end
     end
   end
+
+  describe DBus::Type do
+    describe "#<<" do
+      it "raises if the argument is not a Type" do
+        t = DBus::Type.new(DBus::Type::ARRAY)
+        expect { t << "s" }.to raise_error(ArgumentError)
+      end
+
+      # TODO: the following raise checks do not occur in practice, as there are
+      # parallel checks in the parses. The code could be simplified?
+      it "raises if adding too much to an array" do
+        t = DBus::Type.new(DBus::Type::ARRAY)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        t << b
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+
+      it "raises if adding too much to a dict_entry" do
+        t = DBus::Type.new(DBus::Type::DICT_ENTRY, abstract: true)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        t << b
+        t << b
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+
+      it "raises if adding to a non-container" do
+        t = DBus::Type.new(DBus::Type::STRING)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+
+        t = DBus::Type.new(DBus::Type::VARIANT)
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+    end
+
+    describe DBus::Type::Array do
+      describe ".[]" do
+        it "takes Type argument" do
+          t = DBus::Type::Array[DBus::Type.new("s")]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "takes 's':String argument" do
+          t = DBus::Type::Array["s"]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Array[String]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "rejects Integer:Class argument" do
+          expect { DBus::Type::Array[Integer] }.to raise_error(ArgumentError)
+        end
+
+        it "rejects /./:Regexp argument" do
+          expect { DBus::Type::Array[/./] }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe DBus::Type::Hash do
+      describe ".[]" do
+        it "takes Type arguments" do
+          t = DBus::Type::Hash[DBus::Type.new("s"), DBus::Type.new("v")]
+          expect(t.to_s).to eq "a{sv}"
+        end
+
+        it "takes 's':String arguments" do
+          t = DBus::Type::Hash["s", "v"]
+          expect(t.to_s).to eq "a{sv}"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Hash[String, DBus::Type::VARIANT]
+          expect(t.to_s).to eq "a{sv}"
+        end
+      end
+    end
+
+    describe DBus::Type::Struct do
+      describe ".[]" do
+        it "takes Type arguments" do
+          t = DBus::Type::Struct[DBus::Type.new("s"), DBus::Type.new("v")]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "takes 's':String arguments" do
+          t = DBus::Type::Struct["s", "v"]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Struct[String, DBus::Type::VARIANT]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "raises on no arguments" do
+          expect { DBus::Type::Struct[] }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
 end

data/spec/zzz_quit_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe "Quit the service" do
+  it "Tells the service to quit and waits, to collate coverage data" do
+    session_bus = DBus::ASessionBus.new
+    @svc = session_bus.service("org.ruby.service")
+    @obj = @svc.object("/org/ruby/MyInstance")
+    @obj.default_iface = "org.ruby.SampleInterface"
+    @obj.quit
+    sleep 3
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dbus
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta2
+  version: 0.18.0.beta5
 platform: ruby
 authors:
 - Ruby DBus Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-04 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -197,6 +197,7 @@ files:
 - spec/type_spec.rb
 - spec/value_spec.rb
 - spec/variant_spec.rb
+- spec/zzz_quit_spec.rb
 homepage: https://github.com/mvidner/ruby-dbus
 licenses:
 - LGPL-2.1