activematrix 0.0.0

data/lib/matrix_sdk/protocols/is.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Protocols::IS
+  def identity_status
+    request(:get, :identity_api_v1, '/')
+  end
+
+  def identity_get_pubkey(id)
+    id = ERB::Util.url_encode id.to_s
+
+    request(:get, :identity_api_v1, "/pubkey/#{id}")
+  end
+
+  def identity_pubkey_isvalid(key, ephemeral: false)
+    if ephemeral
+      request(:get, :identity_api_v1, '/pubkey/ephemeral/isvalid', query: { public_key: key })
+    else
+      request(:get, :identity_api_v1, '/pubkey/isvalid', query: { public_key: key })
+    end
+  end
+
+  def identity_pubkey_ephemeral_isvalid(key)
+    identity_pubkey_isvalid(key, ephemeral: true)
+  end
+
+  def identity_lookup(medium:, address:)
+    request(:get, :identity_api_v1, '/lookup', query: { medium: medium, address: address })
+  end
+
+  def identity_bulk_lookup(threepids)
+    request(:post, :identity_api_v1, '/bulk_lookup', body: { threepids: threepids })
+  end
+
+  # XXX
+end

data/lib/matrix_sdk/protocols/msc.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# Preliminary support for unmerged MSCs (Matrix Spec Changes)
+module MatrixSdk::Protocols::MSC
+  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' })
+      rescue MatrixSdk::MatrixNotAuthorizedError # Returns 401 if implemented
+        true
+      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
+  #
+  # @example Syncing over SSE
+  #   @since = 'some token'
+  #   api.msc2108_sync_sse(since: @since) do |data, event:, id:|
+  #     if event == 'sync'
+  #       handle(data) # data is the same as a normal sync response
+  #       @since = id
+  #     end
+  #   end
+  #
+  # @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 '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
+    end
+    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.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(cancellation_token) do |ctx|
+      print_http(req)
+      @http_lock&.lock
+      http.request req do |response|
+        @http_lock&.unlock
+        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
+
+          while (index = buffer.index(/\r\n\r\n|\n\n/))
+            stream = buffer.slice!(0..index)
+
+            data = ''
+            event = nil
+            id = nil
+
+            stream.split(/\r?\n/).each do |part|
+              /^data:(.+)$/.match(part) do |m_data|
+                data += "\n" unless data.empty?
+                data += m_data[1].strip
+              end
+              /^event:(.+)$/.match(part) do |m_event|
+                event = m_event[1].strip
+              end
+              /^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
+
+            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
+
+          unless ctx[:run]
+            socket.close
+            break
+          end
+        end
+
+        break unless ctx[:run]
+      end
+    ensure
+      @http_lock.unlock if @http_lock&.owned?
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    thread.run
+
+    [thread, cancellation_token]
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/matrix_sdk/protocols/ss.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Protocols::SS
+  # Gets the server version
+  def server_version
+    MatrixSdk::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
+end

data/lib/matrix_sdk/response.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MatrixSdk
+  # An usability wrapper for API responses as an extended [Hash]
+  # All results can be read as both hash keys and as read-only methods on the key
+  #
+  # @example Simple usage of the response wrapper to get the avatar URL
+  #   resp = api.get_avatar_url(api.whoami?.user_id)
+  #   # => { avatar_url: 'mxc://matrix.org/SDGdghriugerRg' }
+  #   resp.is_a? Hash
+  #   # => true
+  #   resp.key? :avatar_url
+  #   # => true
+  #   resp.avatar_url
+  #   # => 'mxc://matrix.org/SDGdghriugerRg'
+  #   resp.api.set_avatar_url(...)
+  #   # => {}
+  #
+  # @since 0.0.3
+  # @see Hash
+  # @!attribute [r] api
+  #   @return [Api] The API connection that returned the response
+  module Response
+    def self.new(api, data)
+      if data.is_a? Array
+        raise ArgumentError, 'Input data was not an array of hashes' unless data.all? { |v| v.is_a? Hash }
+
+        data.each do |value|
+          Response.new api, value
+        end
+        return data
+      end
+
+      return data if data.instance_variables.include? :@api
+
+      raise ArgumentError, 'Input data was not a hash' unless data.is_a? Hash
+
+      data.extend(Extensions)
+      data.instance_variable_set(:@api, api)
+
+      data.select { |_k, v| v.is_a? Hash }
+          .each { |_v, v| Response.new api, v }
+
+      data
+    end
+
+    module Extensions
+      attr_reader :api
+
+      def respond_to_missing?(name, *_args)
+        return true if key? name
+
+        super
+      end
+
+      def method_missing(name, *args)
+        return fetch(name) if key?(name) && args.empty?
+
+        super
+      end
+    end
+  end
+end