hubbado-trailblazer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 60b8c12b372f5ab077aa00bdf7f9638739d76485423eefebfd1aab14d4c17088
+  data.tar.gz: 3de9bda895d56d17681e98b1c23a9fbce15f2dbb0442ee5500eae57e8aefee6d
+SHA512:
+  metadata.gz: 852d22bce0c966280fad36f04c0eb0ec2df6318b58ccaf3d69a3c21ee15b108f1c91d2c985c715a27e5820c7aec742f5483819354d4fef57f2eaac3f7668cdf1
+  data.tar.gz: e6a2141bac839c57928ef4891222bdfb1584fd94e2a6eb66d319899084e893a496f9c9cd068b9f66e5592b397f9e2f18209c2cc6ed155e5ff31c27e784ef3240

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# 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).
+
+## [1.0.0] - 2025-05-29
+
+### Added
+
+- Initial release of the hubbado-trailblazer gem

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hubbado
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,215 @@
+# Hubbado Trailblazer
+
+Enhanced Trailblazer operation utilities for Ruby applications with improved error handling, operation execution patterns, and ActiveRecord integration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hubbado-trailblazer'
+```
+
+And then execute:
+
+```bash
+$ POSTURE=dev ./install-gems.sh
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install hubbado-trailblazer
+```
+
+## Overview
+
+This gem extends Trailblazer operations with enhanced execution patterns, automatic transaction handling, and structured error handling. It provides:
+
+- **RunOperation**: A mixin for executing operations with structured result handling
+- **Transaction**: Automatic ActiveRecord transaction wrapping for operations
+- **Macros**: Custom operation macros for common patterns (policies, decorators, contract prepopulation)
+- **Enhanced Error Handling**: Structured error responses with proper exception types
+- **Operation Tracing**: Debug capabilities for operation execution flow
+
+## Usage
+
+### Basic Operation Execution
+
+Create a concern to include the RunOperation functionality in your controllers:
+
+```ruby
+module Concern
+  module Trailblazer
+    extend ActiveSupport::Concern
+
+    included do
+      include Hubbado::Trailblazer::RunOperation
+
+      def _run_options(options)
+        options.merge(
+          current_user: current_user || Users::Models::User.guest,
+        )
+      end
+
+      # Trailblazer takes all the parameters, no permit for us!
+      def _run_params(params)
+        params = params.to_unsafe_hash if params.respond_to?(:to_unsafe_hash)
+        params
+      end
+    end
+  end
+end
+```
+
+Then include it in your controllers:
+
+```ruby
+class UsersController < ApplicationController
+  include Concern::Trailblazer
+
+  def create
+    run_operation Users::Create do |result|
+      result.success do |ctx|
+        redirect_to user_path(ctx[:user])
+      end
+
+      result.validation_failed do |ctx|
+        render :new, locals: { contract: ctx['contract.default'] }
+      end
+
+      result.policy_failed do |ctx|
+        redirect_to root_path, alert: 'Not authorized'
+      end
+
+      result.otherwise do |ctx|
+        redirect_to users_path, alert: 'Something went wrong'
+      end
+    end
+  end
+end
+```
+
+### Transaction Handling
+
+Wrap operations in ActiveRecord transactions that automatically rollback on failure:
+
+```ruby
+class Users::Create < Trailblazer::Operation
+  step Wrap(Hubbado::Trailblazer::Transaction) {
+    step Model(User, :new)
+    step Contract::Build(constant: Users::CreateContract)
+    step Contract::Validate()
+    step Contract::Persist()
+  }
+end
+```
+
+### Custom Macros
+
+#### Policy Macro
+
+Enhanced policy handling for use with Hubbado::Policy:
+
+```ruby
+class Users::Update < Trailblazer::Operation
+  step Hubbado::Trailblazer::Macro::Policy(Users::UpdatePolicy)
+  # ... other steps
+end
+```
+
+#### Decorate Model Macro
+
+Automatically decorate models using `SomeDecorator.build(model, current_user)`:
+
+```ruby
+class Users::Show < Trailblazer::Operation
+  step Model(User, :find)
+  step Hubbado::Trailblazer::Macro::DecorateModel(UserDecorator)
+end
+```
+
+#### Prepopulate Contract Macro
+
+Prepopulate Reform contracts with values from params without validation:
+
+```ruby
+class Users::Edit < Trailblazer::Operation
+  step Model(User, :find)
+  step Contract::Build(constant: Users::UpdateContract)
+  step Hubbado::Trailblazer::Macro::PrepopulateContract()
+end
+```
+
+## Operation Tracing
+
+Debug operation execution by setting the `TRACE_OPERATION` environment variable:
+
+```bash
+# Trace a specific operation
+TRACE_OPERATION=Users::Create rails console
+
+# Trace all operations
+TRACE_OPERATION=_all rails console
+```
+
+This will output detailed execution traces showing which steps pass or fail.
+
+## Advanced Features
+
+### Custom Runtime Options
+
+The concern template methods can be customized for your application's needs:
+
+```ruby
+def _run_options(options)
+  options.merge(
+    current_user: current_user || Users::Models::User.guest,
+    request: request,
+    session: session
+  )
+end
+
+def _run_params(params)
+  params = params.to_unsafe_hash if params.respond_to?(:to_unsafe_hash)
+  params
+end
+```
+
+### Error Handling
+
+The gem provides structured error handling with specific exception types:
+
+- `Hubbado::Trailblazer::Errors::Unauthorized` - Raised when policies fail
+- `Hubbado::Trailblazer::OperationFailed` - Raised when operations fail unexpectedly
+
+## Testing
+
+Run the test suite:
+
+```bash
+$ ./test.sh
+```
+
+The gem uses TestBench for testing and includes comprehensive test coverage for all operation patterns and macros.
+
+## Requirements
+
+- Ruby >= 3.2
+- ActiveRecord
+- Trailblazer Operation
+- Reform (for contract testing)
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Make your changes and add tests
+4. Ensure all tests pass (`./test.sh`)
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request
+
+## License
+
+This gem is available under the MIT License. See the LICENSE file for more details.

data/hubbado-trailblazer.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = "hubbado-trailblazer"
+  s.version = "1.0.0"
+  s.summary = "Enhanced Trailblazer operation utilities for Ruby applications with improved error handling, operation execution patterns, and ActiveRecord integration."
+
+  s.authors = ["Hubbado Devs"]
+  s.email = ["devs@hubbado.com"]
+  s.homepage = 'https://github.com/hubbado/hubbado-trailblazer'
+
+  s.metadata["github_repo"] = s.homepage
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["changelog_uri"] = "#{s.homepage}/blob/master/CHANGELOG.md"
+
+  s.require_paths = ["lib"]
+  s.files = Dir.glob(%w[
+    lib/**/*.rb
+    *.gemspec
+    LICENSE*
+    README*
+    CHANGELOG*
+  ])
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = ">= 3.2"
+
+  s.add_dependency "activerecord"
+  s.add_dependency "evt-template_method"
+  s.add_dependency "hubbado-log"
+  s.add_dependency "trailblazer-operation"
+
+  s.add_development_dependency "debug"
+  s.add_development_dependency "dry-validation"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "hubbado-style"
+  s.add_development_dependency "reform"
+  s.add_development_dependency "test_bench"
+  s.add_development_dependency "trailblazer-macro"
+  s.add_development_dependency "trailblazer-macro-contract"
+end

data/lib/hubbado/trailblazer/errors.rb

@@ -0,0 +1,15 @@
+module Hubbado
+  module Trailblazer
+    module Errors
+      class Unauthorized < StandardError
+        attr_reader :result
+
+        def initialize(message = nil, result = nil)
+          @result = result
+
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/macro/decorate_model.rb

@@ -0,0 +1,19 @@
+module Hubbado
+  module Trailblazer
+    module Macro
+      def self.DecorateModel(decorator, model: :model)
+        task = ->((ctx, flow_options), _) do
+          unless ctx[model] && ctx[:current_user]
+            return ::Trailblazer::Activity::Left, [ctx, flow_options]
+          end
+
+          ctx[model] = decorator.build(ctx[model], ctx[:current_user])
+
+          [::Trailblazer::Activity::Right, [ctx, flow_options]]
+        end
+
+        { task: task, id: "Decorate" }
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/macro/policy.rb

@@ -0,0 +1,44 @@
+module Hubbado
+  module Trailblazer
+    module Macro
+      def self.Policy(policy_class, action, name: :default, model: :model)
+        ::Trailblazer::Macro::Policy.step(
+          Policy.build(policy_class, action, model), name: name
+        )
+      end
+
+      module Policy
+        def self.build(policy_class, action, model)
+          Condition.new(policy_class, action, model)
+        end
+
+        # Pundit::Condition is invoked at runtime when iterating the pipe.
+        class Condition
+          def initialize(policy_class, action, model)
+            @policy_class = policy_class
+            @action = action
+            @model = model
+          end
+
+          # Instantiate the actual policy object, and call it.
+          def call((options), *)
+            policy = build_policy(options)
+            result!(policy.send(@action), policy)
+          end
+
+          private
+
+          def build_policy(options)
+            @policy_class.build(options[:current_user], options[@model])
+          end
+
+          def result!(policy_result, policy)
+            data = { policy: policy, policy_result: policy_result }
+
+            ::Trailblazer::Operation::Result.new(policy_result.permitted?, data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/macro/prepopulate_contract.rb

@@ -0,0 +1,27 @@
+module Hubbado
+  module Trailblazer
+    module Macro
+      # This is used to pre-populate a contract before validating it, so that
+      # form options can be built based on the contract values
+      #
+      # For example, a contract, for a not yet saved assignment, might have
+      # timesheet approvers that depend on the client company ID in the
+      # contract
+      def self.PrepopulateContract(key:)
+        task = ->((ctx, flow_options), _) do
+          ctx[:prepopulated_contract] = key
+
+          params = ctx[:params][key]
+
+          return ::Trailblazer::Activity::Right, [ctx, flow_options] unless params
+
+          ctx['contract.default'].deserialize(params)
+
+          [::Trailblazer::Activity::Right, [ctx, flow_options]]
+        end
+
+        { task: task, id: "PrepopulateContract" }
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/run_operation.rb

@@ -0,0 +1,224 @@
+module Hubbado
+  module Trailblazer
+    # This allows you to run an operation and then respond differently based on
+    # the result of the operation.
+    #
+    # run_operation MyOperation do |result|
+    #   result.success do |ctx|
+    #     ...
+    #  end
+    #
+    #  result.policy_failed do |ctx|
+    #    # This is optional if not used the operation will raise an exception
+    #    ...
+    #    # Also optionally you can raise the default exception, it will not be raised
+    #    # if the block is executed otherwise when the block is finished
+    #    result.raise_policy_failed
+    #  end
+    #
+    #  result.validation_failed do |ctx|
+    #    ...
+    #  end
+    #
+    #  result.otherwise do |ctx|
+    #   # This is optional if not used the operation will raise an exception
+    #    ...
+    #   # Also optionally you can raise the default exception, it will not be raised
+    #   # if the block is executed otherwise when the block is finished
+    #   result.raise_operation_failed
+    #  end
+    # end
+    #
+    # ctx is the context built by the operation.
+    #
+    # If there is a policy failure and you have not implemented
+    # `result.policy_failed` then an exception will be raised.
+    #
+    # If the operation fails (due to non-policy error) and you have not
+    # implemented `result.otherwise` then an exception will be raised.
+    #
+    # Note, it is on purpose that implementing `result.otherwise` is not enough
+    # to stop an exception being raised if the policy fails. This to prevent a
+    # `result.otherwise` block rendering a form when the policy failed.
+    #
+    # We also considered TrailblazerEndpoint in place of this, but it seemed to
+    # be complicated for what it quite a simple usecase
+    #
+    # Tracing operations
+    #
+    # Setting the ENV variable TRACE_OPERATION to the class name of an
+    # operation (or to "_all") will cause the operation to be run with "wtf?"
+    # rather than `call`, outputting the trace of the operation, and showing
+    # which step failed, to stdout (not logging)
+    #
+    # This is useful when debugging traces
+    module RunOperation
+      include TemplateMethod
+
+      # Implement this if params need pre-processing before being passed to the operation
+      # For example, a controller needs to turn params into an unsafe hash
+      template_method :_run_params do |params|
+        params
+      end
+
+      # Implement this to inject additional context into the operation
+      # For example, a a controller can pass in current_user
+      template_method :_run_options do |ctx|
+        ctx
+      end
+
+      def _run_runtime_options(ctx = {}, *dependencies)
+        [_run_options(ctx), *dependencies]
+      end
+
+      def run_operation(operation, params = self.params, *options)
+        trace_operation = TraceOperation.(operation)
+        operation_method = trace_operation ? 'wtf?' : 'call'
+
+        operation_arguments = { params: _run_params(params) }
+        operation_arguments[:request] = request if respond_to?(:request)
+        operation_arguments.merge!(*_run_runtime_options(*options))
+
+        ctx = operation.send(operation_method, operation_arguments)
+
+        result = Result.new(operation, ctx, trace_operation)
+
+        yield(result) if block_given?
+
+        if ctx['result.policy.default']&.failure?
+          result.raise_policy_failed unless result.policy_failed_executed?
+        elsif ctx.failure? && !result.validation_failed_executed? && !result.otherwise_executed?
+          result.raise_operation_failed
+        end
+
+        result.returned
+      end
+
+      class Result
+        include Hubbado::Log::Dependency
+
+        attr_reader :returned
+        attr_reader :trace_operation
+
+        def initialize(operation, ctx, trace_operation)
+          @operation = operation
+          @ctx = ctx
+          @trace_operation = trace_operation
+        end
+
+        def log_level
+          trace_operation ? :debug : :info
+        end
+
+        def success
+          return unless ctx.success?
+
+          @success_executed = true
+          @returned = yield(ctx)
+
+          logger.send(log_level, "Success block executed for operation #{operation}")
+          @returned
+        end
+
+        def policy_failed
+          return unless ctx['result.policy.default']&.failure?
+
+          @policy_failed_executed = true
+          @returned = yield(ctx)
+
+          logger.send(log_level, "Policy failed block executed for operation #{operation}")
+          @returned
+        end
+
+        def validation_failed
+          return if success_executed?
+
+          contract = ctx['contract.default']
+          # TODO: We cannot call `contract.valid?` here, since the following
+          # steps will have converted form errors from strings to symbols:
+          #
+          # contract = Companies::Controls::Contracts::InviteMember.example
+          # contract.validate({name: 'Some name', email: 'email@example.com', role: :staff)
+          # contract.errors.add :email, :taken
+          # contract.valid?
+          #
+          # This only happens if errors are added outside of the validation
+          return if contract.nil? || contract.errors.full_messages.empty?
+
+          @validation_failed_executed = true
+          @returned = yield(ctx)
+
+          if trace_operation
+            logger.send(
+              log_level,
+              "Validation failed: #{ctx['contract.default'].errors.full_messages.join(', ')}"
+            )
+          else
+            logger.send(log_level, "Validation failed")
+          end
+          @returned
+        end
+
+        def otherwise
+          return if executed?
+
+          @otherwise_executed = true
+          @returned = yield(ctx)
+
+          logger.send(log_level, "Otherwise block executed for operation #{operation}")
+          @returned
+        end
+
+        def raise_operation_failed
+          msg = "Operation #{operation.name} failed"
+
+          error_messages = ctx['contract.default']&.errors&.full_messages
+
+          if error_messages&.any?
+            msg += " with errors:\n\n#{error_messages.map { |e| "  - #{e}" }.join("\n")}"
+          end
+
+          raise StandardError, msg
+        end
+
+        def raise_policy_failed
+          current_user = ctx[:current_user]
+          true_user = ctx[:true_user]
+
+          msg = "User #{current_user&.id}/#{true_user&.id} (#{current_user&.roles&.join ', '}) " \
+                "not allowed to run #{operation.name}"
+
+          raise Hubbado::Trailblazer::Errors::Unauthorized.new(msg, ctx['result.policy.default'][:policy_result])
+        end
+
+        def success_executed?
+          !!@success_executed
+        end
+
+        def policy_failed_executed?
+          !!@policy_failed_executed
+        end
+
+        def validation_failed_executed?
+          !!@validation_failed_executed
+        end
+
+        def otherwise_executed?
+          !!@otherwise_executed
+        end
+
+        def executed?
+          success_executed? ||
+            policy_failed_executed? ||
+            validation_failed_executed? ||
+            otherwise_executed?
+        end
+
+        private
+
+        attr_reader :operation
+        attr_reader :ctx
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/trace_operation.rb

@@ -0,0 +1,9 @@
+module Hubbado
+  module Trailblazer
+    module TraceOperation
+      def self.call(operation)
+        [operation.name, '_all'].include?(ENV.fetch('TRACE_OPERATION', nil))
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer/transaction.rb

@@ -0,0 +1,16 @@
+module Hubbado
+  module Trailblazer
+    class Transaction
+      def self.call((_ctx, _flow_options), *)
+        res = nil
+
+        ActiveRecord::Base.transaction do
+          res = yield
+          raise ActiveRecord::Rollback if res.first.to_h[:semantic] == :failure
+        end
+
+        res
+      end
+    end
+  end
+end

data/lib/hubbado/trailblazer.rb

@@ -0,0 +1,5 @@
+module Hubbado
+  module Trailblazer
+    OperationFailed = Class.new(StandardError)
+  end
+end

data/lib/hubbado-trailblazer.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+require 'hubbado/log'
+require 'template_method'
+require 'trailblazer/operation'
+
+require 'hubbado/trailblazer'
+
+require 'hubbado/trailblazer/transaction'
+require 'hubbado/trailblazer/errors'
+require 'hubbado/trailblazer/run_operation'
+require 'hubbado/trailblazer/trace_operation'
+
+require 'hubbado/trailblazer/macro/decorate_model'
+require 'hubbado/trailblazer/macro/policy'
+require 'hubbado/trailblazer/macro/prepopulate_contract'

metadata

@@ -0,0 +1,223 @@
+--- !ruby/object:Gem::Specification
+name: hubbado-trailblazer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Hubbado Devs
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-template_method
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hubbado-log
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-operation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hubbado-style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reform
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-macro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-macro-contract
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- devs@hubbado.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- hubbado-trailblazer.gemspec
+- lib/hubbado-trailblazer.rb
+- lib/hubbado/trailblazer.rb
+- lib/hubbado/trailblazer/errors.rb
+- lib/hubbado/trailblazer/macro/decorate_model.rb
+- lib/hubbado/trailblazer/macro/policy.rb
+- lib/hubbado/trailblazer/macro/prepopulate_contract.rb
+- lib/hubbado/trailblazer/run_operation.rb
+- lib/hubbado/trailblazer/trace_operation.rb
+- lib/hubbado/trailblazer/transaction.rb
+homepage: https://github.com/hubbado/hubbado-trailblazer
+licenses: []
+metadata:
+  github_repo: https://github.com/hubbado/hubbado-trailblazer
+  homepage_uri: https://github.com/hubbado/hubbado-trailblazer
+  changelog_uri: https://github.com/hubbado/hubbado-trailblazer/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Enhanced Trailblazer operation utilities for Ruby applications with improved
+  error handling, operation execution patterns, and ActiveRecord integration.
+test_files: []