senro_usecaser 0.1.0

data/sig/generated/senro_usecaser/provider.rbs

@@ -0,0 +1,153 @@
+# Generated from lib/senro_usecaser/provider.rb with RBS::Inline
+
+module SenroUsecaser
+  # Base class for dependency providers
+  #
+  # Providers allow organizing dependency registrations across multiple files.
+  # Each provider is responsible for registering a group of related dependencies.
+  #
+  # @example Basic provider
+  #   class UserProvider < SenroUsecaser::Provider
+  #     def register(container)
+  #       container.register(:user_repository, UserRepository.new)
+  #       container.register_singleton(:user_service) do |c|
+  #         UserService.new(repo: c.resolve(:user_repository))
+  #       end
+  #     end
+  #   end
+  #
+  # @example Provider with namespace
+  #   class AdminProvider < SenroUsecaser::Provider
+  #     namespace :admin
+  #
+  #     def register(container)
+  #       container.register(:user_repository, AdminUserRepository.new)
+  #     end
+  #   end
+  #
+  # @example Provider with dependencies
+  #   class PersistenceProvider < SenroUsecaser::Provider
+  #     depends_on CoreProvider
+  #
+  #     def register(container)
+  #       container.register(:database, Database.connect)
+  #     end
+  #   end
+  #
+  # @example Conditional provider
+  #   class DevelopmentProvider < SenroUsecaser::Provider
+  #     enabled_if { SenroUsecaser.env.development? }
+  #   end
+  class Provider
+    # Declares dependencies on other providers
+    #
+    # @example
+    #   class PersistenceProvider < SenroUsecaser::Provider
+    #     depends_on CoreProvider
+    #     depends_on ConfigProvider
+    #   end
+    #
+    # : (*singleton(Provider)) -> void
+    def self.depends_on: (*singleton(Provider)) -> void
+
+    # Returns the list of provider dependencies
+    #
+    # : () -> Array[singleton(Provider)]
+    def self.provider_dependencies: () -> Array[singleton(Provider)]
+
+    # Sets a condition for enabling this provider
+    #
+    # @example
+    #   class DevelopmentProvider < SenroUsecaser::Provider
+    #     enabled_if { Rails.env.development? }
+    #   end
+    #
+    # : () { () -> bool } -> void
+    def self.enabled_if: () { () -> boolish } -> void
+
+    # Returns whether this provider is enabled
+    #
+    # : () -> bool
+    def self.enabled?: () -> bool
+
+    # Sets the namespace for this provider's registrations
+    #
+    # @example
+    #   class AdminProvider < SenroUsecaser::Provider
+    #     namespace :admin
+    #   end
+    #
+    # : ((Symbol | String)) -> void
+    def self.namespace: (Symbol | String) -> void
+
+    # @rbs!
+    #   def self.provider_namespace: () -> (Symbol | String)?
+    attr_reader provider_namespace: untyped
+
+    # Registers this provider's dependencies to the given container
+    #
+    # : (Container) -> void
+    def self.call: (Container) -> void
+
+    # Registers dependencies to the container, wrapped in namespace if declared
+    #
+    # : (Container) -> void
+    def register_to: (Container) -> void
+
+    # Returns the effective namespace for this provider
+    # Uses explicitly declared namespace, or infers from module structure if configured
+    #
+    # : () -> (Symbol | String)?
+    def effective_namespace: () -> (Symbol | String)?
+
+    # Infers namespace from the class's module structure
+    #
+    # @example
+    #   Admin::UserProvider => "admin"
+    #   Admin::Reports::ReportProvider => "admin::reports"
+    #   CoreProvider => nil
+    #
+    # : () -> String?
+    def infer_namespace_from_class: () -> String?
+
+    # Called before register. Override in subclasses.
+    #
+    # @example
+    #   def before_register(container)
+    #     # Setup work
+    #   end
+    #
+    # : (Container) -> void
+    def before_register: (Container) -> void
+
+    # Override this method to register dependencies
+    #
+    # @example
+    #   def register(container)
+    #     container.register(:logger, Logger.new)
+    #   end
+    #
+    # : (Container) -> void
+    def register: (Container) -> void
+
+    # Called after all providers are registered. Override in subclasses.
+    #
+    # @example
+    #   def after_boot(container)
+    #     container.resolve(:database).verify_connection!
+    #   end
+    #
+    # : (Container) -> void
+    def after_boot: (Container) -> void
+
+    # Called on application shutdown. Override in subclasses.
+    #
+    # @example
+    #   def shutdown(container)
+    #     container.resolve(:database).disconnect
+    #   end
+    #
+    # : (Container) -> void
+    def shutdown: (Container) -> void
+  end
+end

data/sig/generated/senro_usecaser/result.rbs

@@ -0,0 +1,109 @@
+# Generated from lib/senro_usecaser/result.rb with RBS::Inline
+
+module SenroUsecaser
+  # Represents the result of a UseCase execution
+  #
+  # Result is a generic type that holds either a success value or an array of errors.
+  # Use {.success} and {.failure} class methods to create instances.
+  #
+  # @example Success case
+  #   result = SenroUsecaser::Result.success(user)
+  #   result.success? # => true
+  #   result.value    # => user
+  #
+  # @example Failure case
+  #   result = SenroUsecaser::Result.failure(
+  #     SenroUsecaser::Error.new(code: :not_found, message: "User not found")
+  #   )
+  #   result.failure? # => true
+  #   result.errors   # => [#<SenroUsecaser::Error ...>]
+  #
+  # @rbs generic T
+  class Result[T]
+    attr_reader value: T?
+
+    attr_reader errors: Array[Error]
+
+    # Creates a success Result with the given value
+    #
+    # : [T] (T) -> Result[T]
+    def self.success: [T] (T) -> Result[T]
+
+    # Creates a failure Result with the given errors
+    #
+    # : (*Error) -> Result[untyped]
+    def self.failure: (*Error) -> Result[untyped]
+
+    # Creates a failure Result from an exception
+    #
+    # @example
+    #   begin
+    #     # some code that raises
+    #   rescue => e
+    #     Result.from_exception(e)
+    #   end
+    #
+    # : (Exception, ?code: Symbol) -> Result[untyped]
+    def self.from_exception: (Exception, ?code: Symbol) -> Result[untyped]
+
+    # Executes a block and captures any exception as a failure Result
+    #
+    # @example
+    #   result = Result.capture { User.find(id) }
+    #   # If User.find raises, result is a failure with the exception
+    #   # If User.find succeeds, result is a success with the return value
+    #
+    # @example With specific exception classes
+    #   result = Result.capture(ActiveRecord::RecordNotFound, code: :not_found) do
+    #     User.find(id)
+    #   end
+    #
+    # : [T] (*Class, ?code: Symbol) { () -> T } -> Result[T]
+    def self.capture: [T] (*Class, ?code: Symbol) { () -> T } -> Result[T]
+
+    # : (?value: T?, ?errors: Array[Error]) -> void
+    def initialize: (?value: T?, ?errors: Array[Error]) -> void
+
+    # Returns true if the result is a success
+    #
+    # : () -> bool
+    def success?: () -> bool
+
+    # Returns true if the result is a failure
+    #
+    # : () -> bool
+    def failure?: () -> bool
+
+    # Returns the value if success, otherwise raises an error
+    #
+    # : () -> T
+    def value!: () -> T
+
+    # Returns the value if success, otherwise returns the given default
+    #
+    # : [U] (U) -> (T | U)
+    def value_or: [U] (U) -> (T | U)
+
+    # Applies a block to the value if success, returns failure with same errors if failure
+    #
+    # : [U] () { (T) -> U } -> Result[U]
+    def map: [U] () { (T) -> U } -> Result[U]
+
+    # Applies a block to the value if success, returns failure with same errors if failure
+    # The block should return a Result
+    #
+    # : [U] () { (T) -> Result[U] } -> Result[U]
+    def and_then: [U] () { (T) -> Result[U] } -> Result[U]
+
+    # Applies a block to the errors if failure, returns self if success
+    #
+    # : () { (Array[Error]) -> Result[T] } -> Result[T]
+    def or_else: () { (Array[Error]) -> Result[T] } -> Result[T]
+
+    # : (Result[untyped]) -> bool
+    def ==: (Result[untyped]) -> bool
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/generated/senro_usecaser/version.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/senro_usecaser/version.rb with RBS::Inline
+
+module SenroUsecaser
+  # : String
+  VERSION: ::String
+end

data/sig/generated/senro_usecaser.rbs

@@ -0,0 +1,113 @@
+# Generated from lib/senro_usecaser.rb with RBS::Inline
+
+# SenroUsecaser is a type-safe UseCase pattern implementation library for Ruby.
+#
+# It provides:
+# - Type-safe input/output with RBS Inline
+# - DI container with namespaces
+# - Flexible composition with organize/include/extend patterns
+#
+# @example Basic UseCase
+#   class CreateUserUseCase < SenroUsecaser::Base
+#     def call(name:, email:)
+#       user = User.create(name: name, email: email)
+#       success(user)
+#     end
+#   end
+#
+#   result = CreateUserUseCase.call(name: "Taro", email: "taro@example.com")
+#   if result.success?
+#     puts result.value.name
+#   end
+module SenroUsecaser
+  # Returns the global container instance
+  #
+  # @example
+  #   SenroUsecaser.container.register(:logger, Logger.new)
+  #
+  # : () -> Container
+  def self.container: () -> Container
+
+  # Sets the global container instance
+  #
+  # @example
+  #   SenroUsecaser.container = MyCustomContainer.new
+  #
+  # : (Container) -> Container
+  attr_writer container: untyped
+
+  # Resets the global container (useful for testing)
+  #
+  # : () -> void
+  def self.reset_container!: () -> void
+
+  # Registers a provider to the global container
+  #
+  # @example
+  #   SenroUsecaser.register_provider(UserProvider)
+  #
+  # : (singleton(Provider)) -> void
+  def self.register_provider: (singleton(Provider)) -> void
+
+  # Registers multiple providers to the global container
+  #
+  # @example
+  #   SenroUsecaser.register_providers(UserProvider, OrderProvider, PaymentProvider)
+  #
+  # : (*singleton(Provider)) -> void
+  def self.register_providers: (*singleton(Provider)) -> void
+
+  # Returns the configuration instance
+  #
+  # : () -> Configuration
+  def self.configuration: () -> Configuration
+
+  # Configures SenroUsecaser
+  #
+  # @example
+  #   SenroUsecaser.configure do |config|
+  #     config.providers = [CoreProvider, UserProvider]
+  #     config.infer_namespace_from_module = true
+  #   end
+  #
+  # : () { (Configuration) -> void } -> void
+  def self.configure: () { (Configuration) -> void } -> void
+
+  # Boots all configured providers in dependency order
+  #
+  # @example
+  #   SenroUsecaser.configure do |config|
+  #     config.providers = [CoreProvider, UserProvider]
+  #   end
+  #   SenroUsecaser.boot!
+  #
+  # : () -> void
+  def self.boot!: () -> void
+
+  # Shuts down all booted providers
+  #
+  # : () -> void
+  def self.shutdown!: () -> void
+
+  # Returns the current environment
+  #
+  # @example
+  #   SenroUsecaser.env.development?
+  #   SenroUsecaser.env.production?
+  #
+  # : () -> Environment
+  def self.env: () -> Environment
+
+  # Sets the environment
+  #
+  # : (String) -> void
+  def self.env=: (String) -> void
+
+  # Resets all state (useful for testing)
+  #
+  # : () -> void
+  def self.reset!: () -> void
+
+  # : () -> String
+  private def self.detect_environment: () -> String
+end

data/sig/overrides.rbs

@@ -0,0 +1,16 @@
+# Supplementary type definitions for rbs-inline generated types
+# Only add missing declarations that rbs-inline doesn't generate
+
+module SenroUsecaser
+  class Provider
+    # Class method for provider_namespace (attr_reader in class << self)
+    def self.provider_namespace: () -> (Symbol | String)?
+  end
+
+  class Base
+    # Class methods that rbs-inline doesn't generate correctly
+    def self.organized_steps: () -> Array[Step]?
+    def self.use_case_namespace: () -> (Symbol | String)?
+    def self.input_class: () -> Class?
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: senro_usecaser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shogo Kawahara
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  SenroUsecaser is a UseCase pattern implementation library for Ruby.
+  It provides type-safe input/output, DI container with namespaces,
+  and flexible composition with organize/include/extend patterns.
+  Compatible with both Steep (RBS) and Sorbet.
+email:
+- kawahara@bucyou.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE
+- README.md
+- Rakefile
+- Steepfile
+- examples/RBS_GENERATION.md
+- examples/namespace_demo.rb
+- examples/order_system.rb
+- examples/sig/namespace_demo.rbs
+- examples/sig/order_system.rbs
+- lefthook.yml
+- lib/senro_usecaser.rb
+- lib/senro_usecaser/base.rb
+- lib/senro_usecaser/configuration.rb
+- lib/senro_usecaser/container.rb
+- lib/senro_usecaser/error.rb
+- lib/senro_usecaser/provider.rb
+- lib/senro_usecaser/result.rb
+- lib/senro_usecaser/version.rb
+- sig/generated/senro_usecaser.rbs
+- sig/generated/senro_usecaser/base.rbs
+- sig/generated/senro_usecaser/configuration.rbs
+- sig/generated/senro_usecaser/container.rbs
+- sig/generated/senro_usecaser/error.rbs
+- sig/generated/senro_usecaser/provider.rbs
+- sig/generated/senro_usecaser/result.rbs
+- sig/generated/senro_usecaser/version.rbs
+- sig/overrides.rbs
+homepage: https://github.com/kawahara/senro_usecaser
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kawahara/senro_usecaser
+  source_code_uri: https://github.com/kawahara/senro_usecaser
+  changelog_uri: https://github.com/kawahara/senro_usecaser/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A type-safe UseCase pattern implementation library for Ruby
+test_files: []