senro_usecaser 0.1.0

data/lib/senro_usecaser/configuration.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module SenroUsecaser
+  # Configuration for SenroUsecaser
+  #
+  # @example
+  #   SenroUsecaser.configure do |config|
+  #     config.providers = [CoreProvider, UserProvider]
+  #     config.infer_namespace_from_module = true
+  #   end
+  #
+  class Configuration
+    # List of provider classes to boot
+    #: () -> Array[singleton(Provider)]
+    attr_accessor :providers
+
+    # Whether to infer namespace from module structure
+    #: () -> bool
+    attr_accessor :infer_namespace_from_module
+
+    #: () -> void
+    def initialize
+      @providers = []
+      @infer_namespace_from_module = false
+    end
+  end
+
+  # Environment detection
+  #
+  # @example
+  #   SenroUsecaser.env.development?
+  #   SenroUsecaser.env.production?
+  #
+  class Environment
+    #: (String) -> void
+    def initialize(name)
+      @name = name
+    end
+
+    #: () -> String
+    attr_reader :name
+
+    #: () -> bool
+    def development?
+      @name == "development"
+    end
+
+    #: () -> bool
+    def test?
+      @name == "test"
+    end
+
+    #: () -> bool
+    def production?
+      @name == "production"
+    end
+
+    #: () -> String
+    def to_s
+      @name
+    end
+  end
+
+  # Provider boot manager
+  #
+  # Resolves provider dependencies and boots them in correct order.
+  #
+  class ProviderBooter
+    # Error raised when circular dependencies are detected
+    class CircularDependencyError < StandardError; end
+
+    #: (Array[singleton(Provider)], Container) -> void
+    def initialize(provider_classes, container)
+      @provider_classes = provider_classes
+      @container = container
+      @booted_providers = [] #: Array[singleton(Provider)]
+      @provider_instances = {} #: Hash[singleton(Provider), Provider]
+    end
+
+    # Boots all providers in dependency order
+    #
+    #: () -> void
+    def boot!
+      sorted = topological_sort(@provider_classes)
+
+      sorted.each do |provider_class|
+        next unless provider_class.enabled?
+
+        instance = provider_class.new
+        @provider_instances[provider_class] = instance
+        instance.register_to(@container)
+        @booted_providers << provider_class
+      end
+
+      # Call after_boot on all providers
+      @booted_providers.each do |provider_class|
+        @provider_instances[provider_class].after_boot(@container)
+      end
+    end
+
+    # Shuts down all providers in reverse order
+    #
+    #: () -> void
+    def shutdown!
+      @booted_providers.reverse_each do |provider_class|
+        @provider_instances[provider_class].shutdown(@container)
+      end
+    end
+
+    private
+
+    # Topologically sorts providers based on dependencies
+    #
+    #: (Array[singleton(Provider)]) -> Array[singleton(Provider)]
+    def topological_sort(providers)
+      sorted = [] #: Array[singleton(Provider)]
+      visited = {} #: Hash[singleton(Provider), bool]
+      visiting = {} #: Hash[singleton(Provider), bool]
+
+      providers.each do |provider|
+        visit(provider, sorted, visited, visiting) unless visited[provider]
+      end
+
+      sorted
+    end
+
+    #: (singleton(Provider), Array[singleton(Provider)], untyped, untyped) -> void
+    def visit(provider, sorted, visited, visiting)
+      return if visited[provider]
+
+      if visiting[provider]
+        raise CircularDependencyError,
+              "Circular dependency detected involving #{provider.name}"
+      end
+
+      visiting[provider] = true
+
+      provider.provider_dependencies.each do |dep|
+        visit(dep, sorted, visited, visiting) unless visited[dep]
+      end
+
+      visiting.delete(provider)
+      visited[provider] = true
+      sorted << provider
+    end
+  end
+end

data/lib/senro_usecaser/container.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module SenroUsecaser
+  # Wrapper for singleton registrations that caches the result
+  class SingletonRegistration
+    #: (^(Container) -> untyped) -> void
+    def initialize(block)
+      @block = block
+      @resolved = false
+      @value = nil
+    end
+
+    #: (Container) -> untyped
+    def call(container)
+      unless @resolved
+        @value = @block.call(container)
+        @resolved = true
+      end
+      @value
+    end
+  end
+
+  # DI Container with namespace support
+  #
+  # @example Basic usage
+  #   container = SenroUsecaser::Container.new
+  #   container.register(:logger, Logger.new)
+  #   container.resolve(:logger) # => Logger instance
+  #
+  # @example With namespaces
+  #   container = SenroUsecaser::Container.new
+  #   container.register(:logger, Logger.new)
+  #
+  #   container.namespace(:admin) do
+  #     register(:user_repository, AdminUserRepository.new)
+  #   end
+  #
+  #   # From admin namespace, can resolve both admin and root dependencies
+  #   container.resolve_in(:admin, :user_repository) # => AdminUserRepository
+  #   container.resolve_in(:admin, :logger)          # => Logger (from root)
+  class Container
+    # Error raised when a dependency cannot be resolved
+    class ResolutionError < StandardError; end
+
+    # Error raised when a dependency is already registered
+    class DuplicateRegistrationError < StandardError; end
+
+    #: (?parent: Container?) -> void
+    def initialize(parent: nil)
+      @parent = parent
+      @registrations = {} #: Hash[String, untyped]
+      @current_namespace = [] #: Array[Symbol]
+    end
+
+    # Creates a scoped child container that inherits from this container
+    #
+    # @example
+    #   scoped = container.scope do
+    #     register(:current_user, current_user)
+    #   end
+    #   scoped.resolve(:current_user) # => current_user
+    #   scoped.resolve(:logger)       # => resolved from parent
+    #
+    #: () ?{ () -> void } -> Container
+    def scope(&block)
+      child = Container.new(parent: self)
+      child.instance_eval(&block) if block # steep:ignore BlockTypeMismatch
+      child
+    end
+
+    # Registers a dependency in the current namespace
+    #
+    # @example With value (returns same value every time)
+    #   container.register(:logger, Logger.new)
+    #
+    # @example With block (lazy evaluation, called every time, receives container)
+    #   container.register(:database) { |container| Database.connect }
+    #
+    #: (Symbol, ?untyped) ?{ (Container) -> untyped } -> void
+    def register(key, value = nil, &block)
+      raise ArgumentError, "Provide either a value or a block, not both" if value && block
+      raise ArgumentError, "Provide either a value or a block" if value.nil? && block.nil?
+
+      full_key = build_key(key)
+      check_duplicate_registration!(full_key)
+
+      @registrations[full_key] = block || ->(_) { value }
+    end
+
+    # Registers a lazy dependency (block is called every time on resolve)
+    #
+    # @example
+    #   container.register_lazy(:connection) { |c| Database.connect }
+    #
+    # @example With dependency resolution
+    #   container.register_lazy(:user_repository) do |container|
+    #     UserRepository.new(current_user: container.resolve(:current_user))
+    #   end
+    #
+    #: [T] (Symbol) { (Container) -> T } -> void
+    def register_lazy(key, &block)
+      raise ArgumentError, "Block is required for register_lazy" unless block
+
+      full_key = build_key(key)
+      check_duplicate_registration!(full_key)
+
+      @registrations[full_key] = block
+    end
+
+    # Registers a singleton dependency (block is called once and cached)
+    #
+    # @example
+    #   container.register_singleton(:database) { |c| Database.connect }
+    #   container.resolve(:database) # => same instance every time
+    #
+    # @example With dependency resolution
+    #   container.register_singleton(:service) do |container|
+    #     Service.new(logger: container.resolve(:logger))
+    #   end
+    #
+    #: [T] (Symbol) { (Container) -> T } -> void
+    def register_singleton(key, &block)
+      raise ArgumentError, "Block is required for register_singleton" unless block
+
+      full_key = build_key(key)
+      check_duplicate_registration!(full_key)
+
+      @registrations[full_key] = SingletonRegistration.new(block)
+    end
+
+    # Resolves a dependency from the current namespace or its ancestors
+    #
+    # @example
+    #   container.resolve(:logger)
+    #
+    #: [T] (Symbol) -> T
+    def resolve(key)
+      resolve_in(current_namespace_path, key)
+    end
+
+    # Resolves a dependency from a specific namespace or its ancestors
+    #
+    # @example
+    #   container.resolve_in(:admin, :logger)
+    #   container.resolve_in("admin::reports", :generator)
+    #
+    #: [T] ((Symbol | String | Array[Symbol]), Symbol) -> T
+    def resolve_in(namespace, key)
+      registration = find_registration(namespace, key)
+
+      unless registration
+        raise ResolutionError,
+              "Dependency #{key.inspect} not found in namespace #{namespace.inspect} or its ancestors"
+      end
+
+      # Always invoke with self (the resolving container) for proper scoping
+      invoke_registration(registration)
+    end
+
+    # Checks if a dependency is registered
+    #
+    #: (Symbol) -> bool
+    def registered?(key)
+      registered_in?(current_namespace_path, key)
+    end
+
+    # Checks if a dependency is registered in a specific namespace or its ancestors
+    #
+    #: ((Symbol | String | Array[Symbol]), Symbol) -> bool
+    def registered_in?(namespace, key)
+      namespace_parts = normalize_namespace(namespace)
+
+      (namespace_parts.length + 1).times do |i|
+        current_parts = namespace_parts[0, namespace_parts.length - i] || []
+        full_key = build_key_with_namespace(current_parts, key)
+        return true if @registrations.key?(full_key)
+      end
+
+      # Check parent container if available
+      return @parent.registered_in?(namespace, key) if @parent
+
+      false
+    end
+
+    # Creates a namespace scope for registering dependencies
+    #
+    # @example
+    #   container.namespace(:admin) do
+    #     register(:user_repository, AdminUserRepository.new)
+    #
+    #     namespace(:reports) do
+    #       register(:generator, ReportGenerator.new)
+    #     end
+    #   end
+    #
+    #: ((Symbol | String)) { () -> void } -> void
+    def namespace(name, &)
+      @current_namespace.push(name.to_sym)
+      instance_eval(&) # steep:ignore BlockTypeMismatch
+    ensure
+      @current_namespace.pop
+    end
+
+    # Returns all registered keys (including parent keys)
+    #
+    #: () -> Array[String]
+    def keys
+      own_keys = @registrations.keys
+      return own_keys unless @parent
+
+      (own_keys + @parent.keys).uniq
+    end
+
+    # Returns only keys registered in this container (excluding parent)
+    #
+    #: () -> Array[String]
+    def own_keys
+      @registrations.keys
+    end
+
+    # Returns the parent container if any
+    #
+    #: () -> Container?
+    attr_reader :parent
+
+    # Clears all registrations
+    #
+    #: () -> void
+    def clear!
+      @registrations.clear
+    end
+
+    private
+
+    #: () -> String
+    def current_namespace_path
+      @current_namespace.join("::")
+    end
+
+    #: (Symbol) -> String
+    def build_key(key)
+      build_key_with_namespace(@current_namespace, key)
+    end
+
+    #: (Array[Symbol], Symbol) -> String
+    def build_key_with_namespace(namespace_parts, key)
+      if namespace_parts.empty?
+        key.to_s
+      else
+        "#{namespace_parts.join("::")}::#{key}"
+      end
+    end
+
+    #: ((Symbol | String | Array[Symbol])) -> Array[Symbol]
+    def normalize_namespace(namespace)
+      case namespace
+      when Array then normalize_array_namespace(namespace)
+      when Symbol then normalize_symbol_namespace(namespace)
+      when String then normalize_string_namespace(namespace)
+      else raise ArgumentError, "Invalid namespace: #{namespace.inspect}"
+      end
+    end
+
+    #: (Array[Symbol]) -> Array[Symbol]
+    def normalize_array_namespace(namespace)
+      namespace.map(&:to_sym)
+    end
+
+    #: (Symbol) -> Array[Symbol]
+    def normalize_symbol_namespace(namespace)
+      namespace == :root ? [] : [namespace]
+    end
+
+    #: (String) -> Array[Symbol]
+    def normalize_string_namespace(namespace)
+      namespace.empty? ? [] : namespace.split("::").map(&:to_sym)
+    end
+
+    #: (String) -> void
+    def check_duplicate_registration!(full_key)
+      return unless @registrations.key?(full_key)
+
+      raise DuplicateRegistrationError, "Dependency #{full_key.inspect} is already registered"
+    end
+
+    # Invokes a registration, passing the container for dependency resolution
+    #
+    #: (untyped) -> untyped
+    def invoke_registration(registration)
+      registration.call(self)
+    end
+
+    protected
+
+    # Finds a registration in this container or its parent chain
+    #
+    #: ((Symbol | String | Array[Symbol]), Symbol) -> untyped
+    def find_registration(namespace, key)
+      namespace_parts = normalize_namespace(namespace)
+
+      # Try to find in the specified namespace and its ancestors
+      (namespace_parts.length + 1).times do |i|
+        current_parts = namespace_parts[0, namespace_parts.length - i] || []
+        full_key = build_key_with_namespace(current_parts, key)
+
+        return @registrations[full_key] if @registrations.key?(full_key)
+      end
+
+      # Fall back to parent container if available
+      @parent&.find_registration(namespace, key)
+    end
+  end
+end

data/lib/senro_usecaser/error.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module SenroUsecaser
+  # Represents an error in a Result
+  #
+  # @example Basic error
+  #   error = SenroUsecaser::Error.new(
+  #     code: :invalid_email,
+  #     message: "Email format is invalid",
+  #     field: :email
+  #   )
+  #
+  # @example Error from exception
+  #   begin
+  #     # some code that raises
+  #   rescue => e
+  #     error = SenroUsecaser::Error.new(
+  #       code: :unexpected_error,
+  #       message: e.message,
+  #       cause: e
+  #     )
+  #   end
+  class Error
+    #: Symbol
+    attr_reader :code
+
+    #: String
+    attr_reader :message
+
+    #: Symbol?
+    attr_reader :field
+
+    #: Exception?
+    attr_reader :cause
+
+    #: (code: Symbol, message: String, ?field: Symbol?, ?cause: Exception?) -> void
+    def initialize(code:, message:, field: nil, cause: nil)
+      @code = code
+      @message = message
+      @field = field
+      @cause = cause
+    end
+
+    # Creates an Error from an exception
+    #
+    #: (Exception, ?code: Symbol) -> Error
+    def self.from_exception(exception, code: :exception)
+      new(
+        code: code,
+        message: exception.message,
+        cause: exception
+      )
+    end
+
+    # Returns true if this error was caused by an exception
+    #
+    #: () -> bool
+    def caused_by_exception?
+      !cause.nil?
+    end
+
+    #: (Error) -> bool
+    def ==(other)
+      return false unless other.is_a?(Error)
+
+      code == other.code && message == other.message && field == other.field && cause == other.cause
+    end
+
+    #: () -> String
+    def to_s
+      base = field ? "[#{field}] #{message} (#{code})" : "#{message} (#{code})"
+      cause ? "#{base} caused by #{cause.class}" : base
+    end
+
+    #: () -> String
+    def inspect
+      parts = [
+        "code=#{code.inspect}",
+        "message=#{message.inspect}",
+        "field=#{field.inspect}"
+      ]
+      parts << "cause=#{cause.class}" if cause
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+  end
+end