guided_interactor 1.0.3

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in guided_interactor.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    guided_interactor (1.0.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  guided_interactor!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019
+
+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,83 @@
+# Guided Interactor
+
+Guided Interactor is a spin-off from the [interactor](https://github.com/collectiveidea/interactor) gem. The Interactor 
+Design Pattern allows us to build simple, single-purpose objects that move the business logic away from controllers and 
+models. However, it also has some downsides, with the biggest pain point for me being the "Black Box Effect" 
+with `context` - you never know what goes in or what comes out.
+
+```
+# Typical interactor:
+
+class Foo
+  include Interactor
+
+  def call
+    context.message = "#{context.greeting} #{context.name.capitalize}!"
+  end
+end
+
+Foo.call(greeting: "Hello", name: "Waldo")
+=> #<Interactor::Context greeting="Hello", name="Waldo", message="Hello Waldo!">
+
+Foo.call(greeting: "Hi")
+NoMethodError: undefined method `capitalize' for nil:NilClass
+```
+
+Guided Interactor is trying to fill the gap by providing more flexibility and clarity. Previously we have agreed to use 
+`delegate :foo, to: :context` on two separate lines to define parameters expected and parameters that are set inside the 
+interactor. This gem introduces 3 additional methods: `expects`, `expects!` and `provides`:
+
+```
+class MyInteractor
+  include GuidedInteractor
+
+  expects :foo
+  expects! :bar
+  provides :waldo
+  
+  def call
+    # do smth
+  end
+
+end
+```
+
+`expects` and `provides` are aliases and simply delegate the specified parameters to the context. `expexts!` does the same,
+but adds a before hook that fails the context if any of the parameters is missing. The example above could then be rewritten
+like this:
+
+```
+# Guided interactor:
+
+class Foo
+  include GuidedInteractor
+  
+  expects :greeting
+  expects! :first_name, :last_name
+  provides :message
+
+  def call
+    context.message = "#{greeting} #{first_name.capitalize} #{last_name.capitalize}!"
+    puts message
+  end
+end
+
+Foo.call(greeting: "Hello", first_name: "Waldo", last_name: "smith")
+Hello Waldo Smith!
+=> #<GuidedInteractor::Context greeting="Hello", first_name="Waldo", last_name="smith", message="Hello Waldo Smith!">
+
+result = Foo.call(greeting: "Hi")
+=> #<GuidedInteractor::Context greeting="Hi">
+result.success?
+=> false
+
+Foo.call!(greeting: "Hi", first_name: 'John')
+GuidedInteractor::Failure: #<GuidedInteractor::Context greeting="Hi", first_name="John">
+```
+
+## Future plans
+In the future, there are plans to add further guidance to guided interactors, including more validations, defaults and error handling.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.3

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "guided_interactor"
+
+# 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/guided_interactor.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "guided_interactor/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "guided_interactor"
+  spec.version       = GuidedInteractor::VERSION
+  spec.authors       = ["Pille"]
+  spec.email         = ["pille.peri@gmail.com"]
+
+  spec.summary       = "A guided interactor"
+  spec.homepage      = "https://github.com/pillep/guided_interactor"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  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", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/guided_interactor.rb

@@ -0,0 +1,72 @@
+require 'guided_interactor/version'
+require 'guided_interactor/context'
+require 'guided_interactor/error'
+require 'guided_interactor/hooks'
+require 'guided_interactor/organizer'
+require 'guided_interactor/delegator'
+
+# Usage
+#
+#   class MyInteractor
+#     include GuidedInteractor
+#
+#     expects :foo
+#     expects! :bar, :baz
+#     provides :waldo
+#
+#     def call
+#       context.waldo = 'waldo'
+#       puts foo
+#       puts waldo
+#     end
+#   end
+module GuidedInteractor
+
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      include Hooks
+      include Delegator
+
+      attr_reader :context
+    end
+  end
+
+  module ClassMethods
+
+    def call(context = {})
+      new(context).tap(&:run).context
+    end
+
+    def call!(context = {})
+      new(context).tap(&:run!).context
+    end
+
+  end
+
+  def initialize(context = {})
+    @context = Context.build(context)
+  end
+
+  def run
+    run!
+  rescue Failure
+  end
+
+  def run!
+    with_hooks do
+      call
+      context.called!(self)
+    end
+  rescue StandardError
+    context.rollback!
+    raise
+  end
+
+  def call
+  end
+
+  def rollback
+  end
+
+end

data/lib/guided_interactor/context.rb

@@ -0,0 +1,40 @@
+require 'ostruct'
+
+module GuidedInteractor
+  class Context < OpenStruct
+
+    def self.build(context = {})
+      self === context ? context : new(context)
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      @failure || false
+    end
+
+    def fail!(context = {})
+      context.each { |key, value| modifiable[key.to_sym] = value }
+      @failure = true
+      raise Failure, self
+    end
+
+    def called!(interactor)
+      _called << interactor
+    end
+
+    def rollback!
+      return false if @rolled_back
+
+      _called.reverse_each(&:rollback)
+      @rolled_back = true
+    end
+
+    def _called
+      @called ||= []
+    end
+
+  end
+end

data/lib/guided_interactor/delegator.rb

@@ -0,0 +1,36 @@
+module GuidedInteractor
+  module Delegator
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      def expects(*params)
+        params.each do |param|
+          define_method param do
+            context.public_send(param)
+          end
+          private param
+        end
+      end
+
+      def expects!(*params)
+        expects(*params)
+
+        before do
+          params.each do |param|
+            context.fail! if context.public_send(param).nil?
+          end
+        end
+      end
+
+      alias_method :provides, :expects
+
+    end
+
+  end
+end

data/lib/guided_interactor/error.rb

@@ -0,0 +1,12 @@
+module GuidedInteractor
+  class Failure < StandardError
+
+    attr_reader :context
+
+    def initialize(context = nil)
+      @context = context
+      super
+    end
+
+  end
+end

data/lib/guided_interactor/hooks.rb

@@ -0,0 +1,74 @@
+module GuidedInteractor
+  module Hooks
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      def around(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| around_hooks.push(hook) }
+      end
+
+      def before(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| before_hooks.push(hook) }
+      end
+
+      def after(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| after_hooks.unshift(hook) }
+      end
+
+      def around_hooks
+        @around_hooks ||= []
+      end
+
+      def before_hooks
+        @before_hooks ||= []
+      end
+
+      def after_hooks
+        @after_hooks ||= []
+      end
+
+    end
+
+    private
+
+      def with_hooks
+        run_around_hooks do
+          run_before_hooks
+          yield
+          run_after_hooks
+        end
+      end
+
+      def run_around_hooks(&block)
+        self.class.around_hooks.reverse.reduce(block) do |chain, hook|
+          proc { run_hook(hook, chain) }
+        end.call
+      end
+
+      def run_before_hooks
+        run_hooks(self.class.before_hooks)
+      end
+
+      def run_after_hooks
+        run_hooks(self.class.after_hooks)
+      end
+
+      def run_hooks(hooks)
+        hooks.each { |hook| run_hook(hook) }
+      end
+
+      def run_hook(hook, *args)
+        hook.is_a?(Symbol) ? send(hook, *args) : instance_exec(*args, &hook)
+      end
+
+  end
+end