simple-interactors 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f7ff7d77b7cbbd6cf739e8ee2e00563500748a216908263cbe74eb4ab8032b41
+  data.tar.gz: 81488ca044bd1a3061a8936949ffb9ebb2b3c203fe3bb7b51fff01a8ddf10383
+SHA512:
+  metadata.gz: 923eb61eca94d6dd0c0761f25446d820d786cec8c49190973de9cfecde23ff158ec7d751f523700ec2c7ff08d84b6cadf31608614a5d56e75ff4948eed978c05
+  data.tar.gz: 5efd10c8b01e2b8fcb137aea8402bbb0557edda3d652f91720956349eed9098789c38418142656522d673b3cf6a87a207a8ce9fc606228a653f4f2ff2f3fd80c

data/README.md

@@ -0,0 +1,53 @@
+# SimpleInteractors
+
+The Hanami::Utils (https://github.com/hanami/utils) used to include an implementation of the interactor pattern. But it no longer does, see https://github.com/hanami/utils/issues/401
+
+This gem includes the original Hanami Interactor and it is a drop by replacement. You should be able to just include this gem and continue to use Hanami::Interactor as you used to.
+
+My future goal is to create an alternative implementation of Interactor that is independent of Hanami.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple-interactors'
+```
+
+## Usage
+
+```ruby
+require 'hanami/interactor'
+
+class YourClass
+  include Hanami::Interactor
+
+  def initialize(person:, current_user:)
+    @person       = person
+    @current_user = current_user
+  end
+
+  def call
+    # do your business logic here.
+  end
+end
+```
+
+```ruby
+class PeopleController < ApplicationController
+
+  def create
+    result = YourClass.new(person: person_params, current_user: current_user).call
+
+    if result.success?
+      redirect_to :index
+    else
+      render :new
+    end
+  end
+end
+```
+
+## Copyright
+
+Copyright © 2022 Gonzalo Rodríguez-Baltanás Díaz – Released under MIT License

data/lib/hanami/interactor.rb

@@ -0,0 +1,617 @@
+require "hanami/utils/basic_object"
+require "hanami/utils/class_attribute"
+require "hanami/utils/hash"
+
+module Hanami
+  # Hanami Interactor
+  #
+  # @since 0.3.5
+  module Interactor
+    # Result of an operation
+    #
+    # @since 0.3.5
+    class Result < Utils::BasicObject
+      # Concrete methods
+      #
+      # @since 0.3.5
+      # @api private
+      #
+      # @see Hanami::Interactor::Result#respond_to_missing?
+      METHODS = ::Hash[initialize: true,
+                       success?: true,
+                       successful?: true,
+                       failure?: true,
+                       fail!: true,
+                       prepare!: true,
+                       errors: true,
+                       error: true].freeze
+
+      # Initialize a new result
+      #
+      # @param payload [Hash] a payload to carry on
+      #
+      # @return [Hanami::Interactor::Result]
+      #
+      # @since 0.3.5
+      # @api private
+      def initialize(payload = {})
+        @payload = payload
+        @errors  = []
+        @success = true
+      end
+
+      # Checks if the current status is successful
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.8.1
+      def successful?
+        @success && errors.empty?
+      end
+
+      # @since 0.3.5
+      alias_method :success?, :successful?
+
+      # Checks if the current status is not successful
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.9.2
+      def failure?
+        !successful?
+      end
+
+      # Forces the status to be a failure
+      #
+      # @since 0.3.5
+      def fail!
+        @success = false
+      end
+
+      # Returns all the errors collected during an operation
+      #
+      # @return [Array] the errors
+      #
+      # @since 0.3.5
+      #
+      # @see Hanami::Interactor::Result#error
+      # @see Hanami::Interactor#call
+      # @see Hanami::Interactor#error
+      # @see Hanami::Interactor#error!
+      def errors
+        @errors.dup
+      end
+
+      # @since 0.5.0
+      # @api private
+      def add_error(*errors)
+        @errors << errors
+        @errors.flatten!
+        nil
+      end
+
+      # Returns the first errors collected during an operation
+      #
+      # @return [nil,String] the error, if present
+      #
+      # @since 0.3.5
+      #
+      # @see Hanami::Interactor::Result#errors
+      # @see Hanami::Interactor#call
+      # @see Hanami::Interactor#error
+      # @see Hanami::Interactor#error!
+      def error
+        errors.first
+      end
+
+      # Prepares the result before to be returned
+      #
+      # @param payload [Hash] an updated payload
+      #
+      # @since 0.3.5
+      # @api private
+      def prepare!(payload)
+        @payload.merge!(payload)
+        self
+      end
+
+      protected
+
+      # @since 0.3.5
+      # @api private
+      def method_missing(method_name, *)
+        @payload.fetch(method_name) { super }
+      end
+
+      # @since 0.3.5
+      # @api private
+      def respond_to_missing?(method_name, _include_all)
+        method_name = method_name.to_sym
+        METHODS[method_name] || @payload.key?(method_name)
+      end
+
+      # @since 0.3.5
+      # @api private
+      def __inspect
+        " @success=#{@success} @payload=#{@payload.inspect}"
+      end
+    end
+
+    # Override for <tt>Module#included</tt>.
+    #
+    # @since 0.3.5
+    # @api private
+    def self.included(base)
+      super
+
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    # Interactor legacy interface
+    #
+    # @since 0.3.5
+    module LegacyInterface
+      # Initialize an interactor
+      #
+      # It accepts arbitrary number of arguments.
+      # Developers can override it.
+      #
+      # @param args [Array<Object>] arbitrary number of arguments
+      #
+      # @return [Hanami::Interactor] the interactor
+      #
+      # @since 0.3.5
+      #
+      # @example Override #initialize
+      #   require 'hanami/interactor'
+      #
+      #   class UpdateProfile
+      #     include Hanami::Interactor
+      #
+      #     def initialize(user, params)
+      #       @user   = user
+      #       @params = params
+      #     end
+      #
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      def initialize(*args, **kwargs)
+        super
+      ensure
+        @__result = ::Hanami::Interactor::Result.new
+      end
+
+      # Triggers the operation and return a result.
+      #
+      # All the instance variables will be available in the result.
+      #
+      # ATTENTION: This must be implemented by the including class.
+      #
+      # @return [Hanami::Interactor::Result] the result of the operation
+      #
+      # @raise [NoMethodError] if this isn't implemented by the including class.
+      #
+      # @example Expose instance variables in result payload
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user, :params
+      #
+      #     def initialize(params)
+      #       @params = params
+      #       @foo    = 'bar'
+      #     end
+      #
+      #     def call
+      #       @user = UserRepository.new.create(@params)
+      #     end
+      #   end
+      #
+      #   result = Signup.new(name: 'Luca').call
+      #   result.failure? # => false
+      #   result.successful? # => true
+      #
+      #   result.user   # => #<User:0x007fa311105778 @id=1 @name="Luca">
+      #   result.params # => { :name=>"Luca" }
+      #   result.foo    # => raises NoMethodError
+      #
+      # @example Failed precondition
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user
+      #
+      #     def initialize(params)
+      #       @params = params
+      #     end
+      #
+      #     # THIS WON'T BE INVOKED BECAUSE #valid? WILL RETURN false
+      #     def call
+      #       @user = UserRepository.new.create(@params)
+      #     end
+      #
+      #     private
+      #     def valid?
+      #       @params.valid?
+      #     end
+      #   end
+      #
+      #   result = Signup.new(name: nil).call
+      #   result.successful? # => false
+      #   result.failure? # => true
+      #
+      #   result.user   # => #<User:0x007fa311105778 @id=nil @name="Luca">
+      #
+      # @example Bad usage
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #
+      #     # Method #call is not defined
+      #   end
+      #
+      #   Signup.new.call # => NoMethodError
+      def call
+        _call { super }
+      end
+
+      private
+
+      # @since 0.3.5
+      # @api private
+      def _call
+        catch :fail do
+          validate!
+          yield
+        end
+
+        _prepare!
+      end
+
+      # @since 0.3.5
+      def validate!
+        fail! unless valid?
+      end
+    end
+
+    # Interactor interface
+    # @since 1.1.0
+    module Interface
+      # Triggers the operation and return a result.
+      #
+      # All the exposed instance variables will be available in the result.
+      #
+      # ATTENTION: This must be implemented by the including class.
+      #
+      # @return [Hanami::Interactor::Result] the result of the operation
+      #
+      # @raise [NoMethodError] if this isn't implemented by the including class.
+      #
+      # @example Expose instance variables in result payload
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user, :params
+      #
+      #     def call(params)
+      #       @params = params
+      #       @foo = 'bar'
+      #       @user = UserRepository.new.persist(User.new(params))
+      #     end
+      #   end
+      #
+      #   result = Signup.new(name: 'Luca').call
+      #   result.failure? # => false
+      #   result.successful? # => true
+      #
+      #   result.user   # => #<User:0x007fa311105778 @id=1 @name="Luca">
+      #   result.params # => { :name=>"Luca" }
+      #   result.foo    # => raises NoMethodError
+      #
+      # @example Failed precondition
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #     expose :user
+      #
+      #     # THIS WON'T BE INVOKED BECAUSE #valid? WILL RETURN false
+      #     def call(params)
+      #       @user = User.new(params)
+      #       @user = UserRepository.new.persist(@user)
+      #     end
+      #
+      #     private
+      #     def valid?(params)
+      #       params.valid?
+      #     end
+      #   end
+      #
+      #   result = Signup.new.call(name: nil)
+      #   result.successful? # => false
+      #   result.failure? # => true
+      #
+      #   result.user   # => nil
+      #
+      # @example Bad usage
+      #   require 'hanami/interactor'
+      #
+      #   class Signup
+      #     include Hanami::Interactor
+      #
+      #     # Method #call is not defined
+      #   end
+      #
+      #   Signup.new.call # => NoMethodError
+      def call(*args, **kwargs)
+        @__result = ::Hanami::Interactor::Result.new
+        _call(*args, **kwargs) { super }
+      end
+
+      private
+
+      # @api private
+      # @since 1.1.0
+      def _call(*args, **kwargs)
+        catch :fail do
+          validate!(*args, **kwargs)
+          yield
+        end
+
+        _prepare!
+      end
+
+      # @since 1.1.0
+      def validate!(*args, **kwargs)
+        fail! unless valid?(*args, **kwargs)
+      end
+    end
+
+    private
+
+    # Checks if proceed with <tt>#call</tt> invocation.
+    # By default it returns <tt>true</tt>.
+    #
+    # Developers can override it.
+    #
+    # @return [TrueClass,FalseClass] the result of the check
+    #
+    # @since 0.3.5
+    def valid?(*)
+      true
+    end
+
+    # Fails and interrupts the current flow.
+    #
+    # @since 0.3.5
+    #
+    # @example
+    #   require 'hanami/interactor'
+    #
+    #   class CreateEmailTest
+    #     include Hanami::Interactor
+    #
+    #     def initialize(params)
+    #       @params     = params
+    #     end
+    #
+    #     def call
+    #       persist_email_test!
+    #       capture_screenshot!
+    #     end
+    #
+    #     private
+    #     def persist_email_test!
+    #       @email_test = EmailTestRepository.new.create(@params)
+    #     end
+    #
+    #     # IF THIS RAISES AN EXCEPTION WE FORCE A FAILURE
+    #     def capture_screenshot!
+    #       Screenshot.new(@email_test).capture!
+    #     rescue
+    #       fail!
+    #     end
+    #   end
+    #
+    #   result = CreateEmailTest.new(account_id: 1).call
+    #   result.successful? # => false
+    def fail!
+      @__result.fail!
+      throw :fail
+    end
+
+    # Logs an error without interrupting the flow.
+    #
+    # When used, the returned result won't be successful.
+    #
+    # @param message [String] the error message
+    #
+    # @return false
+    #
+    # @since 0.3.5
+    #
+    # @see Hanami::Interactor#error!
+    #
+    # @example
+    #   require 'hanami/interactor'
+    #
+    #   class CreateRecord
+    #     include Hanami::Interactor
+    #     expose :logger
+    #
+    #     def initialize
+    #       @logger = []
+    #     end
+    #
+    #     def call
+    #       prepare_data!
+    #       persist!
+    #       sync!
+    #     end
+    #
+    #     private
+    #     def prepare_data!
+    #       @logger << __method__
+    #       error "Prepare data error"
+    #     end
+    #
+    #     def persist!
+    #       @logger << __method__
+    #       error "Persist error"
+    #     end
+    #
+    #     def sync!
+    #       @logger << __method__
+    #     end
+    #   end
+    #
+    #   result = CreateRecord.new.call
+    #   result.successful? # => false
+    #
+    #   result.errors # => ["Prepare data error", "Persist error"]
+    #   result.logger # => [:prepare_data!, :persist!, :sync!]
+    def error(message)
+      @__result.add_error message
+      false
+    end
+
+    # Logs an error and interrupts the flow.
+    #
+    # When used, the returned result won't be successful.
+    #
+    # @param message [String] the error message
+    #
+    # @since 0.3.5
+    #
+    # @see Hanami::Interactor#error
+    #
+    # @example
+    #   require 'hanami/interactor'
+    #
+    #   class CreateRecord
+    #     include Hanami::Interactor
+    #     expose :logger
+    #
+    #     def initialize
+    #       @logger = []
+    #     end
+    #
+    #     def call
+    #       prepare_data!
+    #       persist!
+    #       sync!
+    #     end
+    #
+    #     private
+    #     def prepare_data!
+    #       @logger << __method__
+    #       error "Prepare data error"
+    #     end
+    #
+    #     def persist!
+    #       @logger << __method__
+    #       error! "Persist error"
+    #     end
+    #
+    #     # THIS WILL NEVER BE INVOKED BECAUSE WE USE #error! IN #persist!
+    #     def sync!
+    #       @logger << __method__
+    #     end
+    #   end
+    #
+    #   result = CreateRecord.new.call
+    #   result.successful? # => false
+    #
+    #   result.errors # => ["Prepare data error", "Persist error"]
+    #   result.logger # => [:prepare_data!, :persist!]
+    def error!(message)
+      error(message)
+      fail!
+    end
+
+    # @since 0.3.5
+    # @api private
+    def _prepare!
+      @__result.prepare!(_exposures)
+    end
+
+    # @since 0.5.0
+    # @api private
+    def _exposures
+      ::Hash[].tap do |result|
+        self.class.exposures.each do |name, ivar|
+          result[name] = instance_variable_defined?(ivar) ? instance_variable_get(ivar) : nil
+        end
+      end
+    end
+  end
+
+  # @since 0.5.0
+  # @api private
+  module ClassMethods
+    # @since 0.5.0
+    # @api private
+    def self.extended(interactor)
+      interactor.class_eval do
+        include Utils::ClassAttribute
+
+        class_attribute :exposures
+        self.exposures = {}
+      end
+    end
+
+    def method_added(method_name)
+      super
+      return unless method_name == :call
+
+      if instance_method(:call).arity.zero?
+        prepend Hanami::Interactor::LegacyInterface
+      else
+        prepend Hanami::Interactor::Interface
+      end
+    end
+
+    # Exposes local instance variables into the returning value of <tt>#call</tt>
+    #
+    # @param instance_variable_names [Symbol,Array<Symbol>] one or more instance
+    #   variable names
+    #
+    # @since 0.5.0
+    #
+    # @see Hanami::Interactor::Result
+    #
+    # @example Exposes instance variable
+    #
+    #   class Signup
+    #     include Hanami::Interactor
+    #     expose :user
+    #
+    #     def initialize(params)
+    #       @params = params
+    #       @user   = User.new(@params[:user])
+    #     end
+    #
+    #     def call
+    #       # ...
+    #     end
+    #   end
+    #
+    #   result = Signup.new(user: { name: "Luca" }).call
+    #
+    #   result.user   # => #<User:0x007fa85c58ccd8 @name="Luca">
+    #   result.params # => NoMethodError
+    def expose(*instance_variable_names)
+      instance_variable_names.each do |name|
+        exposures[name.to_sym] = "@#{name}"
+      end
+    end
+  end
+end

data/lib/hanami/utils/basic_object.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Utils
+    # BasicObject
+    #
+    # @since 0.3.5
+    class BasicObject < ::BasicObject
+      # Lookups constants at the top-level namespace, if they are missing in the
+      # current context.
+      #
+      # @param name [Symbol] the constant name
+      #
+      # @return [Object, Module] the constant
+      #
+      # @raise [NameError] if the constant cannot be found
+      #
+      # @since 1.3.4
+      # @api private
+      #
+      # @see https://ruby-doc.org/core/Module.html#method-i-const_missing
+      def self.const_missing(name)
+        ::Object.const_get(name)
+      end
+
+      # Returns the class for debugging purposes.
+      #
+      # @since 0.3.5
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-class
+      def class
+        (class << self; self; end).superclass
+      end
+
+      # Bare minimum inspect for debugging purposes.
+      #
+      # @return [String] the inspect string
+      #
+      # @since 0.3.5
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-inspect
+      def inspect
+        "#<#{self.class}:#{'0x0000%x' % (__id__ << 1)}#{__inspect}>"
+      end
+
+      # @!macro [attach] instance_of?(class)
+      #
+      # Determines if self is an instance of given class or module
+      #
+      # @param class [Class,Module] the class of module to verify
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @raise [TypeError] if the given argument is not of the expected types
+      #
+      # @since 1.3.2
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-instance_of-3F
+      define_method :instance_of?, ::Object.instance_method(:instance_of?)
+
+      # @!macro [attach] is_a?(class)
+      #
+      # Determines if self is of the type of the object class or module
+      #
+      # @param class [Class,Module] the class of module to verify
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @raise [TypeError] if the given argument is not of the expected types
+      #
+      # @since 1.3.2
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-is_a-3F
+      define_method :is_a?, ::Object.instance_method(:is_a?)
+
+      # @!macro [attach] kind_of?(class)
+      #
+      # Determines if self is of the kind of the object class or module
+      #
+      # @param class [Class,Module] the class of module to verify
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @raise [TypeError] if the given argument is not of the expected types
+      #
+      # @since 1.3.2
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-kind_of-3F
+      define_method :kind_of?, ::Object.instance_method(:kind_of?)
+
+      # Alias for __id__
+      #
+      # @return [Fixnum] the object id
+      #
+      # @since 0.9.0
+      #
+      # @see http://ruby-doc.org/core/Object.html#method-i-object_id
+      def object_id
+        __id__
+      end
+
+      # Interface for pp
+      #
+      # @param printer [PP] the Pretty Printable printer
+      # @return [String] the pretty-printable inspection of the object
+      #
+      # @since 0.9.0
+      #
+      # @see https://ruby-doc.org/stdlib/libdoc/pp/rdoc/PP.html
+      def pretty_print(printer)
+        printer.text(inspect)
+      end
+
+      # Returns true if responds to the given method.
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.3.5
+      #
+      # @see http://ruby-doc.org/core-2.2.1/Object.html#method-i-respond_to-3F
+      def respond_to?(method_name, include_all = false)
+        respond_to_missing?(method_name, include_all)
+      end
+
+      private
+
+      # Must be overridden by descendants
+      #
+      # @since 0.3.5
+      # @api private
+      def respond_to_missing?(_method_name, _include_all)
+        ::Kernel.raise ::NotImplementedError
+      end
+
+      # @since 0.3.5
+      # @api private
+      def __inspect
+      end
+    end
+  end
+end

data/lib/simple-interactors/version.rb

@@ -0,0 +1,3 @@
+module SimpleInteractors
+  VERSION = "0.0.1"
+end

data/lib/simple-interactors.rb

@@ -0,0 +1,6 @@
+require "hanami/interactor"
+
+module SimpleInteractors
+  require "simple-interactors/version"
+
+end

data/simple-interactors.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("lib", __dir__)
+
+require "simple-interactors/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "simple-interactors"
+  spec.version       = SimpleInteractors::VERSION
+  spec.authors       = ["Gonzalo Rodríguez-Baltanás Díaz"]
+  spec.email         = ["siotopo@gmail.com"]
+  spec.description   = "Interactors for Ruby on Rails applications"
+  spec.summary       = "Interactors for Ruby on Rails applications"
+  spec.homepage      = "https://github.com/Nerian/simple-interactors"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md simple-interactors.gemspec`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.add_dependency "hanami-utils"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: simple-interactors
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gonzalo Rodríguez-Baltanás Díaz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hanami-utils
+  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: bundler
+  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: rake
+  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: rspec
+  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'
+description: Interactors for Ruby on Rails applications
+email:
+- siotopo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/hanami/interactor.rb
+- lib/hanami/utils/basic_object.rb
+- lib/simple-interactors.rb
+- lib/simple-interactors/version.rb
+- simple-interactors.gemspec
+homepage: https://github.com/Nerian/simple-interactors
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.11
+signing_key:
+specification_version: 4
+summary: Interactors for Ruby on Rails applications
+test_files: []