ruby-dbus 0.18.0.beta4 → 0.18.0.beta7

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,10 +250,10 @@ module DBus
         when Type::VARIANT
           append_variant(val)
         when Type::ARRAY
-          val = val.value if val.is_a?(Data::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}"
@@ -282,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]

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

@@ -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,32 @@ module DBus
         end
       end
 
-      @sigtype = sigtype
-      @members = []
+      @sigtype = sigtype.freeze
+      @members = [] # not frozen yet, Parser#parse_one or Factory will do it
+      freeze
+    end
+
+    # A Type is equal to
+    # - another Type with the same string representation
+    # - a String ({SingleCompleteType}) describing the type
+    def ==(other)
+      case other
+      when ::String
+        to_s == other
+      else
+        eql?(other)
+      end
+    end
+
+    # A Type is eql? to
+    # - another Type with the same string representation
+    #
+    # Hash key equality
+    # See https://ruby-doc.org/core-3.0.0/Object.html#method-i-eql-3F
+    def eql?(other)
+      return false unless other.is_a?(Type)
+
+      @sigtype == other.sigtype && @members == other.members
     end
 
     # Return the required alignment for the type.
@@ -124,16 +146,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
@@ -159,7 +180,7 @@ module DBus
 
     def inspect
       s = TYPE_MAPPING[@sigtype].first
-      if [STRUCT, ARRAY].member?(@sigtype)
+      if [STRUCT, ARRAY, DICT_ENTRY].member?(@sigtype)
         s += ": #{@members.inspect}"
       end
       s
@@ -232,6 +253,7 @@ module DBus
         else
           res = Type.new(char)
         end
+        res.members.freeze
         res
       end
 
@@ -243,7 +265,7 @@ module DBus
         while (c = nextchar)
           ret << parse_one(c)
         end
-        ret
+        ret.freeze
       end
 
       # Parse one {SingleCompleteType}
@@ -255,9 +277,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 +395,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 +404,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
@@ -286,8 +415,9 @@ module DBus
   # @param string_type [SingleCompleteType]
   # @param value [::Object]
   # @return [Array(DBus::Type::Type,::Object)]
+  # @deprecated Use {Data::Variant.new} 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