decouplio 1.0.0alpha

data/benchmarks/benchmarks.rb

@@ -0,0 +1,527 @@
+# frozen_string_literal: true
+
+require 'active_interaction'
+require 'interactor'
+require 'mutations'
+require 'trailblazer'
+require_relative '../lib/decouplio'
+require 'pry'
+require 'benchmark'
+require 'ruby-prof'
+
+class MutationTest < Mutations::Command
+  required do
+    string :param1
+  end
+
+  def execute
+    @param1 = 'param1'
+    @context = {}
+    step_one
+    step_two
+    step_three
+    step_four
+    step_five
+    step_six
+    step_seven
+    step_eight
+    step_nine
+
+    @context
+  end
+
+  def step_one
+    @context[:step_one] = @param1
+  end
+
+  def step_two
+    @context[:step_two] = @context[:step_one]
+  end
+
+  def step_three
+    @context[:step_three] = @context[:step_two]
+  end
+
+  def step_four
+    @context[:step_four] = @context[:step_three]
+  end
+
+  def step_five
+    @context[:step_five] = @context[:step_four]
+  end
+
+  def step_six
+    @context[:step_six] = @context[:step_five]
+  end
+
+  def step_seven
+    @context[:step_seven] = @context[:step_six]
+  end
+
+  def step_eight
+    @context[:step_eight] = @context[:step_seven]
+  end
+
+  def step_nine
+    @context[:step_nine] = @context[:step_eight]
+  end
+end
+
+class ActiveInteractionTest < ActiveInteraction::Base
+  string :param1
+
+  def execute
+    @context = {}
+    step_one
+    step_two
+    step_three
+    step_four
+    step_five
+    step_six
+    step_seven
+    step_eight
+    step_nine
+
+    @context
+  end
+
+  def step_one
+    @context[:step_one] = param1
+  end
+
+  def step_two
+    @context[:step_two] = @context[:step_one]
+  end
+
+  def step_three
+    @context[:step_three] = @context[:step_two]
+  end
+
+  def step_four
+    @context[:step_four] = @context[:step_three]
+  end
+
+  def step_five
+    @context[:step_five] = @context[:step_four]
+  end
+
+  def step_six
+    @context[:step_six] = @context[:step_five]
+  end
+
+  def step_seven
+    @context[:step_seven] = @context[:step_six]
+  end
+
+  def step_eight
+    @context[:step_eight] = @context[:step_seven]
+  end
+
+  def step_nine
+    @context[:step_nine] = @context[:step_eight]
+  end
+end
+
+class DecouplioTestSeveralSteps < Decouplio::Action
+  logic do
+    step :step_one
+    step :step_two
+    step :step_three
+    step :step_four
+    step :step_five
+    step :step_six
+    step :step_seven
+    step :step_eight
+    step :step_nine
+  end
+
+  def step_one(param1:, **)
+    ctx[:step_one] = param1
+  end
+
+  def step_two(step_one:, **)
+    ctx[:step_two] = step_one
+  end
+
+  def step_three(step_two:, **)
+    ctx[:step_three] = step_two
+  end
+
+  def step_four(step_three:, **)
+    ctx[:step_four] = step_three
+  end
+
+  def step_five(step_four:, **)
+    ctx[:step_five] = step_four
+  end
+
+  def step_six(step_five:, **)
+    ctx[:step_six] = step_five
+  end
+
+  def step_seven(step_six:, **)
+    ctx[:step_seven] = step_six
+  end
+
+  def step_eight(step_seven:, **)
+    ctx[:step_eight] = step_seven
+  end
+
+  def step_nine(step_eight:, **)
+    ctx[:step_nine] = step_eight
+  end
+end
+
+class DecouplioTestOneStep < Decouplio::Action
+  logic do
+    step :step_one
+  end
+
+  def step_one(param1:, **)
+    ctx[:step_one] = param1
+    ctx[:step_two] = ctx[:step_one]
+    ctx[:step_three] = ctx[:step_two]
+    ctx[:step_four] = ctx[:step_three]
+    ctx[:step_five] = ctx[:step_four]
+    ctx[:step_six] = ctx[:step_five]
+    ctx[:step_seven] = ctx[:step_six]
+    ctx[:step_eight] = ctx[:step_seven]
+    ctx[:step_nine] = ctx[:step_eight]
+  end
+end
+
+class StepOne
+  include Interactor
+
+  def call
+    context.step_one = context.param1
+  end
+end
+
+class StepTwo
+  include Interactor
+
+  def call
+    context.step_two = context.step_one
+  end
+end
+
+class StepThree
+  include Interactor
+
+  def call
+    context.step_three = context.step_two
+  end
+end
+
+class StepFour
+  include Interactor
+
+  def call
+    context.step_four = context.step_three
+  end
+end
+
+class StepFive
+  include Interactor
+
+  def call
+    context.step_five = context.step_four
+  end
+end
+
+class StepSix
+  include Interactor
+
+  def call
+    context.step_six = context.step_five
+  end
+end
+
+class StepSeven
+  include Interactor
+
+  def call
+    context.step_seven = context.step_six
+  end
+end
+
+class StepEight
+  include Interactor
+
+  def call
+    context.step_eight = context.step_seven
+  end
+end
+
+class StepNine
+  include Interactor
+
+  def call
+    context.step_nine = context.step_eight
+  end
+end
+
+class InteractorTestOrganizer
+  include Interactor::Organizer
+
+  organize StepOne,
+           StepTwo,
+           StepThree,
+           StepFour,
+           StepFive,
+           StepSix,
+           StepSeven,
+           StepEight,
+           StepNine
+end
+
+class InteractorWithoutOrganizer
+  include Interactor
+
+  def call
+    step_one
+    step_two
+    step_three
+    step_four
+    step_five
+    step_six
+    step_seven
+    step_eight
+    step_nine
+  end
+
+  def step_one
+    context.step_one = context.param1
+  end
+
+  def step_two
+    context.step_two = context.step_one
+  end
+
+  def step_three
+    context.step_three = context.step_two
+  end
+
+  def step_four
+    context.step_four = context.step_three
+  end
+
+  def step_five
+    context.step_five = context.step_four
+  end
+
+  def step_six
+    context.step_six = context.step_five
+  end
+
+  def step_seven
+    context.step_seven = context.step_six
+  end
+
+  def step_eight
+    context.step_eight = context.step_seven
+  end
+
+  def step_nine
+    context.step_nine = context.step_eight
+  end
+end
+
+class RegularServiceTest
+  attr_accessor :ctx, :param1
+
+  def self.call(param1:)
+    new(param1: param1).call
+  end
+
+  def initialize(param1:)
+    @param1 = param1
+    @ctx = {}
+  end
+
+  def call
+    step_one
+    step_two
+    step_three
+    step_four
+    step_five
+    step_six
+    step_seven
+    step_eight
+    step_nine
+  end
+
+  def step_one
+    ctx[:step_one] = param1
+  end
+
+  def step_two
+    ctx[:step_two] = ctx[:step_one]
+  end
+
+  def step_three
+    ctx[:step_three] = ctx[:step_two]
+  end
+
+  def step_four
+    ctx[:step_four] = ctx[:step_three]
+  end
+
+  def step_five
+    ctx[:step_five] = ctx[:step_four]
+  end
+
+  def step_six
+    ctx[:step_six] = ctx[:step_five]
+  end
+
+  def step_seven
+    ctx[:step_seven] = ctx[:step_six]
+  end
+
+  def step_eight
+    ctx[:step_eight] = ctx[:step_seven]
+  end
+
+  def step_nine
+    ctx[:step_nine] = ctx[:step_eight]
+  end
+end
+
+class TrailblazerTestSeveralSteps < Trailblazer::Activity::Railway
+  step :step_one
+  step :step_two
+  step :step_three
+  step :step_four
+  step :step_five
+  step :step_six
+  step :step_seven
+  step :step_eight
+  step :step_nine
+
+  def step_one(ctx, param1:, **)
+    ctx[:step_one] = param1
+  end
+
+  def step_two(ctx, step_one:, **)
+    ctx[:step_two] = step_one
+  end
+
+  def step_three(ctx, step_two:, **)
+    ctx[:step_three] = step_two
+  end
+
+  def step_four(ctx, step_three:, **)
+    ctx[:step_four] = step_three
+  end
+
+  def step_five(ctx, step_four:, **)
+    ctx[:step_five] = step_four
+  end
+
+  def step_six(ctx, step_five:, **)
+    ctx[:step_six] = step_five
+  end
+
+  def step_seven(ctx, step_six:, **)
+    ctx[:step_seven] = step_six
+  end
+
+  def step_eight(ctx, step_seven:, **)
+    ctx[:step_eight] = step_seven
+  end
+
+  def step_nine(ctx, step_eight:, **)
+    ctx[:step_nine] = step_eight
+  end
+end
+
+class TrailblazerTestOneStep < Trailblazer::Activity::Railway
+  step :step_one
+
+  def step_one(ctx, param1:, **)
+    ctx[:step_one] = param1
+    ctx[:step_two] = ctx[:step_one]
+    ctx[:step_three] = ctx[:step_two]
+    ctx[:step_four] = ctx[:step_three]
+    ctx[:step_five] = ctx[:step_four]
+    ctx[:step_six] = ctx[:step_five]
+    ctx[:step_seven] = ctx[:step_six]
+    ctx[:step_eight] = ctx[:step_seven]
+    ctx[:step_nine] = ctx[:step_eight]
+  end
+end
+
+iteration_count = 1_000_000
+
+# result = RubyProf.profile do
+#   iteration_count.times { InteractorTestOrganizer.call(param1: 'param1') }
+# end
+
+# class Two
+#   def initialize
+#     @ctx = {}
+#   end
+
+#   def one
+#     @ctx[:one] = 'one'
+#   end
+
+#   def two
+#     @ctx[:two] = @ctx[:one]
+#   end
+
+#   def three
+#     @ctx[:three] = @ctx[:two]
+#   end
+# end
+
+# instance = Two.new
+
+# Benchmark.bmbm do |x|
+#   x.report("PublicSend") { iteration_count.times { instance.public_send(:one) } }
+#   x.report("Send") { iteration_count.times { instance.send(:one) } }
+#   x.report("call instance method") { iteration_count.times { instance.one } }
+# end
+
+# array_one = []
+# array_two = []
+
+# Benchmark.bmbm do |x|
+#   x.report("<<") { iteration_count.times { array_one << 1 } }
+#   x.report("push") { iteration_count.times { array_two << 1 } }
+# end
+
+# result = RubyProf.profile do
+# iteration_count.times { DecouplioTest.call(param1: 'param1') }
+# end
+# result = RubyProf.profile do
+#   iteration_count.times { RegularServiceTest.call(param1: 'param1') }
+# end
+# result = RubyProf.profile do
+#   iteration_count.times { TrailblazerTest.call(param1: 'param1') }
+# end
+# result = RubyProf.profile do
+#   iteration_count.times { ActiveInteractionTest.run(param1: 'param1') }
+# end
+# result = RubyProf.profile do
+#   iteration_count.times { MutationTest.run(param1: 'param1') }
+# end
+
+# printer = RubyProf::GraphPrinter.new(result)
+# printer.print(STDOUT, {})
+
+Benchmark.bmbm do |x|
+  x.report('RegularService') { iteration_count.times { RegularServiceTest.call(param1: 'param1') } }
+  x.report('Mutation') { iteration_count.times { MutationTest.run(param1: 'param1') } }
+  x.report('ActiveInteraction') { iteration_count.times { ActiveInteractionTest.run(param1: 'param1') } }
+  x.report('Trailblazer one step') { iteration_count.times { TrailblazerTestOneStep.call(param1: 'param1') } }
+  x.report('Interactor one interactor') { iteration_count.times { InteractorWithoutOrganizer.call(param1: 'param1') } }
+  x.report('Decouplio one step') { iteration_count.times { DecouplioTestOneStep.call(param1: 'param1') } }
+  x.report('Trailblazer several steps') { iteration_count.times { TrailblazerTestSeveralSteps.call(param1: 'param1') } }
+  x.report('Interactor several interactions with organizer') do
+    iteration_count.times { InteractorTestOrganizer.call(param1: 'param1') }
+  end
+  x.report('Decouplio several steps') { iteration_count.times { DecouplioTestSeveralSteps.call(param1: 'param1') } }
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'decouplio'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/decouplio.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'decouplio/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'decouplio'
+  spec.version       = Decouplio::VERSION
+  spec.authors       = ['Alex Bal']
+  spec.email         = ['differencialx@gmail.com']
+
+  spec.summary       = 'Gem for business logic encapsulation'
+  spec.description   = "Decouplio is a zero dependency, thread safe and framework agnostic gem designed to encapsulate application business logic. It's reverse engineered through TDD and inspired by such frameworks and gems like Trailblazer, Interactor."
+  spec.homepage      = 'http://nohomepage.com'
+  spec.license       = 'MIT'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/differencialx/decouplio'
+    spec.metadata['changelog_uri'] = 'https://github.com/differencialx/decouplio/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '>= 12.3.2'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+end

data/docker-compose.yml

@@ -0,0 +1,18 @@
+version: "3.7"
+
+services:
+  benchmark:
+    build:
+      dockerfile: benchmarks/Dockerfile
+      context: .
+    command: "ruby benchmarks.rb"
+    deploy:
+      resources:
+        limits:
+          cpus: '1'
+          memory: 400M
+  test:
+    build:
+      dockerfile: Dockerfile
+      context: .
+    command: "rspec"

data/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

data/docs/benchmarks.md

@@ -0,0 +1 @@
+## Benchmarks

data/docs/context.md

@@ -0,0 +1,74 @@
+# Context
+
+Currently context is a simple `Hash` which can be accessed by step methods.
+
+```ruby
+require 'decouplio'
+
+class SomeAction < Decouplio::Action
+  logic do
+    step :step_one
+    step :step_two
+  end
+
+  def step_one(**)
+    ctx[:step_one] = 'Step one ctx value'
+  end
+
+  # step method receives ctx as an argument
+  def step_two(step_one:, **)
+    ctx[:step_two] = step_one
+  end
+end
+
+action = SomeAction.call
+
+action # =>
+# Result: success
+
+# Railway Flow:
+#   step_one -> step_two
+
+# Context:
+#   {:step_one=>"Step one ctx value", :step_two=>"Step one ctx value"}
+
+# Errors:
+#   {}
+```
+
+All key values passed into `call` method will be automatically assigned to action context.
+
+```ruby
+require 'decouplio'
+
+class SomeActionCtx < Decouplio::Action
+  logic do
+    step :step_one
+  end
+
+  def step_one(**)
+    puts ctx
+    ctx[:result] = ctx[:one] + ctx[:two]
+  end
+end
+
+action = SomeActionCtx.call(
+  one: 1,
+  two: 2
+) # =>
+# {:one=>1, :two=>2}
+
+action[:result] # => 3
+
+action # =>
+# Result: success
+
+# Railway Flow:
+#   step_one
+
+# Context:
+#   {:one=>1, :two=>2, :result=>3}
+
+# Errors:
+#   {}
+```