matrix_sdk 2.1.2 → 2.4.0

data/lib/matrix_sdk/rooms/space.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Rooms
+  class Space < MatrixSdk::Room
+    TYPE = 'm.space'
+
+    def tree(suggested_only: nil, max_rooms: nil)
+      begin
+        data = client.api.request :get, :client_unstable, "/org.matrix.msc2946/rooms/#{id}/spaces", query: {
+          suggested_only: suggested_only,
+          max_rooms_per_space: max_rooms
+        }.compact
+      rescue
+        data = client.api.request :get, :client_r0, "/rooms/#{id}/spaces", query: {
+          suggested_only: suggested_only,
+          max_rooms_per_space: max_rooms
+        }.compact
+      end
+
+      rooms = data.rooms.map do |r|
+        next if r[:room_id] == id
+
+        room = client.ensure_room(r[:room_id])
+        room.instance_variable_set :@room_type, r[:room_type] if r.key? :room_type
+        room = room.to_space if room.space?
+
+        # Inject available room information
+        r.each do |k, v|
+          if room.respond_to?("#{k}_cached?".to_sym) && send("#{k}_cached?".to_sym)
+            room.send(:tinycache_adapter).write(k, v)
+          elsif room.instance_variable_defined? "@#{k}"
+            room.instance_variable_set("@#{k}", v)
+          end
+        end
+        room
+      end
+      rooms.compact!
+
+      grouping = {}
+      data.events.each do |ev|
+        next unless ev[:type] == 'm.space.child'
+        next unless ev[:content].key? :via
+
+        d = (grouping[ev[:room_id]] ||= [])
+        d << ev[:state_key]
+      end
+
+      build_tree = proc do |entry|
+        next if entry.nil?
+
+        room = self if entry == id
+        room ||= rooms.find { |r| r.id == entry }
+        puts "Unable to find room for entry #{entry}" unless room
+        # next if room.nil?
+
+        ret = {
+          room => []
+        }
+
+        grouping[entry]&.each do |child|
+          if grouping.key?(child)
+            ret[room] << build_tree.call(child)
+          else
+            child_r = self if child == id
+            child_r ||= rooms.find { |r| r.id == child }
+
+            ret[room] << child_r
+          end
+        end
+
+        ret[room].compact!
+
+        ret
+      end
+
+      build_tree.call(id)
+    end
+  end
+end

data/lib/matrix_sdk/user.rb

@@ -59,7 +59,7 @@ module MatrixSdk
     # Only works for the current user object, as requested by
     #     client.get_user(:self)
     #
-    # @param url [String,URI::MATRIX] the new avatar URL
+    # @param url [String,URI::MXC] the new avatar URL
     # @note Requires a mxc:// URL, check example on
     #   {MatrixSdk::Protocols::CS#set_avatar_url} for how this can be done
     # @see MatrixSdk::Protocols::CS#set_avatar_url
@@ -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/util/events.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module MatrixSdk
+  class EventHandlerArray < Hash
+    include MatrixSdk::Logging
+    attr_accessor :reraise_exceptions
+
+    def initialize(*args)
+      @reraise_exceptions = false
+
+      super(*args)
+    end
+
+    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) if !h[:filter] || event.matches?(h[:filter], filter)
+      rescue StandardError => e
+        logger.error "#{e.class.name} occurred when firing event (#{event})\n#{e}"
+
+        raise e if @reraise_exceptions
+      end
+    end
+  end
+
+  class Event
+    extend MatrixSdk::Extensions
+
+    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 ErrorEvent < Event
+    attr_accessor :error
+
+    def initialize(error, source)
+      @error = error
+      super source
+    end
+
+    def source
+      @sender
+    end
+  end
+
+  class MatrixEvent < Event
+    attr_accessor :event, :filter
+    alias data event
+
+    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
+
+    def [](key)
+      event[key]
+    end
+
+    def to_s
+      "#{event[:type]}: #{event.reject { |k, _v| k == :type }.to_json}"
+    end
+
+    def method_missing(method, *args)
+      return event[method] if event.key? method
+
+      super
+    end
+
+    def respond_to_missing?(method, *)
+      return true if event.key? method
+
+      super
+    end
+  end
+end

data/lib/matrix_sdk/util/extensions.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+unless Object.respond_to? :yield_self
+  class Object
+    def yield_self
+      yield(self)
+    end
+  end
+end
+
+module MatrixSdk
+  module Extensions
+    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
+          reentrant = caller_locations.any? { |l| l.absolute_path == __FILE__ && l.label == 'inspect' }
+          "\\\#<\#{self.class} \#{instance_variables
+            .reject { |f| %i[#{symbols.map { |s| "@#{s}" }.join ' '}].include? f }
+            .map { |f| "\#{f}=\#{reentrant ? instance_variable_get(f) : instance_variable_get(f).inspect}" }.join " " }}>"
+        end
+      *, __FILE__, __LINE__ - 7
+    end
+  end
+
+  module Logging
+    def logger
+      return MatrixSdk.logger if MatrixSdk.global_logger?
+
+      @logger ||= ::Logging.logger[self]
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/matrix_sdk/util/tinycache.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'matrix_sdk/util/tinycache_adapter'
+
+module MatrixSdk::Util
+  module Tinycache
+    CACHE_LEVELS = {
+      none: 0,
+      some: 1,
+      all: 2
+    }.freeze
+
+    def self.adapter
+      @adapter ||= TinycacheAdapter
+    end
+
+    def self.adapter=(adapter)
+      @adapter = adapter
+    end
+
+    def self.extended(base)
+      helper_name = base.send(:cache_helper_module_name)
+      base.send :remove_const, helper_name if base.const_defined?(helper_name)
+      base.prepend base.const_set(helper_name, Module.new)
+
+      base.include InstanceMethods
+    end
+
+    def cached(*methods, **opts)
+      methods.each { |method| build_cache_methods(method, **opts) }
+    end
+
+    module InstanceMethods
+      def tinycache_adapter
+        @tinycache_adapter ||= Tinycache.adapter.new.tap do |adapter|
+          adapter.config = self.class.tinycache_adapter_config if adapter.respond_to? :config=
+          adapter.client = client if respond_to?(:client) && adapter.respond_to?(:client=)
+        end
+      end
+    end
+
+    def tinycache_adapter_config
+      @tinycache_adapter_config ||= {}
+    end
+
+    private
+
+    def default_cache_key
+      proc do |method_name, _method_args|
+        method_name.to_sym
+      end
+    end
+
+    def cache_helper_module_name
+      class_name = name&.gsub(/:/, '') || to_s.gsub(/[^a-zA-Z_0-9]/, '')
+      "#{class_name}Tinycache"
+    end
+
+    def build_cache_methods(method_name, cache_key: default_cache_key, cache_level: :none, expires_in: nil, **opts)
+      raise ArgumentError, 'Cache key must be a three-arg proc' unless cache_key.is_a? Proc
+
+      method_names = build_method_names(method_name)
+      tinycache_adapter_config[method_name] = {
+        level: cache_level,
+        expires: expires_in || 1 * 365 * 24 * 60 * 60 # 1 year
+      }
+
+      helper = const_get(cache_helper_module_name)
+      return if method_names.any? { |k, _| helper.respond_to? k }
+
+      helper.class_eval do
+        define_method(method_names[:cache_key]) do |*args|
+          cache_key.call(method_name, args)
+        end
+
+        define_method(method_names[:with_cache]) do |*args|
+          tinycache_adapter.fetch(__send__(method_names[:cache_key], *args), expires_in: expires_in) do
+            __send__(method_names[:without_cache], *args)
+          end
+        end
+
+        define_method(method_names[:without_cache]) do |*args|
+          orig = method(method_name).super_method
+          orig.call(*args)
+        end
+
+        define_method(method_names[:clear_cache]) do |*args|
+          tinycache_adapter.delete(__send__(method_names[:cache_key], *args))
+        end
+
+        define_method(method_names[:cached]) do
+          true
+        end
+
+        define_method(method_names[:has_value]) do |*args|
+          tinycache_adapter.valid?(__send__(method_names[:cache_key], *args))
+        end
+
+        define_method(method_name) do |*args|
+          unless_proc = opts[:unless].is_a?(Symbol) ? opts[:unless].to_proc : opts[:unless]
+
+          skip_cache = false
+          skip_cache ||= unless_proc&.call(self, method_name, args)
+          skip_cache ||= CACHE_LEVELS[client&.cache || :all] < CACHE_LEVELS[cache_level]
+
+          if skip_cache
+            __send__(method_names[:without_cache], *args)
+          else
+            __send__(method_names[:with_cache], *args)
+          end
+        end
+      end
+    end
+
+    def build_method_names(method)
+      # Clean up method name (split any suffix)
+      method_name = method.to_s.sub(/([?!=])$/, '')
+      punctuation = Regexp.last_match(-1)
+
+      {
+        cache_key: "#{method_name}_cache_key#{punctuation}",
+        with_cache: "#{method_name}_with_cache#{punctuation}",
+        without_cache: "#{method_name}_without_cache#{punctuation}",
+        clear_cache: "clear_#{method_name}_cache#{punctuation}",
+        cached: "#{method}_cached?",
+        has_value: "#{method}_has_value?"
+      }
+    end
+  end
+end

data/lib/matrix_sdk/util/tinycache_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Util
+  class TinycacheAdapter
+    attr_accessor :config, :client
+
+    def initialize
+      @config = {}
+
+      clear
+    end
+
+    def read(key)
+      cache[key]&.value
+    end
+
+    def write(key, value, expires_in: nil, cache_level: nil)
+      expires_in ||= config.dig(key, :expires)
+      expires_in ||= 24 * 60 * 60
+      cache_level ||= client&.cache
+      cache_level ||= :all
+      cache_level = Tinycache::CACHE_LEVELS[cache_level] unless cache_level.is_a? Integer
+
+      return value if cache_level < Tinycache::CACHE_LEVELS[config.dig(key, :level) || :none]
+
+      cache[key] = Value.new(value, Time.now, Time.now + expires_in)
+      value
+    end
+
+    def exist?(key)
+      cache.key?(key)
+    end
+
+    def valid?(key)
+      exist?(key) && !cache[key].expired?
+    end
+
+    def fetch(key, expires_in: nil, cache_level: nil, **_opts)
+      expires_in ||= config.dig(key, :expires)
+      cache_level ||= client&.cache
+      cache_level ||= :all
+      cache_level = Tinycache::CACHE_LEVELS[cache_level]
+
+      return read(key) if exist?(key) && !cache[key].expired?
+
+      value = yield
+      write(key, value, expires_in: expires_in, cache_level: cache_level)
+    end
+
+    def delete(key)
+      return false unless exist?(key)
+
+      cache.delete key
+      true
+    end
+
+    def clear
+      @cache = {}
+    end
+
+    def cleanup
+      @cache.delete_if { |_, v| v.expired? }
+    end
+
+    private
+
+    Value = Struct.new(:value, :timestamp, :expires_at) do
+      def expired?
+        return false if expires_at.nil?
+
+        Time.now > expires_at
+      end
+    end
+
+    attr_reader :cache
+  end
+end