matrix_sdk 2.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1de46ea35a8763e17d834c9395dc95a12c3084557085a0eb6b8e5f1fa25979a
-  data.tar.gz: 13a55698bf72695e8e690d4d5f6618d7efe595f06c32c65580b10e9bf550724e
+  metadata.gz: 4f16ccd1ed10b02a963b9dbd736e577375ca41b26fb45743bc0344f219b1d70f
+  data.tar.gz: 3d8eef54f71ccf9e04c0da896e6189fd8d4c2c34c269e2890de37dd4cec023a6
 SHA512:
-  metadata.gz: 919a27ee7fd758c382eafe3f8aad89c13da2a6cc6542ccd8bfe52d09186d93453b12406dfe6b03b6aa63d1898dbacfb6dbced4f4e9606722ad04df4f237cf600
-  data.tar.gz: a8f5c0bc4fb07a089e0d1daebeb8996c6d36157550e73e3869a8bb55f25cc2c405a064654fc49c8bdb323f9d8c168b3c785e52b9f88fbc168ee29c152f7472a5
+  metadata.gz: 01de0cccbcf0724a101526190ea4e164ec1235daaa0e0c3d42ed445e760246b2b81a054ba4bd7e88229fdb0833e4fe3a8624a4de3dfd032bfa50b4f23946caf1
+  data.tar.gz: 1b177862e3b01aef4c10de6a4318b8348a5c6e00885f0b137ce13a269bf0d5579e6a72b93a87a9366b8d75ec2549518a7d21f2da5db4d7f1d60fa464ff11d83b

data/CHANGELOG.md

@@ -1,6 +1,41 @@
+## 2.2.0 - 2020-11-20
+
+- Adds direct message (1:1) room mapping to client abstraction
+- Adds Api#get_room_event_context (#13)
+- Improves support for JRuby
+
+## 2.1.3 - 2020-09-18
+
+- Adds separate state event handler as Client#on_state_event
+- Changes Client sync interval to by-default run at full speed
+- Fixes state events being sent twice if included in both timeline and state of a sync
+- Improves error reporting of broken 200 responses
+- Improves event handlers for rooms, to not depend on a specific room object instance anymore
+
+## 2.1.2 - 2020-09-10
+
+- Adds method for reading complete member lists for rooms, improves the CS spec adherence
+- Adds test for state events
+- Fixes state event handler for rooms not actually passing events
+- Fixes Api#new_for_domain using a faulty URI in certain cases
+
+## 2.1.1 - 2020-08-21
+
+- Fixes crash if state event content is null (#11)
+- Fixes an uninitialized URI constant exception when requiring only the main library file
+- Fixes the Api#get_pushrules method missing an ending slash in the request URI
+- Fixes discovery code for client/server connections based on domain
+
+## 2.1.0 - 2020-05-22
+
+- Adds unique query IDs as well as duration in API debug output, to make it easier to track long requests
+- Finishes up MSC support, get sync over SSE working flawlessly
+- Exposes the #listen_forever method in the client abstraction
+- Fixes room access methods
+
 ## 2.0.1 - 2020-03-13
 
-- Add code for handling non-final MSC's in protocols
+- Adds code for handling non-final MSC's in protocols
   - Currently implementing clients parts of MSC2018 for Sync over Server Sent Events
 
 ## 2.0.0 - 2020-02-14

data/lib/matrix_sdk/api.rb

@@ -92,6 +92,8 @@ module MatrixSdk
       uri = URI("http#{ssl ? 's' : ''}://#{domain}")
       well_known = nil
       target_uri = nil
+      logger = ::Logging.logger[self]
+      logger.debug "Resolving #{domain}"
 
       if !port.nil? && !port.empty?
         # If the domain is fully qualified according to Matrix (FQDN and port) then skip discovery
@@ -99,21 +101,30 @@ module MatrixSdk
       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
+          require 'resolv'
+          resolver = Resolv::DNS.new
+          srv = "_matrix._tcp.#{domain}"
+          logger.debug "Trying DNS #{srv}..."
+          d = resolver.getresource(srv, Resolv::DNS::Resource::IN::SRV)
+          d
+        rescue StandardError => e
+          logger.debug "DNS lookup failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if target_uri.nil?
           # Attempt .well-known discovery for server-to-server
           well_known = begin
-                         data = Net::HTTP.get("https://#{domain}/.well-known/matrix/server")
-                         JSON.parse(data)
-                       rescue StandardError
-                         nil
-                       end
+            wk_uri = URI("https://#{domain}/.well-known/matrix/server")
+            logger.debug "Trying #{wk_uri}..."
+            data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+              http.get(wk_uri.path).body
+            end
+            JSON.parse(data)
+          rescue StandardError => e
+            logger.debug "Well-known failed with #{e.class}: #{e.message}"
+            nil
+          end
 
           target_uri = well_known['m.server'] if well_known&.key?('m.server')
         else
@@ -122,11 +133,16 @@ module MatrixSdk
       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)
-                     rescue StandardError
-                       nil
-                     end
+          wk_uri = URI("https://#{domain}/.well-known/matrix/client")
+          logger.debug "Trying #{wk_uri}..."
+          data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+            http.get(wk_uri.path).body
+          end
+          JSON.parse(data)
+        rescue StandardError => e
+          logger.debug "Well-known failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if well_known
           key = 'm.homeserver'
@@ -138,6 +154,7 @@ module MatrixSdk
           end
         end
       end
+      logger.debug "Using #{target_uri.inspect}"
 
       # Fall back to direct domain connection
       target_uri ||= URI("https://#{domain}:8448")
@@ -161,6 +178,7 @@ module MatrixSdk
     def protocols
       self
         .class.included_modules
+        .reject { |m| m&.name.nil? }
         .select { |m| m.name.start_with? 'MatrixSdk::Protocols::' }
         .map { |m| m.name.split('::').last.to_sym }
     end
@@ -250,37 +268,32 @@ module MatrixSdk
         u.query = [u.query, URI.encode_www_form(options.fetch(:query))].flatten.compact.join('&') if options[:query]
         u.query = nil if u.query.nil? || u.query.empty?
       end
-      request = Net::HTTP.const_get(method.to_s.capitalize.to_sym).new url.request_uri
-      request.body = options[:body] if options.key? :body
-      request.body = request.body.to_json if options.key?(:body) && !request.body.is_a?(String)
-      request.body_stream = options[:body_stream] if options.key? :body_stream
-
-      global_headers.each { |h, v| request[h] = v }
-      if request.body || request.body_stream
-        request.content_type = 'application/json'
-        request.content_length = (request.body || request.body_stream).size
-      end
-
-      request['authorization'] = "Bearer #{access_token}" if access_token && !options.fetch(:skip_auth, false)
-      if options.key? :headers
-        options[:headers].each do |h, v|
-          request[h.to_s.downcase] = v
-        end
-      end
 
       failures = 0
       loop do
         raise MatrixConnectionError, "Server still too busy to handle request after #{failures} attempts, try again later" if failures >= 10
 
-        print_http(request)
+        req_id = ('A'..'Z').to_a.sample(4).join
+
+        req_obj = construct_request(url: url, method: method, **options)
+        print_http(req_obj, id: req_id)
         begin
-          response = http.request request
-        rescue EOFError => e
+          dur_start = Time.now
+          response = http.request req_obj
+          dur_end = Time.now
+          duration = dur_end - dur_start
+        rescue EOFError
           logger.error 'Socket closed unexpectedly'
-          raise e
+          raise
+        end
+        print_http(response, duration: duration, id: req_id)
+
+        begin
+          data = JSON.parse(response.body, symbolize_names: true)
+        rescue JSON::JSONError => e
+          logger.debug "#{e.class} error when parsing response. #{e}"
+          data = nil
         end
-        print_http(response)
-        data = JSON.parse(response.body, symbolize_names: true) rescue nil
 
         if response.is_a? Net::HTTPTooManyRequests
           raise MatrixRequestError.new_by_code(data, response.code) unless autoretry
@@ -291,24 +304,63 @@ module MatrixSdk
           next
         end
 
-        return MatrixSdk::Response.new self, data if response.is_a? Net::HTTPSuccess
+        if response.is_a? Net::HTTPSuccess
+          unless data
+            logger.error "Received non-parsable data in 200 response; #{response.body.inspect}"
+            raise MatrixConnectionError, response
+          end
+          return MatrixSdk::Response.new self, data
+        end
         raise MatrixRequestError.new_by_code(data, response.code) if data
 
         raise MatrixConnectionError.class_by_code(response.code), response
       end
     end
 
+    # Generate a transaction ID
+    #
+    # @return [String] An arbitrary transaction ID
+    def transaction_id
+      ret = @transaction_id ||= 0
+      @transaction_id = @transaction_id.succ
+      ret
+    end
+
     private
 
-    def print_http(http, body: true)
+    def construct_request(method:, url:, **options)
+      request = Net::HTTP.const_get(method.to_s.capitalize.to_sym).new url.request_uri
+
+      # FIXME: Handle bodies better, avoid duplicating work
+      request.body = options[:body] if options.key? :body
+      request.body = request.body.to_json if options.key?(:body) && !request.body.is_a?(String)
+      request.body_stream = options[:body_stream] if options.key? :body_stream
+
+      global_headers.each { |h, v| request[h] = v }
+      if request.body || request.body_stream
+        request.content_type = 'application/json'
+        request.content_length = (request.body || request.body_stream).size
+      end
+
+      request['authorization'] = "Bearer #{access_token}" if access_token && !options.fetch(:skip_auth, false)
+      if options.key? :headers
+        options[:headers].each do |h, v|
+          request[h.to_s.downcase] = v
+        end
+      end
+
+      request
+    end
+
+    def print_http(http, body: true, duration: nil, id: nil)
       return unless logger.debug?
 
       if http.is_a? Net::HTTPRequest
-        dir = '>'
+        dir = "#{id ? "#{id} : " : nil}>"
         logger.debug "#{dir} Sending a #{http.method} request to `#{http.path}`:"
       else
-        dir = '<'
-        logger.debug "#{dir} Received a #{http.code} #{http.message} response:"
+        dir = "#{id ? "#{id} : " : nil}<"
+        logger.debug "#{dir} Received a #{http.code} #{http.message} response:#{duration ? " [#{(duration * 1000).to_i}ms]" : nil}"
       end
       http.to_hash.map { |k, v| "#{k}: #{k == 'authorization' ? '[ REDACTED ]' : v.join(', ')}" }.each do |h|
         logger.debug "#{dir} #{h}"
@@ -316,7 +368,7 @@ module MatrixSdk
       logger.debug dir
       if body
         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.is_a? Hash
+        clean_body.each_key { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body.is_a? Hash
         clean_body = clean_body.to_s 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
       end
@@ -324,12 +376,6 @@ module MatrixSdk
       logger.warn "#{e.class} occured while printing request debug; #{e.message}\n#{e.backtrace.join "\n"}"
     end
 
-    def transaction_id
-      ret = @transaction_id ||= 0
-      @transaction_id = @transaction_id.succ
-      ret
-    end
-
     def api_to_path(api)
       # TODO: <api>_current / <api>_latest
       "/_matrix/#{api.to_s.split('_').join('/')}"

data/lib/matrix_sdk/client.rb

@@ -23,7 +23,7 @@ module MatrixSdk
     attr_reader :api, :next_batch
     attr_accessor :cache, :sync_filter
 
-    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event
+    events :error, :event, :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
 
@@ -44,7 +44,7 @@ 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))
@@ -70,8 +70,6 @@ module MatrixSdk
         @api = Api.new hs_url, params
       end
 
-      @rooms = {}
-      @users = {}
       @cache = client_cache
       @identity_server = nil
 
@@ -79,7 +77,6 @@ module MatrixSdk
       @sync_thread = nil
       @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) }, state: { lazy_load_members: true } } }
 
-      @should_listen = false
       @next_batch = nil
 
       @bad_sync_timeout_limit = 60 * 60
@@ -88,6 +85,11 @@ module MatrixSdk
         instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
       end
 
+      @rooms = {}
+      @room_handlers = {}
+      @users = {}
+      @should_listen = false
+
       raise ArgumentError, 'Cache value must be one of of [:all, :some, :none]' unless %i[all some none].include? @cache
 
       return unless params[:user_id]
@@ -154,6 +156,27 @@ module MatrixSdk
       rooms
     end
 
+    # Gets a list of all direct chat rooms (1:1 chats / direct message chats) for the currenct user
+    #
+    # @return [Hash[String,Array[String]]] A mapping of MXIDs to a list of direct rooms with that user
+    def direct_rooms
+      Hash[api.get_account_data(mxid, 'm.direct').map do |mxid, rooms|
+        [mxid.to_s, rooms]
+      end]
+    end
+
+    # Gets a direct message room for the given user if one exists
+    #
+    # @note Will return the oldest room if multiple exist
+    # @return [Room,nil] A direct message room if one exists
+    def direct_room(mxid)
+      mxid = MatrixSdk::MXID.new mxid.to_s unless mxid.is_a? MatrixSdk::MXID
+      raise ArgumentError, 'Must be a valid user ID' unless mxid.user?
+
+      room_id = direct_rooms[mxid.to_s]&.first
+      ensure_room room_id if room_id
+    end
+
     # Gets a list of all relevant rooms, either the ones currently handled by
     # the client, or the list of currently joined ones if no rooms are handled
     #
@@ -343,7 +366,7 @@ module MatrixSdk
 
     # Joins an already created room
     #
-    # @param room_id_or_alias [String,MXID] A room alias (#room:exmaple.com) or a room ID (!id:example.com)
+    # @param room_id_or_alias [String,MXID] A room alias (#room:example.com) or a room ID (!id:example.com)
     # @param server_name [Array[String]] A list of servers to attempt the join through, required for IDs
     # @return [Room] The resulting room
     # @see Protocols::CS#join_room
@@ -424,12 +447,27 @@ module MatrixSdk
 
       @should_listen = true
       if api.protocol?(:MSC) && api.msc2108?
+        params[:filter] = sync_filter unless params.key? :filter
+        params[:filter] = params[:filter].to_json unless params[:filter].nil? || params[:filter].is_a?(String)
         params[:since] = @next_batch if @next_batch
-        thread = api.msc2108_sync_sse(params) do |data, event:, id:|
-          logger.debug "Handling SSE event '#{event}' from '#{id}'"
+
+        errors = 0
+        thread, cancel_token = api.msc2108_sync_sse(params) do |data, event:, id:|
           @next_batch = id if id
-          handle_sync_response(data) if event.to_sym == :sync
+          case event.to_sym
+          when :sync
+            handle_sync_response(data)
+            errors = 0
+          when :sync_error
+            logger.error "SSE Sync error received; #{data.type}: #{data.message}"
+            errors += 1
+
+            # TODO: Allow configuring
+            raise 'Aborting due to excessive errors' if errors >= 5
+          end
         end
+
+        @should_listen = cancel_token
       else
         thread = Thread.new { listen_forever(params) }
       end
@@ -441,8 +479,15 @@ module MatrixSdk
     def stop_listener_thread
       return unless @sync_thread
 
-      @should_listen = false
-      @sync_thread.join if @sync_thread.alive?
+      if @should_listen.is_a? Hash
+        @should_listen[:run] = false
+      else
+        @should_listen = false
+      end
+      if @sync_thread.alive?
+        ret = @sync_thread.join(2)
+        @sync_thread.kill unless ret
+      end
       @sync_thread = nil
     end
 
@@ -503,9 +548,7 @@ module MatrixSdk
       end
     end
 
-    private
-
-    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 30, **params)
+    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 0, **params)
       orig_bad_sync_timeout = bad_sync_timeout + 0
       while @should_listen
         begin
@@ -528,6 +571,8 @@ module MatrixSdk
       fire_error(ErrorEvent.new(e, :listener_thread))
     end
 
+    private
+
     def post_authentication(data)
       @mxid = data[:user_id]
       @api.access_token = data[:access_token]
@@ -539,7 +584,10 @@ module MatrixSdk
     def handle_state(room_id, state_event)
       return unless state_event.key? :type
 
+      on_state_event.fire(MatrixEvent.new(self, state_event), state_event[:type])
+
       room = ensure_room(room_id)
+      room.send :put_state_event, state_event
       content = state_event[:content]
       case state_event[:type]
       when 'm.room.name'
@@ -553,9 +601,9 @@ module MatrixSdk
       when 'm.room.aliases'
         room.instance_variable_get('@aliases').concat content[:aliases]
       when 'm.room.join_rules'
-        room.instance_variable_set '@join_rule', content[:join_rule].to_sym
+        room.instance_variable_set '@join_rule', content[:join_rule].nil? ? nil : content[:join_rule].to_sym
       when 'm.room.guest_access'
-        room.instance_variable_set '@guest_access', content[:guest_access].to_sym
+        room.instance_variable_set '@guest_access', content[:guest_access].nil? ? nil : content[:guest_access].to_sym
       when 'm.room.member'
         return unless cache == :all
 
@@ -596,7 +644,12 @@ module MatrixSdk
 
         join[:timeline][:events].each do |event|
           event[:room_id] = room_id.to_s
-          handle_state(room_id, event) unless event[:type] == 'm.room.message'
+          # Avoid sending two identical state events if it's both in state and timeline
+          if event.key?(:state_key)
+            state_event = join.dig(:state, :events).find { |ev| ev[:event_id] == event[:event_id] }
+
+            handle_state(room_id, event) unless event == state_event
+          end
           room.send :put_event, event
 
           fire_event(MatrixEvent.new(self, event), event[:type])

data/lib/matrix_sdk/extensions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module URI
   # A mxc:// Matrix content URL
   class MATRIX < Generic
@@ -189,7 +191,9 @@ module MatrixSdk
     end
 
     def respond_to_missing?(method, *)
-      event.key? method
+      return true if event.key? method
+
+      super
     end
   end
 end

data/lib/matrix_sdk/mxid.rb

@@ -32,13 +32,13 @@ module MatrixSdk
     #
     # @return [String]
     def homeserver
-      port_s = port ? ':' + port.to_s : ''
+      port_s = port ? ":#{port}" : ''
       domain ? domain + port_s : ''
     end
 
     # Gets the homserver part of the ID as a suffix (':homeserver')
     def homeserver_suffix
-      ':' + homeserver if domain
+      ":#{homeserver}" if domain
     end
 
     def to_s
@@ -49,18 +49,13 @@ module MatrixSdk
     #
     # @return [Symbol] The MXID type, one of (:user_id, :room_id, :event_id, :group_id, or :room_alias)
     def type
-      case sigil
-      when '@'
-        :user_id
-      when '!'
-        :room_id
-      when '$'
-        :event_id
-      when '+'
-        :group_id
-      when '#'
-        :room_alias
-      end
+      {
+        '@' => :user_id,
+        '!' => :room_id,
+        '$' => :event_id,
+        '+' => :group_id,
+        '#' => :room_alias
+      }[sigil]
     end
 
     # Checks if the ID is valid

data/lib/matrix_sdk/protocols/cs.rb

@@ -767,6 +767,30 @@ module MatrixSdk::Protocols::CS
     request(:get, :client_r0, "/rooms/#{room_id}/state", query: query)
   end
 
+  # Retrieves number of events that happened just before and after the specified event
+  #
+  # @param room_id [MXID,String] The room to get events from.
+  # @param event_id [MXID,String] The event to get context around.
+  # @option params [Integer] :limit (10) The limit of messages to retrieve
+  # @option params [String] :filter A filter to limit the retrieval to
+  # @return [Response] A response hash with contextual event information
+  # @see https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-rooms-roomid-context-eventid
+  #      The Matrix Spec, for more information about the call and response
+  # @example Find event context with filter and limit specified
+  #   api.get_room_event_context('#room:example.com', '$event_id:example.com', filter: { types: ['m.room.message'] }.to_json, limit: 20)
+  def get_room_event_context(room_id, event_id, **params)
+    query = {}
+    query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)
+
+    query[:limit] = params.fetch(:limit) if params.key? :limit
+    query[:filter] = params.fetch(:filter) if params.key? :filter
+
+    room_id = ERB::Util.url_encode room_id.to_s
+    event_id = ERB::Util.url_encode event_id.to_s
+
+    request(:get, :client_r0, "/rooms/#{room_id}/context/#{event_id}", query: query)
+  end
+
   ## Specialized getters for specced state
   #
 
@@ -1085,7 +1109,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] The resulting state event
   # @see https://matrix.org/docs/spec/client_server/latest.html#m-room-guest-server-acl
   #      The Matrix Spec, for more information about the event and data
-  def set_room_server_acl(room_id, allow_ip_literals: false, allow:, deny:, **params)
+  def set_room_server_acl(room_id, allow:, deny:, allow_ip_literals: false, **params)
     content = {
       allow_ip_literals: allow_ip_literals,
       allow: allow,
@@ -1637,7 +1661,7 @@ module MatrixSdk::Protocols::CS
 
     room_id = ERB::Util.url_encode room_id.to_s
 
-    request(:get, :client_r0, "/rooms/#{room_id}/members", query: query)
+    request(:get, :client_r0, "/rooms/#{room_id}/members", query: query.merge(params))
   end
 
   # Gets a list of the joined members in a room
@@ -1712,7 +1736,7 @@ module MatrixSdk::Protocols::CS
   #   # => { :device_keys => { :'@alice:example.com' => { :ABCDEFGHIJ => { ...
   # @see https://matrix.org/docs/spec/client_server/latest#post-matrix-client-r0-keys-query
   #      The Matrix Spec, for more information about the parameters and data
-  def keys_query(timeout: nil, device_keys:, token: nil, **params)
+  def keys_query(device_keys:, timeout: nil, token: nil, **params)
     body = {
       timeout: (timeout || 10) * 1000,
       device_keys: device_keys
@@ -1823,7 +1847,7 @@ module MatrixSdk::Protocols::CS
   # @see https://matrix.org/docs/spec/client_server/latest#get-matrix-client-r0-pushrules
   #      The Matrix Spec, for more information about the parameters and data
   def get_pushrules
-    request(:get, :client_r0, '/pushrules')
+    request(:get, :client_r0, '/pushrules/')
   end
 
   # Retrieves a single registered push rule for the current user
@@ -1834,7 +1858,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] A response hash containing the full data of the requested push rule
   # @see https://matrix.org/docs/spec/client_server/latest#get-matrix-client-r0-pushrules-scope-kind-ruleid
   #      The Matrix Spec, for more information about the parameters and data
-  def get_pushrule(scope: 'global', kind:, id:)
+  def get_pushrule(kind:, id:, scope: 'global')
     scope = ERB::Util.url_encode scope.to_s
     kind = ERB::Util.url_encode kind.to_s
     id = ERB::Util.url_encode id.to_s
@@ -1850,7 +1874,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] A response hash containing an :enabled key for if the rule is enabled or not
   # @see https://matrix.org/docs/spec/client_server/latest#get-matrix-client-r0-pushrules-scope-kind-ruleid-enabled
   #      The Matrix Spec, for more information about the parameters and data
-  def get_pushrule_enabled(scope: 'global', kind:, id:)
+  def get_pushrule_enabled(kind:, id:, scope: 'global')
     scope = ERB::Util.url_encode scope.to_s
     kind = ERB::Util.url_encode kind.to_s
     id = ERB::Util.url_encode id.to_s
@@ -1867,7 +1891,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] An empty response hash if the push rule was enabled/disabled successfully
   # @see https://matrix.org/docs/spec/client_server/latest#put-matrix-client-r0-pushrules-scope-kind-ruleid-enabled
   #      The Matrix Spec, for more information about the parameters and data
-  def set_pushrule_enabled(enabled, scope: 'global', kind:, id:)
+  def set_pushrule_enabled(enabled, kind:, id:, scope: 'global')
     scope = ERB::Util.url_encode scope.to_s
     kind = ERB::Util.url_encode kind.to_s
     id = ERB::Util.url_encode id.to_s
@@ -1887,7 +1911,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] A response hash containing an :enabled key for if the rule is enabled or not
   # @see https://matrix.org/docs/spec/client_server/latest#get-matrix-client-r0-pushrules-scope-kind-ruleid-actions
   #      The Matrix Spec, for more information about the parameters and data
-  def get_pushrule_actions(scope: 'global', kind:, id:)
+  def get_pushrule_actions(kind:, id:, scope: 'global')
     scope = ERB::Util.url_encode scope.to_s
     kind = ERB::Util.url_encode kind.to_s
     id = ERB::Util.url_encode id.to_s
@@ -1904,7 +1928,7 @@ module MatrixSdk::Protocols::CS
   # @return [Response] An empty response hash if the push rule actions were modified successfully
   # @see https://matrix.org/docs/spec/client_server/latest#put-matrix-client-r0-pushrules-scope-kind-ruleid-actions
   #      The Matrix Spec, for more information about the parameters and data
-  def set_pushrule_actions(actions, scope: 'global', kind:, id:)
+  def set_pushrule_actions(actions, kind:, id:, scope: 'global')
     scope = ERB::Util.url_encode scope.to_s
     kind = ERB::Util.url_encode kind.to_s
     id = ERB::Util.url_encode id.to_s

data/lib/matrix_sdk/protocols/msc.rb

@@ -2,16 +2,13 @@
 
 # Preliminary support for unmerged MSCs (Matrix Spec Changes)
 module MatrixSdk::Protocols::MSC
-  def self.included(_)
-    @msc = {}
-  end
-
   def refresh_mscs
     @msc = {}
   end
 
   # Check if there's support for MSC2108 - Sync over Server Sent Events
   def msc2108?
+    @msc ||= {}
     @msc[2108] ||= \
       begin
         request(:get, :client_r0, '/sync/sse', skip_auth: true, headers: { accept: 'text/event-stream' })
@@ -20,13 +17,13 @@ module MatrixSdk::Protocols::MSC
       rescue MatrixSdk::MatrixRequestError
         false
       end
+  rescue StandardError => e
+    logger.debug "Failed to check MSC2108 status;\n#{e.inspect}"
+    false
   end
 
   # Sync over Server Sent Events - MSC2108
   #
-  # @note With the default Ruby Net::HTTP server, body fragments are cached up to 16kB,
-  #       which will result in large batches and delays if your filters trim a lot of data.
-  #
   # @example Syncing over SSE
   #   @since = 'some token'
   #   api.msc2108_sync_sse(since: @since) do |data, event:, id:|
@@ -38,10 +35,11 @@ module MatrixSdk::Protocols::MSC
   #
   # @see Protocols::CS#sync
   # @see https://github.com/matrix-org/matrix-doc/pull/2108/
+  # rubocop:disable Metrics/MethodLength
   def msc2108_sync_sse(since: nil, **params, &on_data)
     raise ArgumentError, 'Must be given a block accepting two args - data and { event:, id: }' \
       unless on_data.is_a?(Proc) && on_data.arity == 2
-    raise MatrixNotAuthorizedError unless access_token
+    raise 'Needs to be logged in' unless access_token # TODO: Better error
 
     query = params.select do |k, _v|
       %i[filter full_state set_presence].include? k
@@ -49,24 +47,56 @@ 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'
+    req['accept-encoding'] = 'identity' # Disable compression on the SSE stream
     req['authorization'] = "Bearer #{access_token}"
     req['last-event-id'] = since if since
 
+    cancellation_token = { run: true }
+
     # rubocop:disable Metrics/BlockLength
-    thread = Thread.new do
+    thread = Thread.new(cancellation_token) do |ctx|
       print_http(req)
       http.request req do |response|
+        break unless ctx[:run]
+
         print_http(response, body: false)
         raise MatrixRequestError.new_by_code(JSON.parse(response.body, symbolize_names: true), response.code) unless response.is_a? Net::HTTPSuccess
 
+        # Override buffer size for BufferedIO
+        socket = response.instance_variable_get :@socket
+        if socket.is_a? Net::BufferedIO
+          socket.instance_eval do
+            def rbuf_fill
+              bufsize_override = 1024
+              loop do
+                case rv = @io.read_nonblock(bufsize_override, exception: false)
+                when String
+                  @rbuf << rv
+                  rv.clear
+                  return
+                when :wait_readable
+                  @io.to_io.wait_readable(@read_timeout) || raise(Net::ReadTimeout)
+                when :wait_writable
+                  @io.to_io.wait_writable(@read_timeout) || raise(Net::ReadTimeout)
+                when nil
+                  raise EOFError, 'end of file reached'
+                end
+              end
+            end
+          end
+        end
+
+        stream_id = ('A'..'Z').to_a.sample(4).join
+
+        logger.debug "MSC2108 : #{stream_id} : Starting SSE stream."
+
         buffer = ''
         response.read_body do |chunk|
           buffer += chunk
-          logger.debug "< MSC2108: Received #{chunk.length}B of data."
 
           while (index = buffer.index(/\r\n\r\n|\n\n/))
             stream = buffer.slice!(0..index)
@@ -86,20 +116,32 @@ module MatrixSdk::Protocols::MSC
               /^id:(.+)$/.match(part) do |m_id|
                 id = m_id[1].strip
               end
+              /^:(.+)$/.match(part) do |m_comment|
+                logger.debug "MSC2108 : #{stream_id} : Received comment '#{m_comment[1].strip}'"
+              end
             end
 
-            data = JSON.parse(data, symbolize_names: true)
+            if %w[sync sync_error].include? event
+              data = JSON.parse(data, symbolize_names: true)
+              yield((MatrixSdk::Response.new self, data), event: event, id: id)
+            elsif event
+              logger.info "MSC2108 : #{stream_id} : Received unknown event '#{event}'; #{data}"
+            end
+          end
 
-            yield((MatrixSdk::Response.new self, data), event: event, id: id)
+          unless ctx[:run]
+            socket.close
+            break
           end
         end
+        break unless ctx[:run]
       end
     end
     # rubocop:enable Metrics/BlockLength
 
-    thread.abort_on_exception = true
     thread.run
 
-    thread
+    [thread, cancellation_token]
   end
+  # rubocop:enable Metrics/MethodLength
 end

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

@@ -42,19 +42,11 @@ module MatrixSdk
     #        The timeline events are what will end up in here
     attr_reader :id, :client, :topic, :aliases, :members, :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, :members, :events, :prev_batch, :logger
 
     alias room_id id
 
@@ -85,8 +77,6 @@ module MatrixSdk
       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
@@ -114,6 +104,28 @@ module MatrixSdk
       logger.debug "Created room #{room_id}"
     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
     #
@@ -157,6 +169,17 @@ module MatrixSdk
       members
     end
 
+    # Get all members (member events) in the room
+    #
+    # @note This will also count members who've knocked, been invited, have left, or have been banned.
+    #
+    # @param params [Hash] Additional query parameters to pass to the room member listing - e.g. for filtering purposes.
+    #
+    # @return [Array(User)] The complete list of members in the room, regardless of membership state
+    def all_members(**params)
+      client.api.get_room_members(id, **params)[:chunk].map { |ch| client.get_user(ch[:state_key]) }
+    end
+
     # Gets the current name of the room, querying the API if necessary
     #
     # @note Will cache the current name for 15 minutes
@@ -340,7 +363,7 @@ 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(reverse = false, limit = 10) # rubocop:disable Style/OptionalBooleanParameter
       data = client.api.get_room_messages(id, @prev_batch, direction: :b, limit: limit)
 
       events = data[:chunk]
@@ -512,10 +535,10 @@ module MatrixSdk
     # @return [Boolean] if the name was changed or not
     def reload_name!
       data = begin
-               client.api.get_room_name(id)
-             rescue MatrixNotFoundError
-               nil
-             end
+        client.api.get_room_name(id)
+      rescue MatrixNotFoundError
+        nil
+      end
       changed = data[:name] != @name
       @name = data[:name] if changed
       changed
@@ -535,10 +558,10 @@ module MatrixSdk
     # @return [Boolean] if the topic was changed or not
     def reload_topic!
       data = begin
-               client.api.get_room_topic(id)
-             rescue MatrixNotFoundError
-               nil
-             end
+        client.api.get_room_topic(id)
+      rescue MatrixNotFoundError
+        nil
+      end
       changed = data[:topic] != @topic
       @topic = data[:topic] if changed
       changed
@@ -590,7 +613,7 @@ module MatrixSdk
     #
     # @param join_rule [:invite,:public] The join rule of the room
     def join_rule=(join_rule)
-      client.api.set_join_rule(id, join_rule)
+      client.api.set_room_join_rules(id, join_rule)
       @join_rule = join_rule
     end
 
@@ -606,7 +629,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_guest_access(id, guest_access)
+      client.api.set_room_guest_access(id, guest_access)
       @guest_access = guest_access
     end
 
@@ -670,15 +693,35 @@ module MatrixSdk
       members << member unless members.any? { |m| m.id == member.id }
     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
+
     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)
+      return unless room_handlers?
+
+      ensure_room_handlers[:state_event].fire(MatrixEvent.new(self, event), event[:type])
     end
   end
 end

data/lib/matrix_sdk/user.rb

@@ -122,6 +122,14 @@ module MatrixSdk
       Time.now - (since / 1000)
     end
 
+    # Gets a direct message room with the user if one exists
+    #
+    # @return [Room,nil] A direct message room if one exists
+    # @see MatrixSdk::Client#direct_room
+    def direct_room
+      client.direct_room(id)
+    end
+
     # 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|

data/lib/matrix_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MatrixSdk
-  VERSION = '2.0.1'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: matrix_sdk
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Alexander Olofsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-13 00:00:00.000000000 Z
+date: 2020-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha