matrix_sdk 2.4.0 → 2.7.0

data/lib/matrix_sdk/protocols/msc.rb

@@ -60,7 +60,9 @@ module MatrixSdk::Protocols::MSC
     # rubocop:disable Metrics/BlockLength
     thread = Thread.new(cancellation_token) do |ctx|
       print_http(req)
+      @http_lock&.lock
       http.request req do |response|
+        @http_lock&.unlock
         break unless ctx[:run]
 
         print_http(response, body: false)
@@ -134,8 +136,11 @@ module MatrixSdk::Protocols::MSC
             break
           end
         end
+
         break unless ctx[:run]
       end
+    ensure
+      @http_lock.unlock if @http_lock&.owned?
     end
     # rubocop:enable Metrics/BlockLength
 

data/lib/matrix_sdk/response.rb

@@ -31,6 +31,8 @@ module MatrixSdk
         return data
       end
 
+      return data if data.instance_variables.include? :@api
+
       raise ArgumentError, 'Input data was not a hash' unless data.is_a? Hash
 
       data.extend(Extensions)

data/lib/matrix_sdk/room.rb

@@ -31,9 +31,11 @@ module MatrixSdk
     ignore_inspect :client, :events, :prev_batch, :logger, :tinycache_adapter
 
     # Requires heavy lookups, so they're cached for an hour
-    cached :joined_members, :aliases, cache_level: :all, expires_in: 60 * 60
-    # Only cache unfiltered requests for all members
-    cached :all_members, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 3600
+    cached :joined_members, cache_level: :all, expires_in: 60 * 60
+
+    # Only cache unfiltered requests for aliases and members
+    cached :aliases, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
+    cached :all_members, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
 
     # Much simpler to look up, and lighter data-wise, so the cache is wider
     cached :canonical_alias, :name, :avatar_url, :topic, :guest_access, :join_rule, :power_levels, cache_level: :some, expires_in: 15 * 60
@@ -53,7 +55,7 @@ module MatrixSdk
     # @option data [String] :topic The current topic of the room
     # @option data [String,MXID] :canonical_alias The canonical alias of the room
     # @option data [Array(String,MXID)] :aliases All non-canonical aliases of the room
-    # @option data [:invite,:public] :join_rule The join rule for the room
+    # @option data [:invite,:public,:knock] :join_rule The join rule for the room
     # @option data [:can_join,:forbidden] :guest_access The guest access setting for the room
     # @option data [Boolean] :world_readable If the room is readable by the entire world
     # @option data [Array(User)] :members The list of joined members
@@ -125,6 +127,12 @@ module MatrixSdk
       ensure_room_handlers[:event]
     end
 
+    # @!attribute [r] on_account_data
+    #   @return [EventHandlerArray] The list of event handlers for account data changes
+    def on_account_data
+      ensure_room_handlers[:account_data]
+    end
+
     # @!attribute [r] on_state_event
     #   @return [EventHandlerArray] The list of event handlers for only state events
     def on_state_event
@@ -206,6 +214,32 @@ module MatrixSdk
       nil
     end
 
+    # Checks if the room is a direct message / 1:1 room
+    #
+    # @param members_only [Boolean] Should directness only care about member count?
+    # @return [Boolean]
+    def dm?(members_only: false)
+      return true if !members_only && client.direct_rooms.any? { |_uid, rooms| rooms.include? id.to_s }
+
+      joined_members.count <= 2
+    end
+
+    # Mark a room as a direct (1:1) message Room
+    def dm=(direct)
+      rooms = client.direct_rooms
+      dirty = false
+      list_for_room = (rooms[id.to_s] ||= [])
+      if direct && !list_for_room.include?(id.to_s)
+        list_for_room << id.to_s
+        dirty = true
+      elsif !direct && list_for_room.include?(id.to_s)
+        list_for_room.delete id.to_s
+        rooms.delete id.to_s if list_for_room.empty?
+        dirty = true
+      end
+      client.account_data['m.direct'] = rooms if dirty
+    end
+
     # Gets the avatar url of the room - if any
     #
     # @return [String,nil] The avatar URL - if any
@@ -230,14 +264,14 @@ module MatrixSdk
     #
     # @return [:can_join,:forbidden] The current guest access right
     def guest_access
-      client.api.get_room_guest_access(id)[:guest_access].to_sym
+      client.api.get_room_guest_access(id)[:guest_access]&.to_sym
     end
 
     # Gets the join rule for the room
     #
     # @return [:public,:knock,:invite,:private] The current join rule
     def join_rule
-      client.api.get_room_join_rules(id)[:join_rule].to_sym
+      client.api.get_room_join_rules(id)[:join_rule]&.to_sym
     end
 
     # Checks if +guest_access+ is set to +:can_join+
@@ -250,11 +284,16 @@ module MatrixSdk
       join_rule == :invite
     end
 
+    # Checks if +join_rule+ is set to +:knock+
+    def knock_only?
+      join_rule == :knock
+    end
+
     # Gets the history visibility of the room
     #
     # @return [:invited,:joined,:shared,:world_readable] The current history visibility for the room
     def history_visibility
-      client.api.get_room_state(id, 'm.room.history_visibility')[:history_visibility].to_sym
+      client.api.get_room_state(id, 'm.room.history_visibility')[:history_visibility]&.to_sym
     end
 
     # Checks if the room history is world readable
@@ -267,15 +306,14 @@ module MatrixSdk
 
     # Gets the room aliases
     #
+    # @param canonical_only [Boolean] Should the list of aliases only contain the canonical ones
     # @return [Array[String]] The assigned room aliases
-    def aliases
-      client.api.get_room_aliases(id).aliases
-    rescue MatrixNotFoundError
-      data = client.api.get_room_state_all(id)
-      data.select { |chunk| chunk[:type] == 'm.room.aliases' && chunk.key?(:content) && chunk[:content].key?(:aliases) }
-          .map { |chunk| chunk[:content][:aliases] }
-          .flatten
-          .compact
+    def aliases(canonical_only: true)
+      canonical = client.api.get_room_state(id, 'm.room.canonical_alias') rescue {}
+      aliases = ([canonical[:alias]].compact + (canonical[:alt_aliases] || [])).uniq.sort
+      return aliases if canonical_only
+
+      (aliases + client.api.get_room_aliases(id).aliases).uniq.sort
     end
 
     #
@@ -394,6 +432,31 @@ module MatrixSdk
       client.api.send_content(id, url, name, 'm.audio', extra_information: audio_info)
     end
 
+    # Sends a customized message to the Room
+    #
+    # @param body [String] The clear-text body of the message
+    # @param content [Hash] The custom content of the message
+    # @param msgtype [String] The type of the message, should be one of the known types (m.text, m.notice, m.emote, etc)
+    def send_custom_message(body, content = {}, msgtype: nil)
+      content.merge!(
+        body: body,
+        msgtype: msgtype || 'm.text'
+      )
+
+      client.api.send_message_event(id, 'm.room.message', content)
+    end
+
+    # Sends a custom timeline event to the Room
+    #
+    # @param type [String,Symbol] The type of the Event.
+    #   For custom events, this should be written in reverse DNS format (e.g. com.example.event)
+    # @param content [Hash] The contents of the message, this will be the
+    #   :content key of the resulting event object
+    # @see Protocols::CS#send_message_event
+    def send_event(type, content = {})
+      client.api.send_message_event(id, type, content)
+    end
+
     # Redacts a message from the room
     #
     # @param event_id [String] the ID of the event to redact
@@ -490,12 +553,18 @@ module MatrixSdk
       true
     end
 
+    def account_data
+      return MatrixSdk::Util::AccountDataCache.new client, room: self if client.cache == :none
+
+      @account_data ||= MatrixSdk::Util::AccountDataCache.new client, room: self
+    end
+
     # Retrieves a custom entry from the room-specific account data
     #
     # @param type [String] the data type to retrieve
     # @return [Hash] the data that was stored under the given type
     def get_account_data(type)
-      client.api.get_room_account_data(client.mxid, id, type)
+      account_data[type]
     end
 
     # Stores a custom entry into the room-specific account data
@@ -503,7 +572,7 @@ module MatrixSdk
     # @param type [String] the data type to store
     # @param account_data [Hash] the data to store
     def set_account_data(type, account_data)
-      client.api.set_room_account_data(client.mxid, id, type, account_data)
+      self.account_data[type] = account_data
       true
     end
 
@@ -735,13 +804,27 @@ module MatrixSdk
     def user_powerlevel(user, use_default: true)
       user = user.id if user.is_a? User
       user = MXID.new(user.to_s) unless user.is_a? MXID
-      raise ArgumentError, 'Must provide a valid user or MXID' unless user.user?
+      raise ArgumentError, 'Must provide a valid User or MXID' unless user.user?
 
-      level = power_levels[:users][user.to_s.to_sym]
-      level = power_levels[:users_default] || 0 if level.nil? && use_default
+      level = power_levels.dig(:users, user.to_s.to_sym)
+      level ||= power_levels[:users_default] || 0 if use_default
       level
     end
 
+    # Checks if a user can send a given event type in the room
+    #
+    # @param user [User,MXID,String] The user to check
+    # @param event [String,Symbol] The event type to check
+    # @param state [Boolean] If the given event is a state event or a message event
+    # @return [Boolean] If the given user is allowed to send an event of the given type
+    def user_can_send?(user, event, state: false)
+      user_pl = user_powerlevel(user)
+      event_pl = power_levels.dig(:events, event.to_s.to_sym)
+      event_pl ||= state ? (power_levels[:state_default] || 50) : (power_levels[:events_default] || 0)
+
+      user_pl >= event_pl
+    end
+
     # Check if a user is an admin in the room
     #
     # @param user [User,MXID,String] The user to check for admin privileges
@@ -812,8 +895,17 @@ module MatrixSdk
 
       if users
         data[:users] = {} unless data.key? :users
-        data[:users].merge!(users)
-        data[:users].delete_if { |_k, v| v.nil? }
+        users.each do |user, level|
+          user = user.id if user.is_a? User
+          user = MXID.new(user.to_s) unless user.is_a? MXID
+          raise ArgumentError, 'Must provide a valid user or MXID' unless user.user?
+
+          if level.nil?
+            data[:users].delete(user.to_s.to_sym)
+          else
+            data[:users][user.to_s.to_sym] = level
+          end
+        end
       end
 
       client.api.set_power_levels(id, data)
@@ -846,10 +938,14 @@ module MatrixSdk
     private
 
     def ensure_member(member)
+      return unless client.cache == :all
+
       tinycache_adapter.write(:joined_members, []) unless tinycache_adapter.exist? :joined_members
 
       members = tinycache_adapter.read(:joined_members) || []
       members << member unless members.any? { |m| m.id == member.id }
+
+      tinycache_adapter.write(:joined_members, members)
     end
 
     def handle_power_levels(event)
@@ -857,27 +953,27 @@ module MatrixSdk
     end
 
     def handle_room_name(event)
-      tinycache_adapter.write(:name, event[:content][:name])
+      tinycache_adapter.write(:name, event.dig(*%i[content name]))
     end
 
     def handle_room_topic(event)
-      tinycache_adapter.write(:topic, event[:content][:topic])
+      tinycache_adapter.write(:topic, event.dig(*%i[content topic]))
     end
 
     def handle_room_guest_access(event)
-      tinycache_adapter.write(:guest_access, event[:content][:guest_access].to_sym)
+      tinycache_adapter.write(:guest_access, event.dig(*%i[content guest_access])&.to_sym)
     end
 
     def handle_room_join_rules(event)
-      tinycache_adapter.write(:join_rule, event[:content][:join_rule].to_sym)
+      tinycache_adapter.write(:join_rule, event.dig(*%i[content join_rule])&.to_sym)
     end
 
     def handle_room_member(event)
       return unless client.cache == :all
 
-      if event[:content][:membership] == 'join'
+      if event.dig(*%i[content membership]) == 'join'
         ensure_member(client.get_user(event[:state_key]).dup.tap do |u|
-          u.instance_variable_set :@display_name, event[:content][:displayname]
+          u.instance_variable_set(:@display_name, event.dig(*%i[content displayname]))
         end)
       elsif tinycache_adapter.exist? :joined_members
         members = tinycache_adapter.read(:joined_members)
@@ -886,20 +982,12 @@ module MatrixSdk
     end
 
     def handle_room_canonical_alias(event)
-      canonical_alias = tinycache_adapter.write :canonical_alias, event[:content][:alias]
+      canonical_alias = tinycache_adapter.write(:canonical_alias, event.dig(*%i[content alias]))
 
       data = tinycache_adapter.read(:aliases) || []
       data << canonical_alias
-      tinycache_adapter.write(:aliases, data)
-    end
-
-    def handle_room_aliases(event)
-      tinycache_adapter.write(:aliases, []) unless tinycache_adapter.exist? :aliases
-
-      aliases = tinycache_adapter.read(:aliases) || []
-      aliases.concat event[:content][:aliases]
-
-      tinycache_adapter.write(:aliases, aliases)
+      data += event.dig(*%i[content alt_aliases]) || []
+      tinycache_adapter.write(:aliases, data.uniq.sort)
     end
 
     def room_handlers?
@@ -908,6 +996,7 @@ module MatrixSdk
 
     def ensure_room_handlers
       client.instance_variable_get(:@room_handlers)[id] ||= {
+        account_data: MatrixSdk::EventHandlerArray.new,
         event: MatrixSdk::EventHandlerArray.new,
         state_event: MatrixSdk::EventHandlerArray.new,
         ephemeral_event: MatrixSdk::EventHandlerArray.new
@@ -915,7 +1004,6 @@ module MatrixSdk
     end
 
     INTERNAL_HANDLERS = {
-      'm.room.aliases' => :handle_room_aliases,
       'm.room.canonical_alias' => :handle_room_canonical_alias,
       'm.room.guest_access' => :handle_room_guest_access,
       'm.room.join_rules' => :handle_room_join_rules,
@@ -924,6 +1012,7 @@ module MatrixSdk
       'm.room.power_levels' => :handle_power_levels,
       'm.room.topic' => :handle_room_topic
     }.freeze
+
     def put_event(event)
       ensure_room_handlers[:event].fire(MatrixEvent.new(self, event), event[:type]) if room_handlers?
 
@@ -931,6 +1020,17 @@ module MatrixSdk
       @events.shift if @events.length > @event_history_limit
     end
 
+    def put_account_data(event)
+      if client.cache != :none
+        adapter = account_data.tinycache_adapter
+        adapter.write(event[:type], event[:content], expires_in: account_data.cache_time)
+      end
+
+      return unless room_handlers?
+
+      ensure_room_handlers[:account_data].fire(MatrixEvent.new(self, event))
+    end
+
     def put_ephemeral_event(event)
       return unless room_handlers?
 

data/lib/matrix_sdk/rooms/space.rb

@@ -6,12 +6,12 @@ module MatrixSdk::Rooms
 
     def tree(suggested_only: nil, max_rooms: nil)
       begin
-        data = client.api.request :get, :client_unstable, "/org.matrix.msc2946/rooms/#{id}/spaces", query: {
+        data = client.api.request :get, :client_r0, "/rooms/#{id}/spaces", query: {
           suggested_only: suggested_only,
           max_rooms_per_space: max_rooms
         }.compact
-      rescue
-        data = client.api.request :get, :client_r0, "/rooms/#{id}/spaces", query: {
+      rescue MatrixRequestError
+        data = client.api.request :get, :client_unstable, "/org.matrix.msc2946/rooms/#{id}/spaces", query: {
           suggested_only: suggested_only,
           max_rooms_per_space: max_rooms
         }.compact

data/lib/matrix_sdk/user.rb

@@ -28,6 +28,12 @@ module MatrixSdk
       end
     end
 
+    def to_s
+      "#{display_name} (#{id})" if @display_name
+
+      @id.to_s
+    end
+
     # @return [String] the display name
     # @see MatrixSdk::Protocols::CS#get_display_name
     def display_name
@@ -68,13 +74,29 @@ module MatrixSdk
       @avatar_url = url
     end
 
+    # Check if the user is an admin in a given room
+    #
+    # @param room [String,MXID] the room to check
+    # @return [Boolean] If the user is an admin (PL >= 100)
+    def admin?(room)
+      client.ensure_room(room).user_powerlevel(self) >= 100
+    end
+
+    # Check if the user is a moderator in a given room
+    #
+    # @param room [String,MXID] the room to check
+    # @return [Boolean] If the user is an admin (PL >= 50)
+    def moderator?(room)
+      client.ensure_room(room).user_powerlevel(self) >= 50
+    end
+
     # Get the user's current presence status
     #
     # @return [Symbol] One of :online, :offline, :unavailable
     # @see MatrixSdk::Protocols::CS#get_presence_status
     # @note This information is not cached in the abstraction layer
     def presence
-      raw_presence[:presence].to_sym
+      raw_presence[:presence]&.to_sym
     end
 
     # Sets the user's current presence status
@@ -132,8 +154,8 @@ module MatrixSdk
 
     # Returns all the current device keys for the user, retrieving them if necessary
     def device_keys
-      @device_keys ||= client.api.keys_query(device_keys: { id => [] }).yield_self do |resp|
-        resp[:device_keys][id.to_sym]
+      @device_keys ||= client.api.keys_query(device_keys: { id => [] }).yield_self do |resp| # rubocop:disable Style/ObjectThen # Keep Ruby 2.5 support a little longer
+        resp.dig(:device_keys, id.to_sym)
       end
     end
 

data/lib/matrix_sdk/util/account_data_cache.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Util
+  class AccountDataCache
+    extend MatrixSdk::Extensions
+    extend MatrixSdk::Util::Tinycache
+    include Enumerable
+
+    attr_reader :client, :room
+
+    attr_accessor :cache_time
+
+    ignore_inspect :client, :room, :tinycache_adapter
+
+    def initialize(client, room: nil, cache_time: 1 * 60 * 60, **_params)
+      raise ArgumentError, 'Must be given a Client instance' unless client.is_a? MatrixSdk::Client
+
+      @client = client
+      @cache_time = cache_time
+
+      return unless room
+
+      @room = room
+      @room = client.ensure_room room unless @room.is_a? MatrixSdk::Room
+    end
+
+    def reload!
+      tinycache_adapter.clear
+    end
+
+    def keys
+      tinycache_adapter.send(:cache).keys
+    end
+
+    def values
+      keys.map { |key| tinycache_adapter.read(key) }
+    end
+
+    def size
+      keys.count
+    end
+
+    def key?(key)
+      keys.key?(key.to_s)
+    end
+
+    def each(live: false)
+      return to_enum(__method__, live: live) { keys.count } unless block_given?
+
+      keys.each do |key|
+        v = live ? self[key] : tinycache_adapter.read(key)
+        # hash = v.hash
+        yield key, v
+        # self[key] = v if hash != v.hash
+      end
+    end
+
+    def delete(key)
+      key = key.to_s unless key.is_a? String
+      if room
+        client.api.set_room_account_data(client.mxid, room.id, key, {})
+      else
+        client.api.set_account_data(client.mxid, key, {})
+      end
+      tinycache_adapter.delete(key)
+    end
+
+    def [](key)
+      key = key.to_s unless key.is_a? String
+      tinycache_adapter.fetch(key, expires_in: @cache_time) do
+        if room
+          client.api.get_room_account_data(client.mxid, room.id, key)
+        else
+          client.api.get_account_data(client.mxid, key)
+        end
+      rescue MatrixSdk::MatrixNotFoundError
+        {}
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_s unless key.is_a? String
+      if room
+        client.api.set_room_account_data(client.mxid, room.id, key, value)
+      else
+        client.api.set_account_data(client.mxid, key, value)
+      end
+      tinycache_adapter.write(key, value)
+    end
+  end
+end

data/lib/matrix_sdk/util/extensions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'pp'
+
 unless Object.respond_to? :yield_self
   class Object
     def yield_self
@@ -51,21 +53,29 @@ module MatrixSdk
 
     def ignore_inspect(*symbols)
       class_eval %*
-        def inspect
-          reentrant = caller_locations.any? { |l| l.absolute_path == __FILE__ && l.label == 'inspect' }
-          "\\\#<\#{self.class} \#{instance_variables
+        include PP::ObjectMixin
+
+        def pretty_print_instance_variables
+          instance_variables
             .reject { |f| %i[#{symbols.map { |s| "@#{s}" }.join ' '}].include? f }
-            .map { |f| "\#{f}=\#{reentrant ? instance_variable_get(f) : instance_variable_get(f).inspect}" }.join " " }}>"
+            .sort
         end
-      *, __FILE__, __LINE__ - 7
+
+        def pretty_print(pp)
+          pp.pp(self)
+        end
+
+        alias inspect pretty_print_inspect
+      *, __FILE__, __LINE__ - 14
     end
   end
 
   module Logging
     def logger
       return MatrixSdk.logger if MatrixSdk.global_logger?
+      return @logger if instance_variable_defined?(:@logger) && @logger
 
-      @logger ||= ::Logging.logger[self]
+      ::Logging.logger[self]
     end
 
     def logger=(logger)

data/lib/matrix_sdk/util/tinycache.rb

@@ -62,7 +62,7 @@ module MatrixSdk::Util
       method_names = build_method_names(method_name)
       tinycache_adapter_config[method_name] = {
         level: cache_level,
-        expires: expires_in || 1 * 365 * 24 * 60 * 60 # 1 year
+        expires: expires_in || (1 * 365 * 24 * 60 * 60) # 1 year
       }
 
       helper = const_get(cache_helper_module_name)
@@ -75,13 +75,25 @@ module MatrixSdk::Util
 
         define_method(method_names[:with_cache]) do |*args|
           tinycache_adapter.fetch(__send__(method_names[:cache_key], *args), expires_in: expires_in) do
-            __send__(method_names[:without_cache], *args)
+            named = args.delete_at(-1) if args.last.is_a? Hash
+
+            if named
+              __send__(method_names[:without_cache], *args, **named)
+            else
+              __send__(method_names[:without_cache], *args)
+            end
           end
         end
 
         define_method(method_names[:without_cache]) do |*args|
           orig = method(method_name).super_method
-          orig.call(*args)
+          named = args.delete_at(-1) if args.last.is_a? Hash
+
+          if named
+            orig.call(*args, **named)
+          else
+            orig.call(*args)
+          end
         end
 
         define_method(method_names[:clear_cache]) do |*args|
@@ -99,8 +111,12 @@ module MatrixSdk::Util
         define_method(method_name) do |*args|
           unless_proc = opts[:unless].is_a?(Symbol) ? opts[:unless].to_proc : opts[:unless]
 
+          raise ArgumentError, 'Invalid proc provided (must have arity between 1..3)' if unless_proc && !(1..3).include?(unless_proc.arity)
+
           skip_cache = false
-          skip_cache ||= unless_proc&.call(self, method_name, args)
+          skip_cache ||= unless_proc.call(self, method_name, args) if unless_proc&.arity == 3
+          skip_cache ||= unless_proc.call(method_name, args) if unless_proc&.arity == 2
+          skip_cache ||= unless_proc.call(args) if unless_proc&.arity == 1
           skip_cache ||= CACHE_LEVELS[client&.cache || :all] < CACHE_LEVELS[cache_level]
 
           if skip_cache

data/lib/matrix_sdk/util/tinycache_adapter.rb

@@ -2,8 +2,12 @@
 
 module MatrixSdk::Util
   class TinycacheAdapter
+    extend MatrixSdk::Extensions
+
     attr_accessor :config, :client
 
+    ignore_inspect :client
+
     def initialize
       @config = {}
 
@@ -59,7 +63,7 @@ module MatrixSdk::Util
     end
 
     def cleanup
-      @cache.delete_if { |_, v| v.expired? }
+      @cache.select { |_, v| v.expired? }.each { |_, v| v.value = nil }
     end
 
     private