opera 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93222fbcb9fdd360cdadc340319157bc57dfe2229cb33a03ed46b1995f31a65
-  data.tar.gz: 7e909537e4b3af6d636d0eb174180f47212e8e49a7bf76a66c47109c60c363e7
+  metadata.gz: a69b196af65cb01e20f10d595444751505e0a241f6264e00c8de370c05def135
+  data.tar.gz: b17458445a2f96f47abb45064084498d8e4efb208a2dc04aa1e4abba1d2ab7ee
 SHA512:
-  metadata.gz: 76e6997c8fd873844a0a91c93e03c55e7297312abfd5e8ad45471c310c2d943e222664f7bbd0439a25cf7bb287aeac92dca0dd24ea9b84d653dd6d16d6b259cd
-  data.tar.gz: 0f2c582ef8d69e8e90010aa7c9b8db2c7e7483514dd3dc7da4da1ca521f5ae71e5f799c99744b75e8c0b4d32a220273b32e2f5e946a1a3060aa48280648674ee
+  metadata.gz: f4531f3b0cea01d642df058dc6a956de5e036b1259dd2dff659b4a67dc0956a34e965032442860b3b03af1997e1af9a41fe18845fbff4a13ef04a22f11adddc1
+  data.tar.gz: ea82fa32434682ec8f9dbbe3754204c3b9edcd586a64805debee5332ef05a69ef913523e309bf729bff626fa21eb79383058740bd3d9ee2cc5a7770f82c710d1

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Opera Changelog
 
+### 0.7.0 - Apr 30, 2026
+
+- Add `:if` / `:unless` options to all instructions except `always` (`validate`, `transaction`, `step`, `success`, `finish_if`, `operation`, `operations`, `within`) for declarative conditional execution. Conditions accept a Symbol (method name) or a Proc/Lambda (evaluated via `instance_exec` in the operation instance scope). Skipped instructions do not execute and are not recorded in `result.executions`; for block instructions (`transaction`, `within`) the whole block, including nested instructions, is skipped. For `operation` / `operations`, the conventional `<method>_output` slot in context is set to `nil` when skipped, matching the historical `return Opera::Operation::Result.new` early-exit behavior. Passing both `:if` and `:unless` on the same instruction raises `ArgumentError` at class load time.
+
+### 0.6.0 - Apr 15, 2026
+
+- Add `always` executor: runs its step unconditionally after all regular steps, regardless of failure or an early finish
+
 ### 0.5.1 - Apr 15, 2026
 
 - Remove `Marshal.dump` from instruction execution for ~40-55% throughput improvement
@@ -14,6 +22,7 @@
 - Remove `benchmark` executor
 
 ### 0.4.1 - Feb 18, 2026
+
 - Add parsed errors to default `output!` exception message
 
 ### 0.4.0 - May 22, 2025

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opera (0.5.1)
+    opera (0.7.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -112,16 +112,49 @@ end
 
 ## DSL Reference
 
-| Instruction | Description |
-|---|---|
-| `step :method` | Executes a method. Returns falsy to stop execution. |
-| `validate :method` | Executes a method that must return `Dry::Validation::Result` or `Opera::Operation::Result`. Errors are accumulated -- all validations run even if some fail. |
-| `transaction do ... end` | Wraps steps in a database transaction. Rolls back on error. |
-| `success :method` or `success do ... end` | Like `step`, but a falsy return does **not** stop execution. Use for side effects. |
-| `finish_if :method` | Stops execution (successfully) if the method returns truthy. |
-| `operation :method` | Calls an inner operation. Must return `Opera::Operation::Result`. Propagates errors on failure. Output stored in `context[:<method>_output]`. |
-| `operations :method` | Like `operation`, but the method must return an array of `Opera::Operation::Result`. |
-| `within :method do ... end` | Wraps nested steps with a custom method that must `yield`. If it doesn't yield, nested steps are skipped. |
+| Instruction                               | Description                                                                                                                                                                                                                                                                                       |
+| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `step :method`                            | Executes a method. Returns falsy to stop execution.                                                                                                                                                                                                                                               |
+| `validate :method`                        | Executes a method that must return `Dry::Validation::Result` or `Opera::Operation::Result`. Errors are accumulated -- all validations run even if some fail.                                                                                                                                      |
+| `transaction do ... end`                  | Wraps steps in a database transaction. Rolls back on error.                                                                                                                                                                                                                                       |
+| `success :method` or `success do ... end` | Like `step`, but a falsy return does **not** stop execution. Use for side effects.                                                                                                                                                                                                                |
+| `finish_if :method`                       | Stops execution (successfully) if the method returns truthy.                                                                                                                                                                                                                                      |
+| `operation :method`                       | Calls an inner operation. Must return `Opera::Operation::Result`. Propagates errors on failure. Output stored in `context[:<method>_output]`.                                                                                                                                                     |
+| `operations :method`                      | Like `operation`, but the method must return an array of `Opera::Operation::Result`.                                                                                                                                                                                                              |
+| `within :method do ... end`               | Wraps nested steps with a custom method that must `yield`. If it doesn't yield, nested steps are skipped.                                                                                                                                                                                         |
+| `always :method`                          | Executes a step unconditionally after all regular steps, even after a failure or an early finish. Must appear at the end of the operation — only other `always` steps may follow. Cannot be used inside blocks. Use `result.success?` / `result.failure?` inside the method to branch on outcome. |
+
+### Conditional execution (`:if` / `:unless`)
+
+The `:if` and `:unless` keyword arguments provide declarative conditional
+execution. They are supported on `validate`, `transaction`, `step`, `success`,
+`finish_if`, `operation`, `operations`, and `within` (every instruction except
+`always`). For block instructions (`transaction`, `within`), a falsy condition
+skips the whole block, including its nested instructions.
+
+The condition is evaluated **before** the instruction runs -- if the condition
+is not met the instruction is skipped entirely (no method invocation, no side
+effects, not recorded in `result.executions`).
+
+The condition value can be a **Symbol** (method name on the operation) or a
+**Proc/Lambda** (evaluated via `instance_exec` in the operation instance
+scope).
+
+```ruby
+# Symbol form
+step :notify_user, if: :notifications_enabled?
+
+# Lambda form
+step :recalculate, unless: -> { params[:skip_recalculation] }
+```
+
+When an `operation` or `operations` instruction is skipped, its
+`context[:<method>_output]` slot is set to `nil` (matching the historical
+`return Opera::Operation::Result.new` early-exit behavior). For other
+instructions no context output is set.
+
+Passing both `:if` and `:unless` on the same instruction raises `ArgumentError`
+at class load time.
 
 ### Combining instructions
 
@@ -147,25 +180,26 @@ class MyOperation < Opera::Operation::Base
   end
 
   step :output
+  always :audit_trail
 end
 ```
 
 ## Result API
 
-| Method | Returns | Description |
-|---|---|---|
-| `success?` | `Boolean` | `true` if no errors |
-| `failure?` | `Boolean` | `true` if any errors |
-| `output` | `Object` | The operation's return value |
-| `output!` | `Object` | Returns output if success, raises `OutputError` if failure |
-| `output=` | | Sets the output |
-| `errors` | `Hash` | Accumulated error messages |
-| `failures` | `Hash` | Alias for `errors` |
-| `information` | `Hash` | Developer-facing metadata |
-| `executions` | `Array` | Ordered list of executed steps (development mode only) |
-| `add_error(key, value)` | | Adds a single error |
-| `add_errors(hash)` | | Merges multiple errors |
-| `add_information(hash)` | | Merges metadata |
+| Method                  | Returns   | Description                                                |
+| ----------------------- | --------- | ---------------------------------------------------------- |
+| `success?`              | `Boolean` | `true` if no errors                                        |
+| `failure?`              | `Boolean` | `true` if any errors                                       |
+| `output`                | `Object`  | The operation's return value                               |
+| `output!`               | `Object`  | Returns output if success, raises `OutputError` if failure |
+| `output=`               |           | Sets the output                                            |
+| `errors`                | `Hash`    | Accumulated error messages                                 |
+| `failures`              | `Hash`    | Alias for `errors`                                         |
+| `information`           | `Hash`    | Developer-facing metadata                                  |
+| `executions`            | `Array`   | Ordered list of executed steps (development mode only)     |
+| `add_error(key, value)` |           | Adds a single error                                        |
+| `add_errors(hash)`      |           | Merges multiple errors                                     |
+| `add_information(hash)` |           | Merges metadata                                            |
 
 ```ruby
 # Pre-set output (useful in specs)
@@ -174,13 +208,13 @@ Opera::Operation::Result.new(output: 'success')
 
 ## Operation Instance Methods
 
-| Method | Description |
-|---|---|
-| `context` | Mutable `Hash` for passing data between steps |
-| `params` | Immutable `Hash` received via `call` |
-| `dependencies` | Immutable `Hash` received via `call` |
-| `result` | The `Opera::Operation::Result` instance |
-| `finish!` | Halts step execution (operation is still successful) |
+| Method         | Description                                          |
+| -------------- | ---------------------------------------------------- |
+| `context`      | Mutable `Hash` for passing data between steps        |
+| `params`       | Immutable `Hash` received via `call`                 |
+| `dependencies` | Immutable `Hash` received via `call`                 |
+| `result`       | The `Opera::Operation::Result` instance              |
+| `finish!`      | Halts step execution (operation is still successful) |
 
 ## Testing
 
@@ -204,6 +238,7 @@ Detailed examples with full input/output are available in the [`docs/examples/`]
 - [Finish If](docs/examples/finish-if.md)
 - [Inner Operations](docs/examples/inner-operations.md)
 - [Within](docs/examples/within.md)
+- [Always](docs/examples/always.md)
 - [Context, Params & Dependencies](docs/examples/context-params-dependencies.md)
 
 ## Development

data/benchmarks/operation_benchmark.rb

@@ -4,7 +4,7 @@
 #
 # Exercises the full execution path: step dispatch, instruction iteration,
 # context accessors, validate, transaction, success, finish_if, operation,
-# operations, and within -- with nested inner operations and loops to
+# operations, within, and always -- with nested inner operations and loops to
 # simulate realistic workloads.
 #
 # Usage:
@@ -122,7 +122,9 @@ ComplexOperation = Class.new(Opera::Operation::Base) do
     step :log_audit
   end
 
-  step :output
+  step :processing_error
+
+  always :output
 
   def schema
     Opera::Operation::Result.new(output: params)
@@ -165,6 +167,10 @@ ComplexOperation = Class.new(Opera::Operation::Base) do
     context[:audited] = true
   end
 
+  def processing_error
+    result.add_error(:base, 'processing failed')
+  end
+
   def output
     result.output = {
       profile: profile,
@@ -280,6 +286,43 @@ BatchOperation = Class.new(Opera::Operation::Base) do
   end
 end
 
+# ---------------------------------------------------------------------------
+# Always operation — exercises always steps on both success and failure paths
+# ---------------------------------------------------------------------------
+AlwaysOperation = Class.new(Opera::Operation::Base) do
+  context do
+    attr_accessor :log, default: -> { [] }
+  end
+
+  step :prepare
+  step :process
+  always :audit
+  always :cleanup
+
+  def prepare
+    log << :prepare
+    context[:value] = params.fetch(:value, 0)
+  end
+
+  def process
+    if params[:fail]
+      result.add_error(:base, 'processing failed')
+    else
+      context[:value] *= 2
+      log << :process
+    end
+  end
+
+  def audit
+    log << (result.success? ? :audit_success : :audit_failure)
+    result.output = { value: context[:value], log: log, success: result.success?, failure: result.failure? }
+  end
+
+  def cleanup
+    log << :cleanup
+  end
+end
+
 # ---------------------------------------------------------------------------
 # Benchmark
 # ---------------------------------------------------------------------------
@@ -288,6 +331,8 @@ PARAMS = { name: 'benchmark', batch_size: 5 }.freeze
 BATCH_PARAMS = { count: 5 }.freeze
 VALIDATION_PARAMS = { first_name: 'Jane', last_name: 'Doe', email: 'jane@example.com' }.freeze
 WITHIN_PARAMS = {}.freeze
+ALWAYS_SUCCESS_PARAMS = { value: 21 }.freeze
+ALWAYS_FAILURE_PARAMS = { value: 21, fail: true }.freeze
 
 # Warm up
 3.times do
@@ -295,6 +340,8 @@ WITHIN_PARAMS = {}.freeze
   BatchOperation.call(params: BATCH_PARAMS)
   ValidationOperation.call(params: VALIDATION_PARAMS)
   WithinOperation.call(params: WITHIN_PARAMS)
+  AlwaysOperation.call(params: ALWAYS_SUCCESS_PARAMS)
+  AlwaysOperation.call(params: ALWAYS_FAILURE_PARAMS)
 end
 
 puts "Opera v#{Opera::VERSION} — #{ITERATIONS} iterations each"
@@ -322,6 +369,14 @@ Benchmark.bm(35) do |x|
     ITERATIONS.times { LeafOperation.call(params: { n: 42 }) }
   end
 
+  x.report('AlwaysOperation (success path):') do
+    ITERATIONS.times { AlwaysOperation.call(params: ALWAYS_SUCCESS_PARAMS) }
+  end
+
+  x.report('AlwaysOperation (failure path):') do
+    ITERATIONS.times { AlwaysOperation.call(params: ALWAYS_FAILURE_PARAMS) }
+  end
+
   # Total operations executed in ComplexOperation run:
   # 1 complex + 1 inner + 5 leaf = 7 operations per iteration
   # = 7000 total operation instantiations for ComplexOperation alone

data/docs/examples/always.md

@@ -0,0 +1,267 @@
+# Always
+
+`always` runs a step unconditionally at the end of the operation pipeline, after all regular steps have run (or been skipped). Unlike a regular `step`, it is never skipped — not when a prior step adds an error, not when `finish!` or `finish_if` DSL is called.
+
+## Placement rules
+
+- `always` steps must appear **after all other instructions** at the top level of the operation.
+- Once an `always` is declared, only further `always` steps may follow — any other instruction (`step`, `operation`, `transaction`, `within`, etc.) raises an `ArgumentError` at class load time.
+- `always` **cannot** be used inside blocks (`transaction do`, `within do`, `success do`, `validate do`). Doing so raises an `ArgumentError` at class load time.
+
+```ruby
+# correct
+step :a
+step :b
+always :c
+always :d
+
+# raises ArgumentError — step follows always
+step :a
+always :b
+step :c
+
+# raises ArgumentError — always inside a transaction block
+transaction do
+  step :a
+  always :b  # not allowed here
+end
+```
+
+## Basic usage
+
+```ruby
+class Order::Submit < Opera::Operation::Base
+  context do
+    attr_accessor :order
+  end
+
+  dependencies do
+    attr_reader :current_account, :audit_logger
+  end
+
+  step :build
+  step :charge
+  step :send_confirmation
+  always :audit_log
+
+  def build
+    self.order = current_account.orders.build(params)
+  end
+
+  def charge
+    result.add_error(:base, 'card declined') unless order.charge!
+  end
+
+  def send_confirmation
+    # only reached when charge succeeds
+    OrderMailer.confirmation(order).deliver_later
+  end
+
+  def audit_log
+    # always runs, regardless of whether charge succeeded or failed
+    audit_logger.record(order: order, success: result.success?)
+  end
+end
+```
+
+## Inspecting result state inside an always step
+
+`result.success?` and `result.failure?` reflect the state of the operation **at the point `always` runs** — i.e. after all regular steps have executed (or been skipped due to failure). This lets you branch on the final outcome:
+
+```ruby
+class Profile::Delete < Opera::Operation::Base
+  context do
+    attr_accessor :profile
+  end
+
+  dependencies do
+    attr_reader :current_account, :notifier
+  end
+
+  step :find
+  step :destroy
+  always :notify
+
+  def find
+    self.profile = current_account.profiles.find(params[:id])
+  end
+
+  def destroy
+    result.add_error(:base, 'cannot delete') unless profile.destroy
+  end
+
+  def notify
+    if result.success?
+      notifier.call(event: :deleted, profile_id: params[:id])
+    else
+      notifier.call(event: :delete_failed, profile_id: params[:id], errors: result.errors)
+    end
+  end
+end
+```
+
+## Multiple always steps
+
+Multiple `always` steps are allowed and run in the order they are declared in:
+
+```ruby
+class Report::Generate < Opera::Operation::Base
+  dependencies do
+    attr_reader :audit_logger, :metrics
+  end
+
+  step :fetch_data
+  step :render
+  always :record_audit
+  always :record_metrics
+
+  def fetch_data
+    # ...
+  end
+
+  def render
+    # ...
+  end
+
+  def record_audit
+    audit_logger.call(success: result.success?, errors: result.errors)
+  end
+
+  def record_metrics
+    metrics.increment(result.success? ? 'report.success' : 'report.failure')
+  end
+end
+```
+
+## Operation finishes early
+
+### With finish_if
+
+`finish_if` halts execution successfully when its method returns truthy — subsequent regular steps are skipped, but `always` steps still run. Inside the always step, `result.success?` returns `true` because no errors were added:
+
+```ruby
+class Import::Run < Opera::Operation::Base
+  dependencies do
+    attr_reader :audit_logger
+  end
+
+  step :check_preconditions
+  finish_if :already_imported?
+  step :import
+  step :output
+  always :record_attempt
+
+  def check_preconditions
+    # validate source data is present
+  end
+
+  def already_imported?
+    Import.exists?(ref: params[:ref])
+  end
+
+  def import
+    Import.create!(params)
+  end
+
+  def output
+    result.output = { imported: true }
+  end
+
+  def record_attempt
+    # called whether import ran, was skipped via finish_if, or failed
+    audit_logger.call(ref: params[:ref], success: result.success?)
+  end
+end
+```
+
+### With finish!
+
+Calling `finish!` inside a step halts execution immediately and marks the operation successful. `always` steps still run afterwards:
+
+```ruby
+class Profile::Upsert < Opera::Operation::Base
+  context do
+    attr_accessor :profile
+  end
+
+  dependencies do
+    attr_reader :current_account, :audit_logger
+  end
+
+  step :find_existing
+  step :update_existing
+  step :create_new
+  step :output
+  always :audit_log
+
+  def find_existing
+    self.profile = current_account.profiles.find_by(email: params[:email])
+  end
+
+  def update_existing
+    return unless profile
+
+    profile.update!(params)
+    finish!
+  end
+
+  def create_new
+    self.profile = current_account.profiles.create!(params)
+  end
+
+  def output
+    result.output = { model: profile }
+  end
+
+  def audit_log
+    # runs whether the record was updated (finish! path), created, or failed
+    audit_logger.record(profile: profile, success: result.success?)
+  end
+end
+```
+
+## Combining with DSL blocks
+
+`always` cannot be placed inside `transaction`, `within` or `validate` blocks. Place it after those blocks at the top level:
+
+```ruby
+class Ledger::Transfer < Opera::Operation::Base
+  configure do |config|
+    config.transaction_class = ActiveRecord::Base
+  end
+
+  dependencies do
+    attr_reader :audit_logger
+  end
+
+  transaction do
+    step :debit
+    step :credit
+  end
+
+  step :output
+  always :record_attempt
+
+  def debit
+    result.add_error(:base, 'insufficient funds') unless account.debit(params[:amount])
+  end
+
+  def credit
+    account.credit(params[:amount])
+  end
+
+  def output
+    result.output = { transferred: params[:amount] }
+  end
+
+  def record_attempt
+    # runs after the transaction (and rollback, if any) has settled.
+    # result.success? / result.failure? reflect the final outcome.
+    audit_logger.call(
+      params: params,
+      success: result.success?,
+      errors: result.errors
+    )
+  end
+end
+```

data/lib/opera/operation/builder/options_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Builder
+      class OptionsBuilder
+        ALLOWED_OPTIONS = %i[if unless].freeze
+
+        def self.build(opts)
+          return {} if opts.empty?
+
+          unknown = opts.keys - ALLOWED_OPTIONS
+          raise ArgumentError, "Unknown option(s): #{unknown.inspect}. Allowed: #{ALLOWED_OPTIONS}" if unknown.any?
+
+          { predicate: build_predicate(opts) }.compact
+        end
+
+        def self.build_predicate(opts)
+          return nil unless opts[:if] || opts[:unless]
+          raise ArgumentError, 'Cannot use :if and :unless together' if opts[:if] && opts[:unless]
+
+          cond = opts[:if] || opts[:unless]
+          condition_proc = cond.is_a?(Symbol) ? proc { send(cond) } : cond
+          opts.key?(:if) ? condition_proc : proc { !instance_exec(&condition_proc) }
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/builder.rb

@@ -3,7 +3,8 @@
 module Opera
   module Operation
     module Builder
-      INSTRUCTIONS = %I[validate transaction step success finish_if operation operations within].freeze
+      INSTRUCTIONS = %I[validate transaction step success finish_if operation operations within always].freeze
+      INNER_INSTRUCTIONS = (INSTRUCTIONS - %I[always]).freeze
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -14,12 +15,23 @@ module Opera
           @instructions ||= []
         end
 
-        INSTRUCTIONS.each do |instruction|
-          define_method instruction do |method = nil, &blk|
+        INNER_INSTRUCTIONS.each do |instruction|
+          define_method instruction do |method = nil, **opts, &blk|
+            if instructions.any? { |i| i[:kind] == :always }
+              raise ArgumentError,
+                    "`#{instruction}` cannot appear after `always`. " \
+                    'All `always` steps must be at the end of the operation.'
+            end
+
             check_method_availability!(method) if method
-            instructions.concat(InnerBuilder.new.send(instruction, method, &blk))
+            instructions.concat(InnerBuilder.new.send(instruction, method, **opts, &blk))
           end
         end
+
+        def always(method)
+          check_method_availability!(method)
+          instructions << { kind: :always, method: method }
+        end
       end
 
       class InnerBuilder
@@ -30,22 +42,22 @@ module Opera
           instance_eval(&block) if block_given?
         end
 
-        INSTRUCTIONS.each do |instruction|
-          define_method instruction do |method = nil, &blk|
-            instructions << if !blk.nil?
-                              {
-                                kind: instruction,
-                                label: method,
-                                instructions: InnerBuilder.new(&blk).instructions
-                              }
-                            else
-                              {
-                                kind: instruction,
-                                method: method
-                              }
-                            end
+        INNER_INSTRUCTIONS.each do |instruction|
+          define_method instruction do |method = nil, **opts, &blk|
+            entry = if blk
+                      { kind: instruction, label: method, instructions: InnerBuilder.new(&blk).instructions }
+                    else
+                      { kind: instruction, method: method }
+                    end
+            instructions << entry.merge(OptionsBuilder.build(opts))
           end
         end
+
+        def always(_method)
+          raise ArgumentError,
+                '`always` cannot be used inside a block (transaction, within, success, validate). ' \
+                'Place `always` steps at the top level of the operation, after all other instructions.'
+        end
       end
     end
   end

data/lib/opera/operation/executor.rb

@@ -21,8 +21,9 @@ module Opera
 
       def evaluate_instructions(instructions = [])
         instructions.each do |instruction|
+          next if instruction[:kind] != :always && break_condition
+
           evaluate_instruction(instruction)
-          break if break_condition
         end
       end
 
@@ -40,6 +41,11 @@ module Opera
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
       def evaluate_instruction(instruction)
+        if instruction[:predicate] && !operation.instance_exec(&instruction[:predicate])
+          add_instruction_output(instruction, nil) if %i[operation operations].include?(instruction[:kind])
+          return
+        end
+
         case instruction[:kind]
         when :step
           Instructions::Executors::Step.new(operation).call(instruction)
@@ -57,6 +63,8 @@ module Opera
           Instructions::Executors::FinishIf.new(operation).call(instruction)
         when :within
           Instructions::Executors::Within.new(operation).call(instruction)
+        when :always
+          Instructions::Executors::Always.new(operation).call(instruction)
         else
           raise(UnknownInstructionError, "Unknown instruction #{instruction[:kind]}")
         end

data/lib/opera/operation/instructions/executors/always.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Always < Executor
+          def call(instruction)
+            execute_step(instruction)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation.rb

@@ -2,6 +2,7 @@
 
 require 'opera/operation/attributes_dsl'
 require 'opera/operation/builder'
+require 'opera/operation/builder/options_builder'
 require 'opera/operation/base'
 require 'opera/operation/executor'
 require 'opera/operation/instrumentation'
@@ -15,6 +16,7 @@ require 'opera/operation/instructions/executors/operation'
 require 'opera/operation/instructions/executors/operations'
 require 'opera/operation/instructions/executors/step'
 require 'opera/operation/instructions/executors/within'
+require 'opera/operation/instructions/executors/always'
 
 module Opera
   module Operation

data/lib/opera/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Opera
-  VERSION = '0.5.1'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opera
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - ProFinda Development Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-15 00:00:00.000000000 Z
+date: 2026-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -77,6 +77,7 @@ files:
 - bin/console
 - bin/setup
 - docker-compose.yml
+- docs/examples/always.md
 - docs/examples/basic-operation.md
 - docs/examples/context-params-dependencies.md
 - docs/examples/finish-if.md
@@ -91,8 +92,10 @@ files:
 - lib/opera/operation/attributes_dsl.rb
 - lib/opera/operation/base.rb
 - lib/opera/operation/builder.rb
+- lib/opera/operation/builder/options_builder.rb
 - lib/opera/operation/config.rb
 - lib/opera/operation/executor.rb
+- lib/opera/operation/instructions/executors/always.rb
 - lib/opera/operation/instructions/executors/finish_if.rb
 - lib/opera/operation/instructions/executors/operation.rb
 - lib/opera/operation/instructions/executors/operations.rb