matrix_sdk 2.5.0 → 2.8.0

data/lib/matrix_sdk/bot/main.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Bot
+  PARAMS_CONFIG = {} # rubocop:disable Style/MutableConstant Intended
+
+  require 'optparse'
+  parser = OptionParser.new do |op|
+    op.on('-s homeserver', 'Specify homeserver') { |val| PARAMS_CONFIG[:homeserver] = val }
+
+    op.on('-T token', 'Token') { |val| PARAMS_CONFIG[:access_token] = val }
+    op.on('-U username', 'Username') { |val| PARAMS_CONFIG[:username] = val }
+    op.on('-P password', 'Password') { |val| PARAMS_CONFIG[:password] = val }
+
+    op.on('-q', 'Disable logging') { PARAMS_CONFIG[:logging] = false }
+    op.on('-v', 'Enable verbose output') { PARAMS_CONFIG[:logging] = !(PARAMS_CONFIG[:log_level] = :debug).nil? }
+  end
+
+  begin
+    parser.parse!(ARGV.dup)
+  rescue StandardError => e
+    PARAMS_CONFIG[:optparse_error] = e
+  end
+
+  MatrixSdk.logger.appenders.each do |log|
+    log.layout = Logging::Layouts.pattern(
+      pattern: "%d|%.1l %c : %m\n"
+    )
+  end
+  MatrixSdk.debug! if ENV['MATRIX_DEBUG'] == '1'
+
+  require 'matrix_sdk/bot/base'
+  class Instance < Base
+    set :logging, true
+    set :log_level, :info
+
+    set :app_file, caller_files.first || $PROGRAM_NAME
+    set(:run) { File.expand_path($PROGRAM_NAME) == File.expand_path(app_file) }
+
+    if run? && ARGV.any?
+      error = PARAMS_CONFIG.delete(:optparse_error)
+      raise error if error
+
+      PARAMS_CONFIG.each { |k, v| set k, v }
+    end
+  end
+
+  module Delegator
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if respond_to? method_name
+
+          Delegator.target.send(method_name, *args, &block)
+        end
+        # ensure keyword argument passing is compatible with ruby >= 2.7
+        ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
+        private method_name
+      end
+    end
+
+    delegate :command, :client, :event,
+             :settings,
+             :set, :enable, :disable
+
+    class << self
+      attr_accessor :target
+    end
+
+    self.target = Instance
+  end
+
+  # Trigger the global instance to run once the main class finishes
+  at_exit do
+    remove_const(:PARAMS_CONFIG)
+    Instance.run! if $!.nil? && Instance.run? # rubocop:disable Style/SpecialGlobalVars Don't want to require into global scope
+  end
+end
+
+extend MatrixSdk::Bot::Delegator # rubocop:disable Style/MixinUsage Intended

data/lib/matrix_sdk/bot.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'matrix_sdk'
+require 'matrix_sdk/bot/main'

data/lib/matrix_sdk/client.rb

@@ -21,12 +21,12 @@ module MatrixSdk
     # @!attribute sync_filter [rw] The global sync filter
     #   @return [Hash,String] A filter definition, either as defined by the
     #           Matrix spec, or as an identifier returned by a filter creation request
-    attr_reader :api, :next_batch
-    attr_accessor :cache, :sync_filter
+    attr_reader :api
+    attr_accessor :cache, :sync_filter, :next_batch
 
-    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event, :state_event
+    events :error, :event, :account_data, :presence_event, :invite_event, :leave_event, :ephemeral_event, :state_event
     ignore_inspect :api,
-                   :on_event, :on_presence_event, :on_invite_event, :on_leave_event, :on_ephemeral_event
+                   :on_event, :on_account_data, :on_presence_event, :on_invite_event, :on_leave_event, :on_ephemeral_event
 
     def_delegators :@api,
                    :access_token, :access_token=, :device_id, :device_id=, :homeserver, :homeserver=,
@@ -45,10 +45,10 @@ module MatrixSdk
     # @see #initialize
     def self.new_for_domain(domain, **params)
       api = MatrixSdk::Api.new_for_domain(domain, keep_wellknown: true)
-      return new(api, params) unless api.well_known&.key?('m.identity_server')
+      return new(api, **params) unless api.well_known&.key?('m.identity_server')
 
       identity_server = MatrixSdk::Api.new(api.well_known['m.identity_server']['base_url'], protocols: %i[IS])
-      new(api, params.merge(identity_server: identity_server))
+      new(api, **params.merge(identity_server: identity_server))
     end
 
     # @param hs_url [String,URI,Api] The URL to the Matrix homeserver, without the /_matrix/ part, or an existing Api instance
@@ -75,7 +75,6 @@ module MatrixSdk
       @identity_server = nil
       @mxid = nil
 
-      @sync_token = nil
       @sync_thread = nil
       @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) }, state: { lazy_load_members: true } } }
 
@@ -99,6 +98,9 @@ module MatrixSdk
       @mxid = params[:user_id]
     end
 
+    alias sync_token next_batch
+    alias sync_token= next_batch=
+
     # Gets the currently logged in user's MXID
     #
     # @return [MXID] The MXID of the current user
@@ -161,7 +163,14 @@ module MatrixSdk
     #
     # @return [Hash[String,Array[String]]] A mapping of MXIDs to a list of direct rooms with that user
     def direct_rooms
-      api.get_account_data(mxid, 'm.direct').transform_keys(&:to_s)
+      account_data['m.direct'].transform_keys(&:to_s)
+    end
+
+    # Retrieve an account data helper
+    def account_data
+      return MatrixSdk::Util::AccountDataCache.new self if cache == :none
+
+      @account_data ||= MatrixSdk::Util::AccountDataCache.new self
     end
 
     # Gets a direct message room for the given user if one exists
@@ -395,15 +404,16 @@ module MatrixSdk
     # @param only_canonical [Boolean] Only match alias against the canonical alias
     # @return [Room] The found room
     # @return [nil] If no room was found
-    def find_room(room_id_or_alias, only_canonical: false)
+    def find_room(room_id_or_alias, only_canonical: true)
       room_id_or_alias = MXID.new(room_id_or_alias.to_s) unless room_id_or_alias.is_a? MXID
       raise ArgumentError, 'Must be a room id or alias' unless room_id_or_alias.room?
 
       return @rooms.fetch(room_id_or_alias.to_s, nil) if room_id_or_alias.room_id?
 
-      return @rooms.values.find { |r| r.canonical_alias == room_id_or_alias.to_s } if only_canonical
+      room = @rooms.values.find { |r| r.aliases.include? room_id_or_alias.to_s }
+      return room if only_canonical
 
-      @rooms.values.find { |r| r.aliases.include? room_id_or_alias.to_s }
+      room || @rooms.values.find { |r| r.aliases(canonical_only: false).include? room_id_or_alias.to_s }
     end
 
     # Get a User instance from a MXID
@@ -497,8 +507,9 @@ module MatrixSdk
       else
         @should_listen = false
       end
+
       if @sync_thread.alive?
-        ret = @sync_thread.join(2)
+        ret = @sync_thread.join(0.1)
         @sync_thread.kill unless ret
       end
       @sync_thread = nil
@@ -567,10 +578,13 @@ module MatrixSdk
       while @should_listen
         begin
           sync(**params.merge(timeout: timeout))
+          return unless @should_listen
 
           bad_sync_timeout = orig_bad_sync_timeout
           sleep(sync_interval) if sync_interval.positive?
         rescue MatrixRequestError => e
+          return unless @should_listen
+
           logger.warn("A #{e.class} occurred during sync")
           if e.httpstatus >= 500
             logger.warn("Serverside error, retrying in #{bad_sync_timeout} seconds...")
@@ -605,6 +619,14 @@ module MatrixSdk
     end
 
     def handle_sync_response(data)
+      data.dig(:account_data, :events)&.each do |account_data|
+        if cache != :none
+          adapter = self.account_data.tinycache_adapter
+          adapter.write(account_data[:type], account_data[:content], expires_in: self.account_data.cache_time)
+        end
+        fire_account_data(MatrixEvent.new(self, account_data))
+      end
+
       data.dig(:presence, :events)&.each do |presence_update|
         fire_presence_event(MatrixEvent.new(self, presence_update))
       end
@@ -624,6 +646,13 @@ module MatrixSdk
         room.instance_variable_set '@prev_batch', join.dig(:timeline, :prev_batch)
         room.instance_variable_set :@members_loaded, true unless sync_filter.fetch(:room, {}).fetch(:state, {}).fetch(:lazy_load_members, false)
 
+        join.dig(:account_data, :events)&.each do |account_data|
+          account_data[:room_id] = room_id.to_s
+          room.send :put_account_data, account_data
+
+          fire_account_data(MatrixEvent.new(self, account_data))
+        end
+
         join.dig(:state, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           handle_state(room_id, event)
@@ -651,10 +680,13 @@ module MatrixSdk
       end
 
       unless cache == :none
+        account_data.tinycache_adapter.cleanup if instance_variable_defined?(:@account_data) && @account_data
         @rooms.each do |_id, room|
           # Clean up old cache data after every sync
           # TODO Run this in a thread?
           room.tinycache_adapter.cleanup
+          room.account_data.tinycache_adapter.cleanup
+          room.room_state.tinycache_adapter.cleanup
         end
       end
 

data/lib/matrix_sdk/mxid.rb

@@ -45,6 +45,8 @@ module MatrixSdk
       "#{sigil}#{localpart}#{homeserver_suffix}"
     end
 
+    alias to_str to_s
+
     # Returns the type of the ID
     #
     # @return [Symbol] The MXID type, one of (:user_id, :room_id, :event_id, :group_id, or :room_alias)

data/lib/matrix_sdk/protocols/cs.rb

@@ -203,7 +203,7 @@ module MatrixSdk::Protocols::CS
     data[:device_id] = device_id if device_id
 
     request(:post, client_api_latest, '/login', body: data, query: query).tap do |resp|
-      @access_token = resp.token if resp.key?(:token) && options[:store_token]
+      @access_token = resp.access_token if resp.key?(:access_token) && options[:store_token]
       @device_id = resp.device_id if resp.key?(:device_id) && options[:store_device_id]
     end
   end
@@ -519,6 +519,8 @@ module MatrixSdk::Protocols::CS
     request(:put, client_api_latest, "/rooms/#{room_id}/state/#{event_type}#{"/#{state_key}" unless state_key.nil?}", body: content, query: query)
   end
 
+  alias set_room_state send_state_event
+
   # Sends a message event to a room
   # @param room_id [MXID,String] The room ID to send the message event to
   # @param event_type [String] The event type of the message
@@ -912,31 +914,23 @@ module MatrixSdk::Protocols::CS
     send_state_event(room_id, 'm.room.avatar', content, **params)
   end
 
-  # Gets a list of current aliases of a room
+  # Gets a list of currently known aliases of a room
   #
   # @param [MXID,String] room_id The room ID to look up
-  # @param [Hash] params Extra options to provide to the request, see #get_room_state
   # @return [Response] A response hash with the array :aliases
-  # @raise [MatrixNotFoundError] Raised if no aliases has been set on the room by the specified HS
-  # @see get_room_state
-  # @see https://matrix.org/docs/spec/client_server/latest.html#m-room-avatar
+  # @raise [MatrixForbiddenError] Raised if the user doesn't have the right to read aliases
+  # @see https://spec.matrix.org/v1.1/client-server-api/#get_matrixclientv3roomsroomidaliases
   #      The Matrix Spec, for more information about the event and data
   # @example Looking up aliases for a room
   #   api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org')
-  #   # MatrixSdk::MatrixNotFoundError: HTTP 404 (M_NOT_FOUND): Event not found.
-  #   api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org', key: 'matrix.org')
   #   # => {:aliases=>["#matrix:matrix.org"]}
-  #   api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org', key: 'kittenface.studio')
-  #   # => {:aliases=>["#worlddominationhq:kittenface.studio"]}
-  # @example A way to find all aliases for a room
-  #   api.get_room_state('!mjbDjyNsRXndKLkHIe:matrix.org')
-  #      .select { |ch| ch[:type] == 'm.room.aliases' }
-  #      .map { |ch| ch[:content][:aliases] }
-  #      .flatten
-  #      .compact
-  #   # => ["#synapse:im.kabi.tk", "#synapse:matrix.org", "#synapse-community:matrix.org", "#synapse-ops:matrix.org", "#synops:matrix.org", ...
   def get_room_aliases(room_id, **params)
-    get_room_state(room_id, 'm.room.aliases', **params)
+    query = {}
+    query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)
+
+    room_id = ERB::Util.url_encode room_id.to_s
+
+    request(:get, client_api_latest, "/rooms/#{room_id}/aliases", query: query)
   end
 
   # Gets a list of pinned events in a room

data/lib/matrix_sdk/protocols/msc.rb

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