matrix_sdk 2.5.0 → 2.8.0

data/lib/matrix_sdk/room.rb

@@ -31,12 +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
 
-    # 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
+    # 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
 
     alias room_id id
     alias members joined_members
@@ -82,6 +81,12 @@ module MatrixSdk
 
       @prev_batch = nil
 
+      %i[name topic canonical_alias avatar_url].each do |type|
+        room_state.tinycache_adapter.write("m.room.#{type}", { type => data.delete(type) }) if data.key? type
+      end
+      room_state.tinycache_adapter.write('m.room.join_rules', { join_rule: data.delete(:join_rule) }) if data.key? :join_rule
+      room_state.tinycache_adapter.write('m.room.history_visibility', { history_visibility: data.delete(:world_readable) ? :world_readable : nil }) if data.key? :world_readable
+
       data.each do |k, v|
         next if %i[client].include? k
 
@@ -125,6 +130,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
@@ -167,7 +178,7 @@ module MatrixSdk
 
     # @return [String, nil] the canonical alias of the room
     def canonical_alias
-      client.api.get_room_state(id, 'm.room.canonical_alias')[:alias]
+      get_state('m.room.canonical_alias')[:alias]
     rescue MatrixSdk::MatrixNotFoundError
       nil
     end
@@ -200,17 +211,43 @@ module MatrixSdk
     #
     # @return [String,nil] The room name - if any
     def name
-      client.api.get_room_name(id)[:name]
+      get_state('m.room.name')[:name]
     rescue MatrixNotFoundError
       # No room name has been specified
       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
     def avatar_url
-      client.api.get_room_avatar(id)[:url]
+      get_state('m.room.avatar_url')[:url]
     rescue MatrixNotFoundError
       # No avatar has been set
       nil
@@ -220,7 +257,7 @@ module MatrixSdk
     #
     # @return [String,nil] The topic of the room
     def topic
-      client.api.get_room_topic(id)[:topic]
+      get_state('m.room.topic')[:topic]
     rescue MatrixNotFoundError
       # No room name has been specified
       nil
@@ -230,14 +267,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
+      get_state('m.room.guest_access')[: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
+      get_state('m.room.join_rules')[:join_rule]&.to_sym
     end
 
     # Checks if +guest_access+ is set to +:can_join+
@@ -255,11 +292,27 @@ module MatrixSdk
       join_rule == :knock
     end
 
+    def room_state
+      return MatrixSdk::Util::StateEventCache.new self if client.cache == :none
+
+      @room_state ||= MatrixSdk::Util::StateEventCache.new self
+    end
+
+    # Gets a state object in the room
+    def get_state(type, state_key: nil)
+      room_state[type, state_key]
+    end
+
+    # Sets a state object in the room
+    def set_state(type, data, state_key: nil)
+      room_state[type, state_key] = data
+    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
+      get_state('m.room.history_visibility')[:history_visibility]&.to_sym
     end
 
     # Checks if the room history is world readable
@@ -272,15 +325,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.dig(*%i[content aliases]).nil? }
-          .map { |chunk| chunk.dig(*%i[content aliases]) }
-          .flatten
-          .compact
+    def aliases(canonical_only: true)
+      canonical = get_state('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
 
     #
@@ -399,6 +451,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
@@ -495,12 +572,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
@@ -508,7 +591,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
 
@@ -534,8 +617,7 @@ module MatrixSdk
     #
     # @return [Response] The content of the m.room.create event
     def creation_info
-      # Not caching here, easier to cache the important values separately instead
-      client.api.get_room_creation_info(id)
+      room_state['m.room.create']
     end
 
     # Retrieves the type of the room
@@ -543,9 +625,6 @@ module MatrixSdk
     # @return ['m.space',String,nil] The type of the room
     def room_type
       # Can't change, so a permanent cache is ok
-      return @room_type if @room_type_retrieved || @room_type
-
-      @room_type_retrieved = true
       @room_type ||= creation_info[:type]
     end
 
@@ -553,6 +632,7 @@ module MatrixSdk
     #
     # @return [String] The version of the room
     def room_version
+      # Can't change, so a permanent cache is ok
       @room_version ||= creation_info[:room_version]
     end
 
@@ -627,8 +707,7 @@ module MatrixSdk
     #
     # @param name [String] The new name to set
     def name=(name)
-      tinycache_adapter.write(:name, name)
-      client.api.set_room_name(id, name)
+      room_state['m.room.name'] = { name: name }
       name
     end
 
@@ -636,7 +715,7 @@ module MatrixSdk
     #
     # @return [Boolean] if the name was changed or not
     def reload_name!
-      clear_name_cache
+      room_state.expire('m.room.name')
     end
     alias refresh_name! reload_name!
 
@@ -644,8 +723,7 @@ module MatrixSdk
     #
     # @param topic [String] The new topic to set
     def topic=(topic)
-      tinycache_adapter.write(:topic, topic)
-      client.api.set_room_topic(id, topic)
+      room_state['m.room.topic'] = { topic: topic }
       topic
     end
 
@@ -653,7 +731,7 @@ module MatrixSdk
     #
     # @return [Boolean] if the topic was changed or not
     def reload_topic!
-      clear_topic_cache
+      room_state.expire('m.room.topic')
     end
     alias refresh_topic! reload_topic!
 
@@ -672,6 +750,7 @@ module MatrixSdk
     # @note The list of aliases is not sorted, ordering changes will result in
     #       alias list updates.
     def reload_aliases!
+      room_state.expire('m.room.canonical_alias')
       clear_aliases_cache
     end
     alias refresh_aliases! reload_aliases!
@@ -688,8 +767,7 @@ module MatrixSdk
     #
     # @param join_rule [:invite,:public] The join rule of the room
     def join_rule=(join_rule)
-      client.api.set_room_join_rules(id, join_rule)
-      tinycache_adapter.write(:join_rule, join_rule)
+      room_state['m.room.join_rules'] = { join_rule: join_rule }
       join_rule
     end
 
@@ -705,8 +783,7 @@ module MatrixSdk
     #
     # @param guest_access [:can_join,:forbidden] The new guest access status of the room
     def guest_access=(guest_access)
-      client.api.set_room_guest_access(id, guest_access)
-      tinycache_adapter.write(:guest_access, guest_access)
+      room_state['m.room.guest_access'] = { guest_access: guest_access }
       guest_access
     end
 
@@ -717,8 +794,7 @@ module MatrixSdk
       avatar_url = URI(avatar_url) unless avatar_url.is_a? URI
       raise ArgumentError, 'Must be a valid MXC URL' unless avatar_url.is_a? URI::MXC
 
-      client.api.set_room_avatar(id, avatar_url)
-      tinycache_adapter.write(:avatar_url, avatar_url)
+      room_state['m.room.avatar_url'] = { avatar_url: avatar_url }
       avatar_url
     end
 
@@ -728,7 +804,7 @@ module MatrixSdk
     # @return [Hash] The current power levels as set for the room
     # @see Protocols::CS#get_power_levels
     def power_levels
-      client.api.get_power_levels(id)
+      get_state('m.room.power_levels')
     end
 
     # Gets the power level of a user in the room
@@ -740,13 +816,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.dig(:users, user.to_s.to_sym)
-      level = power_levels[:users_default] || 0 if level.nil? && use_default
+      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
@@ -811,8 +901,9 @@ module MatrixSdk
     def modify_user_power_levels(users = nil, users_default = nil)
       return false if users.nil? && users_default.nil?
 
-      data = power_levels_without_cache
-      tinycache_adapter.write(:power_levels, data)
+      room_state.tinycache_adapter.expire 'm.room.power_levels'
+
+      data = power_levels
       data[:users_default] = users_default unless users_default.nil?
 
       if users
@@ -830,7 +921,7 @@ module MatrixSdk
         end
       end
 
-      client.api.set_power_levels(id, data)
+      room_state['m.room.power_levels'] = data
       true
     end
 
@@ -842,8 +933,9 @@ module MatrixSdk
     def modify_required_power_levels(events = nil, params = {})
       return false if events.nil? && (params.nil? || params.empty?)
 
-      data = power_levels_without_cache
-      tinycache_adapter.write(:power_levels, data)
+      room_state.tinycache_adapter.expire 'm.room.power_levels'
+
+      data = power_levels
       data.merge!(params)
       data.delete_if { |_k, v| v.nil? }
 
@@ -853,37 +945,21 @@ module MatrixSdk
         data[:events].delete_if { |_k, v| v.nil? }
       end
 
-      client.api.set_power_levels(id, data)
+      room_state['m.room.power_levels'] = data
       true
     end
 
     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 }
-    end
 
-    def handle_power_levels(event)
-      tinycache_adapter.write(:power_levels, event[:content])
-    end
-
-    def handle_room_name(event)
-      tinycache_adapter.write(:name, event.dig(*%i[content name]))
-    end
-
-    def handle_room_topic(event)
-      tinycache_adapter.write(:topic, event.dig(*%i[content topic]))
-    end
-
-    def handle_room_guest_access(event)
-      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.dig(*%i[content join_rule])&.to_sym)
+      tinycache_adapter.write(:joined_members, members)
     end
 
     def handle_room_member(event)
@@ -900,20 +976,13 @@ module MatrixSdk
     end
 
     def handle_room_canonical_alias(event)
-      canonical_alias = tinycache_adapter.write(:canonical_alias, event.dig(*%i[content alias]))
+      room_state.tinycache_adapter.write('m.room.canonical_alias', event[:content], expires_in: room_state.cache_time)
+      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.dig(*%i[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?
@@ -922,22 +991,13 @@ 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
       }
     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,
-      'm.room.member' => :handle_room_member,
-      'm.room.name' => :handle_room_name,
-      '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?
 
@@ -945,14 +1005,37 @@ 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?
 
       ensure_room_handlers[:ephemeral_event].fire(MatrixEvent.new(self, event), event[:type])
     end
 
+    INTERNAL_HANDLERS = {
+      'm.room.canonical_alias' => :handle_room_canonical_alias,
+      'm.room.member' => :handle_room_member
+    }.freeze
+
     def put_state_event(event)
-      send(INTERNAL_HANDLERS[event[:type]], event) if INTERNAL_HANDLERS.key? event[:type]
+      if INTERNAL_HANDLERS.key? event[:type]
+        send(INTERNAL_HANDLERS[event[:type]], event)
+      elsif client.cache != :none
+        adapter = room_state.tinycache_adapter
+        key = event[:type]
+        key += "|#{event[:state_key]}" unless event[:state_key].nil? || event[:state_key].empty?
+        adapter.write(key, event[:content], expires_in: room_state.cache_time)
+      end
 
       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 MatrixRequestError
-        data = client.api.request :get, :client_r0, "/rooms/#{id}/spaces", query: {
+        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,6 +74,22 @@ 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
@@ -132,7 +154,7 @@ 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|
+      @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