matrix_sdk 2.4.0 → 2.7.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

@@ -22,11 +22,11 @@ module MatrixSdk
     #   @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_accessor :cache, :sync_filter, :sync_token
 
-    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
@@ -161,7 +161,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 +402,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 +505,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
@@ -552,11 +561,14 @@ module MatrixSdk
       raise ArgumentError, 'Must be a room ID' unless room_id.room_id?
 
       room_id = room_id.to_s
-      @rooms.fetch(room_id) do
+      ret = @rooms.fetch(room_id) do
         room = Room.new(self, room_id)
         @rooms[room_id] = room unless cache == :none
         room
       end
+      # Need to figure out a way to handle multiple types
+      ret = @rooms[room_id] = ret.to_space if ret.instance_variable_get :@room_type
+      ret
     end
 
     def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 0, **params)
@@ -564,10 +576,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...")
@@ -585,7 +600,7 @@ module MatrixSdk
     private
 
     def post_authentication(data)
-      @mxid = data[:user_id]
+      @mxid = MXID.new data[:user_id]
       @api.access_token = data[:access_token]
       @api.device_id = data[:device_id]
       @api.homeserver = data[:home_server]
@@ -602,6 +617,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
@@ -621,6 +644,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)
@@ -648,10 +678,12 @@ 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
         end
       end
 

data/lib/matrix_sdk/mxid.rb

@@ -12,7 +12,7 @@ module MatrixSdk
 
       # TODO: Community-as-a-Room / Profile-as-a-Room, in case they're going for room aliases
       @sigil = identifier[0]
-      @localpart, @domain, @port = identifier[1..].split(':')
+      @localpart, @domain, @port = identifier[1..-1].split(':') # rubocop:disable Style/SlicingWithRange # Keep support for slightly older Rubies
       @port = @port.to_i if @port
 
       raise ArgumentError, 'Identifier is not a valid MXID' unless valid?
@@ -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)