async-matrix 1.0.0 → 1.1.1

data/lib/async/matrix/bridge/discord/db/puppet.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Maps a Discord user to a Matrix ghost user.
+          #
+          # The ghost's Matrix ID is derived from the username template in the
+          # bridge config (e.g., @discord_123456:example.com). This model
+          # tracks the Discord user's profile info for syncing to Matrix.
+          #
+          #   puppet = Puppet.create(discord_id: "123", username: "alice", name: "Alice")
+          #   puppet.is_bot?          # => false
+          #   puppet.double_puppet?   # => true  (if custom_mxid is set)
+          #
+          class Puppet < Sequel::Model
+            unrestrict_primary_key
+
+            def validate
+              super
+              errors.add(:discord_id, "cannot be empty") if discord_id.nil? || discord_id.empty?
+            end
+
+            # Is this puppet configured for double puppeting?
+            def double_puppet?
+              !custom_mxid.nil? && !custom_mxid.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::Puppet" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    it "creates and retrieves a puppet" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      puppet = Async::Matrix::Bridge::Discord::DB::Puppet.create(
+        discord_id: "123",
+        name: "Alice",
+        username: "alice",
+        global_name: "Alice Wonderland"
+      )
+      puppet.discord_id.should == "123"
+      puppet.name.should == "Alice"
+      puppet.username.should == "alice"
+      puppet.global_name.should == "Alice Wonderland"
+      db.disconnect
+    end
+
+    it "defaults boolean flags to false" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      puppet = Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "200")
+      puppet.is_bot.should == false
+      puppet.is_webhook.should == false
+      puppet.contact_info_set.should == false
+      db.disconnect
+    end
+
+    it "tracks bot and webhook puppets" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      bot = Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "300", is_bot: true)
+      bot.is_bot.should == true
+
+      webhook = Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "301", is_webhook: true)
+      webhook.is_webhook.should == true
+      db.disconnect
+    end
+
+    it "detects double puppet configuration" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      regular = Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "400")
+      regular.double_puppet?.should == false
+
+      double = Async::Matrix::Bridge::Discord::DB::Puppet.create(
+        discord_id: "401",
+        custom_mxid: "@alice:example.com",
+        access_token: "syt_token"
+      )
+      double.double_puppet?.should == true
+      double.access_token.should == "syt_token"
+      db.disconnect
+    end
+
+    it "validates discord_id is present" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      puppet = Async::Matrix::Bridge::Discord::DB::Puppet.new(discord_id: "")
+      puppet.valid?.should == false
+      puppet.errors[:discord_id].should.not.be.empty
+      db.disconnect
+    end
+
+    it "updates avatar info" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Puppet.dataset = db[:puppets]
+
+      puppet = Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "500")
+      puppet.update(avatar_hash: "abc123", avatar_url: "mxc://example.com/abc")
+      puppet.refresh
+      puppet.avatar_hash.should == "abc123"
+      puppet.avatar_url.should == "mxc://example.com/abc"
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db/reaction.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Maps a Discord reaction to a Matrix reaction event.
+          #
+          # Uniquely identified by (discord_message_id, discord_sender,
+          # discord_emoji_name) — one reaction per emoji per user per message.
+          #
+          #   reaction = Reaction.create(
+          #     discord_message_id: "msg1", discord_sender: "user1",
+          #     discord_emoji_name: "\u{1f44d}", mxid: "$react1",
+          #     discord_channel_id: "ch1"
+          #   )
+          #
+          class Reaction < Sequel::Model
+            def validate
+              super
+              errors.add(:discord_message_id, "cannot be empty") if discord_message_id.nil? || discord_message_id.empty?
+              errors.add(:discord_sender, "cannot be empty") if discord_sender.nil? || discord_sender.empty?
+              errors.add(:discord_emoji_name, "cannot be empty") if discord_emoji_name.nil? || discord_emoji_name.empty?
+              errors.add(:mxid, "cannot be empty") if mxid.nil? || mxid.empty?
+            end
+
+            # Find all reactions on a Discord message.
+            def self.by_discord_message(message_id, channel_id, receiver = "")
+              where(
+                discord_message_id: message_id,
+                discord_channel_id: channel_id,
+                discord_channel_receiver: receiver
+              ).all
+            end
+
+            # Find a specific reaction by its Matrix event ID.
+            def self.by_mxid(mxid)
+              first(mxid: mxid)
+            end
+
+            # Find a specific reaction by Discord compound key.
+            def self.by_discord_key(message_id:, sender:, emoji_name:)
+              first(
+                discord_message_id: message_id,
+                discord_sender: sender,
+                discord_emoji_name: emoji_name
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::Reaction" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    it "creates and retrieves a reaction" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      reaction = Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg1",
+        discord_sender: "user1",
+        discord_emoji_name: "\u{1f44d}",
+        mxid: "$react1",
+        discord_channel_id: "ch1"
+      )
+      reaction.discord_emoji_name.should == "\u{1f44d}"
+      reaction.mxid.should == "$react1"
+      db.disconnect
+    end
+
+    it "finds reactions by discord message" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg2", discord_sender: "u1",
+        discord_emoji_name: "\u{1f44d}", mxid: "$r1", discord_channel_id: "ch1"
+      )
+      Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg2", discord_sender: "u2",
+        discord_emoji_name: "\u{2764}", mxid: "$r2", discord_channel_id: "ch1"
+      )
+
+      reactions = Async::Matrix::Bridge::Discord::DB::Reaction.by_discord_message("msg2", "ch1")
+      reactions.length.should == 2
+      db.disconnect
+    end
+
+    it "finds by Discord compound key" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg3", discord_sender: "u1",
+        discord_emoji_name: "custom_emoji", mxid: "$r3", discord_channel_id: "ch1"
+      )
+
+      found = Async::Matrix::Bridge::Discord::DB::Reaction.by_discord_key(
+        message_id: "msg3", sender: "u1", emoji_name: "custom_emoji"
+      )
+      found.should.not.be.nil
+      found.mxid.should == "$r3"
+      db.disconnect
+    end
+
+    it "finds by Matrix event ID" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg4", discord_sender: "u1",
+        discord_emoji_name: "x", mxid: "$find_react", discord_channel_id: "ch1"
+      )
+
+      found = Async::Matrix::Bridge::Discord::DB::Reaction.by_mxid("$find_react")
+      found.discord_message_id.should == "msg4"
+      db.disconnect
+    end
+
+    it "enforces unique reaction per user per emoji per message" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      Async::Matrix::Bridge::Discord::DB::Reaction.create(
+        discord_message_id: "msg5", discord_sender: "u1",
+        discord_emoji_name: "x", mxid: "$r5", discord_channel_id: "ch1"
+      )
+      lambda {
+        Async::Matrix::Bridge::Discord::DB::Reaction.create(
+          discord_message_id: "msg5", discord_sender: "u1",
+          discord_emoji_name: "x", mxid: "$r6", discord_channel_id: "ch1"
+        )
+      }.should.raise(Sequel::UniqueConstraintViolation)
+      db.disconnect
+    end
+
+    it "validates required fields" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Reaction.dataset = db[:reactions]
+
+      r = Async::Matrix::Bridge::Discord::DB::Reaction.new(
+        discord_message_id: "", discord_sender: "",
+        discord_emoji_name: "", mxid: ""
+      )
+      r.valid?.should == false
+      r.errors[:discord_message_id].should.not.be.empty
+      r.errors[:mxid].should.not.be.empty
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db/user.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Maps a Matrix user to their Discord identity and session state.
+          #
+          #   user = User.create(mxid: "@alice:example.com", discord_id: "123456789")
+          #   user.discord_id     # => "123456789"
+          #   user.space_room     # => "!space:example.com"
+          #   user.portals        # => [Portal, ...]
+          #
+          class User < Sequel::Model
+            unrestrict_primary_key
+
+            one_to_many :portals,
+              class: "Async::Matrix::Bridge::Discord::DB::Portal",
+              key: :receiver,
+              primary_key: :discord_id
+
+            def validate
+              super
+              errors.add(:mxid, "cannot be empty") if mxid.nil? || mxid.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::User" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    it "creates and retrieves a user by mxid" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::User.dataset = db[:users]
+
+      user = Async::Matrix::Bridge::Discord::DB::User.create(
+        mxid: "@alice:example.com",
+        discord_id: "123456789"
+      )
+      user.mxid.should == "@alice:example.com"
+      user.discord_id.should == "123456789"
+
+      found = Async::Matrix::Bridge::Discord::DB::User["@alice:example.com"]
+      found.discord_id.should == "123456789"
+      db.disconnect
+    end
+
+    it "stores optional session fields" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::User.dataset = db[:users]
+
+      user = Async::Matrix::Bridge::Discord::DB::User.create(
+        mxid: "@bob:example.com",
+        discord_token: "secret_token",
+        management_room: "!mgmt:example.com",
+        space_room: "!space:example.com",
+        dm_space_room: "!dm:example.com"
+      )
+      user.discord_token.should == "secret_token"
+      user.management_room.should == "!mgmt:example.com"
+      user.space_room.should == "!space:example.com"
+      user.dm_space_room.should == "!dm:example.com"
+      db.disconnect
+    end
+
+    it "enforces unique discord_id" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::User.dataset = db[:users]
+
+      Async::Matrix::Bridge::Discord::DB::User.create(mxid: "@a:x", discord_id: "111")
+      lambda {
+        Async::Matrix::Bridge::Discord::DB::User.create(mxid: "@b:x", discord_id: "111")
+      }.should.raise(Sequel::UniqueConstraintViolation)
+      db.disconnect
+    end
+
+    it "validates mxid is present" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::User.dataset = db[:users]
+
+      user = Async::Matrix::Bridge::Discord::DB::User.new(mxid: "")
+      user.valid?.should == false
+      user.errors[:mxid].should.not.be.empty
+      db.disconnect
+    end
+
+    it "updates discord token" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::User.dataset = db[:users]
+
+      user = Async::Matrix::Bridge::Discord::DB::User.create(mxid: "@c:x")
+      user.update(discord_token: "new_token")
+      user.refresh
+      user.discord_token.should == "new_token"
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "sequel"
+require "sequel/extensions/migration"
+require "async/matrix"
+
+# Sequel::Model requires a database connection at subclass definition time.
+# Set a placeholder in-memory SQLite so models can be defined at require
+# time. The real database is bound later via DB.connect.
+#
+# require_valid_table = false suppresses the column introspection that
+# Sequel normally does on inherited — critical because the placeholder
+# DB has no tables.
+unless Sequel::Model.instance_variable_get(:@db)
+  Sequel::Model.db = Sequel.sqlite
+  Sequel::Model.require_valid_table = false
+end
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        # Database module for the Discord bridge.
+        #
+        # Establishes a connection using the bridge config's database section,
+        # runs Sequel migrations, and wires up all model classes to the database.
+        #
+        # Supports both SQLite (with foreign keys + WAL) and PostgreSQL.
+        #
+        #   db = Async::Matrix::Bridge::Discord::DB.connect(config)
+        #   # All models are now ready:
+        #   DB::User.create(mxid: "@alice:example.com")
+        #   DB::Portal.where(discord_guild_id: "123").all
+        #
+        module DB
+          MIGRATIONS_PATH = File.join(__dir__, "db", "migrations").freeze
+
+          # Connect to the database, run migrations, and bind all models.
+          #
+          # @param config [Async::Matrix::ApplicationService::Config] the bridge config
+          # @return [Sequel::Database]
+          def self.connect(config)
+            db = Connection.establish(config.database)
+            migrate!(db)
+            bind_models(db)
+            db
+          end
+
+          # Run pending migrations.
+          #
+          # @param db [Sequel::Database]
+          def self.migrate!(db)
+            Sequel::Migrator.run(db, MIGRATIONS_PATH)
+          end
+
+          # Bind all model classes to the given database.
+          #
+          # @param db [Sequel::Database]
+          def self.bind_models(db)
+            Async::Matrix::Bridge::Discord::DB::User.dataset        = db[:users]
+            Async::Matrix::Bridge::Discord::DB::Guild.dataset       = db[:guilds]
+            Async::Matrix::Bridge::Discord::DB::Portal.dataset      = db[:portals]
+            Async::Matrix::Bridge::Discord::DB::Puppet.dataset      = db[:puppets]
+            Async::Matrix::Bridge::Discord::DB::Message.dataset     = db[:messages]
+            Async::Matrix::Bridge::Discord::DB::Reaction.dataset    = db[:reactions]
+            Async::Matrix::Bridge::Discord::DB::CachedFile.dataset  = db[:files]
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB" do
+    it "connects, migrates, and binds models from config" do
+      database_config = Object.new
+      database_config.define_singleton_method(:type) { "sqlite3-fk-wal" }
+      database_config.define_singleton_method(:uri)  { "sqlite:/" }
+      database_config.define_singleton_method(:max_open_conns) { 1 }
+
+      config = Object.new
+      config.define_singleton_method(:database) { database_config }
+
+      db = Async::Matrix::Bridge::Discord::DB.connect(config)
+      db.should.be.kind_of Sequel::Database
+
+      # All tables should exist
+      db.tables.should.include :users
+      db.tables.should.include :guilds
+      db.tables.should.include :portals
+      db.tables.should.include :puppets
+      db.tables.should.include :messages
+      db.tables.should.include :reactions
+      db.tables.should.include :files
+
+      # Models should be bound and functional
+      db[:users].delete
+      db[:guilds].delete
+      db[:portals].delete
+      db[:puppets].delete
+
+      Async::Matrix::Bridge::Discord::DB::User.create(mxid: "@db_int:x")
+      Async::Matrix::Bridge::Discord::DB::User["@db_int:x"].should.not.be.nil
+
+      Async::Matrix::Bridge::Discord::DB::Guild.create(discord_id: "g_int")
+      Async::Matrix::Bridge::Discord::DB::Guild["g_int"].should.not.be.nil
+
+      Async::Matrix::Bridge::Discord::DB::Portal.create(discord_id: "p_int", receiver: "")
+      Async::Matrix::Bridge::Discord::DB::Portal["p_int", ""].should.not.be.nil
+
+      Async::Matrix::Bridge::Discord::DB::Puppet.create(discord_id: "d_int")
+      Async::Matrix::Bridge::Discord::DB::Puppet["d_int"].should.not.be.nil
+
+      db.disconnect
+    end
+
+    it "exposes MIGRATIONS_PATH" do
+      File.directory?(Async::Matrix::Bridge::Discord::DB::MIGRATIONS_PATH).should == true
+    end
+
+    it "is idempotent — running migrations twice does not raise" do
+      database_config = Object.new
+      database_config.define_singleton_method(:type) { "sqlite3-fk-wal" }
+      database_config.define_singleton_method(:uri)  { "sqlite:/" }
+      database_config.define_singleton_method(:max_open_conns) { 1 }
+
+      config = Object.new
+      config.define_singleton_method(:database) { database_config }
+
+      db = Async::Matrix::Bridge::Discord::DB.connect(config)
+      lambda { Async::Matrix::Bridge::Discord::DB.migrate!(db) }.should.not.raise
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/double_puppet_client.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    # A Client subclass that authenticates with a user's double puppet token
+    # instead of the appservice's as_token.
+    #
+    # This allows the bridge to send events as the real Matrix user rather
+    # than as the appservice bot or a ghost user.
+    #
+    #   puppet = DoublePuppetClient.new(config, double_puppet_token: "syt_...")
+    #   puppet.send_text("!room:example.com", "sent as the real user")
+    #   puppet.whoami  # => {"user_id" => "@alice:example.com"}
+    #
+    class DoublePuppetClient < Client
+      def initialize(config, double_puppet_token:, **kwargs)
+        super(config, **kwargs)
+        @headers[0] = ["authorization", "Bearer #{double_puppet_token}"]
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::DoublePuppetClient" do
+    def make_config
+      Async::Matrix::ApplicationService::Config.new({
+        "homeserver" => { "address" => "http://localhost:8008", "domain" => "localhost" },
+        "appservice" => { "as_token" => "as_token_value", "hs_token" => "hs_secret", "bot" => { "username" => "bot" } }
+      })
+    end
+
+    it "uses the double_puppet_token for authorization" do
+      puppet = Async::Matrix::DoublePuppetClient.new(make_config, double_puppet_token: "syt_puppet_token")
+      auth_header = puppet.instance_variable_get(:@headers).find { |k, _| k == "authorization" }
+      auth_header[1].should == "Bearer syt_puppet_token"
+    end
+
+    it "does not use the as_token from config" do
+      puppet = Async::Matrix::DoublePuppetClient.new(make_config, double_puppet_token: "syt_puppet_token")
+      auth_header = puppet.instance_variable_get(:@headers).find { |k, _| k == "authorization" }
+      auth_header[1].should.not.include "as_token_value"
+    end
+
+    it "inherits retry defaults from Client" do
+      puppet = Async::Matrix::DoublePuppetClient.new(make_config, double_puppet_token: "syt_puppet_token")
+      puppet.config.appservice.as_token.should == "as_token_value"
+    end
+
+    it "accepts custom retry configuration" do
+      puppet = Async::Matrix::DoublePuppetClient.new(
+        make_config,
+        double_puppet_token: "syt_puppet_token",
+        max_retries: 5,
+        retry_base_delay: 1.0,
+        max_retry_delay: 60
+      )
+      auth_header = puppet.instance_variable_get(:@headers).find { |k, _| k == "authorization" }
+      auth_header[1].should == "Bearer syt_puppet_token"
+    end
+
+    it "responds to all Client methods" do
+      puppet = Async::Matrix::DoublePuppetClient.new(make_config, double_puppet_token: "syt_puppet_token")
+      puppet.should.respond_to :send_text
+      puppet.should.respond_to :send_html
+      puppet.should.respond_to :send_notice
+      puppet.should.respond_to :join_room
+      puppet.should.respond_to :leave_room
+      puppet.should.respond_to :whoami
+      puppet.should.respond_to :api
+    end
+
+    it "is a subclass of Client" do
+      puppet = Async::Matrix::DoublePuppetClient.new(make_config, double_puppet_token: "syt_puppet_token")
+      puppet.should.be.kind_of Async::Matrix::Client
+    end
+  end
+end

data/lib/async/matrix/schema.rb

@@ -3,8 +3,8 @@
 # Released under the Apache License, Version 2.0.
 # Copyright, 2026, by General Intelligence Systems.
 
-require_relative "schema/registry"
-require_relative "schema/validation_error"
+require "bundler/setup"
+require "async/matrix"
 
 module Async
 	module Matrix

data/lib/async/matrix/server.rb

@@ -5,6 +5,7 @@
 
 require "bundler/setup"
 require "async/http"
+require "async/matrix"
 
 module Async
   module Matrix

data/lib/async/matrix/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module Matrix
-    VERSION = "1.0.0"
+    VERSION = "1.1.1"
 	end
 end

data/lib/async/matrix.rb

@@ -3,6 +3,7 @@
 # Released under the Apache License, Version 2.0.
 # Copyright, 2026, by General Intelligence Systems.
 
+require "bundler/setup"
 require "async/http"
 require "scampi"
 
@@ -12,6 +13,7 @@ module Async
 end
 
 Dir.glob("#{__dir__}/matrix/**/*.rb").sort.each do |path|
+  next if path.include?("/migrations/")
   require path
 end