active_operation 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af093d7762abf6f9113d7886eef00e829cef071a
-  data.tar.gz: 07b3bf0cde1c490de17b16c3d93fc16e9d0bd14a
+  metadata.gz: eead73f1ad502fdd329a6cd5ae6acc20306472df
+  data.tar.gz: c4adb13fbb34e04cf4895175babc9d458ff8c6bc
 SHA512:
-  metadata.gz: c8508ccc57a478db664e57e576bbaaa0be53d32ed625314a324b8559d49fa98df406759bb5ee3914b3d7f43ca958e43520f41da265a91021f2490fdea89e981c
-  data.tar.gz: 73c32d9434395e5e3d6d4b667b6c2fe6e621efb10e31cfdea5559380efedd0f901e3d422d4109d7197dc53c928b424a402d37f22a1ec6a5962dde0d08d34b8f6
+  metadata.gz: 32c999e6bd87a939c985ea696250cf00de302fe0b7749edb07339381e1a543c4baaa54bc10b3101b0215f34f9955e9bf13d555ac581a693d276f029015ad0d82
+  data.tar.gz: ac35417f23a2a4321e11869b3c95f8a0120da18cf4b71cbae7ad22494d3eb04b8638f2d119cdaa960cb25c84de908bc63a9a3fb4b9eba736e0b385ecd8afb6fe

data/README.md

@@ -26,6 +26,20 @@ Or install it yourself as:
 $ gem install active_operation
 ```
 
+### Rails
+
+We recommend running the install generator to initialize a base operation:
+
+```
+rails g active_operation:install
+```
+
+You can also generate new operations using:
+
+```
+rails g active_operation:operation Signup
+```
+
 ## Usage
 
 To define an operation, create a new class and inherit from `ActiveOperation::Base`.

data/lib/active_operation.rb

@@ -1,4 +1,5 @@
 require "active_support/callbacks"
+require "delegate"
 require "smart_properties"
 
 module ActiveOperation
@@ -6,6 +7,9 @@ module ActiveOperation
   class AlreadyCompletedError < Error; end
 end
 
-require "active_operation/version"
-require "active_operation/input"
-require "active_operation/base"
+require_relative "active_operation/version"
+require_relative "active_operation/input"
+require_relative "active_operation/base"
+require_relative "active_operation/pipeline"
+
+require_relative "active_operation/matcher" if defined?(::RSpec)

data/lib/active_operation/base.rb

@@ -1,3 +1,5 @@
+require 'active_support/callbacks'
+
 class ActiveOperation::Base
   include SmartProperties
   include ActiveSupport::Callbacks
@@ -14,14 +16,24 @@ class ActiveOperation::Base
   define_callbacks :halted, scope: [:name]
 
   class << self
-    def call(*args)
+    def perform(*args)
       new(*args).call
     end
 
+    def call(*args)
+      perform(*args)
+    end
+
     def inputs
       []
     end
 
+    def to_proc
+      ->(*args) {
+        perform(*args)
+      }
+    end
+
     protected
 
     def input(name, type: :positional, **configuration)
@@ -70,6 +82,8 @@ class ActiveOperation::Base
     end
 
     def inherited(subclass)
+      super
+
       subclass.define_singleton_method(:inputs) do
         superclass.inputs + Array(@inputs)
       end
@@ -82,19 +96,21 @@ class ActiveOperation::Base
     end
   end
 
-  def initialize(*positional_arguments, **keyword_arguments)
-    expected_positional_arguments = self.class.inputs.select(&:positional?)
+  def initialize(*args)
+    arity = self.class.inputs.count(&:positional?)
+    arguments = args.shift(arity)
+    attributes = args.last.kind_of?(Hash) ? args.pop : {}
+
+    raise ArgumentError, "wrong number of arguments #{arguments.length + args.length} for #{arity}" unless args.empty?
 
-    raise ArgumentError, "wrong number of arguments" if positional_arguments.length != expected_positional_arguments.length
+    self.class.inputs.select(&:positional?).each_with_index do |input, index|
+      attributes[input.name] = arguments[index]
+    end
 
-    super(
-      keyword_arguments.merge(
-        expected_positional_arguments.zip(positional_arguments).map { |input, value| [input.name, value] }.to_h
-      )
-    )
+    super(attributes)
   end
 
-  def call
+  def perform
     run_callbacks :execute do
       catch(:abort) do
         next if completed?
@@ -114,6 +130,10 @@ class ActiveOperation::Base
     raise
   end
 
+  def call
+    perform
+  end
+
   def output
     call unless self.completed?
     @output

data/lib/active_operation/matcher.rb

@@ -0,0 +1,3 @@
+require_relative 'matcher/execution'
+require_relative 'matcher/utilize_operation'
+

data/lib/active_operation/matcher/execution.rb

@@ -0,0 +1,166 @@
+module ActiveOperation
+  module Matcher
+    module Execution
+      class Base
+        def and_return(result)
+          @result = result
+          self
+        end
+
+        def when_initialized_with(*input)
+          @input = input
+          self
+        end
+
+        def failure_message
+          raise NotImplementedError, "Expected #{self.class} to implement ##{__callee__}"
+        end
+
+        def failure_message_when_negated
+          raise NotImplementedError, "Expected #{self.class} to implement ##{__callee__}"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        protected
+
+        attr_reader :operation
+        attr_reader :message
+        attr_reader :result
+        attr_reader :input
+
+        def operation=(operation)
+          operation = operation.new(*input) if operation.kind_of?(Class)
+          operation.perform
+          @operation = operation
+        end
+
+        def succeeded?
+          operation.succeeded?
+        end
+
+        def halted?
+          operation.halted?
+        end
+
+        def result_as_expected?
+          return true unless result
+          operation.output == result
+        end
+
+        def message_as_expected?
+          return true unless message
+          operation.message == message
+        end
+
+        def input_as_text
+          humanize(*input)
+        end
+
+        def result_as_text
+          humanize(result)
+        end
+
+        private
+
+        def humanize(*args)
+          args = args.map(&:inspect)
+          last_element = args.pop
+          args.length > 0 ? [args.join(", "), last_element].join(" and ") : last_element
+        end
+      end
+
+      class SucceedToPerform < Base
+        def matches?(operation)
+          self.operation = operation
+          succeeded? && result_as_expected?
+        end
+
+        def description
+          description = "succeed to perform"
+          description += " when initialized with custom input (#{input_as_text})" if input
+          description += " and return the expected result (#{result_as_text})" if result
+          description
+        end
+
+        def failure_message
+          "the operation failed to perform for the following reason(s):\n#{failure_reasons}"
+        end
+
+        def failure_message_when_negated
+          "the operation succeeded unexpectedly"
+        end
+
+        private
+
+        def failure_reasons
+          reasons = []
+          reasons << "it did not succeed at all" unless succeeded?
+          unless result_as_expected?
+            reasons << [
+              "it did not return the expected result",
+              "Expected: #{result.inspect}",
+              "Got: #{operation.result.inspect}"
+            ].join("\n\t  ")
+          end
+          reasons.map { |r| "\t- #{r}" }.join("\n")
+        end
+      end
+
+      class HaltWhilePerforming < Base
+        def matches?(operation)
+          self.operation = operation
+          halted? && result_as_expected? && message_as_expected?
+        end
+
+        def because(message)
+          @message = message
+          self
+        end
+
+        def description
+          description = "halt while performing"
+          description += " because #{message}" if message
+          description += " when initialized with custom input (#{input_as_text})" if input
+          description += " and return the expected result (#{result_as_text})" if result
+          description
+        end
+
+        def failure_message
+          "the operation did not halt while performing for the following reason(s):\n#{failure_reasons}"
+        end
+
+        def failure_message_when_negated
+          "the operation was halted unexpectedly"
+        end
+
+        protected
+
+        def failure_reasons
+          reasons = []
+          reasons << "it did not halt at all" unless halted?
+          reasons << "its message was not as expected" unless message_as_expected?
+          unless result_as_expected?
+            reasons << [
+              "it did not return the expected result",
+              "Expected: #{result.inspect}",
+              "Got: #{operation.result.inspect}"
+            ].join("\n\t  ")
+          end
+          reasons.map { |r| "\t- #{r}" }.join("\n")
+        end
+      end
+
+      def succeed_to_perform
+        SucceedToPerform.new
+      end
+
+      def halt_while_performing
+        HaltWhilePerforming.new
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ActiveOperation::Matcher::Execution
+end

data/lib/active_operation/matcher/utilize_operation.rb

@@ -0,0 +1,90 @@
+module ActiveOperation
+  module Matcher
+    module UtilizeOperation
+
+      class DummyOperation
+        def initialize(*args)
+        end
+
+        def halted?
+          false
+        end
+
+        def succeeded?
+          true
+        end
+
+        def output
+          Object.new
+        end
+
+        def perform
+          output
+        end
+      end
+
+      class Matcher
+        include RSpec::Mocks::ExampleMethods
+
+        attr_reader :composite_operations
+        attr_reader :tested_operation
+        attr_reader :tested_instance
+
+        def initialize(*composite_operations)
+          @composite_operations = composite_operations.flatten
+        end
+
+        def matches?(class_or_instance)
+          if class_or_instance.is_a?(Class)
+            @tested_operation = class_or_instance
+            @tested_instance = class_or_instance.new
+          else
+            @tested_operation = class_or_instance.class
+            @tested_instance = class_or_instance
+          end
+
+          allow(Base).to receive(:new).and_return(DummyOperation.new)
+          composite_operations.each do |composite_operation|
+            dummy_operation = DummyOperation.new
+            expect(dummy_operation).to receive(:perform).and_call_original
+            expect(composite_operation).to receive(:new).and_return(dummy_operation)
+          end
+          allow(tested_instance).to receive(:prepare).and_return(true)
+          allow(tested_instance).to receive(:finalize).and_return(true)
+          tested_instance.perform
+
+          tested_operation.operations == composite_operations
+        end
+
+        def description
+          "utilize the following operations: #{composite_operations.map(&:to_s).join(', ')}"
+        end
+
+        def failure_message
+          expected_but_not_used = composite_operations - tested_operation.operations
+          used_but_not_exptected = tested_operation.operations - composite_operations
+          message = ["Unexpected operation utilization:"]
+          message << "Expected: #{expected_but_not_used.join(', ')}" unless expected_but_not_used.empty?
+          message << "Not expected: #{used_but_not_exptected.join(', ')}" unless used_but_not_exptected.empty?
+          message.join("\n\t")
+        end
+
+        def failure_message_when_negated
+          "Unexpected operation utilization"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+      end
+
+      def utilize_operation(*args)
+        Matcher.new(*args)
+      end
+      alias utilize_operations utilize_operation
+
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ActiveOperation::Matcher::UtilizeOperation
+end

data/lib/active_operation/pipeline.rb

@@ -0,0 +1,94 @@
+module ActiveOperation
+  class Pipeline < Base
+    class OperationFactory < SimpleDelegator
+      def initialize(operation_class, options = {})
+        super(operation_class)
+        @_options = options
+      end
+
+      def new(context, *input)
+        keyword_input_names = inputs.select(&:keyword?).map(&:name)
+        positional_args = input.shift(inputs.count(&:positional?))
+
+        attributes_from_input = input.last.kind_of?(Hash) ? input.pop.slice(*keyword_input_names) : {}
+        attributes_from_input.delete_if { |_, value| value.nil? }
+
+        attributes_from_pipeline = Array(@_options).each_with_object({}) do |(key, value), result|
+          result[key] = value.kind_of?(Proc) ? context.instance_exec(&value) : value
+        end
+
+        __getobj__.new *positional_args, attributes_from_input.merge(attributes_from_pipeline)
+      end
+    end
+
+    class << self
+      def operations
+        []
+      end
+
+      def use(operation, options = {})
+        if operations.empty?
+          inputs = operation.inputs
+
+          inputs.each do |input|
+            input input.name, type: input.type
+          end
+        end
+
+        (@operations ||= []) << OperationFactory.new(operation, options)
+      end
+
+      def compose(*operations, &block)
+        raise ArgumentError, "Expects either an array of operations or a block with configuration instructions" unless !!block ^ !operations.empty?
+
+        if block
+          Class.new(self, &block)
+        else
+          Class.new(self) do
+            operations.each do |operation|
+              use operation
+            end
+          end
+        end
+      end
+
+      protected
+
+      def inherited(subclass)
+        super
+
+        subclass.define_singleton_method(:operations) do
+          superclass.operations + Array(@operations)
+        end
+      end
+    end
+
+    protected
+
+    def execute
+      values = ->(input) { self[input.name] }
+
+      positional_arguments = self.class.inputs.select(&:positional?).map(&values)
+      keyword_arguments = self.class.inputs.select(&:keyword?).each_with_object({}) do |input, kwargs|
+        kwargs[input.name] = values.call(input)
+      end
+      arguments = positional_arguments.push(keyword_arguments)
+
+      self.class.operations.inject(arguments) do |data, operation|
+        operation = if data.respond_to?(:to_ary)
+                      operation.new(self, *data)
+                    else
+                      operation.new(self, data)
+                    end
+
+        operation.perform
+
+        output = operation.output
+
+        halt output if operation.halted?
+
+        output
+      end
+    end
+  end
+end

data/lib/active_operation/version.rb

@@ -1,3 +1,3 @@
 module ActiveOperation
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/generators/active_operation/install/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Generates an application operation as a starting point for your operations.

data/lib/generators/active_operation/install/install_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/base'
+require 'rails/generators/active_record'
+
+module ActiveOperation
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../../../support/templates', __FILE__)
+
+      def create_application_operation
+        template 'application_operation.rb', 'app/operations/application_operation.rb'
+      end
+    end
+  end
+end

data/lib/generators/active_operation/operation/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates an operation with the given name.
+
+Example:
+    rails generate active_operation:operation Signup
+
+    This will create:
+        app/operations/signup.rb

data/lib/generators/active_operation/operation/operation_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/base'
+require 'rails/generators/active_record'
+
+module ActiveOperation
+  module Generators
+    class OperationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../../../../../support/templates', __FILE__)
+
+      def create_operation
+        template 'operation.rb', File.join('app/operations', class_path, "#{file_name}.rb")
+      end
+    end
+  end
+end

data/support/templates/application_operation.rb

@@ -0,0 +1,2 @@
+class ApplicationOperation < ActiveOperation::Base
+end

data/support/templates/operation.rb

@@ -0,0 +1,17 @@
+class <%= name %> < ApplicationOperation
+  # input :email, accepts: String, type: :keyword, required: true
+  # input :password, accepts: String, type: :keyword, required: true
+  #
+  # before do
+  #   user = User.find_by(email: email)
+  #   halt user unless user.nil?
+  # end
+  #
+  # def execute
+  #   User.create!(email: email, password: password)
+  # end
+  #
+  # succeeded do
+  #   Email::SendWelcomeMail.perform(output)
+  # end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_operation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Konstantin Tennhard
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-15 00:00:00.000000000 Z
+date: 2017-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -116,7 +116,17 @@ files:
 - lib/active_operation.rb
 - lib/active_operation/base.rb
 - lib/active_operation/input.rb
+- lib/active_operation/matcher.rb
+- lib/active_operation/matcher/execution.rb
+- lib/active_operation/matcher/utilize_operation.rb
+- lib/active_operation/pipeline.rb
 - lib/active_operation/version.rb
+- lib/generators/active_operation/install/USAGE
+- lib/generators/active_operation/install/install_generator.rb
+- lib/generators/active_operation/operation/USAGE
+- lib/generators/active_operation/operation/operation_generator.rb
+- support/templates/application_operation.rb
+- support/templates/operation.rb
 homepage: https://gitub.com/t6d/active_operation
 licenses:
 - MIT
@@ -137,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: ActiveOperation is a micro-framework for modelling business processes.