matrix_sdk 0.0.4 → 0.1.0

data/lib/matrix_sdk/application_service.rb

@@ -0,0 +1,210 @@
+require 'matrix_sdk'
+
+module MatrixSdk
+  class ApplicationService
+    include MatrixSdk::Logging
+    attr_reader :api, :port
+
+    def_delegators :@api,
+                   :access_token, :access_token=, :device_id, :device_id=, :homeserver, :homeserver=,
+                   :validate_certificate, :validate_certificate=
+
+    def initialize(hs_url, as_token:, hs_token:, default_routes: true, **params)
+      logger.warning 'This abstraction is still under HEAVY development, expect errors'
+
+      params = { protocols: %i[AS CS] }.merge(params).merge(access_token: as_token)
+      if hs_url.is_a? Api
+        @api = hs_url
+        params.each do |k, v|
+          api.instance_variable_set("@#{k}", v) if api.instance_variable_defined? "@#{k}"
+        end
+      else
+        @api = Api.new hs_url, params
+      end
+
+      @id = params.fetch(:id, MatrixSdk::Api::USER_AGENT)
+      @port = params.fetch(:port, 8888)
+      @url = params.fetch(:url, URI("http://localhost:#{@port}"))
+      @as_token = as_token
+      @hs_token = hs_token
+
+      @method_map = {}
+
+      if default_routes
+        add_method(:GET, '/_matrix/app/v1/users/', %r{^/_matrix/app/v1/users/(?<user>[^/]+)$}, :do_get_user)
+        add_method(:GET, '/_matrix/app/v1/rooms/', %r{^/_matrix/app/v1/rooms/(?<room>[^/]+)$}, :do_get_room)
+
+        add_method(:GET, '/_matrix/app/v1/thirdparty/protocol/', %r{^/_matrix/app/v1/thirdparty/protocol/(?<protocol>[^/]+)$}, :do_get_3p_protocol_p)
+        add_method(:GET, '/_matrix/app/v1/thirdparty/user/', %r{^/_matrix/app/v1/thirdparty/user/(?<protocol>[^/]+)$}, :do_get_3p_user_p)
+        add_method(:GET, '/_matrix/app/v1/thirdparty/location/', %r{^/_matrix/app/v1/thirdparty/location/(?<protocol>[^/]+)$}, :do_get_3p_location_p)
+        add_method(:GET, '/_matrix/app/v1/thirdparty/user', %r{^/_matrix/app/v1/thirdparty/user$}, :do_get_3p_user)
+        add_method(:GET, '/_matrix/app/v1/thirdparty/location', %r{^/_matrix/app/v1/thirdparty/location$}, :do_get_3p_location)
+
+        add_method(:PUT, '/_matrix/app/v1/transactions/', %r{^/_matrix/app/v1/transactions/(?<txn_id>[^/]+)$}, :do_put_transaction)
+
+        if params.fetch(:legacy_routes, false)
+          add_method(:GET, '/users/', %r{^/users/(?<user>[^/]+)$}, :do_get_user)
+          add_method(:GET, '/rooms/', %r{^/rooms/(?<room>[^/]+)$}, :do_get_room)
+
+          add_method(:GET, '/_matrix/app/unstable/thirdparty/protocol/', %r{^/_matrix/app/unstable/thirdparty/protocol/(?<protocol>[^/]+)$}, :do_get_3p_protocol_p)
+          add_method(:GET, '/_matrix/app/unstable/thirdparty/user/', %r{^/_matrix/app/unstable/thirdparty/user/(?<protocol>[^/]+)$}, :do_get_3p_user_p)
+          add_method(:GET, '/_matrix/app/unstable/thirdparty/location/', %r{^/_matrix/app/unstable/thirdparty/location/(?<protocol>[^/]+)$}, :do_get_3p_location_p)
+          add_method(:GET, '/_matrix/app/unstable/thirdparty/user', %r{^/_matrix/app/unstable/thirdparty/user$}, :do_get_3p_user)
+          add_method(:GET, '/_matrix/app/unstable/thirdparty/location', %r{^/_matrix/app/unstable/thirdparty/location$}, :do_get_3p_location)
+
+          add_method(:PUT, '/transactions/', %r{^/transactions/(?<txn_id>[^/]+)$}, :do_put_transaction)
+        end
+      end
+
+      start_server
+    end
+
+    def registration
+      {
+        id: @id,
+        url: @url,
+        as_token: @as_token,
+        hs_token: @hs_token,
+        sender_localpart: '',
+        namespaces: {
+          users: [],
+          aliases: [],
+          rooms: []
+        },
+        rate_limited: false,
+        protocols: []
+      }
+    end
+
+    def port=(port)
+      raise ArgumentError, 'Port must be a number' unless port.is_a? Numeric
+
+      raise NotImplementedError, "Can't change port of a running server" if server.status != :Stop
+
+      @port = port
+    end
+
+    protected
+
+    def add_method(verb, prefix, regex, proc = nil, &block)
+      proc ||= block
+      raise ArgumentError, 'No method specified' if proc.nil?
+
+      method_entry = (@method_map[verb] ||= {})[regex] = {
+        verb: verb,
+        prefix: prefix,
+        proc: proc
+      }
+      return true unless @server
+
+      server.mount_proc(method.prefix) { |req, res| _handle_proc(verb, method_entry, req, res) }
+    end
+
+    def do_get_user(user:, **params)
+      [user, params]
+      raise NotImplementedError
+    end
+
+    def do_get_room(room:, **params)
+      [room, params]
+      raise NotImplementedError
+    end
+
+    def do_get_3p_protocol_p(protocol:, **params)
+      [protocol, params]
+      raise NotImplementedError
+    end
+
+    def do_get_3p_user_p(protocol:, **params)
+      [protocol, params]
+      raise NotImplementedError
+    end
+
+    def do_get_3p_location_p(protocol:, **params)
+      [protocol, params]
+      raise NotImplementedError
+    end
+
+    def do_get_3p_location(**params)
+      [protocol, params]
+      raise NotImplementedError
+    end
+
+    def do_get_3p_user(**params)
+      [protocol, params]
+      raise NotImplementedError
+    end
+
+    def do_put_transaction(txn_id:, **params)
+      [txn_id, params]
+      raise NotImplementedError
+    end
+
+    def start_server
+      server.start
+
+      @method_map.each do |verb, method_entry|
+        # break if verb != method_entry[:verb]
+
+        method = method_entry[:proc]
+        server.mount_proc(method.prefix) { |req, res| _handle_proc(verb, method_entry, req, res) }
+      end
+
+      logger.info "Application Service is now running on port #{port}"
+    end
+
+    def stop_server
+      @server.shutdown if @server
+      @server = nil
+    end
+
+    private
+
+    def _handle_proc(verb, method_entry, req, res)
+      logger.debug "Received request for #{verb} #{method_entry}"
+      match = regex.match(req.request_uri.path)
+      match_hash = Hash[match.names.zip(match.captures)].merge(
+        request: req,
+        response: res
+      )
+
+      if method.is_a? Symbol
+        send method, match_hash
+      else
+        method.call match_hash
+      end
+    end
+
+    def server
+      @server ||= WEBrick::HTTPServer.new(Port: port, ServerSoftware: "#{MatrixSdk::Api::USER_AGENT} (Ruby #{RUBY_VERSION})").tap do |server|
+        server.mount_proc '/', &:handle_request
+      end
+    end
+
+    def handle_request(request, response)
+      logger.debug "Received request #{request.inspect}"
+
+      req_method = request.request_method.to_s.to_sym
+      req_uri = request.request_uri
+
+      map = @method_map[req_method]
+      raise WEBrick::HTTPStatus[405], { message: 'Unsupported verb' }.to_json if map.nil?
+
+      discovered = map.find { |k, _v| k =~ req_uri.path }
+      raise WEBrick::HTTPStatus[404], { message: 'Unknown request' }.to_json if discovered.nil?
+
+      method = discovered.last
+      match = Regexp.last_match
+      match_hash = Hash[match.names.zip(match.captures)].merge(
+        request: request,
+        response: response
+      )
+
+      if method.is_a? Symbol
+        send method, match_hash
+      else
+        method.call match_hash
+      end
+    end
+  end
+end

data/lib/matrix_sdk/client.rb

@@ -4,19 +4,28 @@ require 'forwardable'
 
 module MatrixSdk
   class Client
+    include MatrixSdk::Logging
     extend Forwardable
 
     attr_reader :api
     attr_accessor :cache, :sync_filter
 
-    events :event, :presence_event, :invite_event, :left_event, :ephemeral_event
+    events :event, :presence_event, :invite_event, :leave_event, :ephemeral_event
     ignore_inspect :api,
-                   :on_event, :on_presence_event, :on_invite_event, :on_left_event, :on_ephemeral_event
+                   :on_event, :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=,
                    :validate_certificate, :validate_certificate=
 
+    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'
+
+      identity_server = MatrixSdk::Api.new(api.well_known['m.identity_server']['base_url'], protocols: %i[IS])
+      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
     # @param client_cache [:all,:some,:none] (:all) How much data should be cached in the client
     # @param params [Hash] Additional parameters on creation
@@ -40,10 +49,11 @@ module MatrixSdk
       @rooms = {}
       @users = {}
       @cache = client_cache
+      @identity_server = params.fetch(:identity_server, nil)
 
       @sync_token = nil
       @sync_thread = nil
-      @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) } } }
+      @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) }, state: { lazy_load_members: true } } }
 
       @should_listen = false
       @next_batch = nil
@@ -61,10 +71,6 @@ module MatrixSdk
       @mxid = params[:user_id]
     end
 
-    def logger
-      @logger ||= Logging.logger[self]
-    end
-
     def mxid
       @mxid ||= begin
         api.whoami?[:user_id] if api && api.access_token
@@ -154,8 +160,15 @@ module MatrixSdk
       ensure_room(data.fetch(:room_id, room_id_or_alias))
     end
 
-    def find_room(room_id_or_alias)
-      @rooms.fetch(room_id_or_alias, @rooms.values.find { |r| r.canonical_alias == room_id_or_alias })
+    def find_room(room_id_or_alias, only_canonical: false)
+      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 %i[room_id room_alias].include? room_id_or_alias.type
+
+      return @rooms.fetch(room_id_or_alias, 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
+
+      @rooms.values.find { |r| r.aliases.include? room_id_or_alias.to_s }
     end
 
     def get_user(user_id)
@@ -177,10 +190,6 @@ module MatrixSdk
       raise MatrixUnexpectedResponseError, 'Upload succeeded, but no media URI returned'
     end
 
-    def listen_for_events(timeout: 30, **arguments)
-      sync(arguments.merge(timeout: timeout))
-    end
-
     def start_listener_thread(params = {})
       @should_listen = true
       thread = Thread.new { listen_forever(params) }
@@ -196,19 +205,44 @@ module MatrixSdk
       @sync_thread = nil
     end
 
+    def sync(skip_store_batch: false, **params)
+      extra_params = {
+        filter: sync_filter,
+        timeout: 30
+      }
+      extra_params[:since] = @next_batch unless @next_batch.nil?
+      extra_params.merge!(params)
+      extra_params[:filter] = extra_params[:filter].to_json unless extra_params[:filter].is_a? String
+
+      attempts = 0
+      data = loop do
+        begin
+          break api.sync extra_params
+        rescue MatrixSdk::MatrixTimeoutError => e
+          raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
+        end
+      end
+
+      @next_batch = data[:next_batch] unless skip_store_batch
+
+      handle_sync_response(data)
+    end
+
+    alias listen_for_events sync
+
     private
 
     def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 30, **params)
-      orig_bad_sync_timeout = bad_sync_timeout.dup
+      orig_bad_sync_timeout = bad_sync_timeout + 0
       while @should_listen
         begin
           sync(params.merge(timeout: timeout))
 
           bad_sync_timeout = orig_bad_sync_timeout
           sleep(sync_interval) if sync_interval > 0
-        rescue MatrixRequestError => ex
-          logger.warn("A #{ex.class} occurred during sync")
-          if ex.httpstatus >= 500
+        rescue MatrixRequestError => e
+          logger.warn("A #{e.class} occurred during sync")
+          if e.httpstatus >= 500
             logger.warn("Serverside error, retrying in #{bad_sync_timeout} seconds...")
             sleep params[:bad_sync_timeout]
             bad_sync_timeout = [bad_sync_timeout * 2, @bad_sync_timeout_limit].min
@@ -227,7 +261,11 @@ module MatrixSdk
 
     def ensure_room(room_id)
       room_id = room_id.to_s unless room_id.is_a? String
-      @rooms.fetch(room_id) { @rooms[room_id] = Room.new(self, room_id) }
+      @rooms.fetch(room_id) do
+        room = Room.new(self, room_id)
+        @rooms[room_id] = room unless cache == :none
+        room
+      end
     end
 
     def handle_state(room_id, state_event)
@@ -240,6 +278,8 @@ module MatrixSdk
         room.instance_variable_set '@name', content[:name]
       when 'm.room.canonical_alias'
         room.instance_variable_set '@canonical_alias', content[:alias]
+        # Also add as a regular alias
+        room.instance_variable_get('@aliases').concat [content[:alias]]
       when 'm.room.topic'
         room.instance_variable_set '@topic', content[:topic]
       when 'm.room.aliases'
@@ -252,63 +292,48 @@ module MatrixSdk
         return unless cache == :all
 
         if content[:membership] == 'join'
-          room.send :ensure_member, User.new(self, state_event[:state_key], display_name: content[:displayname])
+          room.send(:ensure_member, get_user(state_event[:state_key]).dup.tap do |u|
+            u.instance_variable_set :@display_name, content[:displayname]
+          end)
         elsif %w[leave kick invite].include? content[:membership]
           room.members.delete_if { |m| m.id == state_event[:state_key] }
         end
       end
     end
 
-    def sync(skip_store_batch: false, **params)
-      extra_params = {
-        filter: sync_filter.to_json
-      }
-      extra_params[:since] = @next_batch unless @next_batch.nil?
-
-      attempts = 0
-      data = loop do
-        begin
-          break api.sync extra_params.merge(params)
-        rescue MatrixTimeoutError => ex
-          raise ex if (attempts += 1) > params.fetch(:allow_sync_retry, 0)
-        end
-      end
-
-      @next_batch = data[:next_batch] unless skip_store_batch
-
-      handle_sync_response(data)
-    end
-
     def handle_sync_response(data)
       data[:presence][:events].each do |presence_update|
         fire_presence_event(MatrixEvent.new(self, presence_update))
       end
 
       data[:rooms][:invite].each do |room_id, invite|
-        fire_invite_event(MatrixEvent.new(self, invite), room_id)
+        fire_invite_event(MatrixEvent.new(self, invite), room_id.to_s)
       end
 
       data[:rooms][:leave].each do |room_id, left|
-        fire_leave_event(MatrixEvent.new(self, left), room_id)
+        fire_leave_event(MatrixEvent.new(self, left), room_id.to_s)
       end
 
       data[:rooms][:join].each do |room_id, join|
         room = ensure_room(room_id)
         room.instance_variable_set '@prev_batch', join[:timeline][:prev_batch]
+        room.instance_variable_set :@members_loaded, true unless sync_filter.fetch(:room, {}).fetch(:state, {}).fetch(:lazy_load_members, false)
+
         join[:state][:events].each do |event|
-          event[:room_id] = room_id
+          event[:room_id] = room_id.to_s
           handle_state(room_id, event)
         end
 
         join[:timeline][:events].each do |event|
-          event[:room_id] = room_id
+          event[:room_id] = room_id.to_s
+          handle_state(room_id, event) unless event[:type] == 'm.room.message'
           room.send :put_event, event
 
           fire_event(MatrixEvent.new(self, event), event[:type])
         end
 
         join[:ephemeral][:events].each do |event|
-          event[:room_id] = room_id
+          event[:room_id] = room_id.to_s
           room.send :put_ephemeral_event, event
 
           fire_ephemeral_event(MatrixEvent.new(self, event), event[:type])

data/lib/matrix_sdk/extensions.rb

@@ -10,6 +10,14 @@ module URI
   @@schemes['MXC'] = MATRIX
 end
 
+unless Object.respond_to? :yield_self
+  class Object
+    def yield_self
+      yield(self)
+    end
+  end
+end
+
 def events(*symbols)
   module_name = "#{name}Events"
 
@@ -52,15 +60,23 @@ end
 def ignore_inspect(*symbols)
   class_eval %*
     def inspect
+      reentrant = caller_locations.any? { |l| l.absolute_path == __FILE__ && l.label == 'inspect' }
       "\#{to_s[0..-2]} \#{instance_variables
         .reject { |f| %i[#{symbols.map { |s| "@#{s}" }.join ' '}].include? f }
-        .map { |f| "\#{f}=\#{instance_variable_get(f).inspect}" }.join " " }}>"
+        .map { |f| "\#{f}=\#{reentrant ? instance_variable_get(f) : instance_variable_get(f).inspect}" }.join " " }}>"
     end
-  *, __FILE__, __LINE__ - 6
+  *, __FILE__, __LINE__ - 7
 end
 
 module MatrixSdk
+  module Logging
+    def logger
+      @logger ||= ::Logging.logger[self]
+    end
+  end
+
   class EventHandlerArray < Hash
+    include MatrixSdk::Logging
     attr_accessor :reraise_exceptions
 
     def initialize(*args)
@@ -82,17 +98,13 @@ module MatrixSdk
       reverse_each do |_k, h|
         begin
           h[:block].call(event) if event.matches?(h[:filter], filter)
-        rescue StandardError => ex
-          logger.error "#{ex.class.name} occurred when firing event (#{event})\n#{ex}"
+        rescue StandardError => e
+          logger.error "#{e.class.name} occurred when firing event (#{event})\n#{e}"
 
-          raise ex if @reraise_exceptions
+          raise e if @reraise_exceptions
         end
       end
     end
-
-    def logger
-      @logger ||= Logging.logger[self]
-    end
   end
 
   class Event
@@ -150,7 +162,7 @@ module MatrixSdk
       super
     end
 
-    def respond_to_missing?(method)
+    def respond_to_missing?(method, *)
       event.key? method
     end
   end