hubbado-sequence 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c072f343cb764529d76c7babb7824217546cadeaf4cab59c305b40b0b1f7647
-  data.tar.gz: 15c860841338562d2ba8b39c8d49d1a95959345eec316489878676a0b9f4a3e4
+  metadata.gz: bae3a73329cdbf0194b5074fae10bd5e2d4035e773ee70f238ca802a5d0f2ae7
+  data.tar.gz: 8ff2d5bc1088333c8480695d411000f7b361efb22e296057c0111f88c0886113
 SHA512:
-  metadata.gz: 414d6011c8b468686ba3fe6f93adfa119d16196b25cc3313073463a56673aaf5a51100cb2b21ecd96e471511b4954cff6bbfd7e14806fc2c9370ac7c40a40020
-  data.tar.gz: df9d8e8d1c8ce2715f7b8582de9ed6a51106f5ff0f6c99caf596d9fb0f8b4ec5dc0818fecf01cb92149aa13f9813c40b7221b4cdcb1604d9a8ef3b0f43e037db
+  metadata.gz: 16069e3f557800e6c0c18e2f6b52c5bec482d2d8610d244e2679403879bf81ab742bbcf4da74d63a03fbaa12614103e51ffe53a6889d45b6cc3a73509ca3ecd5
+  data.tar.gz: c92c360d5fe1995cf05eefb330ab1949d0870d6ede7fcc308f350e7c23f98118544cda4d218580ba62d12793e7bbf6329af7f2b33a4c0adc6b5d87db2bc85dea

data/CHANGELOG.md

@@ -4,6 +4,29 @@ 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.8.0] - Instance calls take only a Ctx; chained pipeline carries the i18n scope
+
+### Changed (breaking)
+
+- **`pipeline` rejects anything but a `Ctx`.** A sequencer's instance
+  `call` takes a `Ctx`, as `docs/design.md` already stated, and
+  `pipeline` now raises `ArgumentError` when it gets keyword arguments or
+  a plain Hash. A spec that calls an instance
+  (`seq = Seq.new; seq.(params: ...)`) must pass
+  `Hubbado::Sequence::Ctx.build(params: ...)`. On a plain Hash, a read of a
+  missing ctx key returned `nil` in the spec while it raised `KeyError` in
+  production through the class-level `.()`, so specs could not find that
+  fault. The class-level `.()` still accepts keyword arguments.
+
+### Fixed
+
+- **A chained `pipeline(ctx).step(...).result` carries the sequencer's
+  i18n scope.** Only the block form tagged its Result, so a sequencer
+  using the chained form got no scope on an instance call, and its
+  parent's scope when nested through `p.invoke`. The pipeline now applies
+  the scope in both forms. The README states that a failure returned
+  without `pipeline` should be built with the `failure` helper.
+
 ## [0.7.0] - Macros::Policy::Check record-less policies; Sequencer i18n_scope applied at boundary
 
 ### Changed (breaking)

data/README.md

@@ -519,11 +519,18 @@ the same kwargs as `Result.failure` (`code:`, `data:`, `step:`,
 4. **Humanized code** — `:not_found` → `"Not found"`.
 
 The sequencer's scope is applied automatically. Both the `failure(ctx, ...)`
-helper *and* the boundary itself (`Sequencer#pipeline` and `Sequencer.()`)
-tag the returned `Result` with `i18n_scope` via `Result#with_i18n_scope`.
-That means an unscoped failure produced inside a macro, a hand-rolled
-step, or anywhere else in the sequencer body picks up the sequencer's
-scope when the Result bubbles out — no `failure` call required.
+helper *and* the boundary itself (the result of `pipeline(ctx)`, in block
+and chained form, and `Sequencer.()`) tag the returned `Result` with
+`i18n_scope` via `Result#with_i18n_scope`. That means an unscoped failure
+produced inside a macro, a hand-rolled step, or anywhere else in the
+pipeline picks up the sequencer's scope when the Result bubbles out — no
+`failure` call required.
+
+A sequencer that returns a failure without `pipeline` must build it with
+`failure(ctx, ...)`, not `Result.failure(...)`. An instance call (a test,
+or a nested sequencer run through `p.invoke`) reaches the sequencer's
+`call` directly, so only the helper gives that failure the sequencer's
+scope there.
 
 ### Defining translations for a sequencer
 
@@ -628,6 +635,13 @@ as substitutes. Tests configure the substitutes for the scenario at hand.
 Substitutes default to pass-through `Result.success(ctx)` so a test only
 configures the ones whose return matters.
 
+An instance call takes a `Ctx`, the same strict ctx that the class-level
+`.()` builds for production, so a test passes one:
+`seq.(Hubbado::Sequence::Ctx.build(params: ..., current_user: ...))`.
+`pipeline` raises `ArgumentError` for keyword arguments or a plain Hash,
+because on a Hash a read of a missing key would return `nil` in the test
+and raise `KeyError` in production.
+
 ### Substituting macros directly
 
 ```ruby
@@ -639,7 +653,7 @@ context "Seqs::UpdateUser::Present happy path" do
   seq.find.succeed_with(user)
   seq.build_contract.succeed_with(contract)
 
-  result = seq.(params: { id: 1 }, current_user: User.new)
+  result = seq.(Hubbado::Sequence::Ctx.build(params: { id: 1 }, current_user: User.new))
 
   test "Is success" do
     assert(result.success?)
@@ -662,7 +676,7 @@ context "Seqs::UpdateUser::Present when the user is not found" do
   seq = Seqs::UpdateUser::Present.new
   seq.find.fail_with(code: :not_found)
 
-  result = seq.(params: { id: 999 }, current_user: User.new)
+  result = seq.(Hubbado::Sequence::Ctx.build(params: { id: 999 }, current_user: User.new))
 
   test "Fails with :not_found" do
     assert(result.code == :not_found)
@@ -703,8 +717,10 @@ context "Seqs::UpdateUser happy path" do
   seq.present.succeed_with(user: user, contract: contract)
 
   result = seq.(
-    params:       { user: { email: "new@example.com" } },
-    current_user: User.new
+    Hubbado::Sequence::Ctx.build(
+      params:       { user: { email: "new@example.com" } },
+      current_user: User.new
+    )
   )
 
   test "Is success" do
@@ -724,7 +740,7 @@ context "Seqs::UpdateUser when Present denies access" do
   seq = Seqs::UpdateUser.new
   seq.present.fail_with(code: :forbidden)
 
-  result = seq.(params: { user: {} }, current_user: User.new)
+  result = seq.(Hubbado::Sequence::Ctx.build(params: { user: {} }, current_user: User.new))
 
   test "Fails" do
     assert(result.failure?)
@@ -747,7 +763,7 @@ context "Seqs::UpdateUser when Present cannot find the record" do
   seq = Seqs::UpdateUser.new
   seq.present.fail_with(code: :not_found)
 
-  result = seq.(params: { id: 999, user: {} }, current_user: User.new)
+  result = seq.(Hubbado::Sequence::Ctx.build(params: { id: 999, user: {} }, current_user: User.new))
 
   test "Fails with :not_found" do
     assert(result.code == :not_found)

data/hubbado-sequence.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name = "hubbado-sequence"
-  s.version = "0.7.0"
+  s.version = "0.8.0"
   s.summary = "A small framework for the short sequences of common steps that controller actions usually boil down to"
   s.description = "A sequencer takes input, runs an ordered sequence of steps, and returns a Result carrying a success-or-failure flag, a structured error, and the working context that was built up during execution. Built with Rails in mind but framework-agnostic."
 

data/lib/hubbado/sequence/pipeline.rb

@@ -4,11 +4,12 @@ module Hubbado
     # `pipeline(ctx)` helper. Not part of the public API — sequencers reach
     # it through the helper.
     class Pipeline
-      def initialize(ctx, dispatcher:)
+      def initialize(ctx, dispatcher:, i18n_scope: nil)
         @ctx = ctx
         @successful_steps = []
         @failed_result = nil
         @dispatcher = dispatcher
+        @i18n_scope = i18n_scope
       end
 
       # `step(:name)` dispatches to `dispatcher.send(name, ctx)`. The method
@@ -55,11 +56,9 @@ module Hubbado
       end
 
       def result
-        if @failed_result
-          @failed_result
-        else
-          Result.success(@ctx, successful_steps: @successful_steps.dup)
-        end
+        result = @failed_result || Result.success(@ctx, successful_steps: @successful_steps.dup)
+
+        result.with_i18n_scope(@i18n_scope)
       end
 
       private

data/lib/hubbado/sequence/sequencer.rb

@@ -95,12 +95,22 @@ module Hubbado
       # block, and returns the final Result — no trailing `.result` needed. The
       # non-block form returns the Pipeline so chained `.step(...)...result`
       # calls still work.
+      #
+      # Anything but a Ctx means an instance call skipped the Ctx that the
+      # class-level `.()` builds; run on a plain Hash, a missing key would
+      # read as nil rather than raise.
       def pipeline(ctx, &block)
-        pipe = Pipeline.new(ctx, dispatcher: self)
+        unless ctx.is_a?(Ctx)
+          raise ArgumentError,
+            "#{self.class.name}#pipeline expects a Hubbado::Sequence::Ctx, got #{ctx.class}; " \
+            "pass Hubbado::Sequence::Ctx.build(...) to an instance call"
+        end
+
+        pipe = Pipeline.new(ctx, dispatcher: self, i18n_scope: i18n_scope)
 
         if block
           block.call(pipe)
-          pipe.result.with_i18n_scope(i18n_scope)
+          pipe.result
         else
           pipe
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hubbado-sequence
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Hubbado Devs
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-18 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-casing