ruby-dbus 0.18.0.beta4 → 0.18.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6e093b55c88614ceebd2cfd0c09a5bba3886b8c561b8e153c034d9249ae5a08
-  data.tar.gz: a2b2931d1b3b9ae560cc6204e297a7daceec2ec85a065a2782cbbeed34286f5d
+  metadata.gz: f8b0c43d3f27f0877e52c0adfb8014374829f97bcd38be6b9fabda1d5da8413c
+  data.tar.gz: 000eadf163b0fab2ef4ab39de81a79714b34392cd81b3be68e12587ddfa93372
 SHA512:
-  metadata.gz: 66e7ad826a0f1ef5bb1abba72a6f76f02fbd4c13c7e7f14caf3abd71946ba4e5a0b9cc16950d60a22eb2d994d73c78306d270296af90f2bf9aa2aaaf4f85dab3
-  data.tar.gz: 4641ca7b18414d7cf58d786ab05d3d3bc3a50d40311b1b5650b6f44a1bfcf0b1cca373eee4445b5cd6e0eb70a42407b244d93c09371d9ea985a66d6d4c79c0d7
+  metadata.gz: c2206dcd935fed4e3711b88b2c0c265e5a335700f9137d2c3972f419791d9c25198d0acf9ba7aaecdbc6a25e540005c64321e5165c6c644838fb3557355861ac
+  data.tar.gz: 212cb8bdcd75e3f35622843f262cdb80eaa07c1919a7d17ffdf601e05c627556343b7855a014f60a220c8a757c201431d66799a6025a98d084aef6cc12f7d8bb

data/NEWS.md

@@ -2,6 +2,23 @@
 
 ## 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:

data/VERSION

@@ -1 +1 @@
-0.18.0.beta4
+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,34 +146,6 @@ 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)
 
@@ -398,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
@@ -494,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
@@ -504,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, member_type: member_type) # initialize(::Array<Data::Base>)
+        new(items, type: type) # initialize(::Array<Data::Base>)
       end
 
       # FIXME: should Data::Array be mutable?
@@ -550,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
@@ -572,46 +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
 
         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
@@ -634,10 +626,10 @@ 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, member_type: nil)
@@ -690,31 +682,19 @@ 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
 
       # @param value [::Object] (#size, #each)
-      # @param member_types [::Array<Type>]
+      # @param type [Type]
       # @return [DictEntry]
-      def self.from_typed(value, member_types:)
+      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
@@ -724,12 +704,12 @@ module DBus
           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

data/lib/dbus/marshall.rb

@@ -118,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
@@ -147,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
@@ -282,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]

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_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
@@ -245,18 +247,18 @@ describe DBus::Data do
   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
       ]
 
@@ -265,8 +267,8 @@ describe DBus::Data do
 
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed(["test", "lest"], member_types: [type])).to be_a(described_class)
+          type = T::Array[String]
+          expect(described_class.from_typed(["test", "lest"], type: type)).to be_a(described_class)
         end
       end
     end
@@ -274,7 +276,7 @@ describe DBus::Data do
     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)]
 
@@ -291,28 +293,25 @@ 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
       ]
 
@@ -321,8 +320,8 @@ describe DBus::Data do
 
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed(["test", "lest"].freeze, member_types: [type, type]))
+          type = T::Struct[T::STRING, T::STRING]
+          expect(described_class.from_typed(["test", "lest"].freeze, type: type))
             .to be_a(described_class)
         end
       end
@@ -331,16 +330,9 @@ describe DBus::Data do
     describe DBus::Data::Variant do
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed("test", member_types: [type])).to be_a(described_class)
-        end
-
-        it "ignores the member_types argument" do
-          type = DBus::Type.new("s")
-          # Base.from_typed is a generic interface with a fixed signature;
-          # So it must offer the member_types parameter, which is misleading
-          # for a Variant
-          value = described_class.from_typed("test", member_types: [type])
+          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

data/spec/property_spec.rb

@@ -163,7 +163,7 @@ describe "PropertyTest" do
     end
   end
 
-  context "an dict-typed property" do
+  context "a dict-typed property" do
     it "gets read as a hash" do
       val = @iface["MyDict"]
       expect(val).to eq({
@@ -172,6 +172,23 @@ describe "PropertyTest" do
                           "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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dbus
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta4
+  version: 0.18.0.beta5
 platform: ruby
 authors:
 - Ruby DBus Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-21 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml