torikago 0.0.1 → 0.1.0

data/sig/torikago.rbs

@@ -0,0 +1,440 @@
+module Torikago
+  VERSION: String
+
+  def self.configuration: () -> Configuration
+  def self.configure: () { (Configuration) -> untyped } -> Configuration
+  def self.gateway: () -> Gateway
+  def self.registry: () -> Registry
+  def self.action: (Symbol | String module_name, String controller_name, Symbol | String action_name) -> ControllerEndpoint
+  def self.version: () -> String
+
+  def version: () -> String
+
+  def self.rails_app?: () -> bool
+  def self.ruby_box_enabled?: () -> bool
+  def self.warn_if_ruby_box_is_disabled_in_rails!: () -> nil
+  def self.reset_runtime_state!: () -> nil
+
+  class Configuration
+    class Definition
+      attr_accessor name: Symbol
+      attr_accessor root: Pathname
+      attr_accessor entrypoint: String?
+      attr_accessor rails_engine: bool
+      attr_accessor setup: String?
+      attr_accessor gemfile: String?
+
+      def initialize: (?name: Symbol, ?root: Pathname, ?entrypoint: String?, ?rails_engine: bool, ?setup: String?, ?gemfile: String?) -> void
+    end
+
+    def initialize: () -> void
+    def register: (Symbol | String name, root: Pathname | String, ?entrypoint: String?, ?rails_engine: bool, ?setup: String?, ?gemfile: String?) -> Definition
+    def registered?: (Symbol | String name) -> bool
+    def each_definition: () -> untyped
+                       | () { (Definition) -> untyped } -> untyped
+    def fetch: (Symbol | String name) -> Definition
+  end
+
+  module CurrentExecution
+    STORAGE_KEY: Symbol
+
+    def current_box: () -> Symbol?
+    def with_box: [A] (Symbol | String box_name) { () -> A } -> A
+
+    def self.current_box: () -> Symbol?
+    def self.with_box: [A] (Symbol | String box_name) { () -> A } -> A
+  end
+
+  class Gateway
+    def self.build: (String public_api_class_name, *untyped, **untyped) -> Invocation
+    def self.invoke: (String public_api_class_name, Symbol | String method_name, *untyped, **untyped) -> untyped
+
+    def initialize: (registry: Registry, configuration: Configuration, ?manifest_loader: untyped) -> void
+    def build: (String public_api_class_name, *untyped, **untyped) -> Invocation
+    def invoke: (String public_api_class_name, Symbol | String method_name, *untyped, **untyped) -> untyped
+    def dispatch: (
+      public_api_class_name: String,
+      method_name: Symbol | String,
+      constructor_args: Array[untyped],
+      constructor_kwargs: Hash[Symbol, untyped],
+      method_args: Array[untyped],
+      method_kwargs: Hash[Symbol, untyped]
+    ) -> untyped
+
+    private
+
+    attr_reader configuration: Configuration
+    attr_reader manifest_loader: untyped
+    attr_reader manifests: Hash[Symbol, Hash[String, untyped]]
+    attr_reader registry: Registry
+
+    def validate_public_api!: (Symbol target_module, String public_api_class_name, Symbol | String method_name, Symbol? caller_module) -> nil
+    def load_manifest: (Configuration::Definition definition) -> Hash[String, untyped]
+    def package_api_manifest_path: (Configuration::Definition definition) -> Pathname
+    def infer_target_module: (String public_api_class_name) -> Symbol
+    def exported_package_apis: (Hash[String, untyped] manifest) -> Hash[String, untyped]
+    def dependency_allowed?: (untyped public_api_entry, Symbol caller_name) -> bool
+    def exported_methods: (untyped public_api_entry) -> Array[String]
+    def allowed_callers: (untyped public_api_entry) -> Array[untyped]
+  end
+
+  class Invocation
+    def initialize: (
+      gateway: Gateway,
+      public_api_class_name: String,
+      constructor_args: Array[untyped],
+      constructor_kwargs: Hash[Symbol, untyped]
+    ) -> void
+    def invoke: (Symbol | String method_name, *untyped, **untyped) -> untyped
+
+    private
+
+    attr_reader constructor_args: Array[untyped]
+    attr_reader constructor_kwargs: Hash[Symbol, untyped]
+    attr_reader gateway: Gateway
+    attr_reader public_api_class_name: String
+  end
+
+  class Registry
+    def initialize: (configuration: Configuration) ?{ (Configuration::Definition) -> EngineContainer } -> void
+    def resolve: (Symbol | String name) -> EngineContainer
+
+    private
+
+    def build_container: (Configuration::Definition definition) -> EngineContainer
+  end
+
+  class RackEndpoint
+    def initialize: (Symbol | String module_name, ?registry: Registry?) -> void
+    def call: (Hash[String, untyped] env) -> untyped
+
+    private
+
+    attr_reader module_name: Symbol
+    def registry: () -> Registry
+  end
+
+  class ControllerEndpoint
+    def initialize: (
+      Symbol | String module_name,
+      String controller_name,
+      Symbol | String action_name,
+      ?registry: Registry?
+    ) -> void
+    def call: (Hash[String, untyped] env) -> untyped
+
+    private
+
+    attr_reader action_name: Symbol
+    attr_reader controller_name: String
+    attr_reader module_name: Symbol
+    def registry: () -> Registry
+  end
+
+  class RootConstantResolver
+    UNRESOLVED: Object
+
+    attr_reader unresolved: Object
+
+    def initialize: (registered_roots: Array[Pathname | String], ?main_box: untyped) -> void
+    def resolve: (Symbol | String name) -> untyped
+
+    private
+
+    attr_reader main_box: untyped
+    attr_reader registered_roots: Array[String]
+
+    def registered_source?: (String? source_path) -> bool
+    def registered_descendant?: (Module namespace, ?Hash[Module, bool] visited) -> bool
+    def normalize_path: (Pathname | String path) -> String
+  end
+
+  class EngineContainer
+    BUNDLER_SETUP_ENV_MUTEX: Mutex
+    TORIKAGO_RUNTIME_CONSTANTS: Array[Symbol]
+    FRAMEWORK_CONSTANTS: Array[Symbol]
+
+    def initialize: (
+      name: Symbol | String,
+      module_root: Pathname | String,
+      ?entrypoint: String?,
+      ?rails_engine: bool,
+      ?setup: String?,
+      ?gemfile: String?,
+      ?registered_roots: Array[Pathname | String]?,
+      ?box_factory: untyped,
+      ?gemfile_dependency_loader: untyped,
+      ?gem_activator: untyped,
+      ?root_constant_resolver: RootConstantResolver?
+    ) -> void
+
+    def invoke: (
+      String public_api_class_name,
+      Symbol | String method_name,
+      constructor_args: Array[untyped],
+      constructor_kwargs: Hash[Symbol, untyped],
+      method_args: Array[untyped],
+      method_kwargs: Hash[Symbol, untyped]
+    ) -> untyped
+    def call: (Hash[String, untyped] env) -> untyped
+    def dispatch_controller: (
+      Hash[String, untyped] env,
+      controller_name: String,
+      action_name: Symbol | String
+    ) -> untyped
+
+    private
+
+    attr_reader box_factory: untyped
+    attr_reader entrypoint: String?
+    attr_reader gem_activator: untyped
+    attr_reader gemfile: String?
+    attr_reader gemfile_dependency_loader: untyped
+    attr_reader module_root: Pathname
+    attr_reader name: Symbol | String
+    attr_reader registered_roots: Array[Pathname | String]
+    attr_reader root_constant_resolver: RootConstantResolver?
+    attr_reader setup: String?
+
+    def boot_runtime!: () -> untyped
+    def boot_controller_runtime!: () -> untyped
+    def load_runtime_files_into_box!: (Array[String] files) -> untyped
+    def dispatch_controller_action: (
+      Hash[String, untyped] env,
+      untyped controller,
+      Symbol | String action_name,
+      Hash[Symbol | String, untyped] path_parameters
+    ) -> untyped
+    def attach_rails_helpers!: () -> untyped
+    def prepare_rails_application_controller_in_box!: () -> untyped
+    def normalize_rails_constant_name!: (String path) -> untyped
+    def rails_constant_name_for: (String path) -> String?
+    def recognize_route: (Hash[String, untyped] env) -> untyped
+    def recognize_rails_route: (untyped routes, Hash[String, untyped] env) -> untyped
+    def camelize_controller: (String controller_path) -> String
+    def load_setup_hook!: () -> untyped
+    def apply_gemfile_overrides!: () -> untyped
+    def prepend_gemfile_require_paths_to_box!: () -> untyped
+    def gemfile_dependencies: () -> Array[Hash[Symbol | String, untyped]]
+    def resolve_public_api_class: (String class_name) -> untyped
+    def resolve_runtime_class: (String class_name) -> untyped
+    def runtime_files: () -> Array[String]
+    def rails_runtime_files: () -> Array[String]
+    def controller_runtime_files: () -> Array[String]
+    def rails_controller_files: () -> Array[String]
+    def public_api_root: () -> Pathname
+    def gemfile_path: () -> Pathname?
+    def setup_path: () -> Pathname?
+    def ensure_root_namespace!: () -> untyped
+    def ensure_root_namespace_in_box!: () -> untyped
+    def isolated_box_enabled?: () -> bool
+    def box: () -> untyped
+    def with_box_runtime_errors: [A] () { () -> A } -> A
+    def prepare_box!: () -> untyped
+    def install_torikago_runtime_bridges!: () -> untyped
+    def install_root_constant_fallback!: () -> untyped
+    def install_host_runtime_bridges!: () -> untyped
+    def install_rails_runtime_support!: () -> untyped
+    def install_host_constant_bridge!: (Symbol constant_name) -> untyped
+    def gateway_model_files: () -> Array[String]
+    def rails_model_file?: (String path) -> bool
+    def load_setup_hook_into_box!: () -> untyped
+    def library_files: () -> Array[String]
+    def rails_engine_entrypoint_files: () -> Array[String]
+    def rails_engine?: () -> bool
+    def ruby_box_runtime_available?: () -> bool
+    def camelize: (String segment) -> String
+    def load_gemfile_dependencies: (Pathname path) -> Array[Hash[Symbol, untyped]]
+    def load_path_gem_dependencies: (Pathname path) -> Array[Hash[Symbol, untyped]]
+    def load_bundler_gem_dependencies: (Pathname path) -> Array[Hash[Symbol, untyped]]
+    def load_installed_gem_dependencies: (Pathname path) -> Array[Hash[Symbol, untyped]]
+    def installed_specs_for: (String gem_name, String requirement) -> Array[Gem::Specification]
+    def exact_version_gemfile_dependencies: (Pathname path) -> Array[Hash[Symbol, String]]
+    def activate_gem_dependency: (Hash[Symbol, untyped] dependency) -> untyped
+    def without_bundler_setup_env: [A] () { () -> A } -> A
+    def without_bundler_setup_env_unsynchronized: [A] () { () -> A } -> A
+  end
+
+  class Checker
+    class Result
+      attr_accessor errors: Array[String]
+      attr_accessor scanned_file_count: Integer
+      attr_accessor gateway_call_count: Integer
+      attr_accessor dynamic_gateway_call_count: Integer
+      attr_accessor manifest_count: Integer
+
+      def initialize: (?errors: Array[String], ?scanned_file_count: Integer, ?gateway_call_count: Integer, ?dynamic_gateway_call_count: Integer, ?manifest_count: Integer) -> void
+      def ok?: () -> bool
+    end
+
+    class GatewayCall
+      attr_accessor class_name: String
+      attr_accessor method_name: Symbol
+
+      def initialize: (class_name: String, method_name: Symbol) -> void
+    end
+
+    class GatewayCallExtractor
+      attr_reader calls: Array[GatewayCall]
+      attr_reader dynamic_call_count: Integer
+
+      def initialize: (String source) -> void
+      def call: () -> GatewayCallExtractor
+
+      private
+
+      attr_reader sexp: untyped
+
+      def walk: (untyped node) -> void
+      def extract: (untyped node) -> void
+      def record: (String? class_name, Symbol? method_name) -> untyped
+      def build_call?: (untyped node) -> bool
+      def gateway_constant?: (untyped node) -> bool
+      def constant_name: (untyped node) -> String?
+      def arguments_from: (untyped node) -> Array[untyped]
+      def string_literal: (untyped node) -> String?
+      def symbol_literal: (untyped node) -> Symbol?
+      def token_value: (untyped token) -> String?
+    end
+
+    def initialize: (configuration: Configuration, source_roots: untyped) -> void
+    def call: () -> Result
+    def errors: () -> Array[String]
+
+    private
+
+    attr_reader configuration: Configuration
+    attr_reader manifests: Hash[Symbol, Hash[String, untyped]]
+    attr_reader source_roots: Array[Pathname]
+
+    def source_files: () -> Array[String]
+    def scan_gateway_calls: (String path, Array[String] errors) -> [Integer, Integer]
+    def validate_manifest_entries: (Configuration::Definition definition, Array[String] errors) -> untyped
+    def public_api_entry_for: (Symbol box_name, String class_name) -> untyped
+    def load_manifest: (Configuration::Definition definition) -> Hash[String, untyped]
+    def expected_public_api_path: (Configuration::Definition definition, String class_name) -> Pathname
+    def infer_box_name: (String class_name) -> Symbol
+    def infer_caller_box_from_path: (String path) -> Symbol?
+    def exported_package_apis: (Hash[String, untyped] manifest) -> Hash[String, untyped]
+    def allowed_callers: (untyped manifest_entry) -> Array[untyped]
+    def exported_methods: (untyped manifest_entry) -> Array[String]
+    def public_instance_methods: (Pathname path, String class_name) -> [Array[String], bool]
+    def class_body_methods: (untyped body) -> { methods: Array[String], dynamic: bool }
+    def bare_call_name: (untyped node) -> String?
+    def contains_call?: (untyped node, String method_name) -> bool
+    def qualified_constant_name: (untyped node, String? namespace) -> String?
+    def constant_name: (untyped node) -> String?
+    def underscore: (String name) -> String
+    def public_api_root: (Configuration::Definition definition) -> Pathname
+  end
+
+  class PackageApiUpdater
+    def initialize: (configuration: Configuration) -> void
+    def call: (?Symbol | String | nil module_name) -> Hash[Symbol, Pathname]
+
+    private
+
+    attr_reader configuration: Configuration
+
+    def definitions_for: (Symbol | String? module_name) -> Array[Configuration::Definition]
+    def load_manifest: (Pathname path) -> Hash[String, untyped]
+    def build_manifest: (Configuration::Definition definition, Hash[String, untyped] existing_manifest) -> Hash[String, untyped]
+    def exported_package_apis: (Hash[String, untyped] manifest) -> Hash[String, untyped]
+    def allowed_callers: (untyped manifest_entry) -> Array[untyped]
+    def exported_methods: (untyped manifest_entry) -> Array[String]
+    def render_manifest: (Hash[String, untyped] manifest) -> String
+    def discover_public_api_classes: (Configuration::Definition definition) -> Array[String]
+    def public_api_root: (Configuration::Definition definition) -> Pathname
+    def class_name_from: (String relative_path) -> String
+    def camelize: (String segment) -> String
+  end
+
+  class CLI
+    HELP_TEXT: String
+
+    def initialize: (?stdin: untyped, ?stdout: untyped, ?stderr: untyped) -> void
+    def run: (Array[String] argv) -> Integer
+
+    private
+
+    attr_reader stderr: untyped
+    attr_reader stdin: untyped
+    attr_reader stdout: untyped
+
+    def run_init: () -> Integer
+    def run_check: () -> Integer
+    def run_update_package_api: (String? module_name) -> Integer
+    def discover_configuration: () -> Configuration
+    def ask: (String prompt, default: String) -> String
+           | (String prompt, ?default: String?) -> String?
+    def discover_module_directories: (Pathname modules_root) -> Array[Pathname]
+    def load_yaml_file: (Pathname path) -> Hash[String, untyped]
+    def render_initializer: (Configuration configuration) -> String
+    def render_package_api_manifest: (Hash[String, untyped] manifest) -> String
+    def yes?: (String? input) -> bool
+  end
+
+  class Error < StandardError
+  end
+
+  class DependencyError < Error
+  end
+
+  class BoxUnavailableError < Error
+  end
+
+  class PublicApiError < Error
+  end
+
+  class GemfileOverrideError < Error
+  end
+end
+
+module Ruby
+  class Box
+    def self.new: () -> Box
+    def load_path: () -> Array[String]
+    def require: (String feature) -> untyped
+    def load: (String path) -> untyped
+    def eval: (String source) -> untyped
+    def const_defined?: (String name, bool inherit) -> bool
+    def const_source_location: (String name, bool inherit) -> [String, Integer]?
+    def const_set: (String name, untyped value) -> untyped
+    def const_get: (String name, ?bool inherit) -> untyped
+  end
+end
+
+module Rails
+  def self.respond_to?: (Symbol name) -> bool
+  def self.application: () -> untyped
+  def self.root: () -> Pathname
+end
+
+module Bundler
+  class BundlerError < StandardError
+  end
+
+  class Definition
+    def self.build: (String gemfile, String? lockfile, nil unlock) -> untyped
+  end
+end
+
+module YAML
+  def self.safe_load: (String yaml, ?permitted_classes: Array[untyped], ?aliases: bool) -> Hash[String, untyped]?
+  def self.dump: (Hash[String, untyped] object) -> String
+end
+
+module FileUtils
+  def self.mkdir_p: (Pathname | String path) -> untyped
+end
+
+class Gem::Specification
+  def self.load: (String path) -> Gem::Specification?
+  def self.find_all_by_name: (String name, String requirement) -> Array[Gem::Specification]
+  def self.dirs: () -> Array[String]
+
+  def name: () -> String
+  def version: () -> Gem::Version
+  def require_paths: () -> Array[String]
+  def full_require_paths: () -> Array[String]
+end

data/test/test_helper.rb

@@ -1,6 +1,5 @@
 require "minitest/autorun"
 
-ENV["RUBY_BOX"] = "1"
 ENV["RAILS_ENV"] = "test"
 
 lib_dir = File.expand_path("../lib", __dir__)