opera 0.2.4 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b63b9dffc54255a4cc0e1e1c7f243258d36eb6e2812702a259073d705b1d680e
-  data.tar.gz: 3dba8a4459b1215f61af896ee712de74cf870103e70681ba30301904632e6225
+  metadata.gz: 74dd04d093748ea3304510e3a1ae919970c073728166e454482777037ed84ad8
+  data.tar.gz: c7da355f5d02435ba7cb4709974e08aaf61ba20968fd8765b05b8d3f317464a7
 SHA512:
-  metadata.gz: ef95fe48da334013d5c873e8b7a1f24dad951ce81b40b0d389c7b348d4a7f376b4bf1ff0b5e1fa861f22dd9fb22a74ad670a7b0ab536b671f85d889c55187651
-  data.tar.gz: 6539b51d037350cab91486f43f837fb194b9dcf298e36266cde0759552ed277866538959307d5a107284fdbc983d36b4695f539957748a2947c490534cec7ba9
+  metadata.gz: eef749a9273739e03aecee31562c23d0c254289be6eb0fc23afe4f1a5a65f6f5b9bce338fb7d651e8e8ebf50f96c1fca708526333ced33b9d2fa551aaa8fe594
+  data.tar.gz: fc82fbc54df5b5c0014e46eff882983dd6b178a7427d829aab1d7b2623682cda4fd2336b43cf9887467cea431d01beeef4b92814179da3afe2abd33183f72699

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Opera Changelog
 
+### 0.2.8 - December 7, 2021
+
+- Fix issue with default value
+- Update Readme
+
+### 0.2.7 - October 29, 2021
+
+- Adds `finish_if` step to DSL
+
+### 0.2.6 - October 29, 2021
+
+- New method Result#failures that returns combined errors and exceptions
+
+### 0.2.5 - August 3, 2021
+
+- make sure that `default` option in accessors is always lambda
+
 ### 0.2.4 - July 26, 2021
 
 - prevent default from overwrite falsy values

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opera (0.2.3)
+    opera (0.2.8)
 
 GEM
   remote: https://rubygems.org/
@@ -81,4 +81,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.2.15
+   2.2.32

data/README.md

@@ -144,6 +144,8 @@ end
 
 [Success](#user-content-success)
 
+[Finish if](#user-content-finish-if)
+
 [Inner Operation](#user-content-inner-operation)
 
 [Inner Operations](#user-content-inner-operations)
@@ -700,7 +702,7 @@ class Profile::Create < Opera::Operation::Base
 end
 ```
 
-#### Example with information (real and total) from benchmark
+#### Example output for success block
 
 ```ruby
 Profile::Create.call(params: {
@@ -712,6 +714,67 @@ Profile::Create.call(params: {
 #<Opera::Operation::Result:0x007fd0248e5638 @errors={"mailer"=>["Missing dependency"]}, @exceptions={}, @information={}, @executions=[:profile_schema, :populate, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 40, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2019-01-03 12:21:35", updated_at: "2019-01-02 12:21:35", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
 ```
 
+### Finish If
+
+```ruby
+class Profile::Create < Opera::Operation::Base
+  context_accessor :profile
+  dependencies_reader :current_account, :mailer
+
+  validate :profile_schema
+
+  step :create
+  finish_if :profile_create_only
+  step :update
+
+  success do
+    step :send_email
+    step :output
+  end
+
+  def profile_schema
+    Dry::Validation.Schema do
+      required(:first_name).filled
+    end.call(params)
+  end
+
+  def create
+    self.profile = current_account.profiles.create(params)
+  end
+
+  def profile_create_only
+    dependencies[:create_only].present?
+  end
+
+  def update
+    profile.update(updated_at: 1.day.ago)
+  end
+
+  # NOTE: We can add an error in this step and it won't break the execution
+  def send_email
+    result.add_error('mailer', 'Missing dependency')
+    mailer&.send_mail(profile: profile)
+  end
+
+  def output
+    result.output = { model: context[:profile] }
+  end
+end
+```
+
+#### Example with information (real and total) from benchmark
+
+```ruby
+Profile::Create.call(params: {
+  first_name: :foo,
+  last_name: :bar
+}, dependencies: {
+  create_only: true,
+  current_account: Account.find(1)
+})
+#<Opera::Operation::Result:0x007fd0248e5638 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :profile_create_only], @output={}>
+```
+
 ### Inner Operation
 
 ```ruby

data/lib/opera/operation/base.rb

@@ -60,7 +60,11 @@ module Opera
               check_method_availability!(attribute)
 
               define_method(attribute) do
-                value = send(method).key?(attribute) ? send(method)[attribute] : options[:default]
+                value = if send(method).key?(attribute)
+                          send(method)[attribute]
+                        elsif options[:default]
+                          instance_exec(&options[:default])
+                        end
 
                 if send(method).frozen?
                   send(method)[attribute] || value

data/lib/opera/operation/builder.rb

@@ -3,7 +3,7 @@
 module Opera
   module Operation
     module Builder
-      INSTRUCTIONS = %I[validate transaction benchmark step success operation operations].freeze
+      INSTRUCTIONS = %I[validate transaction benchmark step success finish_if operation operations].freeze
 
       def self.included(base)
         base.extend(ClassMethods)

data/lib/opera/operation/executor.rb

@@ -46,6 +46,8 @@ module Opera
           Instructions::Executors::Transaction.new(operation).call(instruction)
         when :benchmark
           Instructions::Executors::Benchmark.new(operation).call(instruction)
+        when :finish_if
+          Instructions::Executors::FinishIf.new(operation).call(instruction)
         else
           raise(UnknownInstructionError, "Unknown instruction #{instruction[:kind]}")
         end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class FinishIf < Executor
+          def call(instruction)
+            instruction[:kind] = :step
+            operation.finish! if super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/result.rb

@@ -28,6 +28,10 @@ module Opera
         !failure?
       end
 
+      def failures
+        errors.merge(exceptions)
+      end
+
       # rubocop:disable Metrics/MethodLength
       def add_error(field, message)
         @errors[field] ||= []

data/lib/opera/operation.rb

@@ -8,6 +8,7 @@ require 'opera/operation/config'
 require 'opera/operation/instructions/executors/success'
 require 'opera/operation/instructions/executors/transaction'
 require 'opera/operation/instructions/executors/benchmark'
+require 'opera/operation/instructions/executors/finish_if'
 require 'opera/operation/instructions/executors/validate'
 require 'opera/operation/instructions/executors/operation'
 require 'opera/operation/instructions/executors/operations'
@@ -15,6 +16,5 @@ require 'opera/operation/instructions/executors/step'
 
 module Opera
   module Operation
-
   end
 end

data/lib/opera/version.rb

@@ -1,3 +1,3 @@
 module Opera
-  VERSION = '0.2.4'
+  VERSION = '0.2.8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opera
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.8
 platform: ruby
 authors:
 - ProFinda Development Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-26 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -78,12 +78,12 @@ files:
 - lib/opera.rb
 - lib/opera/errors.rb
 - lib/opera/operation.rb
-- lib/opera/operation/README.md
 - lib/opera/operation/base.rb
 - lib/opera/operation/builder.rb
 - lib/opera/operation/config.rb
 - lib/opera/operation/executor.rb
 - lib/opera/operation/instructions/executors/benchmark.rb
+- lib/opera/operation/instructions/executors/finish_if.rb
 - lib/opera/operation/instructions/executors/operation.rb
 - lib/opera/operation/instructions/executors/operations.rb
 - lib/opera/operation/instructions/executors/step.rb

data/lib/opera/operation/README.md

@@ -1,786 +0,0 @@
-# Opera::Operation
-
-Simple DSL for services/interactions classes.
-
-# Installation
-
-```
-gem install pro_finda-operation
-```
-
-or in Gemfile:
-
-```
-gem 'pro_finda-operation', path: 'vendor/pro_finda-operation'
-```
-
-# Configuration
-
-```ruby
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-  config.transaction_method = :transaction
-  config.reporter = if defined?(Rollbar) then Rollbar else Rails.logger
-end
-
-class A < Opera::Operation::Base
-
-  configure do |config|
-    config.transaction_class = Profile
-    config.reporter = Rails.logger
-  end
-
-  success :populate
-
-  operation :inner_operation
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-    step :destroy
-  end
-
-  validate do
-    step :validate_object
-    step :validate_relationships
-  end
-
-  benchmark do
-    success :hal_sync
-  end
-
-  success do
-    step :send_mail
-    step :report_to_audit_log
-  end
-
-  step :output
-end
-```
-
-# Specs
-
-When using Opera::Operation inside an engine add the following
-configuration to your spec_helper.rb or rails_helper.rb:
-
-```
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-end
-```
-
-Without this extra configuration you will receive:
-```
-NoMethodError:
-  undefined method `transaction' for nil:NilClass
-```
-
-# Debugging
-
-When you want to easily debug exceptions you can add this
-to your dummy.rb:
-
-```
-Rails.application.configure do
-  config.x.reporter = Logger.new(STDERR)
-end
-```
-
-This should display exceptions captured inside operations.
-
-You can also do it in Opera::Operation configuration block:
-
-```
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-  config.reporter = Logger.new(STDERR)
-end
-```
-
-# Content
-[Basic operation](#user-content-basic-operation)
-
-[Example with sanitizing parameters](#user-content-example-with-sanitizing-parameters)
-
-[Example operation with old validations](#user-content-example-operation-with-old-validations)
-
-[Example with step that raises exception](#user-content-example-with-step-that-raises-exception)
-
-[Failing transaction](#user-content-failing-transaction)
-
-[Passing transaction](#user-content-passing-transaction)
-
-[Benchmark](#user-content-benchmark)
-
-[Success](#user-content-success)
-
-[Inner Operation](#user-content-inner-operation)
-
-[Inner Operations](#user-content-inner-operations)
-
-# Usage examples
-
-Some cases and example how to use new operations
-
-## Basic operation
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def send_email
-    dependencies[:mailer]&.send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Call with valid parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000561636dced60 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 30, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-14 16:04:08", updated_at: "2018-12-14 16:04:08", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-#### Call with INVALID parameters - missing first_name
-
-```ruby
-Profile::Create.call(params: {
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000562d3f635390 @errors={:first_name=>["is missing"]}, @exceptions={}, @information={}, @executions=[:profile_schema]>
-```
-
-#### Call with MISSING dependencies
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x007f87ba2c8f00 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 33, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2019-01-03 12:04:25", updated_at: "2019-01-03 12:04:25", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Example with sanitizing parameters
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      configure { config.input_processor = :sanitizer }
-
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(context[:profile_schema_output])
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-# NOTE: Last name is missing in output model
-#<Opera::Operation::Result:0x000055e36a1fab78 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 44, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: nil, created_at: "2018-12-17 11:07:08", updated_at: "2018-12-17 11:07:08", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Example operation with old validations
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :old_validation
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def old_validation
-    return true if context[:profile].valid?
-
-    result.add_information(missing_validations: "Please check dry validations")
-    result.add_errors(context[:profile].errors.messages)
-
-    false
-  end
-
-  def create
-    context[:profile].save
-  end
-
-  def send_email
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Call with valid parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000560ebc9e7a98 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :build_record, :old_validation, :create, :send_email, :output], @output={:model=>#<Profile id: 41, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-14 19:15:12", updated_at: "2018-12-14 19:15:12", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-#### Call with INVALID parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000560ef76ba588 @errors={:last_name=>["can't be blank"]}, @exceptions={}, @information={:missing_validations=>"Please check dry validations"}, @executions=[:build_record, :old_validation]>
-```
-
-## Example with step that raises exception
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :exception
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def exception
-    raise StandardError, 'Example'
-  end
-
-  def create
-    context[:profile] = context[:profile].save
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output(model: context[:profile])
-  end
-end
-```
-##### Call with step throwing exception
-```ruby
-result = Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000562ad0f897c8 @errors={}, @exceptions={"Profile::Create#exception"=>["Example"]}, @information={}, @executions=[:profile_schema, :build_record, :exception]>
-```
-
-## Example with step that finishes execution
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def create
-    context[:profile] = context[:profile].save
-    finish
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output(model: context[:profile])
-  end
-end
-```
-##### Call
-```ruby
-result = Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x007fc2c59a8460 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :build_record, :create]>
-```
-
-## Failing transaction
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  configure do |config|
-    config.transaction_class = Profile
-  end
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-  end
-
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(example_attr: :Example)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with non-existing attribute
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-D, [2018-12-14T16:13:30.946466 #2504] DEBUG -- :   Account Load (0.5ms)  SELECT  "accounts".* FROM "accounts" WHERE "accounts"."deleted_at" IS NULL AND "accounts"."id" = $1 LIMIT $2  [["id", 1], ["LIMIT", 1]]
-D, [2018-12-14T16:13:30.960254 #2504] DEBUG -- :    (0.2ms)  BEGIN
-D, [2018-12-14T16:13:30.983981 #2504] DEBUG -- :   SQL (0.7ms)  INSERT INTO "profiles" ("first_name", "last_name", "created_at", "updated_at", "account_id") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["first_name", "foo"], ["last_name", "bar"], ["created_at", "2018-12-14 16:13:30.982289"], ["updated_at", "2018-12-14 16:13:30.982289"], ["account_id", 1]]
-D, [2018-12-14T16:13:30.986233 #2504] DEBUG -- :    (0.2ms)  ROLLBACK
-#<Opera::Operation::Result:0x00005650e89b7708 @errors={}, @exceptions={"Profile::Create#update"=>["unknown attribute 'example_attr' for Profile."], "Profile::Create#transaction"=>["Opera::Operation::Base::RollbackTransactionError"]}, @information={}, @executions=[:profile_schema, :create, :update]>
-```
-
-## Passing transaction
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  configure do |config|
-    config.transaction_class = Profile
-  end
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-  end
-
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with updating timestamp
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-D, [2018-12-17T12:10:44.842392 #2741] DEBUG -- :   Account Load (0.7ms)  SELECT  "accounts".* FROM "accounts" WHERE "accounts"."deleted_at" IS NULL AND "accounts"."id" = $1 LIMIT $2  [["id", 1], ["LIMIT", 1]]
-D, [2018-12-17T12:10:44.856964 #2741] DEBUG -- :    (0.2ms)  BEGIN
-D, [2018-12-17T12:10:44.881332 #2741] DEBUG -- :   SQL (0.7ms)  INSERT INTO "profiles" ("first_name", "last_name", "created_at", "updated_at", "account_id") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["first_name", "foo"], ["last_name", "bar"], ["created_at", "2018-12-17 12:10:44.879684"], ["updated_at", "2018-12-17 12:10:44.879684"], ["account_id", 1]]
-D, [2018-12-17T12:10:44.886168 #2741] DEBUG -- :   SQL (0.6ms)  UPDATE "profiles" SET "updated_at" = $1 WHERE "profiles"."id" = $2  [["updated_at", "2018-12-16 12:10:44.883164"], ["id", 47]]
-D, [2018-12-17T12:10:44.898132 #2741] DEBUG -- :    (10.3ms)  COMMIT
-#<Opera::Operation::Result:0x0000556528f29058 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 47, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-17 12:10:44", updated_at: "2018-12-16 12:10:44", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Benchmark
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :update
-
-  benchmark do
-    step :send_email
-    step :output
-  end
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with information (real and total) from benchmark
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007ff414a01238 @errors={}, @exceptions={}, @information={:real=>1.800013706088066e-05, :total=>0.0}, @executions=[:profile_schema, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 30, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-19 10:46:00", updated_at: "2018-12-18 10:46:00", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Success
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  success :populate
-
-  step :create
-  step :update
-
-  success do
-    step :send_email
-    step :output
-  end
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def populate
-    context[:attributes] = {}
-    context[:valid] = false
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  # NOTE: We can add an error in this step and it won't break the execution
-  def send_email
-    result.add_error('mailer', 'Missing dependency')
-    dependencies[:mailer]&.send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with information (real and total) from benchmark
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007fd0248e5638 @errors={"mailer"=>["Missing dependency"]}, @exceptions={}, @information={}, @executions=[:profile_schema, :populate, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 40, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2019-01-03 12:21:35", updated_at: "2019-01-02 12:21:35", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Inner Operation
-
-```ruby
-class Profile::Find < Opera::Operation::Base
-  step :find
-
-  def find
-    result.output = Profile.find(params[:id])
-  end
-end
-
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  operation :find
-
-  step :create
-
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      optional(:id).filled
-    end.call(params)
-  end
-
-  def find
-    Profile::Find.call(params: params, dependencies: dependencies)
-  end
-
-  def create
-    return if context[:find_output]
-    puts 'not found'
-  end
-
-  def output
-    result.output = { model: context[:find_output] }
-  end
-end
-```
-
-#### Example with inner operation doing the find
-
-```ruby
-Profile::Create.call(params: {
-  id: 1
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007f99b25f0f20 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :find, :create, :output], @output={:model=>{:id=>1, :user_id=>1, :linkedin_uid=>nil, ...}}>
-```
-
-## Inner Operations
-Expects that method returns array of `Opera::Operation::Result`
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  step :validate
-  step :create
-
-  def validate; end
-
-  def create
-    result.output = { model: "Profile #{Kernel.rand(100)}" }
-  end
-end
-
-class Profile::CreateMultiple < Opera::Operation::Base
-  operations :create_multiple
-
-  step :output
-
-  def create_multiple
-    (0..params[:number]).map do
-      Profile::Create.call
-    end
-  end
-
-  def output
-    result.output = context[:create_multiple_output]
-  end
-end
-```
-
-```ruby
-Profile::CreateMultiple.call(params: { number: 3 })
-
-#<Opera::Operation::Result:0x0000564189f38c90 @errors={}, @exceptions={}, @information={}, @executions=[{:create_multiple=>[[:validate, :create], [:validate, :create], [:validate, :create], [:validate, :create]]}, :output], @output=[{:model=>"Profile 1"}, {:model=>"Profile 7"}, {:model=>"Profile 69"}, {:model=>"Profile 92"}]>
-```
-
-## Opera::Operation::Result - Instance Methods
-
-Sometimes it may be useful to be able to create an instance of the `Result` with preset `output`.
-It can be handy especially in specs. Then just include it in the initializer:
-
-```
-Opera::Operation::Result.new(output: 'success')
-```
-
->
-    - success? - [true, false] - Return true if no errors and no exceptions
-    - failure? - [true, false] - Return true if any error or exception
-    - output   - [Anything]    - Return Anything
-    - output=(Anything)        - Sets content of operation output
-    - add_error(key, value)    - Adds new error message
-    - add_errors(Hash)         - Adds multiple error messages
-    - add_exception(method, message, classname: nil) - Adds new exception
-    - add_exceptions(Hash)     - Adds multiple exceptions
-    - add_information(Hash)    - Adss new information - Useful informations for developers
-
-## Opera::Operation::Base - Class Methods
->
-    - step(Symbol)             - single instruction
-      - return [Truthly]       - continue operation execution
-      - return [False]         - stops operation execution
-      - raise Exception        - exception gets captured and stops operation execution
-    - operation(Symbol)        - single instruction - requires to return Opera::Operation::Result object
-      - return [Opera::Operation::Result] - stops operation STEPS execution if any error, exception
-    - validate(Symbol)         - single dry-validations - requires to return Dry::Validation::Result object
-      - return [Dry::Validation::Result] - stops operation STEPS execution if any error but continue with other validations
-    - transaction(*Symbols)    - list of instructions to be wrapped in transaction
-      - return [Truthly]       - continue operation execution
-      - return [False|Exception] - stops operation execution and breaks transaction/do rollback
-    - call(params: Hash, dependencies: Hash?)
-      - return [Opera::Operation::Result] - never raises an exception
-
-## Opera::Operation::Base - Instance Methods
->
-    - context [Hash]          - used to pass information between steps - only for internal usage
-    - params [Hash]           - immutable and received in call method
-    - dependencies [Hash]     - immutable and received in call method
-    - finish                  - this method interrupts the execution of steps after is invoked