torikago 0.0.1

data/test/torikago/package_api_updater.rb

@@ -0,0 +1,94 @@
+require_relative "../test_helper"
+require "fileutils"
+require "tmpdir"
+require "yaml"
+
+class TorikagoPackageApiUpdaterTest < Minitest::Test
+  def test_update_package_api_creates_manifest_from_package_api_files
+    Dir.mktmpdir("torikago-package-api-updater") do |module_root|
+      package_api_dir = File.join(module_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      File.write(File.join(package_api_dir, "user_create_command.rb"), "")
+      File.write(File.join(package_api_dir, "user_find_query.rb"), "")
+
+      configuration = Torikago::Configuration.new
+      configuration.register(:foo, root: module_root)
+
+      updates = Torikago::PackageApiUpdater.new(configuration: configuration).call
+      manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
+
+      assert_equal [Pathname(File.join(module_root, "package_api.yml"))], updates.values
+      assert_equal(
+        {
+          "exports" => {
+            "Foo::UserCreateCommand" => { "allowed_callers" => [] },
+            "Foo::UserFindQuery" => { "allowed_callers" => [] }
+          }
+        },
+        manifest
+      )
+    end
+  end
+
+  def test_update_package_api_preserves_existing_allowed_callers
+    Dir.mktmpdir("torikago-package-api-updater") do |module_root|
+      package_api_dir = File.join(module_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      File.write(File.join(package_api_dir, "user_create_command.rb"), "")
+      File.write(
+        File.join(module_root, "package_api.yml"),
+        <<~YAML
+          exports:
+            Foo::UserCreateCommand:
+              allowed_callers:
+                - bar
+        YAML
+      )
+
+      configuration = Torikago::Configuration.new
+      configuration.register(:foo, root: module_root)
+
+      Torikago::PackageApiUpdater.new(configuration: configuration).call(:foo)
+      manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
+
+      assert_equal ["bar"], manifest.dig("exports", "Foo::UserCreateCommand", "allowed_callers")
+    end
+  end
+
+  def test_update_package_api_uses_a_configured_entrypoint_directory
+    Dir.mktmpdir("torikago-package-api-updater") do |module_root|
+      package_api_dir = File.join(module_root, "components/public_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      File.write(File.join(package_api_dir, "user_create_command.rb"), "")
+
+      configuration = Torikago::Configuration.new
+      configuration.register(:foo, root: module_root, entrypoint: "components/public_api")
+
+      Torikago::PackageApiUpdater.new(configuration: configuration).call(:foo)
+      manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
+
+      assert_equal(
+        { "allowed_callers" => [] },
+        manifest.dig("exports", "Foo::UserCreateCommand")
+      )
+    end
+  end
+
+  def test_update_package_api_does_not_scan_parent_when_configured_entrypoint_directory_is_missing
+    Dir.mktmpdir("torikago-package-api-updater") do |module_root|
+      FileUtils.mkdir_p(File.join(module_root, "app/models/foo"))
+      File.write(File.join(module_root, "app/models/foo/widget.rb"), "")
+
+      configuration = Torikago::Configuration.new
+      configuration.register(:foo, root: module_root, entrypoint: "app/package_api")
+
+      Torikago::PackageApiUpdater.new(configuration: configuration).call(:foo)
+      manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
+
+      assert_equal({ "exports" => {} }, manifest)
+    end
+  end
+end

data/test/torikago/registry.rb

@@ -0,0 +1,83 @@
+require_relative "../test_helper"
+
+class TorikagoRegistryTest < Minitest::Test
+  def setup
+    @configuration = Torikago::Configuration.new
+    @configuration.register(
+      :foo,
+      root: "/modules/foo",
+      entrypoint: "lib/foo/box_runtime.rb",
+      setup: "config/box_setup.rb",
+      gemfile: "Gemfile"
+    )
+  end
+
+  def test_resolve_returns_a_container_for_a_registered_module
+    registry = Torikago::Registry.new(configuration: @configuration) do |definition|
+      {
+        name: definition.name,
+        root: definition.root.to_s,
+        entrypoint: definition.entrypoint,
+        setup: definition.setup,
+        gemfile: definition.gemfile
+      }
+    end
+
+    container = registry.resolve(:foo)
+
+    assert_equal :foo, container[:name]
+    assert_equal "/modules/foo", container[:root]
+    assert_equal "lib/foo/box_runtime.rb", container[:entrypoint]
+    assert_equal "config/box_setup.rb", container[:setup]
+    assert_equal "Gemfile", container[:gemfile]
+  end
+
+  def test_resolve_reuses_the_same_container_for_the_same_module
+    build_count = 0
+
+    registry = Torikago::Registry.new(configuration: @configuration) do |_definition|
+      build_count += 1
+      Object.new
+    end
+
+    first = registry.resolve(:foo)
+    second = registry.resolve("foo")
+
+    assert_same first, second
+    assert_equal 1, build_count
+  end
+
+  def test_resolve_fails_clearly_for_an_unknown_module
+    registry = Torikago::Registry.new(configuration: @configuration) do |_definition|
+      Object.new
+    end
+
+    error = assert_raises(KeyError) do
+      registry.resolve(:missing)
+    end
+
+    assert_match(/missing/, error.message)
+  end
+
+  def test_resolve_uses_the_container_factory_not_the_gateway
+    captured_definition = nil
+
+    registry = Torikago::Registry.new(configuration: @configuration) do |definition|
+      captured_definition = definition
+      Object.new
+    end
+
+    registry.resolve(:foo)
+
+    refute_nil captured_definition
+    assert_equal :foo, captured_definition.name
+  end
+
+  def test_resolve_builds_an_engine_container_by_default
+    registry = Torikago::Registry.new(configuration: @configuration)
+
+    container = registry.resolve(:foo)
+
+    assert_instance_of Torikago::EngineContainer, container
+  end
+end

data/test/torikago/version.rb

@@ -0,0 +1,11 @@
+require_relative "../test_helper"
+
+class TorikagoVersionTest < Minitest::Test
+  def test_has_a_version_number
+    refute_nil ::Torikago::VERSION
+  end
+
+  def test_version_uses_semver_like_format
+    assert_match(/\A\d+\.\d+\.\d+\z/, ::Torikago::VERSION)
+  end
+end

data/test/torikago.rb

@@ -0,0 +1,110 @@
+require_relative "test_helper"
+require "open3"
+require "rbconfig"
+
+class TorikagoTest < Minitest::Test
+  def test_version_is_available_when_module_is_included
+    object = Class.new { include Torikago }.new
+
+    assert_equal Torikago::VERSION, object.version
+  end
+
+  def test_configure_yields_the_shared_configuration
+    original_configuration = Torikago.configuration
+
+    begin
+      yielded_configuration = nil
+
+      Torikago.configure do |config|
+        yielded_configuration = config
+      end
+
+      assert_same Torikago.configuration, yielded_configuration
+    ensure
+      Torikago.instance_variable_set(:@configuration, original_configuration)
+      Torikago.instance_variable_set(:@registry, nil)
+      Torikago.instance_variable_set(:@gateway, nil)
+    end
+  end
+
+  def test_warns_when_loaded_in_rails_without_ruby_box
+    script = <<~RUBY
+      $LOAD_PATH.unshift(ARGV.fetch(0))
+
+      module Rails
+        class << self
+          attr_accessor :application
+        end
+
+        self.application = Object.new
+      end
+
+      require "torikago"
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(
+      { "RUBY_BOX" => nil },
+      RbConfig.ruby,
+      "-e",
+      script,
+      File.expand_path("../lib", __dir__)
+    )
+
+    assert_predicate status, :success?, stderr
+    assert_match(/\[warn\].*RUBY_BOX=1/, stderr)
+  end
+
+  def test_does_not_warn_when_ruby_box_is_enabled
+    with_ruby_box_env("1") do
+      with_temporary_rails_constant(application: Object.new) do
+        assert_output(nil, "") do
+          Torikago.send(:warn_if_ruby_box_is_disabled_in_rails!)
+        end
+      end
+    end
+  end
+
+  def test_does_not_warn_outside_rails
+    with_ruby_box_env(nil) do
+      assert_output(nil, "") do
+        Torikago.send(:warn_if_ruby_box_is_disabled_in_rails!)
+      end
+    end
+  end
+
+  def test_does_not_warn_when_rails_constant_exists_but_no_application_is_booted
+    with_ruby_box_env(nil) do
+      with_temporary_rails_constant(application: nil) do
+        assert_output(nil, "") do
+          Torikago.send(:warn_if_ruby_box_is_disabled_in_rails!)
+        end
+      end
+    end
+  end
+
+  private
+
+  def with_ruby_box_env(value)
+    original = ENV["RUBY_BOX"]
+    ENV["RUBY_BOX"] = value
+    yield
+  ensure
+    ENV["RUBY_BOX"] = original
+  end
+
+  def with_temporary_rails_constant(application:)
+    had_rails = Object.const_defined?(:Rails)
+    unless had_rails
+      rails_module = Module.new do
+        singleton_class.attr_accessor :application
+      end
+      rails_module.application = application
+      Object.const_set(:Rails, rails_module)
+    end
+
+    Rails.application = application if Rails.respond_to?(:application=)
+    yield
+  ensure
+    Object.send(:remove_const, :Rails) if !had_rails && Object.const_defined?(:Rails)
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: torikago
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+  - se4weed
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+    torikago is a Ruby gem for modular monolith runtime isolation. It boots
+    module-scoped runtimes with Ruby::Box and routes host app and inter-module
+    communication through explicit gateway and registry objects.
+email:
+  - se4weed@gmail.com
+executables:
+  - torikago
+extensions: []
+extra_rdoc_files:
+  - README.ja.md
+files:
+  - LICENSE.txt
+  - README.ja.md
+  - README.md
+  - exe/torikago
+  - lib/torikago.rb
+  - lib/torikago/checker.rb
+  - lib/torikago/cli.rb
+  - lib/torikago/configuration.rb
+  - lib/torikago/current_execution.rb
+  - lib/torikago/engine_container.rb
+  - lib/torikago/errors.rb
+  - lib/torikago/gateway.rb
+  - lib/torikago/package_api_updater.rb
+  - lib/torikago/registry.rb
+  - lib/torikago/version.rb
+  - test/test_helper.rb
+  - test/torikago.rb
+  - test/torikago/checker.rb
+  - test/torikago/cli.rb
+  - test/torikago/configuration.rb
+  - test/torikago/engine_container.rb
+  - test/torikago/gateway.rb
+  - test/torikago/package_api_updater.rb
+  - test/torikago/registry.rb
+  - test/torikago/version.rb
+homepage: "https://github.com/se4weed/torikago"
+licenses:
+  - MIT
+metadata:
+  rubygems_mfa_required: "true"
+rdoc_options: []
+require_paths:
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+requirements: []
+rubygems_version: 4.1.0.dev
+specification_version: 4
+summary: "Runtime isolation for modular monoliths built around Ruby::Box"
+test_files: []