matrix_sdk 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39fdb05386da317f2810f25e668ae14bdd261c807bafc61056fa09dd1d6a8175
-  data.tar.gz: 88b32840ca73b6588f36e35edcccac15e721b071c69a60c6cfc383dceaf67e5f
+  metadata.gz: 4cf8d41f930fae4069a51d6fff87e211a790529c5f157ff6402c15b44770f64d
+  data.tar.gz: 7c06c98e08232dd24f9667dfbb850a2d12ed2021b2f30cb3ad0cbd2a38e8f6e0
 SHA512:
-  metadata.gz: b04d1f07b5d9dd97f3a80a2adffe9a4a29983efc4ee7d1c116c0036233e017d5d9ead02abc9a3048fc9b0ba51c1ee3353fd7ae999a7b5bfc8a41294cd9c1b47c
-  data.tar.gz: a27b7a3bf9b8c411e6026107d3d0a66cd0e86ac96f6bd6284ccc37ec35e3fd67a94a99b1ad2e67f948dd63003bd4f7495fc66baf3b0d1dc880ee300e1aa49b70
+  metadata.gz: dfc1717d3b368fffd50f3fb717a3742bf821f3863e4c493797117f15a724ee4bf15be3b45d2dc1d7971a0206e1f21febf128eef389cdd8fa42274e6da1208530
+  data.tar.gz: 1025e4fc9d9f6fe7718971ba3b4c74a0ac35297eb0bb592ad3e25505ec2ec39a36c5d518a835e357b93994db4197066566b17c0696c2298017cdc560e7e7a1ee

data/.rubocop.yml

@@ -8,6 +8,9 @@ AllCops:
 Lint/Void:
   Enabled: false
 
+Style/ClassAndModuleChildren:
+  Enabled: false
+
 # Don't enforce documentation
 Style/Documentation:
   Enabled: false
@@ -18,6 +21,10 @@ Metrics/ClassLength:
 Metrics/MethodLength:
   Max: 50
 
+# Matrix has a lot of methods in the CS API
+Metrics/ModuleLength:
+  Max: 500
+
 Metrics/LineLength:
   Max: 190
 

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v0.1.0 - 2019-05-10
+
+- Adds code for handling member lazy load in the client abstraction, and activates it by default
+- Adds methods to read device keys from users
+- Adds basic methods for device handling
+- Restructures the API code to separate protocol implementations
+- Improves the domain discovery code to support all currently specced methods
+- Improves performance in sync calls
+- Started work on an application service prototype, not ready for use yet
+- Testing has been written for large parts of the code
+
 ## v0.0.4 - 2019-02-20
 
 - Adds a parameter to the client abstraction to allow retrying syncs on timeouts

data/README.md

@@ -2,6 +2,8 @@
 
 A Ruby gem for easing the development of software that communicates with servers implementing the Matrix protocol.
 
+There is a Matrix room for the discussion about usage and development at [#ruby-matrix-sdk:kittenface.studio](https://matrix.to/#/#ruby-matrix-sdk:kittenface.studio).
+
 Live YARD documentation can be found at; http://aleol57.gitlab-pages.liu.se/ruby-matrix-sdk
 
 ## Example usage

data/examples/simple_client.rb

@@ -16,7 +16,8 @@ ROOM_DISCOVERY_FILTER = {
         'm.room.aliases',
         'm.room.canonical_alias',
         'm.room.member'
-      ]
+      ],
+      lazy_load_members: true
     },
     timeline: { senders: [], types: [] },
     account_data: { senders: [], types: [] }
@@ -30,7 +31,8 @@ ROOM_STATE_FILTER = {
   room: {
     ephemeral: { senders: [], types: [] },
     state: {
-      types: ['m.room.member']
+      types: ['m.room.member'],
+      lazy_load_members: true
     },
     timeline: {
       types: ['m.room.message']
@@ -93,6 +95,7 @@ if $PROGRAM_NAME == __FILE__
   raise "Usage: #{$PROGRAM_NAME} [-d] homeserver_url room_id_or_alias" unless ARGV.length >= 2
   begin
     if ARGV.first == '-d'
+      Thread.abort_on_exception = true
       MatrixSdk.debug!
       ARGV.shift
     end
@@ -111,7 +114,7 @@ if $PROGRAM_NAME == __FILE__
     # Only retrieve list of joined room in first sync
     sync_filter = client.sync_filter.merge(ROOM_DISCOVERY_FILTER)
     sync_filter[:room][:state][:senders] << client.mxid
-    client.listen_for_events(5, filter: sync_filter.to_json)
+    client.listen_for_events(timeout: 5, filter: sync_filter.to_json)
 
     puts 'Finding room...'
     room = client.find_room(ARGV.last)

data/lib/matrix_sdk.rb

@@ -1,10 +1,13 @@
 require 'matrix_sdk/extensions'
 require 'matrix_sdk/version'
 
+require 'json'
+
 autoload :Logging, 'logging'
 
 module MatrixSdk
   autoload :Api, 'matrix_sdk/api'
+  autoload :ApplicationService, 'matrix_sdk/application_service'
   autoload :Client, 'matrix_sdk/client'
   autoload :MXID, 'matrix_sdk/mxid'
   autoload :Response, 'matrix_sdk/response'
@@ -14,15 +17,23 @@ module MatrixSdk
   autoload :MatrixError, 'matrix_sdk/errors'
   autoload :MatrixRequestError, 'matrix_sdk/errors'
   autoload :MatrixConnectionError, 'matrix_sdk/errors'
+  autoload :MatrixTimeoutError, 'matrix_sdk/errors'
   autoload :MatrixUnexpectedResponseError, 'matrix_sdk/errors'
 
+  module Protocols
+    autoload :AS, 'matrix_sdk/protocols/as'
+    autoload :CS, 'matrix_sdk/protocols/cs'
+    autoload :IS, 'matrix_sdk/protocols/is'
+    autoload :SS, 'matrix_sdk/protocols/ss'
+  end
+
   def self.debug!
     logger.level = :debug
   end
 
   def self.logger
-    @logger ||= Logging.logger[self].tap do |logger|
-      logger.add_appenders Logging.appenders.stdout
+    @logger ||= ::Logging.logger[self].tap do |logger|
+      logger.add_appenders ::Logging.appenders.stdout
       logger.level = :info
     end
   end

data/lib/matrix_sdk/api.rb

@@ -1,13 +1,18 @@
 require 'matrix_sdk'
 
-require 'cgi'
-require 'json'
+require 'erb'
 require 'net/http'
 require 'openssl'
 require 'uri'
 
 module MatrixSdk
   class Api
+    include MatrixSdk::Logging
+    include MatrixSdk::Protocols::AS
+    include MatrixSdk::Protocols::CS
+    include MatrixSdk::Protocols::IS
+    include MatrixSdk::Protocols::CS
+
     USER_AGENT = "Ruby Matrix SDK v#{MatrixSdk::VERSION}".freeze
     DEFAULT_HEADERS = {
       'accept' => 'application/json',
@@ -15,12 +20,13 @@ module MatrixSdk
     }.freeze
 
     attr_accessor :access_token, :connection_address, :connection_port, :device_id, :autoretry, :global_headers
-    attr_reader :homeserver, :validate_certificate, :read_timeout
+    attr_reader :homeserver, :validate_certificate, :read_timeout, :protocols, :well_known
 
     ignore_inspect :access_token, :logger
 
     # @param homeserver [String,URI] The URL to the Matrix homeserver, without the /_matrix/ part
     # @param params [Hash] Additional parameters on creation
+    # @option params [Symbol[]] :protocols The protocols to include (:AS, :CS, :IS, :SS), defaults to :CS
     # @option params [String] :address The connection address to the homeserver, if different to the HS URL
     # @option params [Integer] :port The connection port to the homeserver, if different to the HS URL
     # @option params [String] :access_token The access token to use for the connection
@@ -32,12 +38,17 @@ module MatrixSdk
     # @option params [Numeric] :read_timeout (240) The timeout in seconds for reading responses
     # @option params [Hash] :global_headers Additional headers to set for all requests
     # @option params [Boolean] :skip_login Should the API skip logging in if the HS URL contains user information
+    # @option params [Hash] :well_known The .well-known object that the server was discovered through, should not be set manually
     def initialize(homeserver, params = {})
       @homeserver = homeserver
       @homeserver = URI.parse("#{'https://' unless @homeserver.start_with? 'http'}#{@homeserver}") unless @homeserver.is_a? URI
       @homeserver.path.gsub!(/\/?_matrix\/?/, '') if @homeserver.path =~ /_matrix\/?$/
       raise 'Please use the base URL for your HS (without /_matrix/)' if @homeserver.path.include? '/_matrix/'
 
+      @protocols = params.fetch(:protocols, %i[CS])
+      @protocols = [@protocols] unless @protocols.is_a? Array
+      @protocols << :CS if @protocols.include?(:AS) && !@protocols.include?(:CS)
+
       @connection_address = params.fetch(:address, nil)
       @connection_port = params.fetch(:port, nil)
       @access_token = params.fetch(:access_token, nil)
@@ -47,10 +58,11 @@ module MatrixSdk
       @transaction_id = params.fetch(:transaction_id, 0)
       @backoff_time = params.fetch(:backoff_time, 5000)
       @read_timeout = params.fetch(:read_timeout, 240)
+      @well_known = params.fetch(:well_known, {})
       @global_headers = DEFAULT_HEADERS.dup
       @global_headers.merge!(params.fetch(:global_headers)) if params.key? :global_headers
 
-      login(user: @homeserver.user, password: @homeserver.password) if @homeserver.user && @homeserver.password && !@access_token && !params[:skip_login]
+      login(user: @homeserver.user, password: @homeserver.password) if @homeserver.user && @homeserver.password && !@access_token && !params[:skip_login] && protocol?(:CS)
       @homeserver.userinfo = '' unless params[:skip_login]
     end
 
@@ -66,25 +78,42 @@ module MatrixSdk
     #   # => 443
     #
     # @param domain [String] The domain to set up the API connection for, can contain a ':' to denote a port
+    # @param target [:client,:identity,:server] The target for the domain lookup
+    # @param keep_wellknown [Boolean] Should the .well-known response be kept for further handling
     # @param params [Hash] Additional options to pass to .new
     # @return [API] The API connection
-    def self.new_for_domain(domain, params = {})
-      # Attempt SRV record discovery
-      srv = if domain.include? ':'
-              addr, port = domain.split ':'
-              Resolv::DNS::Resource::IN::SRV.new 10, 1, port.to_i, addr
-            else
-              require 'resolv'
-              resolver = Resolv::DNS.new
-              begin
-                resolver.getresource("_matrix._tcp.#{domain}")
-              rescue Resolv::ResolvError
-                nil
-              end
-            end
-
-      # Attempt .well-known discovery
-      if srv.nil?
+    def self.new_for_domain(domain, target: :client, keep_wellknown: false, ssl: true, **params)
+      domain, port = domain.split(':')
+      uri = URI("http#{ssl ? 's' : ''}://#{domain}")
+      well_known = nil
+      target_uri = nil
+
+      if !port.nil? && !port.empty?
+        target_uri = URI("https://#{domain}:#{port}")
+      elsif target == :server
+        # Attempt SRV record discovery
+        target_uri = begin
+                       require 'resolv'
+                       resolver = Resolv::DNS.new
+                       resolver.getresource("_matrix._tcp.#{domain}")
+                     rescue StandardError
+                       nil
+                     end
+
+        if target_uri.nil?
+          well_known = begin
+                         data = Net::HTTP.get("https://#{domain}/.well-known/matrix/server")
+                         JSON.parse(data)
+                       rescue StandardError
+                         nil
+                       end
+
+          target_uri = well_known['m.server'] if well_known && well_known.key?('m.server')
+        else
+          target_uri = URI("https://#{target_uri.target}:#{target_uri.port}")
+        end
+      elsif %i[client identity].include? target
+        # Attempt .well-known discovery
         well_known = begin
                        data = Net::HTTP.get("https://#{domain}/.well-known/matrix/client")
                        JSON.parse(data)
@@ -92,26 +121,31 @@ module MatrixSdk
                        nil
                      end
 
-        return new(well_known['m.homeserver']['base_url']) if well_known &&
-                                                              well_known.key?('m.homeserver') &&
-                                                              well_known['m.homerserver'].key?('base_url')
+        if well_known
+          key = 'm.homeserver'
+          key = 'm.identity_server' if target == :identity
+
+          if well_known.key?(key) && well_known[key].key?('base_url')
+            uri = URI(well_known[key]['base_url'])
+            target_uri = uri
+          end
+        end
       end
 
-      # Fall back to A record on domain
-      srv ||= Resolv::DNS::Resource::IN::SRV.new 10, 1, 8448, domain
+      # Fall back to direct domain connection
+      target_uri ||= URI("https://#{domain}:8448")
+
+      params[:well_known] = well_known if keep_wellknown
 
-      domain = domain.split(':').first if domain.include? ':'
-      new("https://#{domain}",
+      new(uri,
           params.merge(
-            address: srv.target.to_s,
-            port: srv.port
+            address: target_uri.host,
+            port: target_uri.port
           ))
     end
 
-    # Gets the logger for the API
-    # @return [Logging::Logger] The API-scope logger
-    def logger
-      @logger ||= Logging.logger[self]
+    def protocol?(protocol)
+      protocols.include? protocol
     end
 
     # @param seconds [Numeric]
@@ -139,690 +173,6 @@ module MatrixSdk
       @homeserver = hs_info
     end
 
-    # Gets the available client API versions
-    # @return [Array]
-    def client_api_versions
-      @client_api_versions ||= request(:get, :client, '/versions').versions.tap do |vers|
-        vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
-          def latest
-            latest
-          end
-        CODE
-      end
-    end
-
-    # Gets the list of available unstable client API features
-    # @return [Array]
-    def client_api_unstable_features
-      @client_api_unstable_features ||= request(:get, :client, '/versions').unstable_features.tap do |vers|
-        vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
-          def has?(feature)
-            fetch(feature, nil)
-          end
-        CODE
-      end
-    end
-
-    # Gets the server version
-    # @note This uses the unstable federation/v1 API
-    def server_version
-      Response.new(self, request(:get, :federation_v1, '/version').server).tap do |resp|
-        resp.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
-          def to_s
-            "#{name} #{version}"
-          end
-        CODE
-      end
-    end
-
-    # Runs the client API /sync method
-    # @param params [Hash] The sync options to use
-    # @option params [Numeric] :timeout (30.0) The timeout in seconds for the sync
-    # @option params :since The value of the batch token to base the sync from
-    # @option params [String,Hash] :filter The filter to use on the sync
-    # @option params [Boolean] :full_state Should the sync include the full state
-    # @option params [Boolean] :set_presence Should the sync set the user status to online
-    # @return [Response]
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#get-matrix-client-r0-sync
-    #      For more information on the parameters and what they mean
-    def sync(params = {})
-      query = {
-        timeout: 30.0
-      }.merge(params).select do |k, _v|
-        %i[since timeout filter full_state set_presence].include? k
-      end
-
-      query[:timeout] = ((query[:timeout] || 30) * 1000).to_i
-      query[:timeout] = params.delete(:timeout_ms).to_i if params.key? :timeout_ms
-
-      request(:get, :client_r0, '/sync', query: query)
-    end
-
-    # Registers a user using the client API /register endpoint
-    #
-    # @example Regular user registration and login
-    #   api.register(username: 'example', password: 'NotARealPass')
-    #   # => { user_id: '@example:matrix.org', access_token: '...', home_server: 'matrix.org', device_id: 'ABCD123' }
-    #   api.whoami?
-    #   # => { user_id: '@example:matrix.org' }
-    #
-    # @param params [Hash] The registration information, all not handled by Ruby will be passed as JSON in the body
-    # @option params [String,Symbol] :kind ('user') The kind of registration to use
-    # @option params [Boolean] :store_token (true) Should the resulting access token be stored for the API
-    # @option params [Boolean] :store_device_id (store_token value) Should the resulting device ID be stored for the API
-    # @return [Response]
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#post-matrix-client-r0-register
-    #      For options that are permitted in this call
-    def register(params = {})
-      kind = params.delete(:kind) { 'user' }
-      store_token = params.delete(:store_token) { true }
-      store_device_id = params.delete(:store_device_id) { store_token }
-
-      request(:post, :client_r0, '/register', body: params, query: { kind: kind }).tap do |resp|
-        @access_token = resp.token if resp.key?(:token) && store_token
-        @device_id = resp.device_id if resp.key?(:device_id) && store_device_id
-      end
-    end
-
-    # Logs in using the client API /login endpoint, and optionally stores the resulting access for API usage
-    #
-    # @example Logging in with username and password
-    #   api.login(user: 'example', password: 'NotARealPass')
-    #   # => { user_id: '@example:matrix.org', access_token: '...', home_server: 'matrix.org', device_id: 'ABCD123' }
-    #   api.whoami?
-    #   # => { user_id: '@example:matrix.org' }
-    #
-    # @example Advanced login, without storing details
-    #   api.whoami?
-    #   # => { user_id: '@example:matrix.org' }
-    #   api.login(medium: 'email', address: 'someone@somewhere.net', password: '...', store_token: false)
-    #   # => { user_id: '@someone:matrix.org', access_token: ...
-    #   api.whoami?.user_id
-    #   # => '@example:matrix.org'
-    #
-    # @param params [Hash] The login information to use, along with options for said log in
-    # @option params [Boolean] :store_token (true) Should the resulting access token be stored for the API
-    # @option params [Boolean] :store_device_id (store_token value) Should the resulting device ID be stored for the API
-    # @option params [String] :login_type ('m.login.password') The type of login to attempt
-    # @option params [String] :initial_device_display_name (USER_AGENT) The device display name to specify for this login attempt
-    # @option params [String] :device_id The device ID to set on the login
-    # @return [Response] A response hash with the parameters :user_id, :access_token, :home_server, and :device_id.
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#post-matrix-client-r0-login
-    #      The Matrix Spec, for more information about the call and response
-    def login(params = {})
-      options = {}
-      options[:store_token] = params.delete(:store_token) { true }
-      options[:store_device_id] = params.delete(:store_device_id) { options[:store_token] }
-
-      data = {
-        type: params.delete(:login_type) { 'm.login.password' },
-        initial_device_display_name: params.delete(:initial_device_display_name) { USER_AGENT }
-      }.merge params
-      data[:device_id] = device_id if device_id
-
-      request(:post, :client_r0, '/login', body: data).tap do |resp|
-        @access_token = resp.token if resp.key?(:token) && options[:store_token]
-        @device_id = resp.device_id if resp.key?(:device_id) && options[:store_device_id]
-      end
-    end
-
-    # Logs out the currently logged in user
-    # @return [Response] An empty response if the logout was successful
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#post-matrix-client-r0-logout
-    #      The Matrix Spec, for more information about the call and response
-    def logout
-      request(:post, :client_r0, '/logout')
-    end
-
-    # Creates a new room
-    # @param params [Hash] The room creation details
-    # @option params [Symbol] :visibility (:public) The room visibility
-    # @option params [String] :room_alias A room alias to apply on creation
-    # @option params [Boolean] :invite Should the room be created invite-only
-    # @return [Response] A response hash with ...
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#post-matrix-client-r0-createroom
-    #      The Matrix Spec, for more information about the call and response
-    def create_room(params = {})
-      content = {
-        visibility: params.fetch(:visibility, :public)
-      }
-      content[:room_alias_name] = params[:room_alias] if params[:room_alias]
-      content[:invite] = [params[:invite]].flatten if params[:invite]
-
-      request(:post, :client_r0, '/createRoom', content)
-    end
-
-    # Joins a room
-    # @param id_or_alias [MXID,String] The room ID or Alias to join
-    # @return [Response] A response hash with the parameter :room_id
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#post-matrix-client-r0-join-roomidoralias
-    #      The Matrix Spec, for more information about the call and response
-    def join_room(id_or_alias)
-      # id_or_alias = MXID.new id_or_alias.to_s unless id_or_alias.is_a? MXID
-      # raise ArgumentError, 'Not a room ID or alias' unless id_or_alias.room?
-
-      id_or_alias = CGI.escape id_or_alias.to_s
-
-      request(:post, :client_r0, "/join/#{id_or_alias}")
-    end
-
-    # Sends a state event to a room
-    # @param room_id [MXID,String] The room ID to send the state event to
-    # @param event_type [String] The event type to send
-    # @param content [Hash] The contents of the state event
-    # @param params [Hash] Options for the request
-    # @option params [Integer] :timestamp The timestamp when the event was created, only used for AS events
-    # @option params [String] :state_key The state key of the event, if there is one
-    # @return [Response] A response hash with the parameter :event_id
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#put-matrix-client-r0-rooms-roomid-state-eventtype-statekey
-    #      https://matrix.org/docs/spec/client_server/r0.3.0.html#put-matrix-client-r0-rooms-roomid-state-eventtype
-    #      The Matrix Spec, for more information about the call and response
-    def send_state_event(room_id, event_type, content, params = {})
-      query = {}
-      query[:ts] = params[:timestamp].to_i if params.key? :timestamp
-
-      room_id = CGI.escape room_id.to_s
-      event_type = CGI.escape event_type.to_s
-      state_key = CGI.escape params[:state_key].to_s if params.key? :state_key
-
-      request(:put, :client_r0, "/rooms/#{room_id}/state/#{event_type}#{"/#{state_key}" unless state_key.nil?}", body: content, query: query)
-    end
-
-    # 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
-    # @param content [Hash] The contents of the message
-    # @param params [Hash] Options for the request
-    # @option params [Integer] :timestamp The timestamp when the event was created, only used for AS events
-    # @option params [Integer] :txn_id The ID of the transaction, or automatically generated
-    # @return [Response] A response hash with the parameter :event_id
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#put-matrix-client-r0-rooms-roomid-send-eventtype-txnid
-    #      The Matrix Spec, for more information about the call and response
-    def send_message_event(room_id, event_type, content, params = {})
-      query = {}
-      query[:ts] = params[:timestamp].to_i if params.key? :timestamp
-
-      txn_id = transaction_id
-      txn_id = params.fetch(:txn_id, "#{txn_id}#{Time.now.to_i}")
-
-      room_id = CGI.escape room_id.to_s
-      event_type = CGI.escape event_type.to_s
-      txn_id = CGI.escape txn_id.to_s
-
-      request(:put, :client_r0, "/rooms/#{room_id}/send/#{event_type}/#{txn_id}", body: content, query: query)
-    end
-
-    # Redact an event in a room
-    # @param room_id [MXID,String] The room ID to send the message event to
-    # @param event_id [String] The event ID of the event to redact
-    # @param params [Hash] Options for the request
-    # @option params [Integer] :timestamp The timestamp when the event was created, only used for AS events
-    # @option params [String] :reason The reason for the redaction
-    # @option params [Integer] :txn_id The ID of the transaction, or automatically generated
-    # @return [Response] A response hash with the parameter :event_id
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#put-matrix-client-r0-rooms-roomid-redact-eventid-txnid
-    #      The Matrix Spec, for more information about the call and response
-    def redact_event(room_id, event_id, params = {})
-      query = {}
-      query[:ts] = params[:timestamp].to_i if params.key? :timestamp
-
-      content = {}
-      content[:reason] = params[:reason] if params[:reason]
-
-      txn_id = transaction_id
-      txn_id = params.fetch(:txn_id, "#{txn_id}#{Time.now.to_i}")
-
-      room_id = CGI.escape room_id.to_s
-      event_id = CGI.escape event_id.to_s
-      txn_id = CGI.escape txn_id.to_s
-
-      request(:put, :client_r0, "/rooms/#{room_id}/redact/#{event_id}/#{txn_id}", body: content, query: query)
-    end
-
-    # Send a content message to a room
-    #
-    # @example Sending an image to a room
-    #   send_content('!abcd123:localhost',
-    #                'mxc://localhost/1234567',
-    #                'An image of a cat',
-    #                'm.image',
-    #                extra_information: {
-    #                  h: 128,
-    #                  w: 128,
-    #                  mimetype: 'image/png',
-    #                  size: 1024
-    #                })
-    #
-    # @example Sending a file to a room
-    #   send_content('!example:localhost',
-    #                'mxc://localhost/fileurl',
-    #                'Contract.pdf',
-    #                'm.file',
-    #                extra_content: {
-    #                  filename: 'contract.pdf'
-    #                },
-    #                extra_information: {
-    #                  mimetype: 'application/pdf',
-    #                  size: 96674
-    #                })
-    #
-    # @param room_id [MXID,String] The room ID to send the content to
-    # @param url [URI,String] The URL to the content
-    # @param name [String] The name of the content
-    # @param msg_type [String] The message type of the content
-    # @param params [Hash] Options for the request
-    # @option params [Hash] :extra_information ({}) Extra information for the content
-    # @option params [Hash] :extra_content Extra data to insert into the content hash
-    # @return [Response] A response hash with the parameter :event_id
-    # @see send_message_event For more information on the underlying call
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-image
-    #      https://matrix.org/docs/spec/client_server/r0.3.0.html#m-file
-    #      https://matrix.org/docs/spec/client_server/r0.3.0.html#m-video
-    #      https://matrix.org/docs/spec/client_server/r0.3.0.html#m-audio
-    #      The Matrix Spec, for more information about the call and response
-    def send_content(room_id, url, name, msg_type, params = {})
-      content = {
-        url: url,
-        msgtype: msg_type,
-        body: name,
-        info: params.delete(:extra_information) { {} }
-      }
-      content.merge!(params.fetch(:extra_content)) if params.key? :extra_content
-
-      send_message_event(room_id, 'm.room.message', content, params)
-    end
-
-    # Send a geographic location to a room
-    #
-    # @param room_id [MXID,String] The room ID to send the location to
-    # @param geo_uri [URI,String] The geographical URI to send
-    # @param name [String] The name of the location
-    # @param params [Hash] Options for the request
-    # @option params [Hash] :extra_information ({}) Extra information for the location
-    # @option params [URI,String] :thumbnail_url The URL to a thumbnail of the location
-    # @option params [Hash] :thumbnail_info Image information about the location thumbnail
-    # @return [Response] A response hash with the parameter :event_id
-    # @see send_message_event For more information on the underlying call
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-location
-    #      The Matrix Spec, for more information about the call and response
-    def send_location(room_id, geo_uri, name, params = {})
-      content = {
-        geo_uri: geo_uri,
-        msgtype: 'm.location',
-        body: name,
-        info: params.delete(:extra_information) { {} }
-      }
-      content[:info][:thumbnail_url] = params.delete(:thumbnail_url) if params.key? :thumbnail_url
-      content[:info][:thumbnail_info] = params.delete(:thumbnail_info) if params.key? :thumbnail_info
-
-      send_message_event(room_id, 'm.room.message', content, params)
-    end
-
-    # Send a plaintext message to a room
-    #
-    # @param room_id [MXID,String] The room ID to send the message to
-    # @param message [String] The message to send
-    # @param params [Hash] Options for the request
-    # @option params [String] :msg_type ('m.text') The message type to send
-    # @return [Response] A response hash with the parameter :event_id
-    # @see send_message_event For more information on the underlying call
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-text
-    #      The Matrix Spec, for more information about the call and response
-    def send_message(room_id, message, params = {})
-      content = {
-        msgtype: params.delete(:msg_type) { 'm.text' },
-        body: message
-      }
-      send_message_event(room_id, 'm.room.message', content, params)
-    end
-
-    # Send a plaintext emote to a room
-    #
-    # @param room_id [MXID,String] The room ID to send the message to
-    # @param emote [String] The emote to send
-    # @param params [Hash] Options for the request
-    # @option params [String] :msg_type ('m.emote') The message type to send
-    # @return [Response] A response hash with the parameter :event_id
-    # @see send_message_event For more information on the underlying call
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-emote
-    #      The Matrix Spec, for more information about the call and response
-    def send_emote(room_id, emote, params = {})
-      content = {
-        msgtype: params.delete(:msg_type) { 'm.emote' },
-        body: emote
-      }
-      send_message_event(room_id, 'm.room.message', content, params)
-    end
-
-    # Send a plaintext notice to a room
-    #
-    # @param room_id [MXID,String] The room ID to send the message to
-    # @param notice [String] The notice to send
-    # @param params [Hash] Options for the request
-    # @option params [String] :msg_type ('m.notice') The message type to send
-    # @return [Response] A response hash with the parameter :event_id
-    # @see send_message_event For more information on the underlying call
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-notice
-    #      The Matrix Spec, for more information about the call and response
-    def send_notice(room_id, notice, params = {})
-      content = {
-        msgtype: params.delete(:msg_type) { 'm.notice' },
-        body: notice
-      }
-      send_message_event(room_id, 'm.room.message', content, params)
-    end
-
-    # Retrieve additional messages in a room
-    #
-    # @param room_id [MXID,String] The room ID to retrieve messages for
-    # @param token [String] The token to start retrieving from, can be from a sync or from an earlier get_room_messages call
-    # @param direction [:b,:f] The direction to retrieve messages
-    # @param params [Hash] Additional options for the request
-    # @option params [Integer] :limit (10) The limit of messages to retrieve
-    # @option params [String] :to A token to limit retrieval to
-    # @option params [String] :filter A filter to limit the retrieval to
-    # @return [Response] A response hash with the message information containing :start, :end, and :chunk fields
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#get-matrix-client-r0-rooms-roomid-messages
-    #      The Matrix Spec, for more information about the call and response
-    def get_room_messages(room_id, token, direction, params = {})
-      query = {
-        roomId: room_id,
-        from: token,
-        dir: direction,
-        limit: params.fetch(:limit, 10)
-      }
-      query[:to] = params[:to] if params.key? :to
-      query[:filter] = params.fetch(:filter) if params.key? :filter
-
-      room_id = CGI.escape room_id.to_s
-
-      request(:get, :client_r0, "/rooms/#{room_id}/messages", query: query)
-    end
-
-    # Reads the latest instance of a room state event
-    #
-    # @param room_id [MXID,String] The room ID to read from
-    # @param state_type [String] The state type to read
-    # @return [Response] A response hash with the contents of the state event
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#get-matrix-client-r0-rooms-roomid-state-eventtype
-    #      The Matrix Spec, for more information about the call and response
-    def get_room_state(room_id, state_type)
-      room_id = CGI.escape room_id.to_s
-      state_type = CGI.escape state_type.to_s
-
-      request(:get, :client_r0, "/rooms/#{room_id}/state/#{state_type}")
-    end
-
-    # Gets the display name of a room
-    #
-    # @param room_id [MXID,String] The room ID to look up
-    # @return [Response] A response hash with the parameter :name
-    # @see get_room_state
-    # @see https://matrix.org/docs/spec/client_server/r0.3.0.html#m-room-name
-    #      The Matrix Spec, for more information about the event and data
-    def get_room_name(room_id)
-      get_room_state(room_id, 'm.room.name')
-    end
-
-    def set_room_name(room_id, name, params = {})
-      content = {
-        name: name
-      }
-      send_state_event(room_id, 'm.room.name', content, params)
-    end
-
-    def get_room_topic(room_id)
-      get_room_state(room_id, 'm.room.topic')
-    end
-
-    def set_room_topic(room_id, topic, params = {})
-      content = {
-        topic: topic
-      }
-      send_state_event(room_id, 'm.room.topic', content, params)
-    end
-
-    def get_power_levels(room_id)
-      get_room_state(room_id, 'm.room.power_levels')
-    end
-
-    def set_power_levels(room_id, content)
-      content[:events] = {} unless content.key? :events
-      send_state_event(room_id, 'm.room.power_levels', content)
-    end
-
-    def leave_room(room_id)
-      room_id = CGI.escape room_id.to_s
-
-      request(:post, :client_r0, "/rooms/#{room_id}/leave")
-    end
-
-    def forget_room(room_id)
-      room_id = CGI.escape room_id.to_s
-
-      request(:post, :client_r0, "/rooms/#{room_id}/forget")
-    end
-
-    def invite_user(room_id, user_id)
-      content = {
-        user_id: user_id
-      }
-
-      room_id = CGI.escape room_id.to_s
-
-      request(:post, :client_r0, "/rooms/#{room_id}/invite", body: content)
-    end
-
-    def kick_user(room_id, user_id, params = {})
-      set_membership(room_id, user_id, 'leave', params)
-    end
-
-    def get_membership(room_id, user_id)
-      room_id = CGI.escape room_id.to_s
-      user_id = CGI.escape user_id.to_s
-
-      request(:get, :client_r0, "/rooms/#{room_id}/state/m.room.member/#{user_id}")
-    end
-
-    def set_membership(room_id, user_id, membership, params = {})
-      content = {
-        membership: membership,
-        reason: params.delete(:reason) { '' }
-      }
-      content[:displayname] = params.delete(:displayname) if params.key? :displayname
-      content[:avatar_url] = params.delete(:avatar_url) if params.key? :avatar_url
-
-      send_state_event(room_id, 'm.room.member', content, params.merge(state_key: user_id))
-    end
-
-    def ban_user(room_id, user_id, params = {})
-      content = {
-        user_id: user_id,
-        reason: params[:reason] || ''
-      }
-
-      room_id = CGI.escape room_id.to_s
-
-      request(:post, :client_r0, "/rooms/#{room_id}/ban", body: content)
-    end
-
-    def unban_user(room_id, user_id)
-      content = {
-        user_id: user_id
-      }
-
-      room_id = CGI.escape room_id.to_s
-
-      request(:post, :client_r0, "/rooms/#{room_id}/unban", body: content)
-    end
-
-    def get_user_tags(user_id, room_id)
-      room_id = CGI.escape room_id.to_s
-      user_id = CGI.escape user_id.to_s
-
-      request(:get, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags")
-    end
-
-    def remove_user_tag(user_id, room_id, tag)
-      room_id = CGI.escape room_id.to_s
-      user_id = CGI.escape user_id.to_s
-      tag = CGI.escape tag.to_s
-
-      request(:delete, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags/#{tag}")
-    end
-
-    def add_user_tag(user_id, room_id, tag, params = {})
-      if params[:body]
-        content = params[:body]
-      else
-        content = {}
-        content[:order] = params[:order] if params.key? :order
-      end
-
-      room_id = CGI.escape room_id.to_s
-      user_id = CGI.escape user_id.to_s
-      tag = CGI.escape tag.to_s
-
-      request(:put, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags/#{tag}", body: content)
-    end
-
-    def get_account_data(user_id, type_key)
-      user_id = CGI.escape user_id.to_s
-      type_key = CGI.escape type_key.to_s
-
-      request(:get, :client_r0, "/user/#{user_id}/account_data/#{type_key}")
-    end
-
-    def set_account_data(user_id, type_key, account_data)
-      user_id = CGI.escape user_id.to_s
-      type_key = CGI.escape type_key.to_s
-
-      request(:put, :client_r0, "/user/#{user_id}/account_data/#{type_key}", body: account_data)
-    end
-
-    def get_room_account_data(user_id, room_id, type_key)
-      user_id = CGI.escape user_id.to_s
-      room_id = CGI.escape room_id.to_s
-      type_key = CGI.escape type_key.to_s
-
-      request(:get, :client_r0, "/user/#{user_id}/rooms/#{room_id}/account_data/#{type_key}")
-    end
-
-    def set_room_account_data(user_id, room_id, type_key, account_data)
-      user_id = CGI.escape user_id.to_s
-      room_id = CGI.escape room_id.to_s
-      type_key = CGI.escape type_key.to_s
-
-      request(:put, :client_r0, "/user/#{user_id}/rooms/#{room_id}/account_data/#{type_key}", body: account_data)
-    end
-
-    def get_filter(user_id, filter_id)
-      user_id = CGI.escape user_id.to_s
-      filter_id = CGI.escape filter_id.to_s
-
-      request(:get, :client_r0, "/user/#{user_id}/filter/#{filter_id}")
-    end
-
-    def create_filter(user_id, filter_params)
-      user_id = CGI.escape user_id.to_s
-
-      request(:post, :client_r0, "/user/#{user_id}/filter", body: filter_params)
-    end
-
-    def media_upload(content, content_type)
-      request(:post, :media_r0, '/upload', body: content, headers: { 'content-type' => content_type })
-    end
-
-    def get_display_name(user_id)
-      user_id = CGI.escape user_id.to_s
-
-      request(:get, :client_r0, "/profile/#{user_id}/displayname")
-    end
-
-    def set_display_name(user_id, display_name)
-      content = {
-        displayname: display_name
-      }
-
-      user_id = CGI.escape user_id.to_s
-
-      request(:put, :client_r0, "/profile/#{user_id}/displayname", body: content)
-    end
-
-    def get_avatar_url(user_id)
-      user_id = CGI.escape user_id.to_s
-
-      request(:get, :client_r0, "/profile/#{user_id}/avatar_url")
-    end
-
-    def set_avatar_url(user_id, url)
-      content = {
-        avatar_url: url
-      }
-
-      user_id = CGI.escape user_id.to_s
-
-      request(:put, :client_r0, "/profile/#{user_id}/avatar_url", body: content)
-    end
-
-    def get_download_url(mxcurl)
-      mxcurl = URI.parse(mxcurl.to_s) unless mxcurl.is_a? URI
-      raise 'Not a mxc:// URL' unless mxcurl.is_a? URI::MATRIX
-
-      homeserver.dup.tap do |u|
-        full_path = CGI.escape mxcurl.full_path.to_s
-        u.path = "/_matrix/media/r0/download/#{full_path}"
-      end
-    end
-
-    def get_room_id(room_alias)
-      room_alias = CGI.escape room_alias.to_s
-
-      request(:get, :client_r0, "/directory/room/#{room_alias}")
-    end
-
-    def set_room_alias(room_id, room_alias)
-      content = {
-        room_id: room_id
-      }
-
-      room_alias = CGI.escape room_alias.to_s
-
-      request(:put, :client_r0, "/directory/room/#{room_alias}", body: content)
-    end
-
-    def remove_room_alias(room_alias)
-      room_alias = CGI.escape room_alias.to_s
-
-      request(:delete, :client_r0, "/directory/room/#{room_alias}")
-    end
-
-    def get_room_members(room_id)
-      room_id = CGI.escape room_id.to_s
-
-      request(:get, :client_r0, "/rooms/#{room_id}/members")
-    end
-
-    def set_join_rule(room_id, join_rule)
-      content = {
-        join_rule: join_rule
-      }
-
-      send_state_event(room_id, 'm.room.join_rules', content)
-    end
-
-    def set_guest_access(room_id, guest_access)
-      # raise ArgumentError, '`guest_access` must be one of [:can_join, :forbidden]' unless %i[can_join forbidden].include? guest_access
-      content = {
-        guest_access: guest_access
-      }
-      send_state_event(room_id, 'm.room.guest_access', content)
-    end
-
-    def whoami?
-      request(:get, :client_r0, '/account/whoami')
-    end
-
     def request(method, api, path, options = {})
       url = homeserver.dup.tap do |u|
         u.path = api_to_path(api) + path
@@ -891,8 +241,8 @@ module MatrixSdk
       clean_body = JSON.parse(http.body) rescue nil if http.body
       clean_body.keys.each { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body
       logger.debug "#{dir} #{clean_body.length < 200 ? clean_body : clean_body.slice(0..200) + "... [truncated, #{clean_body.length} Bytes]"}" if clean_body
-    rescue StandardError => ex
-      logger.warn "#{ex.class} occured while printing request debug; #{ex.message}\n#{ex.backtrace.join "\n"}"
+    rescue StandardError => e
+      logger.warn "#{e.class} occured while printing request debug; #{e.message}\n#{e.backtrace.join "\n"}"
     end
 
     def transaction_id