solid-process 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 973ae538a96362750bac5c31245c2e8390144c4d67688940fa8b28f2ee27e538
-  data.tar.gz: 057c4bbbd8e2c4fc955c548a714fdb7fbe4396e1b8d624dc7702cc4750e929fa
+  metadata.gz: 56d7e7dae11f894dafd8cd1970ccf6fa1a9e6f6879a8f6370a3c5fa3b8419fcd
+  data.tar.gz: c15ca09276f4e0a366c980fd44cb6885f7cb5e1439786222c324828b2e7a5632
 SHA512:
-  metadata.gz: 20c3a43c503dfc26560ca25cb20a3d4d53f2014de3f9883bfbd872e7759881fc636da985f335d53f9c9c81b730b797f9759649543b49644ddf2e774222a4d2cc
-  data.tar.gz: 3802c1bab8d942f351099e0510f9cfae3d86b110508cea3d96b61c4bd4eb5953c249b2280d4565bc3b02990744d908f229267edffc88eab38100664bebe83959
+  metadata.gz: 3a7afa31c7de01092d6c75130d50e557c83e7e8b12b7a30667fce3bbfdb7c2876298907da67c8c0cfa8b1e1bd375b88d11d106d800bb628cb70e7efe7203324d
+  data.tar.gz: 53b395cec3553f20305db78fc24b51b09283034310363f26bdf53711aec85021aa5aa85cb24645d692d85df0218c8cec2700f42c315f983507dc27375f65f80d

data/.claude/CLAUDE.md

@@ -0,0 +1,112 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`solid-process` is a Ruby gem for encapsulating business logic into manageable processes. It integrates with Rails and provides input validation, dependency injection, and observability features.
+
+## Common Commands
+
+```bash
+# Setup (install dependencies: bundle + appraisal)
+bin/setup
+
+# Clean install + full test suite. Useful when switching Ruby versions.
+bin/matrix
+
+# Run all tests for current Ruby version
+bin/rake matrix
+
+# Run a single test file
+bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb
+
+# Run a specific test by name
+bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb -n test_method_name
+
+# Interactive console
+bin/console
+```
+
+## Lint
+
+**Ensure lint is green before committing.**
+
+```bash
+# Check for style violations (Ruby 3.4+)
+bin/rake standard
+
+# Auto-fix style violations
+bin/rake standard:fix
+```
+
+### Release Checklist
+
+When `lib/solid/process/version.rb` is changed:
+1. Verify `CHANGELOG.md` has a matching version entry (e.g., `## [0.5.0] - YYYY-MM-DD`)
+2. Verify `README.md` compatibility matrix is up-to-date if Ruby/Rails support changed
+
+### Ruby/Rails Version Alignment
+
+When modifying Ruby or Rails version support, ensure these files stay aligned:
+
+| File | Purpose |
+|------|---------|
+| `Appraisals` | Source of truth for gem dependencies per Rails version |
+| `Rakefile` | Local `rake matrix` task conditions |
+| `.github/workflows/main.yml` | CI matrix and step conditions |
+| `README.md` | Compatibility matrix table |
+
+**Key checks:**
+1. Ruby version conditions must match across `Appraisals`, `Rakefile`, and CI
+2. CI string values (e.g., `'head'`) need explicit checks since numeric comparisons won't match them
+3. README table must reflect the actual tested combinations
+4. Ruby `head` should only run against Rails edge (not stable Rails versions)
+
+## Switching Ruby Versions
+
+### ASDF
+
+```bash
+asdf list ruby        # List installed Ruby versions
+asdf set ruby 4.0.1   # Ruby 4.x
+```
+
+## Tests
+
+Always test on multiple Ruby versions when fixing compatibility issues.
+
+### Support Files
+
+Test fixtures in `test/support/` follow numbered naming (e.g., `051_user_token_creation.rb`) for load order. These define sample processes used across multiple tests.
+
+### Fix Library Code, Not Tests
+
+When tests fail due to Ruby version differences:
+1. First check if the **library code** can be updated to normalize behavior
+2. Only modify tests if the library fix isn't possible
+
+### Available Rails versions (see Rakefile for full list)
+```sh
+bundle exec appraisal rails-6-0 rake test # Ruby 2.7, 3.0
+bundle exec appraisal rails-6-1 rake test # Ruby 2.7, 3.0
+bundle exec appraisal rails-7-0 rake test # Ruby 3.0, 3.1, 3.2, 3.3
+bundle exec appraisal rails-7-1 rake test # Ruby 3.0, 3.1, 3.2, 3.3
+bundle exec appraisal rails-7-2 rake test # Ruby 3.1, 3.2, 3.3, 3.4
+bundle exec appraisal rails-8-0 rake test # Ruby 3.2, 3.3, 3.4
+bundle exec appraisal rails-8-1 rake test # Ruby 3.3, 3.4, 4.x
+```
+
+## Architecture
+
+### Core Classes
+
+- **Solid::Process** (`lib/solid/process.rb`) - Base class for business processes. Requires `input` block and `call` method. Returns `Success` or `Failure` outputs.
+
+- **Solid::Model** (`lib/solid/model.rb`) - ActiveModel-based concern providing attributes, validations, and callbacks.
+
+- **Solid::Input** (`lib/solid/input.rb`) - Input validation class, includes Solid::Model.
+
+- **Solid::Value** (`lib/solid/value.rb`) - Immutable value objects.
+
+- **Solid::Output** (`lib/solid/output.rb`) - Wraps solid-result gem for Success/Failure return types.

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.5.0] - 2025-01-27
+
+### Added
+
+- Add support for Ruby 3.4 and 4.x.
+
+- Add support for Rails 7.2, 8.0, and 8.1.
+
+### Fixed
+
+- Fix `BacktraceCleaner::BLOCKS_PATTERN` to handle Ruby 4.x backtrace format (`'Kernel#then'` instead of `` `then' ``).
+
 ## [0.4.0] - 2024-06-23
 
 ### Added

data/README.md

@@ -9,77 +9,242 @@
   </p>
 </p>
 
-## Supported Ruby and Rails
-
-This library is tested against:
-
-| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | Edge |
-|--------------|-----|-----|-----|-----|------|
-| 2.7          | ✅  | ✅  | ✅  | ✅   |      |
-| 3.0          | ✅  | ✅  | ✅  | ✅   |      |
-| 3.1          | ✅  | ✅  | ✅  | ✅   | ✅   |
-| 3.2          | ✅  | ✅  | ✅  | ✅   | ✅   |
-| 3.3          | ✅  | ✅  | ✅  | ✅   | ✅   |
-| Head         |    |    |    | ✅   | ✅   |
+## 📚 Table of Contents <!-- omit from toc -->
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+- [The Basic Structure](#the-basic-structure)
+- [Further Reading](#further-reading)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
+- [Acknowledgments](#acknowledgments)
+- [About](#about)
+
+## Supported Ruby and Rails <!-- omit from toc -->
+
+This library is tested (100% coverage) against:
+
+| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | 7.2 | 8.0 | 8.1 | Edge |
+|--------------|-----|-----|-----|-----|-----|-----|-----|------|
+| 2.7          | ✅  | ✅  | ✅  | ✅  |     |     |     |      |
+| 3.0          | ✅  | ✅  | ✅  | ✅  |     |     |     |      |
+| 3.1          |     |     | ✅  | ✅  | ✅  |     |     |      |
+| 3.2          |     |     | ✅  | ✅  | ✅  | ✅  |     |      |
+| 3.3          |     |     | ✅  | ✅  | ✅  | ✅  | ✅  | ✅   |
+| 3.4          |     |     |     |     | ✅  | ✅  | ✅  | ✅   |
+| 4.x          |     |     |     |     |     |     | ✅  | ✅   |
 
 ## Introduction
 
 `solid-process` is a Ruby/Rails library designed to encapsulate business logic into manageable processes. It simplifies writing, testing, maintaining, and evolving your code, ensuring it remains clear and approachable as your application scales.
 
-**Key Objectives:**
+**Features:** (_touch to expand_)
+
+<details><summary>1️⃣ <strong>Seamless Rails integration</strong></summary>
+
+  > Designed to complement Ruby on Rails, this library integrates smoothly without conflicting with existing framework conventions and features.
+
+</details>
+
+<details><summary>2️⃣ <strong>Support progressive mastery</strong></summary>
+
+  > Offers an intuitive entry point for novices while providing robust, advanced features that cater to experienced developers.
+
+</details>
 
-1. **Seamless Rails integration:** Designed to fully complement the Ruby on Rails framework, this library integrates smoothly without conflicting with existing Rails conventions and capabilities.
+<details><summary>3️⃣ <strong>Promote conceptual integrity and rapid onboarding</strong></summary>
 
-2. **Support progressive mastery:** Offers an intuitive entry point for novices while providing robust, advanced features that cater to experienced developers.
+  > By maintaining a consistent design philosophy, `solid-process` reduces the learning curve for new developers, allowing them to contribute more effectively and quickly to a codebase.
 
-3. **Promote conceptual integrity and rapid onboarding:** By maintaining a consistent design philosophy, `solid-process` reduces the learning curve for new developers, allowing them to contribute more effectively and quickly.
+</details>
 
-4. **Minimize technical debt:** Facilitate smoother transitions and updates as your application expands and your team size increases.
+<details><summary>4️⃣ <strong>Enhanced observability</strong></summary>
 
-5. **Enhanced observability:** Equipped with sophisticated instrumentation mechanisms, the library enables detailed logging and tracing without compromising clarity, even when processes are nested. This ensures the code is both easy to understand and to observe.
+  > Equipped with sophisticated instrumentation mechanisms, the library enables detailed logging and tracing without compromising code readability, even when processes are nested.
 
-### Examples
+</details>
 
-Checkout the [solid-rails-app](https://github.com/solid-process/solid-rails-app) for a full example of how to use `solid-process` in a Rails application. Or take a look at the [examples](examples) folder in this repository.
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
+### Examples <!-- omit in toc -->
+
+Check out [Solid Rails App](https://github.com/solid-process/solid-rails-app) for a complete example of how to use `solid-process` in a Rails application. [Twelve versions (branches)](https://github.com/solid-process/solid-rails-app?tab=readme-ov-file#-repository-branches) show how the gem can be incrementally integrated, access it to see from simple services/form objects to implementing the ports and adapters (hexagonal) architectural pattern.
+
+You can also check the [examples](examples) directory for more simple examples of how to use the gem.
+
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add solid-process
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install solid-process
+
+And require it in your code:
+
+    require 'solid/process'
+
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
+## The Basic Structure
+
+All `Solid::Process` requires at least two things: an `input` and a `call` method.
+
+1. The `input` is a set of attributes needed to perform the work.
+2. The `#call` method is the entry point and where the work is done.
+  - It receives the attributes Hash (symbolized keys), defined by the `input`.
+  - It returns a `Success` or `Failure` as the output.
 
 ```ruby
-gem 'solid-process'
+class User::Creation < Solid::Process
+  input do
+    # Define the attributes needed to perform the work
+  end
+
+  def call(attributes)
+    # Perform the work and return a Success or Failure as the output
+  end
+end
 ```
 
-And then execute:
+#### Example <!-- omit in toc -->
 
-```bash
-$ bundle install
+```ruby
+class User::Creation < Solid::Process
+  input do
+    attribute :email
+    attribute :password
+    attribute :password_confirmation
+  end
+
+  def call(attributes)
+    user = User.create(attributes)
+
+    if user.persisted?
+      Success(:user_created, user: user)
+    else
+      Failure(:user_not_created, user: user)
+    end
+  end
+end
 ```
 
-Or install it yourself as:
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
 
-```bash
-$ gem install solid-process
+### Calling a Process <!-- omit from toc -->
+
+To call a process, you can use the `call` method directly, or instantiate the class and call the `#call` method.
+
+```ruby
+###############
+# Direct call #
+###############
+
+User::Creation.call(email: 'john.doe@email.com', password: 'password', password_confirmation: 'password')
+# => #<Solid::Output::Success type=:user_created value={:user=>#<User id: 1, ...>}>
+
+########################
+# Instantiate and call #
+########################
+
+process = User::Creation.new
+
+process.call(email: 'john.doe@email.com', password: 'password', password_confirmation: 'password')
+```
+
+For now, it's essential to know that a process instance is stateful, and because of this, you can call it only once.
+
+```ruby
+process = User::Creation.new
+
+input = {email: 'john.doe@email.com', password: 'password', password_confirmation: 'password'}
+
+process.call(input)
+
+process.call(input)
+# The `User::Creation#output` is already set. Use `.output` to access the result or create a new instance to call again. (Solid::Process::Error)
 ```
 
-## Usage
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
+## Further Reading
+
+1. [Key Concepts](docs/010_KEY_CONCEPTS.md)
+2. [Basic Usage](docs/020_BASIC_USAGE.md)
+3. [Intermediate Usage](docs/030_INTERMEDIATE_USAGE.md)
+4. [Advanced Usage](docs/040_ADVANCED_USAGE.md)
+5. [Error Handling](docs/050_ERROR_HANDLING.md)
+6. [Testing](docs/060_TESTING.md)
+7. [Instrumentation / Observability](docs/070_INSTRUMENTATION.md)
+8. [Rails Integration](docs/080_RAILS_INTEGRATION.md)
+9. [Internal libraries](docs/090_INTERNAL_LIBRARIES.md)
+  - Solid::Input
+  - Solid::Model
+  - Solid::Value
+  - ActiveModel validations
+10. [Ports and Adapters (Hexagonal Architecture)](docs/100_PORTS_AND_ADAPTERS.md)
 
-TODO: Write usage instructions here
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake dev` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake matrix` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+```bash
+# Run full test suite for current Ruby version
+bin/rake matrix
+
+# Run tests for a specific Rails version
+bundle exec appraisal rails-8-1 rake test
+
+# Run a single test file
+bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb
+
+# Lint (Ruby 3.4+)
+bin/rake standard
+
+# Clean install + full test suite (useful when switching Ruby versions)
+# asdf set ruby <version>
+bin/matrix
+```
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/solid-process/solid-process. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/solid-process/solid-process/blob/main/CODE_OF_CONDUCT.md).
 
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
 ## Code of Conduct
 
 Everyone interacting in the Solid::Process project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/solid-process/solid-process/blob/main/CODE_OF_CONDUCT.md).
+
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>
+
+## Acknowledgments
+
+I want to thank some people who helped me by testing and giving feedback as this project took shape, they are:
+
+- [Diego Linhares](https://github.com/diegolinhares) and [Ralf Schmitz Bongiolo](https://github.com/mrbongiolo) they were the brave ones who worked for a few months with the first versions of the ecosystem (it was called B/CDD). Their feedback was essential for improving DX and helped me to pivot some core decisions.
+- [Vitor Avelino](https://github.com/vitoravelino), [Tomás Coêlho](https://github.com/tomascco), [Haroldo Furtado](https://github.com/haroldofurtado) (I could repeat Ralf and Diego again) for the various feedbacks, documentation, API, support and words of encouragement.
+
+## About
+
+[Rodrigo Serradura](https://rodrigoserradura.com) created this project. He is the Solid Process creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind). This gem can be used independently, but it also contains essential features that facilitate the adoption of Solid Process (the method) in code.
+
+<p align="right"><a href="#-table-of-contents-">⬆️ &nbsp;back to top</a></p>

data/Rakefile

@@ -13,12 +13,32 @@ require "appraisal/task"
 
 Appraisal::Task.new
 
-require "standard/rake"
-
-task :dev do
-  exec "bundle exec appraisal rails-7-1 rake test"
-
-  Rake::Task[:standard].invoke
+require "standard/rake" if RUBY_VERSION >= "3.4"
+
+desc "Run the full test suite in all supported Rails versions"
+task :matrix do
+  if RUBY_VERSION < "3.1"
+    system "bundle exec appraisal rails-6-0 rake test"
+    system "bundle exec appraisal rails-6-1 rake test"
+  end
+
+  if RUBY_VERSION >= "2.7" && RUBY_VERSION < "3.4"
+    system "bundle exec appraisal rails-7-0 rake test"
+    system "bundle exec appraisal rails-7-1 rake test"
+  end
+
+  if RUBY_VERSION >= "3.1" && RUBY_VERSION < "4.0"
+    system "bundle exec appraisal rails-7-2 rake test"
+  end
+
+  if RUBY_VERSION >= "3.2" && RUBY_VERSION < "4.0"
+    system "bundle exec appraisal rails-8-0 rake test"
+  end
+
+  if RUBY_VERSION >= "3.3"
+    system "bundle exec appraisal rails-8-1 rake test"
+    system "bundle exec appraisal rails-edge rake test"
+  end
+
+  Rake::Task[:standard].invoke if RUBY_VERSION >= "3.4"
 end
-
-task default: %i[test]

data/docs/010_KEY_CONCEPTS.md

@@ -0,0 +1,31 @@
+<small>
+
+`Previous` [Table of Contents](../README.md#further-reading) | `Next` [Basic Usage](./020_BASIC_USAGE.md)
+
+</small>
+
+# The Key Concepts
+
+### What is a process?
+
+A sequence of steps or actions to achieve a specific end. In other words, it is a series of steps that produce a result.
+
+### What is a `Solid::Process`?
+
+It is a class that encapsulates reusable business logic. Its main goal is to **ACT AS AN ORCHESTRATOR** who knows the order, what to use, and the steps necessary to produce an expected result.
+
+### Emergent Design
+
+The business rule is directly coupled with business needs. We are often unclear about these rules and how they will be implemented as code. Clarity tends to improve over time and after many maintenance cycles.
+
+For this reason, this abstraction embraces emerging design, allowing developers to implement code in a basic structure that can evolve and become sophisticated through the learnings obtained over time.
+
+### The Mantra
+
+* **Make it Work**, then
+* **Make it Better**, then
+* **Make it Even Better**.
+
+Using the emerging design concept, I invite you to embrace this development cycle, write the minimum necessary to implement processes and add more solid-process features based on actual needs.
+
+<p align="right"><a href="#the-key-concepts">⬆️ &nbsp;back to top</a></p>

data/docs/020_BASIC_USAGE.md

@@ -0,0 +1,46 @@
+<small>
+
+`Previous` [Key Concepts](./010_KEY_CONCEPTS.md) | `Next` [Intermediate Usage](./030_INTERMEDIATE_USAGE.md)
+
+</small>
+
+# Basic Usage
+
+**Status:** 🟡 `in-progress`
+
+In this section, we will learn how to create a simple process to register a user.
+
+```ruby
+class User::Registration < Solid::Process
+  input do
+    attribute :email
+    attribute :password
+    attribute :password_confirmation
+  end
+
+  def call(attributes)
+    user = User.new(attributes)
+
+    return Failure(:invalid_user, user:) if user.invalid?
+
+    ActiveRecord::Base.transaction do
+      user.save!
+
+      account = Account.create!(uuid: SecureRandom.uuid)
+
+      account.memberships.create!(user: user, role: :owner)
+
+      account.task_lists.inbox.create!
+
+      user.create_token!
+    end
+
+    UserMailer.with(
+      user: user,
+      token: user.generate_token_for(:email_confirmation)
+    ).email_confirmation.deliver_later
+
+    Success(:user_registered, user: user)
+  end
+end
+```

data/docs/030_INTERMEDIATE_USAGE.md

@@ -0,0 +1,74 @@
+<small>
+
+`Previous` [Basic Usage](./020_BASIC_USAGE.md) | `Next` [Advanced Usage](./040_ADVANCED_USAGE.md)
+
+</small>
+
+# Intermediate Usage
+
+**Status:** 🟡 `in-progress`
+
+In this section, we will learn how to use steps to express the process in a more structured way.
+
+```ruby
+class User::Registration < Solid::Process
+  input do
+    attribute :email, :string
+    attribute :password, :string
+    attribute :password_confirmation, :string
+  end
+
+  def call(attributes)
+    rollback_on_failure {
+      Given(attributes)
+        .and_then(:create_user)
+        .and_then(:create_user_account)
+        .and_then(:create_user_inbox)
+        .and_then(:create_user_token)
+    }
+      .and_then(:send_email_confirmation)
+      .and_expose(:user_registered, [:user])
+  end
+
+  private
+
+  def create_user(email:, password:, password_confirmation:, **)
+    user = User.create(email:, password:, password_confirmation:)
+
+    return Continue(user:) if user.persisted?
+
+    input.errors.merge!(user.errors)
+
+    Failure(:invalid_input, input:)
+  end
+
+  def create_user_account(user:, **)
+    account = Account.create!(uuid: SecureRandom.uuid)
+
+    account.memberships.create!(user:, role: :owner)
+
+    Continue(account:)
+  end
+
+  def create_user_inbox(account:, **)
+    account.task_lists.inbox.create!
+
+    Continue()
+  end
+
+  def create_user_token(user:, **)
+    user.create_token!
+
+    Continue()
+  end
+
+  def send_email_confirmation(user:, **)
+    UserMailer.with(
+      user:,
+      token: user.generate_token_for(:email_confirmation)
+    ).email_confirmation.deliver_later
+
+    Continue()
+  end
+end
+```

data/docs/040_ADVANCED_USAGE.md

@@ -0,0 +1,96 @@
+<small>
+
+`Previous` [Intermediate Usage](./030_INTERMEDIATE_USAGE.md) | `Next` [Error Handling](./050_ERROR_HANDLING.md)
+
+</small>
+
+# Advanced Usage
+
+**Status:** 🟡 `in-progress`
+
+In this section, we will learn how to use input normalization and validation, dependencies, and nested processes.
+
+```ruby
+class User::Registration < Solid::Process
+  deps do
+    attribute :mailer, default: UserMailer
+    attribute :token_creation, default: User::Token::Creation
+    attribute :task_list_creation, default: Account::Task::List::Creation
+  end
+
+  input do
+    attribute :email, :string
+    attribute :password, :string
+    attribute :password_confirmation, :string
+
+    before_validation do
+      self.email = email.downcase.strip
+    end
+
+    with_options presence: true do
+      validates :email, format: User::Email::REGEXP
+      validates :password, confirmation: true, length: {minimum: User::Password::MINIMUM_LENGTH}
+    end
+  end
+
+  def call(attributes)
+    rollback_on_failure {
+      Given(attributes)
+        .and_then(:check_if_email_is_taken)
+        .and_then(:create_user)
+        .and_then(:create_user_account)
+        .and_then(:create_user_inbox)
+        .and_then(:create_user_token)
+    }
+      .and_then(:send_email_confirmation)
+      .and_expose(:user_registered, [:user])
+  end
+
+  private
+
+  def check_if_email_is_taken(email:, **)
+    input.errors.add(:email, "has already been taken") if User.exists?(email:)
+
+    input.errors.any? ? Failure(:invalid_input, input:) : Continue()
+  end
+
+  def create_user(email:, password:, password_confirmation:, **)
+    user = User.create(email:, password:, password_confirmation:)
+
+    return Continue(user:) if user.persisted?
+
+    input.errors.merge!(user.errors)
+
+    Failure(:invalid_input, input:)
+  end
+
+  def create_user_account(user:, **)
+    account = Account.create!(uuid: SecureRandom.uuid)
+
+    account.memberships.create!(user:, role: :owner)
+
+    Continue(account:)
+  end
+
+  def create_user_inbox(account:, **)
+    case deps.task_list_creation.call(account:, inbox: true)
+    in Solid::Success(task_list:) then Continue()
+    end
+  end
+
+  def create_user_token(user:, **)
+    case deps.token_creation.call(user:)
+    in Solid::Success(token:) then Continue()
+    end
+  end
+
+  def send_email_confirmation(user:, **)
+    deps.mailer.with(
+      user:,
+      token: user.generate_token_for(:email_confirmation)
+    ).email_confirmation.deliver_later
+
+    Continue()
+  end
+end
+```

data/docs/050_ERROR_HANDLING.md

@@ -0,0 +1,3 @@
+# Error handling
+
+**Status:** 🔴 `to-do`

data/docs/060_TESTING.md

@@ -0,0 +1,3 @@
+# Testing
+
+**Status:** 🔴 `to-do`

data/docs/070_INSTRUMENTATION.md

@@ -0,0 +1,3 @@
+# Instrumentation
+
+**Status:** 🔴 `to-do`

data/docs/080_RAILS_INTEGRATION.md

@@ -0,0 +1,3 @@
+# Instrumentation
+
+**Status:** 🔴 `to-do`

data/docs/090_INTERNAL_LIBRARIES.md

@@ -0,0 +1,3 @@
+# Internal Libraries
+
+**Status:** 🔴 `to-do`

data/docs/100_PORTS_AND_ADAPTERS.md

@@ -0,0 +1,3 @@
+# Ports and Adapters (Hexagonal Architecture)
+
+**Status:** 🔴 `to-do`

data/lib/solid/process/backtrace_cleaner.rb

@@ -9,7 +9,7 @@ class Solid::Process::BacktraceCleaner < ActiveSupport::BacktraceCleaner
 
   private
 
-  BLOCKS_PATTERN = /in [`']block in|in `then'|internal:kernel|block \(\d+ levels?\) in/.freeze
+  BLOCKS_PATTERN = /in [`']block in|in [`'](?:Kernel#)?then'|internal:kernel|block \(\d+ levels?\) in/.freeze
 
   def add_blocks_silencer
     add_silencer { |line| line.match?(BLOCKS_PATTERN) }

data/lib/solid/process/event_logs/basic_logger_listener.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 class Solid::Process::EventLogs::BasicLoggerListener
-  include ActiveSupport::Configurable
   include Solid::Result::EventLogs::Listener
 
-  config_accessor(:logger, :backtrace_cleaner)
+  class_attribute :logger, :backtrace_cleaner
 
   self.logger = ActiveSupport::Logger.new($stdout)
   self.backtrace_cleaner = Solid::Process::BacktraceCleaner.new

data/lib/solid/process/version.rb

@@ -2,6 +2,6 @@
 
 module Solid
   class Process
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid-process
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-23 00:00:00.000000000 Z
+date: 2026-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: solid-result
@@ -59,11 +59,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/CLAUDE.md"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/010_KEY_CONCEPTS.md
+- docs/020_BASIC_USAGE.md
+- docs/030_INTERMEDIATE_USAGE.md
+- docs/040_ADVANCED_USAGE.md
+- docs/050_ERROR_HANDLING.md
+- docs/060_TESTING.md
+- docs/070_INSTRUMENTATION.md
+- docs/080_RAILS_INTEGRATION.md
+- docs/090_INTERNAL_LIBRARIES.md
+- docs/100_PORTS_AND_ADAPTERS.md
 - examples/business_processes/.rubocop.yml
 - examples/business_processes/.ruby-version
 - examples/business_processes/.standard.yml
@@ -110,7 +121,8 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/serradura/solid-process
   source_code_uri: https://github.com/serradura/solid-process
-  changelog_uri: https://github.com/serradura/solid-process/CHANGELOG.md
+  changelog_uri: https://github.com/solid-process/solid-process/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -126,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Write business logic for Ruby/Rails that scales.