ruby-dbus 0.18.0.beta3 → 0.18.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aefe0e0b1ea07e4d659c568e496f0018e85ef0364d678169db736f967539175b
-  data.tar.gz: 44c64528e74823a45d318be92b6fc8838b988429c2f1205287682ee40b9a8f38
+  metadata.gz: 54a45385340217271e3fb445cddf6afcddb9892c4bf75b503e7859390f4d2ed7
+  data.tar.gz: 3c4f71745992c5afece87e34909e67f451717c9398ac6efb6235cc64ad1d1b0c
 SHA512:
-  metadata.gz: e6655ff88bcbda618eafc3ec62f74f4a2051a5f6327cd130fddd8a3aaff4b8e999fa2843edde8fd6de9cdb0df95fa6dfd56bf18c1e668ac92ffd1e131f58c9f6
-  data.tar.gz: 4c54cad54ea4833afff8290598c8717a30cb0b221b486378d06070e010b162e54a2dcaa08cb542b21f91cf7dd8ee215646c8461504b676e977b597e325a5b7ae
+  metadata.gz: 864aaaaa867ea04247515d875d836560a558b7a3d780712a41dcd52214d95e47e857d640d66a3573eaf4df778a0320f89ad2c59918c005a2fc80adb8a63074cb
+  data.tar.gz: cabd9d699d8b7aad7c5f77a83aa07389b59c11b34b1219822909a031774b078d0bf001a1bce9bb5912be42caa4adba7608906ebc76dde57ff9f06d13afd7850f

data/NEWS.md

@@ -2,6 +2,44 @@
 
 ## Unreleased
 
+## Ruby D-Bus 0.18.0.beta6 - 2022-05-25
+
+API:
+ * Data::Base#value returns plain Ruby types;
+   Data::Container#exact_value contains Data::Base ([#114][]).
+ * Data::Base#initialize and .from_typed allow plain or exact values, validate
+   argument types.
+ * Implement #== (converting) and #eql? (strict) for Data::Base and DBus::Type.
+
+[#114]: https://github.com/mvidner/ruby-dbus/pull/114
+
+## 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:

data/VERSION

@@ -1 +1 @@
-0.18.0.beta3
+0.18.0.beta6

data/lib/dbus/data.rb

@@ -35,7 +35,7 @@ module DBus
     # construct an appropriate {Data::Base} instance.
     #
     # @param type [SingleCompleteType,Type]
-    # @param value [::Object]
+    # @param value [::Object,Data::Base] a plain value; exact values also allowed
     # @return [Data::Base]
     # @raise TypeError
     def make_typed(type, value)
@@ -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
 
@@ -58,15 +58,28 @@ module DBus
       # @!method self.fixed?
       # @return [Boolean]
 
-      # @return appropriately-typed, valid value
+      # @return [::Object] a valid value, plain-Ruby typed.
+      # @see Data::Container#exact_value
       attr_reader :value
 
+      # @!method self.type_code
+      # @return [String] a single-character string, for example "a" for arrays
+
       # @!method type
       # @abstract
       # Note that for Variants type=="v",
       # 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
@@ -82,7 +95,19 @@ module DBus
 
       # Hash key equality
       # See https://ruby-doc.org/core-3.0.0/Object.html#method-i-eql-3F
-      alias eql? ==
+      # Stricter than #== (RSpec: eq), 1==1.0 but 1.eql(1.0)->false
+      def eql?(other)
+        return false unless other.class == self.class
+
+        other.value.eql?(@value)
+        # TODO: this should work, now check derived classes, exact_value
+      end
+
+      # @param type [Type]
+      def self.assert_type_matches_class(type)
+        raise ArgumentError, "Expecting #{type_code.inspect} for class #{self}, got #{type.sigtype.inspect}" \
+          unless type.sigtype == type_code
+      end
     end
 
     # A value that is not a {Container}.
@@ -103,10 +128,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 +157,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 +395,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
@@ -477,7 +491,7 @@ module DBus
         Byte
       end
 
-      # @return [Array<Type>]
+      # @return [::Array<Type>]
       def self.validate_raw!(value)
         DBus.types(value)
       rescue Type::SignatureException => e
@@ -494,6 +508,44 @@ 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
+
+      # @return something that is, or contains, {Data::Base}.
+      #   Er, this docs kinda sucks.
+      def exact_value
+        @value
+      end
+
+      def value
+        @value.map(&:value)
+      end
+
+      # Hash key equality
+      # See https://ruby-doc.org/core-3.0.0/Object.html#method-i-eql-3F
+      # Stricter than #== (RSpec: eq), 1==1.0 but 1.eql(1.0)->false
+      def eql?(other)
+        return false unless other.class == self.class
+
+        other.exact_value.eql?(exact_value)
+      end
+
+      # def ==(other)
+      #   eql?(other) || super
+      # end
+    end
+
     # An Array, or a Dictionary (Hash).
     class Array < Container
       def self.type_code
@@ -504,44 +556,33 @@ 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:)
-        # TODO: validation
-        member_type = member_types.first
+      def self.from_typed(value, type:)
+        new(value, type: type) # initialize(::Array<Data::Base>)
+      end
 
-        # TODO: Dict??
-        items = value.map do |i|
-          Data.make_typed(member_type, i)
+      def value
+        v = super
+        if type.child.sigtype == Type::DICT_ENTRY
+          # BTW this makes a copy so mutating it is pointless
+          v.to_h
+        else
+          v
         end
-
-        new(items, member_type: member_type) # initialize(::Array<Data::Base>)
       end
 
       # FIXME: should Data::Array be mutable?
@@ -550,13 +591,27 @@ 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)
-        # TODO: copy from another Data::Array
-        @member_type = member_type
-        @type = nil
-        super(value)
+
+      # @param value [Data::Array,Enumerable]
+      # @param type [SingleCompleteType,Type]
+      def initialize(value, type:)
+        type = Type::Factory.make_type(type)
+        self.class.assert_type_matches_class(type)
+        @type = type
+
+        typed_value = case value
+                      when Data::Array
+                        raise ArgumentError, "Specified type is #{type} but value type is #{value.type}" \
+                          unless value.type == type
+
+                        value.exact_value
+                      else
+                        # TODO: Dict??
+                        value.map do |i|
+                          Data.make_typed(type.child, i)
+                        end
+                      end
+        super(typed_value)
       end
     end
 
@@ -572,51 +627,84 @@ 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:)
-        # TODO: validation
-        raise unless value.size == member_types.size
+      def self.from_typed(value, type:)
+        new(value, type: type)
+      end
+
+      # @param value [Data::Struct,Enumerable]
+      # @param type [SingleCompleteType,Type]
+      def initialize(value, type:)
+        type = Type::Factory.make_type(type)
+        self.class.assert_type_matches_class(type)
+        @type = type
 
-        items = member_types.zip(value).map do |item_type, item|
-          Data.make_typed(item_type, item)
+        typed_value = case value
+                      when self.class
+                        raise ArgumentError, "Specified type is #{type} but value type is #{value.type}" \
+                          unless value.type == type
+
+                        value.exact_value
+                      else
+                        member_types = type.members
+                        unless value.size == member_types.size
+                          raise ArgumentError, "Specified type has #{member_types.size} members " \
+                                               "but value has #{value.size} members"
+                        end
+
+                        member_types.zip(value).map do |item_type, item|
+                          Data.make_typed(item_type, item)
+                        end
+                      end
+        super(typed_value)
+      end
+
+      def ==(other)
+        case other
+        when ::Struct
+          @value.size == other.size &&
+            @value.zip(other.to_a).all? { |i, other_i| i == other_i }
+        else
+          super
         end
+      end
+    end
 
-        new(items, member_types: member_types) # initialize(::Array<Data::Base>)
+    # Dictionary/Hash entry.
+    # TODO: shouldn't instantiate?
+    class DictEntry < Struct
+      def self.type_code
+        "e"
       end
 
-      def initialize(value, member_types:)
-        @member_types = member_types
-        @type = nil
-        super(value)
+      # @param value [::Array]
+      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 type [Type]
+      # @return [DictEntry]
+      def self.from_typed(value, type:)
+        new(value, type: type)
       end
     end
 
-    # A generic type
+    # A generic type.
+    #
+    # Implementation note: @value is a {Data::Base}.
     class Variant < Container
       def self.type_code
         "v"
@@ -626,6 +714,10 @@ module DBus
         1
       end
 
+      def value
+        @value.value
+      end
+
       # @param member_type [Type]
       def self.from_items(value, mode:, member_type:)
         return value if mode == :plain
@@ -634,12 +726,12 @@ 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
+        # nil: decide on type of value
         new(value, member_type: nil)
       end
 
@@ -667,73 +759,24 @@ module DBus
       # @param member_type [Type,nil]
       def initialize(value, member_type:)
         # TODO: validate that the given *member_type* matches *value*
-        if value.is_a?(self.class)
+        case value
+        when Data::Variant
           # Copy the contained value instead of boxing it more
           # TODO: except perhaps for round-tripping in exact mode?
           @member_type = value.member_type
-          value = value.value
+          value = value.exact_value
+        when Data::Base
+          @member_type = member_type || value.type
+          raise ArgumentError, "Variant type #{@member_type} does not match value type #{value.type}" \
+            unless @member_type == value.type
         else
           @member_type = member_type || self.class.guess_type(value)
+          value = Data.make_typed(@member_type, value)
         end
         super(value)
       end
     end
 
-    # Dictionary/Hash entry.
-    # TODO: shouldn't instantiate?
-    class DictEntry < Container
-      def self.type_code
-        "e"
-      end
-
-      def self.alignment
-        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
-        value.freeze
-        # DictEntry ignores the :exact mode
-        value
-      end
-
-      # @param value [::Object] (#size, #each)
-      # @param member_types [::Array<Type>]
-      # @return [DictEntry]
-      def self.from_typed(value, member_types:)
-        # 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, member_types: member_types) # initialize(::Array<Data::Base>)
-      end
-
-      def initialize(value, member_types:)
-        @member_types = member_types
-        @type = nil
-        super(value)
-      end
-    end
-
     consts = constants.map { |c_sym| const_get(c_sym) }
     classes = consts.find_all { |c| c.respond_to?(:type_code) }
     by_type_code = classes.map { |cl| [cl.type_code, cl] }.to_h

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
@@ -250,9 +250,10 @@ module DBus
         when Type::VARIANT
           append_variant(val)
         when Type::ARRAY
+          val = val.exact_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.is_a?(Data::DictEntry)
+          val = val.exact_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}"
@@ -281,8 +282,14 @@ 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.exact_value
+      elsif val.is_a?(DBus::Data::Container)
+        vartype = val.type
+        vardata = val.exact_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]
@@ -353,15 +360,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