activematrix 0.0.0

data/lib/matrix_sdk/util/tinycache.rb

@@ -0,0 +1,140 @@
+# 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
+            named = args.delete_at(-1) if args.last.is_a? Hash
+            named ||= {}
+
+            __send__(method_names[:without_cache], *args, **named)
+          end
+        end
+
+        define_method(method_names[:without_cache]) do |*args|
+          orig = method(method_name).super_method
+          named = args.delete_at(-1) if args.last.is_a? Hash
+          named ||= {}
+
+          orig.call(*args, **named)
+        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]
+
+          raise ArgumentError, 'Invalid proc provided (must have arity between 1..3)' if unless_proc && !(1..3).include?(unless_proc.arity)
+
+          skip_cache = false
+          skip_cache ||= unless_proc.call(self, method_name, args) if unless_proc&.arity == 3
+          skip_cache ||= unless_proc.call(method_name, args) if unless_proc&.arity == 2
+          skip_cache ||= unless_proc.call(args) if unless_proc&.arity == 1
+          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,87 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Util
+  class TinycacheAdapter
+    extend MatrixSdk::Extensions
+
+    attr_accessor :config, :client
+
+    ignore_inspect :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 expire(key)
+      return unless exist? key
+
+      cache[key].expires_at = Time.at(0)
+    end
+
+    def clear
+      @cache = {}
+    end
+
+    def cleanup
+      @cache.select { |_, v| v.expired? }.each { |_, v| v.value = nil }
+    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

data/lib/matrix_sdk/util/uri.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module URI
+  # A mxc:// Matrix content URL
+  class MXC < Generic
+    def full_path
+      select(:host, :port, :path, :query, :fragment)
+        .compact
+        .join
+    end
+  end
+
+  # TODO: Use +register_scheme+ on Ruby >=3.1 and fall back to old behavior
+  # for older Rubies. May be removed at EOL of Ruby 3.0.
+  if respond_to? :register_scheme
+    register_scheme 'MXC', MXC
+  else
+    @@schemes['MXC'] = MXC
+  end
+
+  unless scheme_list.key? 'MATRIX'
+    # A matrix: URI according to MSC2312
+    class MATRIX < Generic
+      attr_reader :authority, :action, :mxid, :mxid2, :via
+
+      def initialize(*args)
+        super(*args)
+
+        @action = nil
+        @authority = nil
+        @mxid = nil
+        @mxid2 = nil
+        @via = nil
+
+        raise InvalidComponentError, 'missing opaque part for matrix URL' if !@opaque && !@path
+
+        if @path
+          @authority = @host
+          @authority += ":#{@port}" if @port
+        else
+          @path, @query = @opaque.split('?')
+          @query, @fragment = @query.split('#') if @query&.include? '#'
+          @path, @fragment = @path.split('#') if @path&.include? '#'
+          @path = "/#{path}"
+          @opaque = nil
+        end
+
+        components = @path.delete_prefix('/').split('/', -1)
+        raise InvalidComponentError, 'component count must be 2 or 4' if components.size != 2 && components.size != 4
+
+        sigil = case components.shift
+                when 'u', 'user'
+                  '@'
+                when 'r', 'room'
+                  '#'
+                when 'roomid'
+                  '!'
+                else
+                  raise InvalidComponentError, 'invalid component in path'
+                end
+
+        component = components.shift
+        raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
+
+        @mxid = MatrixSdk::MXID.new("#{sigil}#{component}")
+
+        if components.size == 2
+          sigil2 = case components.shift
+                   when 'e', 'event'
+                     '$'
+                   else
+                     raise InvalidComponentError, 'invalid component in path'
+                   end
+          component = components.shift
+          raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
+
+          @mxid2 = MatrixSdk::MXID.new("#{sigil2}#{component}")
+        end
+
+        return unless @query
+
+        @action = @query.match(/action=([^&]+)/)&.captures&.first&.to_sym
+        @via = @query.scan(/via=([^&]+)/)&.flatten&.compact
+      end
+
+      def mxid2?
+        !@mxid2.nil?
+      end
+    end
+
+    # TODO: Use +register_scheme+ on Ruby >=3.1 and fall back to old behavior
+    # for older Rubies. May be removed at EOL of Ruby 3.0.
+    if respond_to? :register_scheme
+      register_scheme 'MATRIX', MATRIX
+    else
+      @@schemes['MATRIX'] = MATRIX
+    end
+  end
+end

data/lib/matrix_sdk/version.rb

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

data/lib/matrix_sdk.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'matrix_sdk/util/extensions'
+require 'matrix_sdk/util/uri'
+require 'matrix_sdk/version'
+
+require 'json'
+
+autoload :Logging, 'logging'
+
+module MatrixSdk
+  autoload :Api, 'matrix_sdk/api'
+  # autoload :ApplicationService, 'matrix_sdk/application_service'
+  autoload :Client, 'matrix_sdk/client'
+  autoload :MXID, 'matrix_sdk/mxid'
+  autoload :Response, 'matrix_sdk/response'
+  autoload :Room, 'matrix_sdk/room'
+  autoload :User, 'matrix_sdk/user'
+
+  autoload :MatrixError, 'matrix_sdk/errors'
+  autoload :MatrixRequestError, 'matrix_sdk/errors'
+  autoload :MatrixNotAuthorizedError, 'matrix_sdk/errors'
+  autoload :MatrixForbiddenError, 'matrix_sdk/errors'
+  autoload :MatrixNotFoundError, 'matrix_sdk/errors'
+  autoload :MatrixConflictError, 'matrix_sdk/errors'
+  autoload :MatrixTooManyRequestsError, 'matrix_sdk/errors'
+  autoload :MatrixConnectionError, 'matrix_sdk/errors'
+  autoload :MatrixTimeoutError, 'matrix_sdk/errors'
+  autoload :MatrixUnexpectedResponseError, 'matrix_sdk/errors'
+
+  module Bot
+    autoload :Base, 'matrix_sdk/bot/base'
+  end
+
+  module Rooms
+    autoload :Space, 'matrix_sdk/rooms/space'
+  end
+
+  module Util
+    autoload :AccountDataCache, 'matrix_sdk/util/account_data_cache'
+    autoload :StateEventCache, 'matrix_sdk/util/state_event_cache'
+    autoload :Tinycache, 'matrix_sdk/util/tinycache'
+    autoload :TinycacheAdapter, 'matrix_sdk/util/tinycache_adapter'
+  end
+
+  module Protocols
+    autoload :AS, 'matrix_sdk/protocols/as'
+    autoload :CS, 'matrix_sdk/protocols/cs'
+    autoload :IS, 'matrix_sdk/protocols/is'
+    autoload :SS, 'matrix_sdk/protocols/ss'
+
+    # Non-final protocol extensions
+    autoload :MSC, 'matrix_sdk/protocols/msc'
+  end
+
+  def self.debug!
+    logger.level = :debug
+  end
+
+  def self.logger
+    @logger ||= ::Logging.logger[self].tap do |logger|
+      logger.add_appenders ::Logging.appenders.stdout
+      logger.level = :info
+    end
+  end
+
+  def self.logger=(global_logger)
+    @logger = global_logger
+    @global_logger = !global_logger.nil?
+  end
+
+  def self.global_logger?
+    @global_logger ||= false
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: activematrix
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+- Alexander Olofsson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: A Ruby on Rails gem that provides seamless integration with the Matrix
+  protocol, enabling Rails applications to connect and communicate with Matrix servers.
+email:
+- terminale@gmail.com
+- ace@haxalot.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/matrix_sdk.rb
+- lib/matrix_sdk/api.rb
+- lib/matrix_sdk/bot.rb
+- lib/matrix_sdk/bot/base.rb
+- lib/matrix_sdk/bot/main.rb
+- lib/matrix_sdk/client.rb
+- lib/matrix_sdk/errors.rb
+- lib/matrix_sdk/mxid.rb
+- lib/matrix_sdk/protocols/as.rb
+- lib/matrix_sdk/protocols/cs.rb
+- lib/matrix_sdk/protocols/is.rb
+- lib/matrix_sdk/protocols/msc.rb
+- lib/matrix_sdk/protocols/ss.rb
+- lib/matrix_sdk/response.rb
+- lib/matrix_sdk/room.rb
+- lib/matrix_sdk/rooms/space.rb
+- lib/matrix_sdk/user.rb
+- lib/matrix_sdk/util/account_data_cache.rb
+- lib/matrix_sdk/util/events.rb
+- lib/matrix_sdk/util/extensions.rb
+- lib/matrix_sdk/util/state_event_cache.rb
+- lib/matrix_sdk/util/tinycache.rb
+- lib/matrix_sdk/util/tinycache_adapter.rb
+- lib/matrix_sdk/util/uri.rb
+- lib/matrix_sdk/version.rb
+homepage: https://github.com/seuros/activematrix
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Rails gem for connecting to Matrix protocol
+test_files: []