async-matrix 2.1.0-aarch64-linux → 3.0.1-aarch64-linux

data/lib/async/matrix/application_service/config.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-require "forwardable"
-require "json_schemer"
-require "pathname"
-require "yaml"
-require_relative "config/vivify"
-
-module Async
-  module Matrix
-    module ApplicationService
-      # Loads, validates, and provides dot-notation access to a mautrix
-      # bridgev2-compatible YAML configuration file.
-      #
-      # The full schema mirrors the Go structs defined in
-      # mautrix/go v0.27.0 bridgev2/bridgeconfig — split across multiple
-      # JSON Schema files under config/schema/ and composed at runtime via $ref.
-      #
-      # Validated config data is exposed through Vivify-enhanced hashes,
-      # giving natural dot-notation access to every nested field:
-      #
-      #   config = Config.load("bridge.yml")
-      #   config.homeserver.address     # => "http://synapse:8008"
-      #   config.homeserver.domain      # => "localhost"
-      #   config.appservice.as_token    # => "secret..."
-      #   config.appservice.bot.username # => "bot"
-      #   config.bot_mxid               # => "@bot:localhost"
-      #
-      class Config
-        extend Forwardable
-
-        SCHEMA_DIR = Pathname.new(__dir__).join("config", "schema").freeze
-
-        # Delegate every top-level config section to the vivified data hash.
-        def_delegators :@data,
-          :network, :bridge, :database, :homeserver, :appservice,
-          :matrix, :analytics, :provisioning, :public_media, :direct_media,
-          :backfill, :double_puppet, :encryption, :logging,
-          :management_room_texts, :env_config_prefix
-
-        def initialize(data)
-          self.class.validate!(data)
-          @data = Vivify.deep_vivify(data)
-        end
-
-        # Load and validate a YAML config file from disk.
-        def self.load(path)
-          raise Async::Matrix::NotFoundError.new(
-            "M_NOT_FOUND", "Config not found: #{path}"
-          ) unless File.exist?(path)
-
-          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
-          new(data)
-        end
-
-        # Convenience: derive the bot's full Matrix ID from
-        # appservice.bot.username + homeserver.domain.
-        def bot_mxid
-          "@#{appservice.bot.username}:#{homeserver.domain}"
-        end
-
-        # ------------------------------------------------------------------
-        # Schema loading & validation
-        # ------------------------------------------------------------------
-
-        def self.schema
-          @schema ||= JSONSchemer.schema(
-            SCHEMA_DIR.join("config.json"),
-            insert_property_defaults: true
-          )
-        end
-
-        def self.validate!(data)
-          errors = schema.validate(data).to_a
-          return if errors.empty?
-
-          messages = errors.map { |e| e["error"] }.join("; ")
-          raise Async::Matrix::BadJsonError.new(
-            "M_BAD_JSON", "Config validation failed: #{messages}"
-          )
-        end
-      end
-    end
-  end
-end
-
-__END__
-  require "tempfile"
-
-  describe "Async::Matrix::ApplicationService::Config" do
-    def minimal_data
-      {
-        "homeserver" => {
-          "address" => "http://localhost:8008",
-          "domain"  => "localhost"
-        },
-        "appservice" => {
-          "as_token" => "as_secret_token_value",
-          "hs_token" => "hs_secret_token_value",
-          "bot"      => { "username" => "bot" }
-        }
-      }
-    end
-
-    it "parses a minimal valid config" do
-      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
-      config.homeserver.address.should == "http://localhost:8008"
-      config.homeserver.domain.should == "localhost"
-      config.appservice.as_token.should == "as_secret_token_value"
-      config.appservice.hs_token.should == "hs_secret_token_value"
-      config.appservice.bot.username.should == "bot"
-    end
-
-    it "derives bot_mxid from appservice.bot.username and homeserver.domain" do
-      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
-      config.bot_mxid.should == "@bot:localhost"
-    end
-
-    it "inserts property defaults from the schema" do
-      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
-      config.appservice.hostname.should == "0.0.0.0"
-      config.appservice.port.should == 29318
-      config.homeserver.software.should == "standard"
-    end
-
-    it "provides dot-notation access to deeply nested fields" do
-      data = minimal_data.merge(
-        "encryption" => {
-          "allow" => true,
-          "rotation" => { "messages" => 200 }
-        }
-      )
-      config = Async::Matrix::ApplicationService::Config.new(data)
-      config.encryption.allow.should == true
-      config.encryption.rotation.messages.should == 200
-    end
-
-    it "autovivifies missing optional sections as empty hashes" do
-      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
-      config.analytics.should.be.kind_of Hash
-      config.analytics.should.be.empty?
-    end
-
-    it "raises BadJsonError when homeserver.address is missing" do
-      data = {
-        "homeserver" => { "domain" => "localhost" },
-        "appservice" => { "as_token" => "a", "hs_token" => "b" }
-      }
-      lambda {
-        Async::Matrix::ApplicationService::Config.new(data)
-      }.should.raise(Async::Matrix::BadJsonError)
-    end
-
-    it "raises BadJsonError when appservice.as_token is empty" do
-      data = {
-        "homeserver" => { "address" => "http://localhost:8008", "domain" => "localhost" },
-        "appservice" => { "as_token" => "", "hs_token" => "b" }
-      }
-      lambda {
-        Async::Matrix::ApplicationService::Config.new(data)
-      }.should.raise(Async::Matrix::BadJsonError)
-    end
-
-    it "raises BadJsonError for unknown top-level keys" do
-      data = minimal_data.merge("bogus" => "nope")
-      lambda {
-        Async::Matrix::ApplicationService::Config.new(data)
-      }.should.raise(Async::Matrix::BadJsonError)
-    end
-
-    it "validates enum constraints (homeserver.software)" do
-      data = minimal_data
-      data["homeserver"]["software"] = "invalid_value"
-      lambda {
-        Async::Matrix::ApplicationService::Config.new(data)
-      }.should.raise(Async::Matrix::BadJsonError)
-    end
-
-    it "loads from a YAML file" do
-      file = Tempfile.new(["config", ".yml"])
-      file.write(<<~YAML)
-        homeserver:
-          address: "http://localhost:8008"
-          domain: "localhost"
-        appservice:
-          as_token: "as123_secret"
-          hs_token: "hs456_secret"
-          bot:
-            username: "testbot"
-      YAML
-      file.close
-
-      config = Async::Matrix::ApplicationService::Config.load(file.path)
-      config.homeserver.address.should == "http://localhost:8008"
-      config.bot_mxid.should == "@testbot:localhost"
-    ensure
-      file.unlink
-    end
-
-    it "raises NotFoundError for missing file" do
-      lambda {
-        Async::Matrix::ApplicationService::Config.load("/nonexistent/path.yml")
-      }.should.raise(Async::Matrix::NotFoundError)
-    end
-
-    it "accepts the full bridge config with permissions as string presets" do
-      data = minimal_data.merge(
-        "bridge" => {
-          "command_prefix" => "!signal",
-          "permissions" => {
-            "*" => "relay",
-            "localhost" => "user",
-            "@admin:localhost" => "admin"
-          }
-        }
-      )
-      config = Async::Matrix::ApplicationService::Config.new(data)
-      config.bridge.command_prefix.should == "!signal"
-      config.bridge.permissions[:"*"].should == "relay"
-      config.bridge.permissions[:"@admin:localhost"].should == "admin"
-    end
-  end

data/lib/async/matrix/application_service/dispatcher.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-require "console"
-
-module Async
-  module Matrix
-    module ApplicationService
-      # Routes incoming Matrix events to registered handler objects.
-      #
-      # Each handler declares the event types it handles via `#event_types`.
-      # When an event arrives, the dispatcher finds all matching handlers
-      # and calls them. Errors in one handler do not prevent others from running.
-      class Dispatcher
-        def initialize(txn_store: TransactionStore.new)
-          @handlers  = Hash.new { |h, k| h[k] = [] }
-          @txn_store = txn_store
-        end
-
-        # Register a Bot (responds to #handlers) or a plain handler (responds
-        # to #event_types and #call). Bots are expanded into their handlers.
-        def register(handler)
-          if handler.respond_to?(:handlers)
-            handler.handlers.each { |h| register(h) }
-          else
-            handler.event_types.each do |type|
-              @handlers[type] << handler
-              Console.info(self) { "Registered #{handler.class.name} for #{type}" }
-            end
-          end
-        end
-
-        # Idempotently process a homeserver transaction. Duplicate transaction
-        # IDs (already seen) are skipped. Returns :processed or :duplicate.
-        #
-        # The idempotency store lives here rather than in the HTTP layer because
-        # the Grape server is stateless across requests — the dispatcher is the
-        # stable, long-lived object.
-        def receive_transaction(txn_id, body)
-          if @txn_store.seen?(txn_id)
-            Console.debug(self) { "Duplicate transaction #{txn_id} — skipping" }
-            :duplicate
-          else
-            dispatch_transaction(body)
-            @txn_store.mark_seen(txn_id)
-            :processed
-          end
-        end
-
-        def dispatch_transaction(body)
-          Transaction.new(body).then do |txn|
-            txn.events.each    { |event| dispatch(event) }
-            txn.ephemeral.each { |event| dispatch(event) }
-          end
-        end
-
-          def dispatch(event)
-            type     = event.type
-            handlers = @handlers[type]
-
-            if handlers.empty?
-              Console.debug(self) { "No handler for event type: #{type}" }
-            else
-              handlers.each do |handler|
-                begin
-                  handler.call(event)
-                rescue => e
-                  Console.error(self) { "Handler #{handler.class.name} raised #{e.class}: #{e.message}" }
-                end
-              end
-            end
-          end
-
-          def handler_count
-            @handlers.values.flatten.size
-          end
-      end
-    end
-  end
-end
-
-__END__
-  describe "Async::Matrix::ApplicationService::Dispatcher" do
-    it "registers and dispatches to handlers" do
-      received = []
-      handler = Object.new
-      handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      handler.define_singleton_method(:call) { |event| received << event }
-
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      dispatcher.register(handler)
-      dispatcher.handler_count.should == 1
-
-      event = Async::Matrix::ApplicationService::Event.new({
-        "type" => "m.room.message",
-        "content" => {"body" => "hi"}
-      })
-      dispatcher.dispatch(event)
-      received.length.should == 1
-      received.first.content.body.should == "hi"
-    end
-
-    it "ignores events with no matching handler" do
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      event = Async::Matrix::ApplicationService::Event.new({"type" => "m.unknown"})
-      lambda { dispatcher.dispatch(event) }.should.not.raise
-    end
-
-    it "continues dispatching when a handler raises" do
-      results = []
-      bad_handler = Object.new
-      bad_handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      bad_handler.define_singleton_method(:call) { |_| raise "boom" }
-
-      good_handler = Object.new
-      good_handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      good_handler.define_singleton_method(:call) { |e| results << e }
-
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      dispatcher.register(bad_handler)
-      dispatcher.register(good_handler)
-
-      event = Async::Matrix::ApplicationService::Event.new({
-        "type" => "m.room.message",
-        "content" => {"body" => "test"}
-      })
-      dispatcher.dispatch(event)
-      results.length.should == 1
-    end
-
-    it "dispatches a full transaction" do
-      received = []
-      handler = Object.new
-      handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      handler.define_singleton_method(:call) { |e| received << e }
-
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      dispatcher.register(handler)
-
-      dispatcher.dispatch_transaction({
-        "events" => [
-          {"type" => "m.room.message", "content" => {"body" => "one"}},
-          {"type" => "m.room.message", "content" => {"body" => "two"}}
-        ]
-      })
-      received.length.should == 2
-    end
-
-    it "registers a bot (object responding to #handlers)" do
-      received = []
-      handler = Object.new
-      handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      handler.define_singleton_method(:call) { |e| received << e }
-
-      bot = Object.new
-      bot.define_singleton_method(:handlers) { [handler] }
-
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      dispatcher.register(bot)
-      dispatcher.handler_count.should == 1
-
-      dispatcher.dispatch_transaction({
-        "events" => [{"type" => "m.room.message", "content" => {"body" => "hi"}}]
-      })
-      received.length.should == 1
-    end
-
-    it "processes a transaction idempotently via receive_transaction" do
-      received = []
-      handler = Object.new
-      handler.define_singleton_method(:event_types) { ["m.room.message"] }
-      handler.define_singleton_method(:call) { |e| received << e }
-
-      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
-      dispatcher.register(handler)
-
-      body = {"events" => [{"type" => "m.room.message", "content" => {"body" => "hi"}}]}
-
-      dispatcher.receive_transaction("txn1", body).should == :processed
-      dispatcher.receive_transaction("txn1", body).should == :duplicate
-      received.length.should == 1
-    end
-  end

data/lib/async/matrix/application_service/event.rb

@@ -1,285 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-module Async
-	module Matrix
-		module ApplicationService
-			# Wraps the content object of a Matrix event, providing typed access to
-			# schema-defined properties via method_missing.
-			#
-			# Common fields like `msgtype`, `body`, and `membership` have dedicated
-			# accessors for convenience. Any other field defined in the event's schema
-			# (or present in the raw hash) is accessible as a method call:
-			#
-			#   content.msgtype      # => "m.text"
-			#   content.body         # => "hello"
-			#   content.membership   # => "join"
-			#   content.avatar_url   # => "mxc://example.org/abc"
-			#   content["custom"]    # => direct hash access for non-standard fields
-			#
-			class Content
-				attr_reader :msgtype, :body, :membership
-
-				def initialize(data)
-					@data       = data
-					@msgtype    = data["msgtype"]
-					@body       = data["body"]
-					@membership = data["membership"]
-				end
-
-				def to_h = @data
-        def to_s = @body.to_s
-        def to_str = to_s
-
-				# Direct hash access for any content field.
-				def [](key) = @data[key.to_s]
-
-				# Dynamic access to any content field present in the raw data.
-				def method_missing(name, *args)
-					key = name.to_s
-					if @data.key?(key)
-						@data[key]
-					else
-						nil
-					end
-				end
-
-				def respond_to_missing?(name, include_private = false)
-					@data.key?(name.to_s) || super
-				end
-			end
-
-			# Represents a Matrix event received via the Application Service API.
-			#
-			# Provides typed accessors for all envelope fields plus schema-driven
-			# validation using the official Matrix spec YAML schemas.
-			#
-			#   event = Event.new(raw_hash)
-			#   event.type           # => "m.room.message"
-			#   event.sender         # => "@alice:example.org"
-			#   event.content.body   # => "hello"
-			#   event.valid?         # => true
-			#   event.valid!         # => true (or raises Schema::ValidationError)
-			#
-			class Event
-				attr_reader :type, :sender, :room_id, :state_key, :content,
-				            :event_id, :origin_server_ts, :unsigned, :raw
-
-				def initialize(data)
-					@raw       = data
-					@type      = data["type"]
-					@sender    = data["sender"]
-					@room_id   = data["room_id"]
-					@state_key = data["state_key"]
-					@event_id  = data["event_id"]
-					@origin_server_ts = data["origin_server_ts"]
-					@unsigned  = data["unsigned"]
-					@content   = Content.new(data["content"] || {})
-				end
-
-				# The JSONSchemer::Schema for this event's type, or nil if unknown.
-				def schema = Schema[@type]
-
-				# Validate this event against its schema.
-				# Returns true if valid or if no schema exists (lenient).
-				def valid? = Schema.valid?(@raw)
-
-				# Validate this event against its schema.
-				# Raises Schema::ValidationError with detailed errors on failure.
-				# Returns true if valid or if no schema exists.
-				def valid!
-					errors = Schema.validate(@raw)
-					unless errors.empty?
-						raise Schema::ValidationError.new(
-							errors,
-							event_type: @type,
-							event_id: @event_id
-						)
-					end
-					true
-				end
-
-				# Content property names defined by the schema for this event type.
-				# @return [Array<String>]
-				def content_properties = Schema.content_properties(@type)
-
-				# Is this a state event? (has a state_key)
-				def state_event? = !@state_key.nil?
-			end
-		end
-	end
-end
-
-__END__
-	describe "Async::Matrix::ApplicationService::Content" do
-		it "parses msgtype, body, and membership" do
-			content = Async::Matrix::ApplicationService::Content.new({
-				"msgtype" => "m.text",
-				"body" => "hello",
-				"membership" => "join"
-			})
-			content.msgtype.should == "m.text"
-			content.body.should == "hello"
-			content.membership.should == "join"
-		end
-
-		it "handles missing fields gracefully" do
-			content = Async::Matrix::ApplicationService::Content.new({})
-			content.msgtype.should.be.nil
-			content.body.should.be.nil
-			content.membership.should.be.nil
-		end
-
-		it "provides hash access via []" do
-			content = Async::Matrix::ApplicationService::Content.new({"custom_field" => "value"})
-			content["custom_field"].should == "value"
-		end
-
-		it "provides dynamic access via method_missing" do
-			content = Async::Matrix::ApplicationService::Content.new({
-				"avatar_url" => "mxc://example.org/abc",
-				"displayname" => "Alice"
-			})
-			content.avatar_url.should == "mxc://example.org/abc"
-			content.displayname.should == "Alice"
-		end
-
-		it "returns nil for unknown fields via method_missing" do
-			content = Async::Matrix::ApplicationService::Content.new({})
-			content.nonexistent.should.be.nil
-		end
-
-		it "returns the raw hash via to_h" do
-			data = {"msgtype" => "m.text", "body" => "hi"}
-			content = Async::Matrix::ApplicationService::Content.new(data)
-			content.to_h.should == data
-		end
-
-		it "responds to keys present in the data" do
-			content = Async::Matrix::ApplicationService::Content.new({"avatar_url" => "mxc://x/y"})
-			content.respond_to?(:avatar_url).should == true
-			content.respond_to?(:nonexistent).should == false
-		end
-	end
-
-	describe "Async::Matrix::ApplicationService::Event" do
-		it "parses all event fields" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "m.room.message",
-				"sender" => "@alice:example.com",
-				"room_id" => "!abc:example.com",
-				"state_key" => "",
-				"event_id" => "$evt1",
-				"origin_server_ts" => 1234567890,
-				"unsigned" => {"age" => 1000},
-				"content" => {"msgtype" => "m.text", "body" => "hi"}
-			})
-			event.type.should == "m.room.message"
-			event.sender.should == "@alice:example.com"
-			event.room_id.should == "!abc:example.com"
-			event.state_key.should == ""
-			event.event_id.should == "$evt1"
-			event.origin_server_ts.should == 1234567890
-			event.unsigned.should == {"age" => 1000}
-			event.content.should.be.kind_of Async::Matrix::ApplicationService::Content
-			event.content.body.should == "hi"
-		end
-
-		it "defaults content to empty Content when missing" do
-			event = Async::Matrix::ApplicationService::Event.new({"type" => "m.room.message"})
-			event.content.should.be.kind_of Async::Matrix::ApplicationService::Content
-			event.content.body.should.be.nil
-		end
-
-		it "exposes the raw hash" do
-			data = {"type" => "m.room.message", "content" => {"body" => "hi", "msgtype" => "m.text"}}
-			event = Async::Matrix::ApplicationService::Event.new(data)
-			event.raw.should.equal data
-		end
-
-		it "detects state events" do
-			state = Async::Matrix::ApplicationService::Event.new({"type" => "m.room.member", "state_key" => "@a:b"})
-			state.state_event?.should == true
-
-			msg = Async::Matrix::ApplicationService::Event.new({"type" => "m.room.message"})
-			msg.state_event?.should == false
-		end
-
-		it "returns the schema for known event types" do
-			event = Async::Matrix::ApplicationService::Event.new({"type" => "m.room.message", "content" => {}})
-			event.schema.should.not.be.nil
-			event.schema.should.be.kind_of JSONSchemer::Schema
-		end
-
-		it "returns nil schema for unknown event types" do
-			event = Async::Matrix::ApplicationService::Event.new({"type" => "m.custom.event", "content" => {}})
-			event.schema.should.be.nil
-		end
-
-		it "validates a correct event" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "m.room.message",
-				"content" => {"msgtype" => "m.text", "body" => "hello"},
-				"event_id" => "$abc123",
-				"sender" => "@alice:example.org",
-				"origin_server_ts" => 1234567890,
-				"room_id" => "!room:example.org"
-			})
-			event.valid?.should == true
-			event.valid!.should == true
-		end
-
-		it "rejects an invalid event" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "m.room.message",
-				"content" => {"msgtype" => "m.text"},
-				"event_id" => "$abc123",
-				"sender" => "@alice:example.org",
-				"origin_server_ts" => 1234567890,
-				"room_id" => "!room:example.org"
-			})
-			event.valid?.should == false
-		end
-
-		it "raises ValidationError from valid!" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "m.room.member",
-				"content" => {"membership" => "invalid_state"},
-				"state_key" => "@alice:example.org",
-				"event_id" => "$abc123",
-				"sender" => "@alice:example.org",
-				"origin_server_ts" => 1234567890,
-				"room_id" => "!room:example.org"
-			})
-			begin
-				event.valid!
-				raise "should have raised"
-			rescue Async::Matrix::Schema::ValidationError => e
-				e.message.should.include "m.room.member"
-				e.message.should.include "$abc123"
-				e.errors.should.not.be.empty
-			end
-		end
-
-		it "is lenient with unknown event types" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "com.custom.event",
-				"content" => {"anything" => "goes"},
-				"event_id" => "$x",
-				"sender" => "@a:b"
-			})
-			event.valid?.should == true
-			event.valid!.should == true
-		end
-
-		it "returns content properties for known types" do
-			event = Async::Matrix::ApplicationService::Event.new({
-				"type" => "m.room.member",
-				"content" => {"membership" => "join"}
-			})
-			props = event.content_properties
-			props.should.include "membership"
-		end
-	end