torikago 0.0.1 → 0.1.0

data/lib/torikago/engine_container.rb

@@ -1,31 +1,93 @@
 require "pathname"
+require_relative "root_constant_resolver"
 
 module Torikago
   # Owns the runtime for one registered module. When Ruby::Box is available it
   # loads the module into an isolated Box; otherwise it falls back to the host
   # process for development and tests.
   class EngineContainer
-    def initialize(name:, module_root:, entrypoint: nil, setup: nil, gemfile: nil, box_factory: nil, gemfile_dependency_loader: nil, gem_activator: nil)
+    BUNDLER_SETUP_ENV_MUTEX = Mutex.new
+    TORIKAGO_RUNTIME_CONSTANTS = %i[
+      Error
+      DependencyError
+      BoxUnavailableError
+      PublicApiError
+      GemfileOverrideError
+      Gateway
+    ].freeze
+    FRAMEWORK_CONSTANTS = %i[
+      Rails
+      ActionController
+      ActionDispatch
+      ActionView
+      ActiveModel
+      ActiveRecord
+      ActiveSupport
+    ].freeze
+
+    def initialize(name:, module_root:, entrypoint: nil, rails_engine: false, setup: nil, gemfile: nil, registered_roots: nil, box_factory: nil, gemfile_dependency_loader: nil, gem_activator: nil, root_constant_resolver: nil)
       @name = name
       @module_root = Pathname(module_root)
       @entrypoint = entrypoint
+      @rails_engine = rails_engine
       @setup = setup
       @gemfile = gemfile
+      @registered_roots = registered_roots || [@module_root]
       @box_factory = box_factory
       @gemfile_dependency_loader = gemfile_dependency_loader || method(:load_gemfile_dependencies)
       @gem_activator = gem_activator || method(:activate_gem_dependency)
+      @root_constant_resolver = root_constant_resolver
     end
 
-    def call(public_api_class_name, *args, **kwargs)
+    def invoke(public_api_class_name, method_name, constructor_args:, constructor_kwargs:, method_args:, method_kwargs:)
       CurrentExecution.with_box(name) do
         public_api_class = resolve_public_api_class(public_api_class_name)
-        public_api_class.new.call(*args, **kwargs)
+        instance = public_api_class.new(*constructor_args, **constructor_kwargs)
+        instance.public_send(method_name, *method_args, **method_kwargs)
+      end
+    end
+
+    # Dispatches a Rack request to a Rails::Engine owned by this module. Route
+    # recognition happens against the Box-local engine, then the Box-local
+    # controller class is invoked directly so Rails never constantizes the
+    # controller in the host application's Object namespace.
+    def call(env)
+      unless rails_engine?
+        raise ArgumentError, "module #{name} is not registered with rails_engine: true"
+      end
+
+      CurrentExecution.with_box(name) do
+        boot_runtime!
+        route, rack_response = recognize_route(env)
+        return rack_response if rack_response
+
+        controller = resolve_runtime_class("#{camelize_controller(route.fetch(:controller))}Controller")
+
+        dispatch_controller_action(env, controller, route.fetch(:action), route)
+      end
+    end
+
+    # Dispatches a host-owned route to a controller that belongs to this module.
+    # Unlike #call, route recognition has already happened in the host router, so
+    # this path does not require a Rails::Engine inside the module.
+    def dispatch_controller(env, controller_name:, action_name:)
+      CurrentExecution.with_box(name) do
+        boot_controller_runtime!
+        controller = resolve_runtime_class(controller_name)
+
+        dispatch_controller_action(
+          env,
+          controller,
+          action_name,
+          controller: controller_name,
+          action: action_name.to_s
+        )
       end
     end
 
     private
 
-    attr_reader :box_factory, :entrypoint, :gem_activator, :gemfile, :gemfile_dependency_loader, :module_root, :name, :setup
+    attr_reader :box_factory, :entrypoint, :gem_activator, :gemfile, :gemfile_dependency_loader, :module_root, :name, :registered_roots, :root_constant_resolver, :setup
 
     def boot_runtime!
       return if @booted
@@ -33,15 +95,23 @@ module Torikago
       files = runtime_files
       gemfile_dependencies
       if isolated_box_enabled?
-        # The Box starts with an independent load path and constant table, so
-        # boot has to copy enough host context before loading module code.
-        prepare_box!
-        prepend_gemfile_require_paths_to_box!
-        load_setup_hook_into_box!
-        ensure_root_namespace_in_box!
-
-        files.each do |path|
-          box.load(path)
+        without_bundler_setup_env do
+          # The Box starts with an independent load path and constant table, so
+          # boot has to copy enough host context before loading module code.
+          with_box_runtime_errors do
+            prepare_box!
+            prepend_gemfile_require_paths_to_box!
+            install_host_runtime_bridges!
+            load_setup_hook_into_box!
+            ensure_root_namespace_in_box!
+            prepare_rails_application_controller_in_box!
+
+            files.each do |path|
+              box.load(path)
+              normalize_rails_constant_name!(path)
+            end
+            attach_rails_helpers!
+          end
         end
       else
         # Non-Box mode preserves the same public behavior while giving up
@@ -52,12 +122,203 @@ module Torikago
 
         files.each do |path|
           load path
+          normalize_rails_constant_name!(path)
         end
+        attach_rails_helpers!
       end
 
       @booted = true
     end
 
+    def boot_controller_runtime!
+      boot_runtime!
+      return if rails_engine?
+      return if @controller_runtime_booted
+
+      files = controller_runtime_files - runtime_files
+      if isolated_box_enabled?
+        without_bundler_setup_env do
+          with_box_runtime_errors do
+            install_rails_runtime_support!
+            prepare_rails_application_controller_in_box!
+            load_runtime_files_into_box!(files)
+            attach_rails_helpers!
+          end
+        end
+      else
+        files.each do |path|
+          load path
+          normalize_rails_constant_name!(path)
+        end
+        attach_rails_helpers!
+      end
+
+      @controller_runtime_booted = true
+    end
+
+    def load_runtime_files_into_box!(files)
+      files.each do |path|
+        box.load(path)
+        normalize_rails_constant_name!(path)
+      end
+    end
+
+    def dispatch_controller_action(env, controller, action_name, path_parameters)
+      current_parameters = env.fetch(
+        "action_dispatch.request.path_parameters",
+        Hash.new
+      )
+      request_env = env.merge(
+        "action_dispatch.request.path_parameters" =>
+          current_parameters.merge(path_parameters.transform_keys(&:to_sym))
+      )
+
+      controller.action(action_name).call(request_env)
+    end
+
+    def attach_rails_helpers!
+      helper_modules = Dir[module_root.join("app/helpers/**/*_helper.rb").to_s].sort.filter_map do |path|
+        constant_name = rails_constant_name_for(path)
+        resolve_runtime_class(constant_name) if constant_name
+      rescue NameError
+        nil
+      end
+      return if helper_modules.empty?
+
+      rails_controller_files.each do |path|
+        constant_name = rails_constant_name_for(path)
+        next unless constant_name
+
+        controller = resolve_runtime_class(constant_name)
+        next unless controller.respond_to?(:helper)
+
+        helper_modules.each { |helper_module| controller.helper(helper_module) }
+      rescue NameError
+        next
+      end
+    end
+
+    def prepare_rails_application_controller_in_box!
+      return unless Object.const_defined?(:ActionController, false)
+      return unless module_root.join("app/controllers/#{name}/application_controller.rb").exist?
+
+      # FIXME: This workaround only supports controllers under the namespace
+      # derived from the registered module name. Real top-level ActionController
+      # subclasses still expose Ruby::Box's internal prefix to Rails inherited
+      # hooks and helper lookup. Track support for non-namespaced controllers in:
+      # https://github.com/se4weed/torikago/issues/15
+      namespace_name = camelize(name.to_s)
+      namespace = box.const_get(namespace_name)
+      application_controller = if namespace.const_defined?(:ApplicationController, false)
+                                 namespace.const_get(:ApplicationController, false)
+                               else
+                                 action_controller_base = Object.const_get(:ActionController).const_get(:Base)
+                                 namespace.const_set(:ApplicationController, Class.new(action_controller_base))
+                               end
+
+      application_controller.define_singleton_method(:name) { "#{namespace_name}::ApplicationController" }
+      application_controller.define_singleton_method(:inherited) do |subclass|
+        native_name = Module.instance_method(:name).bind_call(subclass)
+        marker = "::#{namespace_name}::"
+        conventional_name = if native_name&.include?(marker)
+                              "#{namespace_name}::#{native_name.split(marker, 2).last}"
+                            else
+                              native_name
+                            end
+        # A class is still anonymous while inherited() runs. Do not let it
+        # inherit ApplicationController's singleton name implementation.
+        subclass.define_singleton_method(:name) { conventional_name }
+        # ActiveSupport's default module_parents implementation constantizes
+        # through the host Object. Return the already-resolved Box namespace.
+        subclass.define_singleton_method(:module_parents) { [namespace] }
+        # AbstractController tries to constantize "<Controller>Helper" in the
+        # host Object namespace during inherited(). Module helpers live in this
+        # Box, so they are attached explicitly after runtime files are loaded.
+        subclass.define_singleton_method(:default_helper_module!) {}
+        subclass.singleton_class.send(:private, :default_helper_module!)
+        super(subclass)
+      end
+    end
+
+    def normalize_rails_constant_name!(path)
+      constant_name = rails_constant_name_for(path)
+      return unless constant_name
+
+      constant = resolve_runtime_class(constant_name)
+      return unless constant.respond_to?(:define_singleton_method)
+
+      # Ruby::Box includes an internal Box prefix in Module#name. Rails derives
+      # helper and model constants from that value, so expose the conventional
+      # application constant name to Rails while keeping the constant itself in
+      # the Box.
+      constant.define_singleton_method(:name) { constant_name }
+      constant.remove_instance_variable(:@controller_path) if constant.instance_variable_defined?(:@controller_path)
+      constant.remove_instance_variable(:@controller_name) if constant.instance_variable_defined?(:@controller_name)
+      if path.include?("/app/controllers/") && constant.respond_to?(:prepend_view_path)
+        constant.prepend_view_path(module_root.join("app/views").to_s)
+      end
+    rescue NameError
+      # Namespace-only files and files that define a differently named helper
+      # do not need normalization.
+      nil
+    end
+
+    def rails_constant_name_for(path)
+      app_root = module_root.join("app").to_s
+      return unless path.start_with?("#{app_root}/")
+
+      relative_path = path.delete_prefix("#{app_root}/")
+      category, constant_path = relative_path.split("/", 2)
+      return unless %w[controllers models helpers].include?(category)
+      return unless constant_path&.end_with?(".rb")
+
+      constant_path.delete_suffix(".rb").split("/").map { |segment| camelize(segment) }.join("::")
+    end
+
+    def recognize_route(env)
+      engine = resolve_runtime_class("#{camelize(name.to_s)}::Engine")
+      routes = engine.routes
+      return recognize_rails_route(routes, env) if routes.respond_to?(:router) && Object.const_defined?(:ActionDispatch, false)
+
+      route = routes.recognize_path(
+        env.fetch("PATH_INFO", "/"),
+        method: env.fetch("REQUEST_METHOD", "GET").downcase.to_sym
+      )
+      [route.transform_keys(&:to_sym), nil]
+    end
+
+    def recognize_rails_route(routes, env)
+      action_dispatch = Object.const_get(:ActionDispatch)
+      request_class = action_dispatch.const_get(:Request)
+      cascade_header = action_dispatch.const_get(:Constants).const_get(:X_CASCADE)
+      request = request_class.new(env)
+      recognized = nil
+
+      routes.router.recognize(request) do |route, parameters|
+        next unless route.app.matches?(request)
+
+        request.path_parameters = parameters
+        if route.app.dispatcher?
+          recognized = [parameters.transform_keys(&:to_sym), nil]
+        else
+          response = route.app.serve(request)
+          next if response[1][cascade_header] == "pass"
+
+          recognized = [nil, response]
+        end
+        break
+      end
+
+      return recognized if recognized
+
+      routing_error = Object.const_get(:ActionController).const_get(:RoutingError)
+      raise routing_error, "No route matches #{env.fetch("PATH_INFO", "/").inspect}"
+    end
+
+    def camelize_controller(controller_path)
+      controller_path.to_s.split("/").map { |segment| camelize(segment) }.join("::")
+    end
+
     def load_setup_hook!
       path = setup_path
       return unless path
@@ -88,30 +349,69 @@ module Torikago
 
       # Put module-specific gems ahead of the host load path so the Box resolves
       # dependency versions from the module Gemfile first.
-      box.load_path.replace(paths.map(&:to_s) + box.load_path)
+      box.load_path.replace(paths.map { |path| path.to_s } + box.load_path)
     end
 
     def gemfile_dependencies
       path = gemfile_path
-      return [] unless path
+      return Array.new unless path
 
       @gemfile_dependencies ||= gemfile_dependency_loader.call(path)
     end
 
     def resolve_public_api_class(class_name)
       boot_runtime!
+      resolve_runtime_class(class_name)
+    end
+
+    def resolve_runtime_class(class_name)
       root = isolated_box_enabled? ? box : Object
       # const_get is evaluated inside the Box object when isolation is enabled,
-      # which keeps public API constants out of the host Object namespace.
+      # which keeps module-owned constants out of the host Object namespace.
       class_name.split("::").reduce(root) { |context, segment| context.const_get(segment) }
     end
 
     def runtime_files
-      @runtime_files ||= [
+      @runtime_files ||= if rails_engine?
+                           rails_runtime_files
+                         else
+                           [
+                             *library_files,
+                             *gateway_model_files,
+                             *Dir[public_api_root.join("**/*.rb").to_s].sort
+                           ]
+                         end
+    end
+
+    def rails_runtime_files
+      [
+        *rails_engine_entrypoint_files,
         *library_files,
-        *gateway_model_files,
+        *Dir[module_root.join("app/models/**/*.rb").to_s].sort,
+        *Dir[module_root.join("app/helpers/**/*.rb").to_s].sort,
+        *rails_controller_files,
+        *Dir[public_api_root.join("**/*.rb").to_s].sort,
+        *Dir[module_root.join("config/routes.rb").to_s].sort
+      ].uniq
+    end
+
+    def controller_runtime_files
+      [
+        *library_files,
+        *Dir[module_root.join("app/models/**/*.rb").to_s].sort,
+        *Dir[module_root.join("app/helpers/**/*.rb").to_s].sort,
+        *rails_controller_files,
         *Dir[public_api_root.join("**/*.rb").to_s].sort
-      ]
+      ].uniq
+    end
+
+    def rails_controller_files
+      files = Dir[module_root.join("app/controllers/**/*.rb").to_s].sort
+      application_controllers, other_controllers = files.partition do |path|
+        File.basename(path) == "application_controller.rb"
+      end
+
+      application_controllers + other_controllers
     end
 
     def public_api_root
@@ -161,8 +461,24 @@ module Torikago
       @box ||= if box_factory
                  box_factory.call
                else
-                 Ruby::Box.new
+                 without_bundler_setup_env { Ruby::Box.new }
                end
+    rescue BoxUnavailableError
+      raise
+    rescue StandardError => e
+      raise unless ENV["RUBY_BOX"] == "1"
+
+      raise BoxUnavailableError, "Ruby::Box is unavailable for module #{name}: #{e.message}"
+    end
+
+    def with_box_runtime_errors
+      yield
+    rescue BoxUnavailableError
+      raise
+    rescue StandardError => e
+      raise unless ENV["RUBY_BOX"] == "1"
+
+      raise BoxUnavailableError, "Ruby::Box is unavailable for module #{name}: #{e.message}"
     end
 
     def prepare_box!
@@ -172,9 +488,65 @@ module Torikago
       if box.respond_to?(:require)
         box.require("torikago/current_execution")
       end
+      install_torikago_runtime_bridges!
+      install_root_constant_fallback!
       @box_prepared = true
     end
 
+    def install_torikago_runtime_bridges!
+      box_torikago = box.const_get(:Torikago)
+
+      TORIKAGO_RUNTIME_CONSTANTS.each do |constant_name|
+        next if box_torikago.const_defined?(constant_name, false)
+
+        box_torikago.const_set(constant_name, Torikago.const_get(constant_name, false))
+      end
+    end
+
+    def install_root_constant_fallback!
+      return unless box.respond_to?(:eval)
+
+      resolver = root_constant_resolver || RootConstantResolver.new(registered_roots: registered_roots)
+      box_torikago = box.const_get(:Torikago)
+      box_torikago.const_set(:ROOT_CONSTANT_RESOLVER, resolver)
+      box_torikago.const_set(:ROOT_CONSTANT_UNRESOLVED, resolver.unresolved)
+      box.eval(<<~RUBY)
+        module Torikago
+          module RootConstantFallback
+            def const_missing(name)
+              resolved = ROOT_CONSTANT_RESOLVER.resolve(name)
+              return resolved unless resolved.equal?(ROOT_CONSTANT_UNRESOLVED)
+
+              super
+            end
+          end
+        end
+
+        Object.singleton_class.prepend(Torikago::RootConstantFallback)
+      RUBY
+    end
+
+    def install_host_runtime_bridges!
+      FRAMEWORK_CONSTANTS.each { |constant_name| install_host_constant_bridge!(constant_name) }
+      install_rails_runtime_support! if rails_engine?
+    end
+
+    def install_rails_runtime_support!
+      install_host_constant_bridge!(:ApplicationController)
+      install_host_constant_bridge!(:ApplicationRecord)
+      return unless Object.const_defined?(:ActiveSupport, false)
+      return unless box.respond_to?(:require)
+
+      box.require("active_support/core_ext/object/blank")
+    end
+
+    def install_host_constant_bridge!(constant_name)
+      return unless Object.const_defined?(constant_name, false)
+      return if box.const_defined?(constant_name, false)
+
+      box.const_set(constant_name, Object.const_get(constant_name, false))
+    end
+
     def gateway_model_files
       # Package APIs may depend on small PORO-style models. Active Record models
       # are skipped because Rails owns their loading and database connection.
@@ -205,22 +577,22 @@ module Torikago
 
       # Monkey patches are only loaded through the explicit setup hook so a
       # module has to opt in to global-ish runtime changes.
-      all_files - monkey_patch_files
+      all_files - monkey_patch_files - rails_engine_entrypoint_files
     end
 
-    def ruby_box_runtime_available?
-      return @ruby_box_runtime_available unless @ruby_box_runtime_available.nil?
+    def rails_engine_entrypoint_files
+      return Array.new unless rails_engine?
+
+      path = module_root.join("lib/#{name}.rb")
+      path.exist? ? [path.to_s] : Array.new
+    end
 
-      @ruby_box_runtime_available = if ENV["RUBY_BOX"] == "1"
-                                      begin
-                                        Ruby::Box.new
-                                        true
-                                      rescue RuntimeError
-                                        false
-                                      end
-                                    else
-                                      false
-                                    end
+    def rails_engine?
+      @rails_engine
+    end
+
+    def ruby_box_runtime_available?
+      ENV["RUBY_BOX"] == "1"
     end
 
     def camelize(segment)
@@ -240,33 +612,15 @@ module Torikago
       installed_gem_dependencies = load_installed_gem_dependencies(path)
       return installed_gem_dependencies unless installed_gem_dependencies.empty?
 
-      require "bundler"
-
-      lockfile = Pathname("#{path}.lock")
-      definition = Bundler::Definition.build(path.to_s, lockfile.exist? ? lockfile.to_s : nil, nil)
-
-      specs_by_name = definition.specs.each_with_object({}) do |spec, specs|
-        specs[spec.name] ||= spec
-      end
-
-      definition.dependencies.filter_map do |dependency|
-        spec = specs_by_name.fetch(dependency.name, nil)
-        next unless spec
-
-        requirement = dependency.requirement.to_s
-        {
-          name: dependency.name,
-          requirement: requirement,
-          require_paths: spec.full_require_paths
-        }
-      end
-    rescue Bundler::BundlerError => e
-      raise GemfileOverrideError, "failed to load gemfile for #{name}: #{e.message}"
+      load_bundler_gem_dependencies(path)
     end
 
     def load_path_gem_dependencies(path)
       path.dirname.then do |gemfile_root|
         path.read.scan(/^\s*gem\s+["']([^"']+)["']\s*,\s*path:\s*["']([^"']+)["']/).filter_map do |gem_name, relative_path|
+          next unless relative_path
+
+          relative_path = relative_path.to_s
           gem_root = gemfile_root.join(relative_path)
           gemspec_path = gem_root.join("#{gem_name}.gemspec")
           gemspec_path = Dir[gem_root.join("*.gemspec").to_s].sort.first unless gemspec_path.exist?
@@ -284,9 +638,38 @@ module Torikago
       end
     end
 
+    def load_bundler_gem_dependencies(path)
+      require "bundler"
+
+      lockfile = Pathname("#{path}.lock")
+      definition = Bundler::Definition.build(path.to_s, lockfile.exist? ? lockfile.to_s : nil, nil)
+
+      specs_by_name = definition.specs.each_with_object(Hash.new) do |spec, specs|
+        specs[spec.name] ||= spec
+      end
+
+      definition.dependencies.filter_map do |dependency|
+        spec = specs_by_name.fetch(dependency.name, nil)
+        next unless spec
+
+        requirement = dependency.requirement.to_s
+        {
+          name: dependency.name,
+          requirement: requirement,
+          require_paths: spec.full_require_paths
+        }
+      end
+    rescue LoadError => e
+      raise GemfileOverrideError, "failed to load bundler for #{name}: #{e.message}"
+    rescue StandardError => e
+      raise unless defined?(Bundler::BundlerError) && e.is_a?(Bundler::BundlerError)
+
+      raise GemfileOverrideError, "failed to load gemfile for #{name}: #{e.message}"
+    end
+
     def load_installed_gem_dependencies(path)
       dependencies = exact_version_gemfile_dependencies(path)
-      return [] if dependencies.empty?
+      return Array.new if dependencies.empty?
 
       dependencies.filter_map do |dependency|
         specs = installed_specs_for(dependency.fetch(:name), dependency.fetch(:requirement))
@@ -326,9 +709,13 @@ module Torikago
         match = line.match(/^\s*gem\s+["']([^"']+)["']\s*,\s*["']=\s*([^"']+)["']/)
         next unless match
 
+        gem_name = match[1]
+        version = match[2]
+        next unless gem_name && version
+
         {
-          name: match[1],
-          requirement: "= #{match[2]}"
+          name: gem_name,
+          requirement: "= #{version}"
         }
       end
     end
@@ -336,5 +723,45 @@ module Torikago
     def activate_gem_dependency(dependency)
       Kernel.send(:gem, dependency.fetch(:name), dependency.fetch(:requirement))
     end
+
+    def without_bundler_setup_env
+      if BUNDLER_SETUP_ENV_MUTEX.owned?
+        without_bundler_setup_env_unsynchronized { yield }
+      else
+        BUNDLER_SETUP_ENV_MUTEX.synchronize do
+          without_bundler_setup_env_unsynchronized { yield }
+        end
+      end
+    end
+
+    def without_bundler_setup_env_unsynchronized
+      rubyopt = ENV["RUBYOPT"]
+      bundler_setup = ENV["BUNDLER_SETUP"]
+
+      if rubyopt&.include?("bundler/setup")
+        options = rubyopt.split.reject { |option| option.include?("bundler/setup") }
+        if options.empty?
+          ENV.delete("RUBYOPT")
+        else
+          ENV["RUBYOPT"] = options.join(" ")
+        end
+      end
+
+      ENV.delete("BUNDLER_SETUP")
+
+      yield
+    ensure
+      if rubyopt
+        ENV["RUBYOPT"] = rubyopt
+      else
+        ENV.delete("RUBYOPT")
+      end
+
+      if bundler_setup
+        ENV["BUNDLER_SETUP"] = bundler_setup
+      else
+        ENV.delete("BUNDLER_SETUP")
+      end
+    end
   end
 end