matrix_sdk 2.1.2 → 2.4.0

data/lib/matrix_sdk/protocols/msc.rb

@@ -47,7 +47,7 @@ module MatrixSdk::Protocols::MSC
     query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)
 
     req = Net::HTTP::Get.new(homeserver.dup.tap do |u|
-      u.path = api_to_path(:client_r0) + '/sync/sse'
+      u.path = "#{api_to_path :client_r0}/sync/sse"
       u.query = URI.encode_www_form(query)
     end)
     req['accept'] = 'text/event-stream'

data/lib/matrix_sdk/response.rb

@@ -46,7 +46,9 @@ module MatrixSdk
       attr_reader :api
 
       def respond_to_missing?(name, *_args)
-        key? name
+        return true if key? name
+
+        super
       end
 
       def method_missing(name, *args)

data/lib/matrix_sdk/room.rb

@@ -1,62 +1,45 @@
 # frozen_string_literal: true
 
 require 'matrix_sdk'
+require 'matrix_sdk/util/events'
+require 'matrix_sdk/util/tinycache'
 
 module MatrixSdk
   # A class for tracking the information about a room on Matrix
   class Room
     extend MatrixSdk::Extensions
+    extend MatrixSdk::Util::Tinycache
     include MatrixSdk::Logging
 
-    # @!attribute [rw] canonical_alias
-    #   @return [String, nil] the canonical alias of the room
     # @!attribute [rw] event_history_limit
     #   @return [Fixnum] the limit of events to keep in the event log
-    attr_accessor :canonical_alias, :event_history_limit
+    attr_accessor :event_history_limit
     # @!attribute [r] id
     #   @return [String] the internal ID of the room
     # @!attribute [r] client
     #   @return [Client] the client for the room
-    # @!attribute [rw] name
-    #   @return [String, nil] the user-provided name of the room
-    #   @see reload_name!
-    # @!attribute [rw] topic
-    #   @return [String, nil] the user-provided topic of the room
-    #   @see reload_topic!
-    # @!attribute [r] aliases
-    #   @return [Array(String)] a list of user-set aliases for the room
-    #   @see add_alias
-    #   @see reload_alias!
-    # @!attribute [rw] join_rule
-    #   @return [:invite, :public] the join rule for the room -
-    #                    either +:invite+ or +:public+
-    # @!attribute [rw] guest_access
-    #   @return [:can_join, :forbidden] the guest access for the room -
-    #                    either +:can_join+ or +:forbidden+
-    # @!attribute [r] members
-    #   @return [Array(User)] the members of the room
-    #   @see reload_members!
     # @!attribute [r] events
     #   @return [Array(Object)] the last +event_history_limit+ events to arrive in the room
     #   @see https://matrix.org/docs/spec/client_server/r0.3.0.html#get-matrix-client-r0-sync
     #        The timeline events are what will end up in here
-    attr_reader :id, :client, :topic, :aliases, :members, :events
+    attr_reader :id, :client, :events
 
-    # @!attribute [r] on_event
-    #   @return [EventHandlerArray] The list of event handlers for all events
-    # @!attribute [r] on_state_event
-    #   @return [EventHandlerArray] The list of event handlers for only state events
-    # @!attribute [r] on_ephemeral_event
-    #   @return [EventHandlerArray] The list of event handlers for only ephemeral events
-    events :event, :state_event, :ephemeral_event
     # @!method inspect
     #   An inspect method that skips a handful of instance variables to avoid
     #   flooding the terminal with debug data.
     #   @return [String] a regular inspect string without the data for some variables
-    ignore_inspect :client, :members, :events, :prev_batch, :logger,
-                   :on_event, :on_state_event, :on_ephemeral_event
+    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
+
+    # 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
 
     alias room_id id
+    alias members joined_members
 
     # Create a new room instance
     #
@@ -80,40 +63,80 @@ module MatrixSdk
     # @option data [String,URI] :avatar_url The avatar URL for the room
     # @option data [String] :prev_batch The previous batch token for backfill
     def initialize(client, room_id, data = {})
+      if client.is_a? Room
+        copy = client
+        client = copy.client
+        room_id = copy.id
+        # data = copy.attributes
+      end
+
       raise ArgumentError, 'Must be given a Client instance' unless client.is_a? Client
 
+      @client = client
       room_id = MXID.new room_id unless room_id.is_a?(MXID)
       raise ArgumentError, 'room_id must be a valid Room ID' unless room_id.room_id?
 
-      event_initialize
-
-      @name = nil
-      @topic = nil
-      @canonical_alias = nil
-      @aliases = []
-      @join_rule = nil
-      @guest_access = nil
-      @world_readable = nil
-      @members = []
       @events = []
-      @members_loaded = false
       @event_history_limit = 10
-      @avatar_url = nil
+      @room_type = nil
 
       @prev_batch = nil
 
       data.each do |k, v|
-        instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
+        next if %i[client].include? k
+
+        if respond_to?("#{k}_cached?".to_sym) && send("#{k}_cached?".to_sym)
+          tinycache_adapter.write(k, v)
+        elsif instance_variable_defined? "@#{k}"
+          instance_variable_set("@#{k}", v)
+        end
       end
 
-      @client = client
       @id = room_id.to_s
 
-      @name_checked = Time.new(0)
-
       logger.debug "Created room #{room_id}"
     end
 
+    #
+    # Casting operators
+    #
+
+    def to_space
+      return nil unless space?
+
+      Rooms::Space.new self, nil
+    end
+
+    def to_s
+      prefix = canonical_alias if canonical_alias_has_value?
+      prefix ||= id
+      return "#{prefix} | #{name}" if name_has_value?
+
+      prefix
+    end
+
+    #
+    # Event handlers
+    #
+
+    # @!attribute [r] on_event
+    #   @return [EventHandlerArray] The list of event handlers for all events
+    def on_event
+      ensure_room_handlers[:event]
+    end
+
+    # @!attribute [r] on_state_event
+    #   @return [EventHandlerArray] The list of event handlers for only state events
+    def on_state_event
+      ensure_room_handlers[:state_event]
+    end
+
+    # @!attribute [r] on_ephemeral_event
+    #   @return [EventHandlerArray] The list of event handlers for only ephemeral events
+    def on_ephemeral_event
+      ensure_room_handlers[:ephemeral_event]
+    end
+
     #
     # State readers
     #
@@ -142,19 +165,22 @@ module MatrixSdk
       'Empty Room'
     end
 
+    # @return [String, nil] the canonical alias of the room
+    def canonical_alias
+      client.api.get_room_state(id, 'm.room.canonical_alias')[:alias]
+    rescue MatrixSdk::MatrixNotFoundError
+      nil
+    end
+
     # Populates and returns the #members array
     #
     # @return [Array(User)] The list of members in the room
     def joined_members
-      return members if @members_loaded && !members.empty?
-
-      client.api.get_room_joined_members(id)[:joined].each do |mxid, data|
-        ensure_member(User.new(client, mxid.to_s,
-                               display_name: data.fetch(:display_name, nil),
-                               avatar_url: data.fetch(:avatar_url, nil)))
+      client.api.get_room_joined_members(id)[:joined].map do |mxid, data|
+        User.new(client, mxid.to_s,
+                 display_name: data.fetch(:display_name, nil),
+                 avatar_url: data.fetch(:avatar_url, nil))
       end
-      @members_loaded = true
-      members
     end
 
     # Get all members (member events) in the room
@@ -174,10 +200,7 @@ module MatrixSdk
     #
     # @return [String,nil] The room name - if any
     def name
-      return @name if Time.now - @name_checked < 900
-
-      @name_checked = Time.now
-      @name ||= client.api.get_room_name(id)
+      client.api.get_room_name(id)[:name]
     rescue MatrixNotFoundError
       # No room name has been specified
       nil
@@ -187,18 +210,34 @@ module MatrixSdk
     #
     # @return [String,nil] The avatar URL - if any
     def avatar_url
-      @avatar_url ||= client.api.get_room_avatar(id).url
+      client.api.get_room_avatar(id)[:url]
     rescue MatrixNotFoundError
       # No avatar has been set
       nil
     end
 
+    # Gets the room topic - if any
+    #
+    # @return [String,nil] The topic of the room
+    def topic
+      client.api.get_room_topic(id)[:topic]
+    rescue MatrixNotFoundError
+      # No room name has been specified
+      nil
+    end
+
+    # Gets the guest access rights for the room
+    #
+    # @return [:can_join,:forbidden] The current guest access right
     def guest_access
-      @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
-      @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+
@@ -211,6 +250,34 @@ module MatrixSdk
       join_rule == :invite
     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
+    end
+
+    # Checks if the room history is world readable
+    #
+    # @return [Boolean] If the history is world readable
+    def world_readable?
+      history_visibility == :world_readable
+    end
+    alias world_readable world_readable?
+
+    # Gets the room aliases
+    #
+    # @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
+    end
+
     #
     # Message handling
     #
@@ -351,7 +418,13 @@ module MatrixSdk
     # @param reverse [Boolean] whether to fill messages in reverse or not
     # @param limit [Integer] the maximum number of messages to backfill
     # @note This will trigger the `on_event` events as messages are added
-    def backfill_messages(reverse = false, limit = 10)
+    def backfill_messages(*args, reverse: false, limit: 10)
+      # To be backwards-compatible
+      if args.length == 2
+        reverse = args.first
+        limit = args.last
+      end
+
       data = client.api.get_room_messages(id, @prev_batch, direction: :b, limit: limit)
 
       events = data[:chunk]
@@ -452,6 +525,41 @@ module MatrixSdk
       true
     end
 
+    # Gets the room creation information
+    #
+    # @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)
+    end
+
+    # Retrieves the type of the room
+    #
+    # @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
+
+    # Retrieves the room version
+    #
+    # @return [String] The version of the room
+    def room_version
+      @room_version ||= creation_info[:room_version]
+    end
+
+    # Checks if the room is a Matrix Space
+    #
+    # @return [Boolean,nil] True if the room is a space
+    def space?
+      room_type == 'm.space'
+    rescue MatrixSdk::MatrixForbiddenError, MatrixSdk::MatrixNotFoundError
+      nil
+    end
+
     # Returns a list of the room tags
     #
     # @return [Response] A list of the tags and their data, with add and remove methods implemented
@@ -469,7 +577,7 @@ module MatrixSdk
           @room
         end
         tag_obj.define_singleton_method(:add) do |tag, **data|
-          @room.add_tag(tag.to_s.to_sym, data)
+          @room.add_tag(tag.to_s.to_sym, **data)
           self[tag.to_s.to_sym] = data
           self
         end
@@ -514,22 +622,16 @@ 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)
-      @name = name
+      name
     end
 
     # Reloads the name of the room
     #
     # @return [Boolean] if the name was changed or not
     def reload_name!
-      data = begin
-               client.api.get_room_name(id)
-             rescue MatrixNotFoundError
-               nil
-             end
-      changed = data[:name] != @name
-      @name = data[:name] if changed
-      changed
+      clear_name_cache
     end
     alias refresh_name! reload_name!
 
@@ -537,22 +639,16 @@ 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)
-      @topic = topic
+      topic
     end
 
     # Reloads the topic of the room
     #
     # @return [Boolean] if the topic was changed or not
     def reload_topic!
-      data = begin
-               client.api.get_room_topic(id)
-             rescue MatrixNotFoundError
-               nil
-             end
-      changed = data[:topic] != @topic
-      @topic = data[:topic] if changed
-      changed
+      clear_topic_cache
     end
     alias refresh_topic! reload_topic!
 
@@ -561,7 +657,7 @@ module MatrixSdk
     # @return [Boolean] if the addition was successful or not
     def add_alias(room_alias)
       client.api.set_room_alias(id, room_alias)
-      @aliases << room_alias
+      tinycache_adapter.read(:aliases) << room_alias if tinycache_adapter.exist?(:aliases)
       true
     end
 
@@ -571,21 +667,7 @@ module MatrixSdk
     # @note The list of aliases is not sorted, ordering changes will result in
     #       alias list updates.
     def reload_aliases!
-      begin
-        new_aliases = client.api.get_room_aliases(id).aliases
-      rescue MatrixNotFoundError
-        data = client.api.get_room_state_all(id)
-        new_aliases = data.select { |chunk| chunk[:type] == 'm.room.aliases' && chunk.key?(:content) && chunk[:content].key?(:aliases) }
-                          .map { |chunk| chunk[:content][:aliases] }
-                          .flatten
-                          .compact
-      end
-
-      return false if new_aliases.nil?
-
-      changed = new_aliases != aliases
-      @aliases = new_aliases if changed
-      changed
+      clear_aliases_cache
     end
     alias refresh_aliases! reload_aliases!
 
@@ -594,7 +676,7 @@ module MatrixSdk
     # @param invite_only [Boolean] If it should be invite only or not
     def invite_only=(invite_only)
       self.join_rule = invite_only ? :invite : :public
-      @join_rule == :invite
+      invite_only
     end
 
     # Sets the join rule of the room
@@ -602,7 +684,8 @@ 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)
-      @join_rule = join_rule
+      tinycache_adapter.write(:join_rule, join_rule)
+      join_rule
     end
 
     # Sets if guests are allowed in the room
@@ -610,7 +693,7 @@ module MatrixSdk
     # @param allow_guests [Boolean] If guests are allowed to join or not
     def allow_guests=(allow_guests)
       self.guest_access = (allow_guests ? :can_join : :forbidden)
-      @guest_access == :can_join
+      allow_guests
     end
 
     # Sets the guest access status for the room
@@ -618,18 +701,101 @@ 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)
-      @guest_access = guest_access
+      tinycache_adapter.write(:guest_access, guest_access)
+      guest_access
     end
 
     # Sets a new avatar URL for the room
     #
-    # @param avatar_url [URI::MATRIX] The mxc:// URL for the new room avatar
+    # @param avatar_url [URI::MXC] The mxc:// URL for the new room avatar
     def avatar_url=(avatar_url)
       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::MATRIX
+      raise ArgumentError, 'Must be a valid MXC URL' unless avatar_url.is_a? URI::MXC
 
       client.api.set_room_avatar(id, avatar_url)
-      @avatar_url = avatar_url
+      tinycache_adapter.write(:avatar_url, avatar_url)
+      avatar_url
+    end
+
+    # Get the power levels of the room
+    #
+    # @note The returned power levels are cached for a minute
+    # @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)
+    end
+
+    # Gets the power level of a user in the room
+    #
+    # @param user [User,MXID,String] The user to check the power level for
+    # @param use_default [Boolean] Should the user default level be checked if no user-specific one exists
+    # @return [Integer,nil] The current power level for the requested user, nil if there's no user specific level
+    #   and use_default is false
+    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?
+
+      level = power_levels[:users][user.to_s.to_sym]
+      level = power_levels[:users_default] || 0 if level.nil? && use_default
+      level
+    end
+
+    # Check if a user is an admin in the room
+    #
+    # @param user [User,MXID,String] The user to check for admin privileges
+    # @param target_level [Integer] The power level that's to be considered as admin privileges
+    # @return [Boolean] If the requested user has a power level highe enough to be an admin
+    # @see #user_powerlevel
+    def admin?(user, target_level: 100)
+      level = user_powerlevel(user, use_default: false)
+      return false unless level
+
+      level >= target_level
+    end
+
+    # Make a user an admin in the room
+    #
+    # @param user [User,MXID,String] The user to give admin privileges
+    # @param level [Integer] The power level to set the user to
+    # @see #modify_user_power_levels
+    def admin!(user, level: 100)
+      return true if admin?(user, target_level: 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?
+
+      modify_user_power_levels({ user.to_s.to_sym => level })
+    end
+
+    # Check if a user is a moderator in the room
+    #
+    # @param user [User,MXID,String] The user to check for admin privileges
+    # @param target_level [Integer] The power level that's to be considered as admin privileges
+    # @return [Boolean] If the requested user has a power level highe enough to be an admin
+    # @see #user_powerlevel
+    def moderator?(user, target_level: 50)
+      level = user_powerlevel(user, use_default: false)
+      return false unless level
+
+      level >= target_level
+    end
+
+    # Make a user a moderator in the room
+    #
+    # @param user [User,MXID,String] The user to give moderator privileges
+    # @param level [Integer] The power level to set the user to
+    # @see #modify_user_power_levels
+    def moderator!(user, level: 50)
+      return true if moderator?(user, target_level: 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?
+
+      modify_user_power_levels({ user.to_s.to_sym => level })
     end
 
     # Modifies the power levels of the room
@@ -640,7 +806,8 @@ module MatrixSdk
     def modify_user_power_levels(users = nil, users_default = nil)
       return false if users.nil? && users_default.nil?
 
-      data = client.api.get_power_levels(id)
+      data = power_levels_without_cache
+      tinycache_adapter.write(:power_levels, data)
       data[:users_default] = users_default unless users_default.nil?
 
       if users
@@ -661,7 +828,8 @@ module MatrixSdk
     def modify_required_power_levels(events = nil, params = {})
       return false if events.nil? && (params.nil? || params.empty?)
 
-      data = client.api.get_power_levels(id)
+      data = power_levels_without_cache
+      tinycache_adapter.write(:power_levels, data)
       data.merge!(params)
       data.delete_if { |_k, v| v.nil? }
 
@@ -678,22 +846,103 @@ module MatrixSdk
     private
 
     def ensure_member(member)
+      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[:content][:name])
+    end
+
+    def handle_room_topic(event)
+      tinycache_adapter.write(:topic, event[:content][:topic])
+    end
+
+    def handle_room_guest_access(event)
+      tinycache_adapter.write(:guest_access, event[:content][:guest_access].to_sym)
+    end
+
+    def handle_room_join_rules(event)
+      tinycache_adapter.write(:join_rule, event[:content][:join_rule].to_sym)
+    end
+
+    def handle_room_member(event)
+      return unless client.cache == :all
+
+      if event[:content][:membership] == 'join'
+        ensure_member(client.get_user(event[:state_key]).dup.tap do |u|
+          u.instance_variable_set :@display_name, event[:content][:displayname]
+        end)
+      elsif tinycache_adapter.exist? :joined_members
+        members = tinycache_adapter.read(:joined_members)
+        members.delete_if { |m| m.id == event[:state_key] }
+      end
+    end
+
+    def handle_room_canonical_alias(event)
+      canonical_alias = tinycache_adapter.write :canonical_alias, event[: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)
+    end
+
+    def room_handlers?
+      client.instance_variable_get(:@room_handlers).key? id
+    end
+
+    def ensure_room_handlers
+      client.instance_variable_get(:@room_handlers)[id] ||= {
+        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?
+
       @events.push event
       @events.shift if @events.length > @event_history_limit
-
-      fire_event MatrixEvent.new(self, event)
     end
 
     def put_ephemeral_event(event)
-      fire_ephemeral_event MatrixEvent.new(self, event)
+      return unless room_handlers?
+
+      ensure_room_handlers[:ephemeral_event].fire(MatrixEvent.new(self, event), event[:type])
     end
 
     def put_state_event(event)
-      fire_state_event MatrixEvent.new(self, event)
+      send(INTERNAL_HANDLERS[event[:type]], event) if INTERNAL_HANDLERS.key? event[:type]
+
+      return unless room_handlers?
+
+      ensure_room_handlers[:state_event].fire(MatrixEvent.new(self, event), event[:type])
     end
   end
 end