interactify 0.3.0.pre.alpha.1 → 0.4.0

data/lib/interactify/jobable.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/job_maker"
-
-module Interactify
-  module Jobable
-    extend ActiveSupport::Concern
-
-    # e.g. if Klass < Base
-    # and Base has a Base::Job class
-    #
-    # then let's make sure to define Klass::Job separately
-    included do |base|
-      def base.inherited(klass)
-        super_klass = klass.superclass
-        super_job = super_klass::Job # really spiffing
-
-        opts = super_job::JOBABLE_OPTS
-        jobable_method_name = super_job::JOBABLE_METHOD_NAME
-
-        to_call = defined?(super_klass::Async) ? :interactor_job : :job_calling
-
-        klass.send(to_call, opts:, method_name: jobable_method_name)
-        super(klass)
-      end
-    end
-
-    class_methods do
-      # create a Job class and an Async class
-      # see job_calling for details on the Job class
-      #
-      # the Async class is a wrapper around the Job class
-      # that allows it to be used in an interactor chain
-      #
-      # E.g.
-      #
-      # class ExampleInteractor
-      #   include Interactify
-      #   expect :foo
-      #
-      #   include Jobable
-      #   interactor_job
-      # end
-      #
-      # doing the following will immediately enqueue a job
-      # that calls the interactor ExampleInteractor with (foo: 'bar')
-      # ExampleInteractor::Async.call(foo: 'bar')
-      #
-      # it will also ensure to pluck only the expects from the context
-      # so that you can have other non primitive values in the context
-      # but the job will only have the expects passed to it
-      #
-      # obviously you will need to be aware that later interactors
-      # in an interactor chain cannot depend on the result of the async
-      # interactor
-      def interactor_job(method_name: :call!, opts: {}, klass_suffix: "")
-        job_maker = JobMaker.new(container_klass: self, opts:, method_name:, klass_suffix:)
-        # with WhateverInteractor::Job you can perform the interactor as a job
-        # from sidekiq
-        # e.g. WhateverInteractor::Job.perform_async(...)
-        const_set("Job#{klass_suffix}", job_maker.job_klass)
-
-        # with WhateverInteractor::Async you can call WhateverInteractor::Job
-        # in an organizer oro on its oen using normal interactor call call! semantics
-        # e.g. WhateverInteractor::Async.call(...)
-        #      WhateverInteractor::Async.call!(...)
-        const_set("Async#{klass_suffix}", job_maker.async_job_klass)
-      end
-
-      # if this was defined in ExampleClass this creates the following class
-      # ExampleClass::Job
-      # this class ia added as a convenience so you can easily turn a
-      # class method into a job
-      #
-      # Example:
-      #
-      # class ExampleClass
-      #   include Jobable
-      #   job_calling method_name: :some_method
-      # end
-      #
-      # # the following class is created that you can use to enqueue a job
-      # in the sidekiq yaml file
-      # ExampleClass::Job.some_method
-      def job_calling(method_name:, opts: {}, klass_suffix: "")
-        job_maker = JobMaker.new(container_klass: self, opts:, method_name:, klass_suffix:)
-
-        const_set("Job#{klass_suffix}", job_maker.job_klass)
-      end
-    end
-  end
-end

data/lib/interactify/mismatching_promise_error.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/contract_failure"
-
-module Interactify
-  class MismatchingPromiseError < ContractFailure
-    def initialize(interactor, promising, promised_keys)
-      super <<~MESSAGE.chomp
-        #{interactor} does not promise:
-        #{promising.inspect}
-
-        Actual promises are:
-        #{promised_keys.inspect}
-      MESSAGE
-    end
-  end
-end

data/lib/interactify/organizer.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/interactor_wrapper"
-
-module Interactify
-  module Organizer
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def organize(*interactors)
-        wrapped = InteractorWrapper.wrap_many(self, interactors)
-
-        super(*wrapped)
-      end
-    end
-
-    def call
-      self.class.organized.each do |interactor|
-        instance = interactor.new(context)
-
-        instance.instance_variable_set(
-          :@_interactor_called_by_non_bang_method,
-          @_interactor_called_by_non_bang_method
-        )
-
-        instance.tap(&:run!)
-      end
-    end
-  end
-end

data/lib/interactify/promising.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/mismatching_promise_error"
-
-module Interactify
-  class Promising
-    attr_reader :interactor, :promising
-
-    def self.validate(interactor, *promising)
-      new(interactor, *promising).validate
-
-      interactor
-    end
-
-    def initialize(interactor, *promising)
-      @interactor = interactor
-      @promising = format_keys promising
-    end
-
-    def validate
-      return if promising == promised_keys
-
-      raise MismatchingPromiseError.new(interactor, promising, promised_keys)
-    end
-
-    def promised_keys
-      format_keys interactor.promised_keys
-    end
-
-    def format_keys(keys)
-      Array(keys).compact.map(&:to_sym).sort
-    end
-  end
-end

data/lib/interactify/rspec/matchers.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "interactify/interactor_wiring"
-
-# Custom matcher that implements expect_inputs
-# e.g.
-# expect(described_class).to expect_inputs(:connection, :order)
-
-RSpec::Matchers.define :expect_inputs do |*expected_inputs|
-  match do |actual|
-    next false unless actual.respond_to?(:expected_keys)
-
-    actual_inputs = Array(actual.expected_keys)
-    @missing_inputs = expected_inputs - actual_inputs
-    @extra_inputs = actual_inputs - expected_inputs
-
-    @missing_inputs.empty? && @extra_inputs.empty?
-  end
-
-  failure_message do |actual|
-    message = "expected #{actual} to expect inputs #{expected_inputs.inspect}"
-    message += "\n\tmissing inputs: #{@missing_inputs}" if @missing_inputs
-    message += "\n\textra inputs: #{@extra_inputs}" if @extra_inputs
-    message
-  end
-end
-
-# Custom matcher that implements promise_outputs
-# e.g. expect(described_class).to promise_outputs(:request_logger)
-RSpec::Matchers.define :promise_outputs do |*expected_outputs|
-  match do |actual|
-    next false unless actual.respond_to?(:promised_keys)
-
-    actual_outputs = Array(actual.promised_keys)
-    @missing_outputs = expected_outputs - actual_outputs
-    @extra_outputs = actual_outputs - expected_outputs
-
-    @missing_outputs.empty? && @extra_outputs.empty?
-  end
-
-  failure_message do |actual|
-    message = "expected #{actual} to promise outputs #{expected_outputs.inspect}"
-    message += "\n\tmissing outputs: #{@missing_outputs}" if @missing_outputs
-    message += "\n\textra outputs: #{@extra_outputs}" if @extra_outputs
-    message
-  end
-end
-
-# Custom matcher that implements organize_interactors
-#
-# e.g. expect(described_class).to organize_interactors(SeparateIntoPackages, SendPackagesToSeko)
-RSpec::Matchers.define :organize_interactors do |*expected_interactors|
-  match do |actual|
-    actual_interactors = actual.organized
-    @missing_interactors = expected_interactors - actual_interactors
-    @extra_interactors = actual_interactors - expected_interactors
-
-    @missing_interactors.empty? && @extra_interactors.empty?
-  end
-
-  failure_message do |actual|
-    message = "expected #{actual} to organize interactors #{expected_interactors.inspect}"
-    message += "\n\tmissing interactors: #{@missing_interactors}" if @missing_interactors
-    message += "\n\textra interactors: #{@extra_interactors}" if @extra_interactors
-    message
-  end
-end

data/lib/interactify/unique_klass_name.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Interactify
-  module UniqueKlassName
-    def self.for(namespace, prefix)
-      id = generate_unique_id
-      klass_name = :"#{prefix}#{id}"
-
-      while namespace.const_defined?(klass_name)
-        id = generate_unique_id
-        klass_name = :"#{prefix}#{id}"
-      end
-
-      klass_name.to_sym
-    end
-
-    def self.generate_unique_id
-      rand(10_000)
-    end
-  end
-end