matrix_sdk 0.0.1 → 0.0.2

data/lib/matrix_sdk/client.rb

@@ -0,0 +1,234 @@
+require 'matrix_sdk'
+
+require 'forwardable'
+
+module MatrixSdk
+  class Client
+    extend Forwardable
+
+    attr_reader :api
+    attr_accessor :cache, :mxid, :sync_filter
+
+    events :event, :presence_event, :invite_event, :left_event, :ephemeral_event
+    ignore_inspect :api,
+                   :on_event, :on_presence_event, :on_invite_event, :on_left_event, :on_ephemeral_event
+
+    alias user_id mxid
+    alias user_id= mxid=
+
+    def_delegators :@api,
+                   :access_token, :access_token=, :device_id, :device_id=, :homeserver, :homeserver=,
+                   :validate_certificate, :validate_certificate=
+
+    def initialize(hs_url, params = {})
+      event_initialize
+
+      params[:user_id] = params[:mxid] if params[:mxid]
+      raise ArgumentError, 'Must provide user_id with access_token' if params[:access_token] && !params[:user_id]
+
+      @api = Api.new hs_url, params
+
+      @rooms = {}
+      @cache = :all
+
+      @sync_token = nil
+      @sync_thread = nil
+      @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) } } }
+
+      @should_listen = false
+
+      @bad_sync_timeout_limit = 60 * 60
+
+      params.each do |k, v|
+        instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
+      end
+
+      raise ArgumentError, 'Cache value must be one of of [:all, :some, :none]' unless %i[all some none].include? @cache
+
+      return unless params[:user_id]
+      @mxid = params[:user_id]
+      sync
+    end
+
+    def logger
+      @logger ||= Logging.logger[self.class.name]
+    end
+
+    def rooms
+      @rooms.values
+    end
+
+    def register_as_guest
+      data = api.register(kind: :guest)
+      post_authentication(data)
+    end
+
+    def register_with_password(username, password)
+      data = api.register(auth: { type: 'm.login.dummy' }, username: username, password: password)
+      post_authentication(data)
+    end
+
+    def login(username, password, params = {})
+      data = api.login(user: username, password: password)
+      post_authentication(data)
+
+      sync(timeout: params.fetch(:sync_timeout, 15)) unless params[:no_sync]
+    end
+
+    def logout
+      api.logout
+      @api.access_token = nil
+      @mxid = nil
+    end
+
+    def create_room(room_alias = nil, params = {})
+      api.create_room(params.merge(room_alias: room_alias))
+    end
+
+    def join_room(room_id_or_alias)
+      data = api.join_room(room_id_or_alias)
+      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 })
+    end
+
+    def get_user(user_id)
+      User.new(self, user_id)
+    end
+
+    def remove_room_alias(room_alias)
+      api.remove_room_alias(room_alias)
+    end
+
+    def upload(content, content_type)
+      data = api.media_upload(content, content_type)
+      return data[:content_uri] if data.key? :content_uri
+      raise MatrixUnexpectedResponseError, 'Upload succeeded, but no media URI returned'
+    end
+
+    def listen_for_events(timeout = 30)
+      sync(timeout: timeout)
+    end
+
+    def start_listener_thread(params = {})
+      @should_listen = true
+      thread = Thread.new { listen_forever(params) }
+      @sync_thread = thread
+      thread.run
+    end
+
+    def stop_listener_thread
+      return unless @sync_thread
+      @should_listen = false
+      @sync_thread.join if @sync_thread.alive?
+      @sync_thread = nil
+    end
+
+    private
+
+    def listen_forever(params = {})
+      timeout = params.fetch(:timeout, 30)
+      params[:bad_sync_timeout] = params.fetch(:bad_sync_timeout, 5)
+
+      bad_sync_timeout = params[:bad_sync_timeout]
+      while @should_listen
+        begin
+          sync(timeout: timeout)
+          bad_sync_timeout = params[:bad_sync_timeout]
+        rescue MatrixRequestError => ex
+          logger.warn("A #{ex.class} occurred during sync")
+          if ex.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
+          end
+        end
+      end
+    end
+
+    def post_authentication(data)
+      @mxid = data[:user_id]
+      @api.access_token = data[:access_token]
+      @api.device_id = data[:device_id]
+      @api.homeserver = data[:home_server]
+      access_token
+    end
+
+    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) }
+    end
+
+    def handle_state(room_id, state_event)
+      return unless state_event.key? :type
+
+      room = ensure_room(room_id)
+      content = state_event[:content]
+      case state_event[:type]
+      when 'm.room.name'
+        room.instance_variable_set '@name', content[:name]
+      when 'm.room.canonical_alias'
+        room.instance_variable_set '@canonical_alias', content[:alias]
+      when 'm.room.topic'
+        room.instance_variable_set '@topic', content[:topic]
+      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
+      when 'm.room.guest_access'
+        room.instance_variable_set '@guest_access', content[:guest_access].to_sym
+      when 'm.room.member'
+        return unless cache == :all
+
+        if content[:membership] == 'join'
+          room.send :ensure_member, User.new(self, state_event[:state_key], display_name: content[:displayname])
+        elsif %w[leave kick invite].include? content[:membership]
+          room.members.delete_if { |m| m.id == state_event[:state_key] }
+        end
+      end
+    end
+
+    def sync(params = {})
+      data = api.sync params.merge(filter: sync_filter.to_json)
+
+      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)
+      end
+
+      data[:rooms][:leave].each do |room_id, left|
+        fire_leave_event(MatrixEvent.new(self, left), room_id)
+      end
+
+      data[:rooms][:join].each do |room_id, join|
+        room = ensure_room(room_id)
+        room.instance_variable_set '@prev_batch', join[:timeline][:prev_batch]
+        join[:state][:events].each do |event|
+          event[:room_id] = room_id
+          handle_state(room_id, event)
+        end
+
+        join[:timeline][:events].each do |event|
+          event[:room_id] = room_id
+          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
+          room.send :put_ephemeral_event, event
+
+          fire_ephemeral_event(MatrixEvent.new(self, event), event[:type])
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/matrix_sdk/errors.rb

@@ -1,15 +1,31 @@
 module MatrixSdk
-  class MatrixError
-    attr_reader :errcode, :error, :httpstatus
+  # A generic error raised for issues in the MatrixSdk
+  class MatrixError < StandardError
+  end
+
+  # An error specialized and raised for failed requests
+  class MatrixRequestError < MatrixError
+    attr_reader :code, :httpstatus, :message
+    alias error message
 
     def initialize(error, status)
-      @errcode = error[:errcode]
-      @error = error[:error]
+      @code = error[:errcode]
       @httpstatus = status
+      @message = error[:error]
+
+      super error[:error]
     end
 
     def to_s
-      "#{errcode}: #{error}"
+      "HTTP #{httpstatus} (#{code}): #{message}"
     end
   end
+
+  # An error raised when errors occur in the connection layer
+  class MatrixConnectionError < MatrixError
+  end
+
+  # An error raised when the homeserver returns an unexpected response to the client
+  class MatrixUnexpectedResponseError < MatrixError
+  end
 end

data/lib/matrix_sdk/extensions.rb

@@ -0,0 +1,119 @@
+module URI
+  class MATRIX < Generic
+    def full_path
+      select(:host, :port, :path, :query, :fragment)
+        .reject(&:nil?)
+        .join
+    end
+  end
+
+  @@schemes['MXC'] = MATRIX
+end
+
+def events(*symbols)
+  module_name = "#{name}Events"
+
+  initializers = []
+  readers = []
+  methods = []
+
+  symbols.each do |sym|
+    name = sym.to_s
+
+    initializers << "
+      @on_#{name} = MatrixSdk::EventHandlerArray.new
+    "
+    readers << ":on_#{name}"
+    methods << "
+      def fire_#{name}(ev, filter = nil)
+        @on_#{name}.fire(ev, filter)
+        when_#{name}(ev) if !ev.handled?
+      end
+
+      def when_#{name}(ev); end
+    "
+  end
+
+  class_eval "
+    module #{module_name}
+      attr_reader #{readers.join ', '}
+
+      def event_initialize
+        #{initializers.join}
+      end
+
+      #{methods.join}
+    end
+
+    include #{module_name}
+  ", __FILE__, __LINE__ - 12
+end
+
+def ignore_inspect(*symbols)
+  class_eval %*
+    def inspect
+      "#<\#{self.class.name}:\#{"%016x" % (object_id << 1)} \#{instance_variables.reject { |f| %i[#{symbols.map { |s| "@#{s}" }.join ' '}].include? f }.map { |f| "\#{f}=\#{instance_variable_get(f).inspect}" }.join ' ' }>"
+    end
+  *, __FILE__, __LINE__ - 4
+end
+
+module MatrixSdk
+  class EventHandlerArray < Hash
+    def add_handler(filter = nil, id = nil, &block)
+      id ||= block.hash
+      self[id] = { filter: filter, id: id, block: block }
+    end
+
+    def remove_handler(id)
+      delete id
+    end
+
+    def fire(event, filter = nil)
+      reverse_each do |_k, h|
+        h[:block].call(event) unless event.matches?(h[:filter], filter)
+      end
+    end
+  end
+
+  class Event
+    attr_writer :handled
+
+    ignore_inspect :sender
+
+    def initialize(sender)
+      @sender = sender
+      @handled = false
+    end
+
+    def handled?
+      @handled
+    end
+
+    def matches?(_filter)
+      true
+    end
+  end
+
+  class MatrixEvent < Event
+    attr_accessor :event, :filter
+
+    ignore_inspect :sender
+
+    def initialize(sender, event = nil, filter = nil)
+      @event = event
+      @filter = filter || @event[:type]
+      super sender
+    end
+
+    def matches?(filter, filter_override = nil)
+      return true if filter_override.nil? && (@filter.nil? || filter.nil?)
+
+      to_match = filter_override || @filter
+      if filter.is_a? Regexp
+        filter.match(to_match) { true } || false
+      else
+        to_match == filter
+      end
+    end
+  end
+end