hubbado-sequence 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 225c967e73e28a28effbc26e9c3bbdfce3357932a8374046dc46056d0dd8dd7d
-  data.tar.gz: 7a446faedf4bb88018c17a6130f29ec85f1fc354929864aaa2dd55f86753ffca
+  metadata.gz: cc373389ca48751e5d60ebc84c00dfd8740b437ec89a53b8d9a1b986ea5c2a48
+  data.tar.gz: 7053947aa597354f5b973832083ebc8cc9e60e4de3a1cee23524045f803a63cd
 SHA512:
-  metadata.gz: f5ae7e6141a9d45576b0b93a0c25ac23a63a9d3a5b4ea5ba134103a91db20633a17a1dc4e41a7a73570dc6745446d55e4e22612249dd75211d9c2be1c02a3143
-  data.tar.gz: a741030d0046941b128a18bc8bb0f58f10bdb677cd8941857d8937263e4dd2c58aaaac6fd2c816deac3f8d310a256c67af516dc7e8428aa3e5e29791cafa3676
+  metadata.gz: 240dbbf380bea6a9007872456c97d052a6cedf0f5b716fbffe63876362f7c66f89f18accbf51d1cd99f2ee0f3f377376c7161770e46d85f6314548bc07d6549b
+  data.tar.gz: ef08b3226afc5465ecac7030ca8e36ad9c3a2ecb967530144bb96aad79a670e2085eda9e74d80b4cc05e4617deab78ac0903150ff5ed6b78f4cf1b58a912d778

data/CHANGELOG.md

@@ -4,6 +4,145 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.6.0] - Result.failure flat kwargs; Dispatch delegates reads and exposes raise helpers
+
+### Changed (breaking)
+
+- **`Result.failure` takes flat kwargs; the `error:` hash wrapper is
+  gone.** The previous shape — `Result.failure(ctx, error: { code:,
+  data:, ... })` — wrapped its keys in an `error:` hash for no reason
+  beyond convention. The fields are now first-class kwargs on
+  `Result.failure` and first-class attrs on `Result`:
+
+  ```ruby
+  # before
+  Result.failure(ctx, error: { code: :forbidden, data: { policy_result: pr } })
+  result.error[:code]                # => :forbidden
+  result.error[:data][:policy_result]
+
+  # after
+  Result.failure(ctx, code: :forbidden, data: { policy_result: pr })
+  result.code                        # => :forbidden
+  result.data[:policy_result]
+  ```
+
+  `Result` exposes `code`, `data`, `step`, `message_override`,
+  `i18n_scope`, `i18n_key`, `i18n_args` as readers. `Result#error`
+  is removed.
+
+  Migration: in callers, replace `Result.failure(ctx, error: { code:
+  :X })` with `Result.failure(ctx, code: :X)`. Replace `result.error[:X]`
+  reads with `result.X`. The `Sequencer#failure(ctx, **error_attrs)`
+  helper is unchanged at the call site (it always took flat kwargs).
+  Macro substitutes' `fail_with(**error_attrs)` is unchanged at the call
+  site; arbitrary extra attrs that used to live in the error hash should
+  move into `data:` (`fail_with(code: :forbidden, data: { reason:
+  :not_owner })`).
+
+- **The per-error `i18n_scope` override path is removed.** Previously a
+  caller could put `i18n_scope:` inside the `error:` hash *and* pass a
+  separate `i18n_scope:` to the surrounding wrapper, with the per-error
+  one winning. With flat kwargs there is one `i18n_scope` slot. The
+  `Sequencer#failure` helper still applies the sequencer's auto-derived
+  scope when the caller doesn't pass one (`error_attrs[:i18n_scope] ||=
+  i18n_scope`), preserving the "caller wins" semantics where it matters
+  in practice. `Result#with_i18n_scope` (used to apply a scope to an
+  already-built Result) is unchanged.
+
+- **`Runner::Dispatch#result` is removed.** Master exposed the wrapped
+  Result via `attr_reader :result`, which was the source of the
+  `result.result.error.dig(...)` four-hop pattern. With the new
+  read-through delegations (`code`, `data`, `step`, `message`,
+  `successful_steps`, `ctx`) there's no reason for outcome blocks to
+  reach into the inner Result. Any caller still doing
+  `result.result.X` from inside a `run_sequence` block will now raise
+  `NoMethodError`; replace with the matching delegation on the
+  dispatch object itself.
+
+- **The `message:` kwarg on `Result.failure` is removed.** It set a
+  literal-string fallback returned by `Result#message` when no
+  translation matched. No in-tree caller used it (the
+  i18n-translation chain plus `humanize_code` fallback covered every
+  real case), and the path was test-only. If a caller needs a custom
+  message they can supply `i18n_key:` and a matching translation, or
+  pass a humanizable `code:` symbol.
+
+### Added
+
+- **`Runner::Dispatch` delegates reads to its wrapped `Result`.** Outcome
+  blocks can call `result.code`, `result.data`, `result.message`,
+  `result.step`, `result.successful_steps`, `result.ctx` on the
+  `Dispatch` object (the block argument) without hopping through an
+  inner `.result.` reference. The previous `result.result.error.dig(...)`
+  pattern collapses to one read.
+
+  ```ruby
+  result.policy_failed do |ctx|
+    if result.data[:policy_result].reason == :not_open
+      redirect_to public_path(ctx[:job])
+    else
+      result.raise_policy_failed
+    end
+  end
+  ```
+
+- **Public raise helpers on `Runner::Dispatch`:** `raise_policy_failed`,
+  `raise_not_found`, and `raise_failed`. They produce the same exceptions
+  the safety net would raise, but can be called explicitly from inside an
+  outcome block — useful when a caller handles some failure cases inline
+  and wants the framework's standard escalation for the rest.
+  `enforce_safety_nets!` now delegates to the same helpers, so the
+  exception shapes stay aligned whether the caller invokes them directly
+  or the runner does it automatically.
+
+## [0.5.0] - Result vocabulary renamed: success/failure and successful_steps
+
+### Changed (breaking)
+
+- **`Result.ok` → `Result.success`** and **`Result.fail` → `Result.failure`**.
+  Aligns with the wider Ruby railway-oriented vocabulary (dry-monads,
+  dry-transaction) and replaces the asymmetric `ok`/`failure?` pair with a
+  consistent `success`/`failure` pair.
+
+  ```ruby
+  # before
+  Result.ok(ctx)
+  Result.fail(ctx, error: { code: :forbidden })
+  result.ok?
+
+  # after
+  Result.success(ctx)
+  Result.failure(ctx, error: { code: :forbidden })
+  result.success?
+  ```
+
+  `result.failure?` is unchanged.
+
+  Migration: search-and-replace `Result.ok(` → `Result.success(`,
+  `Result.fail(` → `Result.failure(`, and `.ok?` → `.success?`. RSpec
+  matchers `be_ok` become `be_success`.
+
+- **`Result#trail` → `Result#successful_steps`** (and `with_trail` →
+  `with_successful_steps`, `trail:` kwarg → `successful_steps:`). The old
+  name was confusing because the failing step is *not* in the list — it
+  lives on `error[:step]`. The new name says exactly what's there.
+
+  ```ruby
+  # before
+  result.trail               # => [:find, :build_contract]
+  result.with_trail([...])
+  Result.ok(ctx, trail: [...])
+
+  # after
+  result.successful_steps    # => [:find, :build_contract]
+  result.with_successful_steps([...])
+  Result.success(ctx, successful_steps: [...])
+  ```
+
+  Migration: search-and-replace `.trail` → `.successful_steps`,
+  `with_trail(` → `with_successful_steps(`, and the keyword argument
+  `trail:` → `successful_steps:`.
+
 ## [0.4.0] - Inline step blocks removed; Pipeline made internal
 
 ### Removed (breaking)