senro_usecaser 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da485bb1bbc5f14668b4e79b4e3a1e840e4e749a2925cc80ad286e2df33732b7
-  data.tar.gz: 5313ff78401d64d823d6691f9c659c58bcf357843e9ee97c3636a584cdf99635
+  metadata.gz: 91d516c2b304a836d4b476c177083ddff38bf8344ddbba14293aa60bee3e07f5
+  data.tar.gz: 0167aac25683c97feeb378123294073025c86d405307facb5e0392f5bf8eec35
 SHA512:
-  metadata.gz: 31e26879fc113e25048d9fde410066837502697308ca6973fe313417fe6cd6be198ef9917c9e5110ae51085032f683d66f920642557e2dd30a179af4aecaa1d7
-  data.tar.gz: 3957e5c91c088dde9e692101ca8db16840289caedb22bb9bf15a242a31da07898124841582ed8ec8eb9c4699e0b64d2805d04c52683245f51341d64cbc57b768
+  metadata.gz: 9592f2b84a831c56b80010cd207588e171407f07a143f19bb25f6cb4bb103bfa23b449c98517c887b4a0d5ff571b5e666afa82877df887978881121c01943996
+  data.tar.gz: f4cdbec706095b338c537eec61179ec9a2d9e251bd570d5ddceef2d0b2503deede7be514501e395c47e191a6e1c5c97f49144c0eb0fc728b3741d98b47ecc0e3

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-01-31
+
+### Added
+
+- **Hook class with dependency injection** - New `SenroUsecaser::Hook` base class for creating hooks with `depends_on` support
+  - Supports `namespace` declaration for scoped dependency resolution
+  - Supports `infer_namespace_from_module` configuration
+  - Can inherit namespace from the UseCase when not explicitly declared
+- **Block hooks can access dependencies**
+  - `before` and `after` blocks now run in instance context via `instance_exec`
+  - Dependencies declared with `depends_on` are directly accessible in block hooks
+
+### Changed
+
+- **Around block signature** - Changed from `|input, &block|` to `|input, use_case, &block|`
+  - The `use_case` argument provides access to dependencies
+- **Input class is now mandatory** - All UseCases must define an `input` class
+- **Renamed `context` to `input`** - Hook parameters renamed for clarity
+
+## [0.1.0] - 2026-01-30
+
+- Initial release

data/README.md

@@ -659,20 +659,30 @@ end
 
 ##### Block Syntax
 
+Block hooks are executed in the UseCase instance context, allowing access to `depends_on` dependencies.
+
 ```ruby
 class CreateUserUseCase < SenroUsecaser::Base
+  depends_on :logger
+  depends_on :metrics
+  input Input
+
+  # before/after blocks can access dependencies directly
   before do |input|
-    # runs before call
+    logger.info("Starting with #{input.class.name}")
   end
 
   after do |input, result|
-    # runs after call
+    logger.info("Finished: #{result.success? ? 'success' : 'failure'}")
+    metrics.increment(:use_case_completed)
   end
 
-  around do |input, &block|
-    ActiveRecord::Base.transaction do
-      block.call
-    end
+  # around block receives use_case as second argument for dependency access
+  around do |input, use_case, &block|
+    use_case.logger.info("Transaction start")
+    result = ActiveRecord::Base.transaction { block.call }
+    use_case.logger.info("Transaction end")
+    result
   end
 
   def call(input)
@@ -681,6 +691,77 @@ class CreateUserUseCase < SenroUsecaser::Base
 end
 ```
 
+##### Hook Classes
+
+For more complex hooks with their own dependencies, use `SenroUsecaser::Hook` class:
+
+```ruby
+class LoggingHook < SenroUsecaser::Hook
+  depends_on :logger
+  depends_on :metrics
+
+  def before(input)
+    logger.info("Starting with #{input.class.name}")
+  end
+
+  def after(input, result)
+    logger.info("Finished: #{result.success? ? 'success' : 'failure'}")
+    metrics.increment(:use_case_completed)
+  end
+
+  def around(input)
+    logger.info("Around start")
+    result = yield
+    logger.info("Around end")
+    result
+  end
+end
+
+class CreateUserUseCase < SenroUsecaser::Base
+  extend_with LoggingHook
+
+  def call(input)
+    # main logic
+  end
+end
+```
+
+Hook classes support:
+- `depends_on` for dependency injection
+- `namespace` for scoped dependency resolution
+- Automatic namespace inference from module structure (when `infer_namespace_from_module` is enabled)
+- Inheriting namespace from the UseCase if not explicitly declared
+
+```ruby
+# Hook with explicit namespace
+class Admin::AuditHook < SenroUsecaser::Hook
+  namespace :admin
+  depends_on :audit_logger
+
+  def after(input, result)
+    audit_logger.log(action: "create", success: result.success?)
+  end
+end
+
+# Hook inheriting namespace from UseCase
+class MetricsHook < SenroUsecaser::Hook
+  depends_on :metrics  # resolved from UseCase's namespace
+
+  def after(input, result)
+    metrics.increment(:completed)
+  end
+end
+
+class Admin::CreateUserUseCase < SenroUsecaser::Base
+  namespace :admin
+  extend_with MetricsHook  # metrics resolved from :admin namespace
+
+  def call(input)
+    # ...
+  end
+end
+```
+
 ##### Input/Output Validation
 
 Use `extend_with` to integrate validation libraries like ActiveModel::Validations:

data/lib/senro_usecaser/base.rb

@@ -262,8 +262,9 @@ module SenroUsecaser
       end
 
       # Adds an around hook
+      # Block receives (input, use_case, &block) where use_case allows access to dependencies
       #
-      #: () { (untyped) { () -> Result[untyped] } -> Result[untyped] } -> void
+      #: () { (untyped, Base) { () -> Result[untyped] } -> Result[untyped] } -> void
       def around(&block)
         around_hooks << block if block
       end
@@ -440,22 +441,39 @@ module SenroUsecaser
     #: (untyped, Proc) -> Proc
     def build_around_chain(input, core_block)
       wrapped_core = -> { wrap_result(core_block.call) }
-      all_around_hooks = collect_around_hooks
+      chain = wrap_extension_around_hooks(input, wrapped_core)
+      wrap_block_around_hooks(input, chain)
+    end
 
-      all_around_hooks.reverse.reduce(wrapped_core) do |inner, hook|
+    # Wraps extension/module around hooks
+    #
+    #: (untyped, Proc) -> Proc
+    def wrap_extension_around_hooks(input, chain)
+      collect_extension_around_hooks.reverse.reduce(chain) do |inner, hook|
         -> { wrap_result(hook.call(input) { inner.call }) }
       end
     end
 
-    # Collects all around hooks from extensions and block-based hooks
+    # Wraps block-based around hooks (pass self as second argument)
+    #
+    #: (untyped, Proc) -> Proc
+    def wrap_block_around_hooks(input, chain)
+      use_case_instance = self
+      self.class.around_hooks.reverse.reduce(chain) do |inner, hook|
+        -> { wrap_result(hook.call(input, use_case_instance) { inner.call }) }
+      end
+    end
+
+    # Collects around hooks from Hook classes and extension modules (not block-based)
     #
     #: () -> Array[Proc]
-    def collect_around_hooks
-      hooks = [] #: Array[Proc]
+    def collect_extension_around_hooks
+      hooks = hook_instances.map { |hook_instance| hook_instance.method(:around).to_proc }
       self.class.extensions.each do |ext|
+        next if hook_class?(ext)
+
         hooks << ext.method(:around).to_proc if ext.respond_to?(:around)
       end
-      hooks.concat(self.class.around_hooks)
       hooks
     end
 
@@ -463,20 +481,49 @@ module SenroUsecaser
     #
     #: (untyped) -> void
     def run_before_hooks(input)
+      hook_instances.each do |hook_instance|
+        hook_instance.before(input)
+      end
       self.class.extensions.each do |ext|
+        next if hook_class?(ext)
+
         ext.send(:before, input) if ext.respond_to?(:before)
       end
-      self.class.before_hooks.each { |hook| hook.call(input) }
+      self.class.before_hooks.each { |hook| instance_exec(input, &hook) } # steep:ignore BlockTypeMismatch
     end
 
     # Runs all after hooks
     #
     #: (untyped, Result[untyped]) -> void
     def run_after_hooks(input, result)
+      hook_instances.each do |hook_instance|
+        hook_instance.after(input, result)
+      end
       self.class.extensions.each do |ext|
+        next if hook_class?(ext)
+
         ext.send(:after, input, result) if ext.respond_to?(:after)
       end
-      self.class.after_hooks.each { |hook| hook.call(input, result) }
+      self.class.after_hooks.each { |hook| instance_exec(input, result, &hook) } # steep:ignore BlockTypeMismatch
+    end
+
+    # Returns instantiated hook objects
+    #
+    #: () -> Array[Hook]
+    def hook_instances
+      @hook_instances ||= self.class.extensions.filter_map do |ext|
+        next unless hook_class?(ext)
+
+        hook_class = ext #: singleton(Hook)
+        hook_class.new(container: @_container, use_case_namespace: effective_namespace)
+      end
+    end
+
+    # Checks if the extension is a Hook class
+    #
+    #: (untyped) -> bool
+    def hook_class?(ext)
+      ext.is_a?(Class) && ext < Hook
     end
 
     # Resolves dependencies from the container

data/lib/senro_usecaser/hook.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module SenroUsecaser
+  # Base class for hooks with dependency injection support
+  #
+  # Hook classes provide a way to define before/after/around hooks
+  # with access to the DI container and automatic dependency resolution.
+  #
+  # @example Basic hook
+  #   class LoggingHook < SenroUsecaser::Hook
+  #     depends_on :logger, Logger
+  #
+  #     def before(input)
+  #       logger.info("Starting with #{input.class.name}")
+  #     end
+  #
+  #     def after(input, result)
+  #       logger.info("Finished: #{result.success? ? 'success' : 'failure'}")
+  #     end
+  #   end
+  #
+  # @example Hook with namespace
+  #   class Admin::AuditHook < SenroUsecaser::Hook
+  #     namespace :admin
+  #     depends_on :audit_logger, AuditLogger
+  #
+  #     def after(input, result)
+  #       audit_logger.log(input: input, result: result)
+  #     end
+  #   end
+  #
+  # @example Hook with around
+  #   class TransactionHook < SenroUsecaser::Hook
+  #     def around(input)
+  #       ActiveRecord::Base.transaction { yield }
+  #     end
+  #   end
+  class Hook
+    class << self
+      # Declares a dependency to be injected from the container
+      #
+      #: (Symbol, ?Class) -> void
+      def depends_on(name, type = nil)
+        dependencies << name unless dependencies.include?(name)
+        dependency_types[name] = type if type
+
+        define_method(name) do
+          @_dependencies[name]
+        end
+      end
+
+      # Returns the list of declared dependencies
+      #
+      #: () -> Array[Symbol]
+      def dependencies
+        @dependencies ||= []
+      end
+
+      # Returns the dependency type mapping
+      #
+      #: () -> Hash[Symbol, Class]
+      def dependency_types
+        @dependency_types ||= {}
+      end
+
+      # Sets or returns the namespace for dependency resolution
+      #
+      #: (?(Symbol | String)) -> (Symbol | String)?
+      def namespace(name = nil)
+        if name
+          @hook_namespace = name
+        else
+          @hook_namespace
+        end
+      end
+
+      # Alias for namespace() without arguments
+      #
+      #: () -> (Symbol | String)?
+      def hook_namespace # rubocop:disable Style/TrivialAccessors
+        @hook_namespace
+      end
+
+      # @api private
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@dependencies, dependencies.dup)
+        subclass.instance_variable_set(:@dependency_types, dependency_types.dup)
+        subclass.instance_variable_set(:@hook_namespace, @hook_namespace)
+      end
+    end
+
+    # Initializes the hook with dependencies resolved from the container
+    #
+    #: (container: Container, ?use_case_namespace: (Symbol | String)?) -> void
+    def initialize(container:, use_case_namespace: nil)
+      @_container = container
+      @_use_case_namespace = use_case_namespace
+      @_dependencies = {} #: Hash[Symbol, untyped]
+
+      resolve_dependencies
+    end
+
+    # Called before the UseCase executes
+    # Override in subclass to add before logic
+    #
+    #: (untyped) -> void
+    def before(input)
+      # Override in subclass
+    end
+
+    # Called after the UseCase executes
+    # Override in subclass to add after logic
+    #
+    #: (untyped, Result[untyped]) -> void
+    def after(input, result)
+      # Override in subclass
+    end
+
+    # Wraps the UseCase execution
+    # Override in subclass to add around logic
+    #
+    #: (untyped) { () -> Result[untyped] } -> Result[untyped]
+    def around(_input)
+      yield
+    end
+
+    private
+
+    # Returns the effective namespace for dependency resolution
+    #
+    #: () -> (Symbol | String)?
+    def effective_namespace
+      return self.class.hook_namespace if self.class.hook_namespace
+      return @_use_case_namespace if @_use_case_namespace
+      return nil unless SenroUsecaser.configuration.infer_namespace_from_module
+
+      infer_namespace_from_class
+    end
+
+    # Infers namespace from the class's module structure
+    #
+    #: () -> String?
+    def infer_namespace_from_class
+      class_name = self.class.name
+      return nil unless class_name
+
+      parts = class_name.split("::")
+      return nil if parts.length <= 1
+
+      module_parts = parts[0...-1] || [] #: Array[String]
+      return nil if module_parts.empty?
+
+      module_parts.map { |part| part.gsub(/([a-z])([A-Z])/, '\1_\2').downcase }.join("::")
+    end
+
+    # Resolves dependencies from the container
+    #
+    #: () -> void
+    def resolve_dependencies
+      self.class.dependencies.each do |name|
+        @_dependencies[name] = resolve_from_container(name)
+      end
+    end
+
+    # Resolves a single dependency from the container
+    #
+    #: (Symbol) -> untyped
+    def resolve_from_container(name)
+      namespace = effective_namespace
+      if namespace
+        @_container.resolve_in(namespace, name)
+      else
+        @_container.resolve(name)
+      end
+    end
+  end
+end

data/lib/senro_usecaser/version.rb

@@ -4,5 +4,5 @@
 
 module SenroUsecaser
   #: String
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/senro_usecaser.rb

@@ -8,6 +8,7 @@ require_relative "senro_usecaser/result"
 require_relative "senro_usecaser/container"
 require_relative "senro_usecaser/configuration"
 require_relative "senro_usecaser/provider"
+require_relative "senro_usecaser/hook"
 require_relative "senro_usecaser/base"
 
 # SenroUsecaser is a type-safe UseCase pattern implementation library for Ruby.

data/sig/generated/senro_usecaser/base.rbs

@@ -178,8 +178,9 @@ module SenroUsecaser
     def self.after_hooks: () -> Array[Proc]
 
     # Adds an around hook
+    # Block receives (input, use_case, &block) where use_case allows access to dependencies
     #
-    # : () { (untyped) { () -> Result[untyped] } -> Result[untyped] } -> void
+    # : () { (untyped, Base) { () -> Result[untyped] } -> Result[untyped] } -> void
     def self.around: () ?{ (?) -> untyped } -> untyped
 
     # Returns the list of around hooks
@@ -281,10 +282,20 @@ module SenroUsecaser
     # : (untyped, Proc) -> Proc
     def build_around_chain: (untyped, Proc) -> Proc
 
-    # Collects all around hooks from extensions and block-based hooks
+    # Wraps extension/module around hooks
+    #
+    # : (untyped, Proc) -> Proc
+    def wrap_extension_around_hooks: (untyped, Proc) -> Proc
+
+    # Wraps block-based around hooks (pass self as second argument)
+    #
+    # : (untyped, Proc) -> Proc
+    def wrap_block_around_hooks: (untyped, Proc) -> Proc
+
+    # Collects around hooks from Hook classes and extension modules (not block-based)
     #
     # : () -> Array[Proc]
-    def collect_around_hooks: () -> Array[Proc]
+    def collect_extension_around_hooks: () -> Array[Proc]
 
     # Runs all before hooks
     #
@@ -296,6 +307,16 @@ module SenroUsecaser
     # : (untyped, Result[untyped]) -> void
     def run_after_hooks: (untyped, Result[untyped]) -> void
 
+    # Returns instantiated hook objects
+    #
+    # : () -> Array[Hook]
+    def hook_instances: () -> Array[Hook]
+
+    # Checks if the extension is a Hook class
+    #
+    # : (untyped) -> bool
+    def hook_class?: (untyped) -> bool
+
     # Resolves dependencies from the container
     #
     # : (Container, Hash[Symbol, untyped]) -> void

data/sig/generated/senro_usecaser/hook.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/senro_usecaser/hook.rb with RBS::Inline
+
+module SenroUsecaser
+  # Base class for hooks with dependency injection support
+  #
+  # Hook classes provide a way to define before/after/around hooks
+  # with access to the DI container and automatic dependency resolution.
+  #
+  # @example Basic hook
+  #   class LoggingHook < SenroUsecaser::Hook
+  #     depends_on :logger, Logger
+  #
+  #     def before(input)
+  #       logger.info("Starting with #{input.class.name}")
+  #     end
+  #
+  #     def after(input, result)
+  #       logger.info("Finished: #{result.success? ? 'success' : 'failure'}")
+  #     end
+  #   end
+  #
+  # @example Hook with namespace
+  #   class Admin::AuditHook < SenroUsecaser::Hook
+  #     namespace :admin
+  #     depends_on :audit_logger, AuditLogger
+  #
+  #     def after(input, result)
+  #       audit_logger.log(input: input, result: result)
+  #     end
+  #   end
+  #
+  # @example Hook with around
+  #   class TransactionHook < SenroUsecaser::Hook
+  #     def around(input)
+  #       ActiveRecord::Base.transaction { yield }
+  #     end
+  #   end
+  class Hook
+    # Declares a dependency to be injected from the container
+    #
+    # : (Symbol, ?Class) -> void
+    def self.depends_on: (Symbol, ?Class) -> void
+
+    # Returns the list of declared dependencies
+    #
+    # : () -> Array[Symbol]
+    def self.dependencies: () -> Array[Symbol]
+
+    # Returns the dependency type mapping
+    #
+    # : () -> Hash[Symbol, Class]
+    def self.dependency_types: () -> Hash[Symbol, Class]
+
+    # Sets or returns the namespace for dependency resolution
+    #
+    # : (?(Symbol | String)) -> (Symbol | String)?
+    def self.namespace: (?Symbol | String) -> (Symbol | String)?
+
+    # Alias for namespace() without arguments
+    #
+    # : () -> (Symbol | String)?
+    def self.hook_namespace: () -> (Symbol | String)?
+
+    # @api private
+    def self.inherited: (untyped subclass) -> untyped
+
+    # Initializes the hook with dependencies resolved from the container
+    #
+    # : (container: Container, ?use_case_namespace: (Symbol | String)?) -> void
+    def initialize: (container: Container, ?use_case_namespace: (Symbol | String)?) -> void
+
+    # Called before the UseCase executes
+    # Override in subclass to add before logic
+    #
+    # : (untyped) -> void
+    def before: (untyped) -> void
+
+    # Called after the UseCase executes
+    # Override in subclass to add after logic
+    #
+    # : (untyped, Result[untyped]) -> void
+    def after: (untyped, Result[untyped]) -> void
+
+    # Wraps the UseCase execution
+    # Override in subclass to add around logic
+    #
+    # : (untyped) { () -> Result[untyped] } -> Result[untyped]
+    def around: (untyped) { () -> Result[untyped] } -> Result[untyped]
+
+    private
+
+    # Returns the effective namespace for dependency resolution
+    #
+    # : () -> (Symbol | String)?
+    def effective_namespace: () -> (Symbol | String)?
+
+    # Infers namespace from the class's module structure
+    #
+    # : () -> String?
+    def infer_namespace_from_class: () -> String?
+
+    # Resolves dependencies from the container
+    #
+    # : () -> void
+    def resolve_dependencies: () -> void
+
+    # Resolves a single dependency from the container
+    #
+    # : (Symbol) -> untyped
+    def resolve_from_container: (Symbol) -> untyped
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: senro_usecaser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Shogo Kawahara
@@ -22,6 +22,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
@@ -37,6 +38,7 @@ files:
 - lib/senro_usecaser/configuration.rb
 - lib/senro_usecaser/container.rb
 - lib/senro_usecaser/error.rb
+- lib/senro_usecaser/hook.rb
 - lib/senro_usecaser/provider.rb
 - lib/senro_usecaser/result.rb
 - lib/senro_usecaser/version.rb
@@ -45,6 +47,7 @@ files:
 - sig/generated/senro_usecaser/configuration.rbs
 - sig/generated/senro_usecaser/container.rbs
 - sig/generated/senro_usecaser/error.rbs
+- sig/generated/senro_usecaser/hook.rbs
 - sig/generated/senro_usecaser/provider.rbs
 - sig/generated/senro_usecaser/result.rbs
 - sig/generated/senro_usecaser/version.rbs