composable_operations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2815a0e9caf243a6e502b0f277cb98c36b44b9d5
+  data.tar.gz: 668f9e8de07e9287f7498909fca06f2d61ab4904
+SHA512:
+  metadata.gz: 962cef4189be9cabea7c2df388d1f6be24929a211eafe43f9fadddec9ff4375fd553a977a01641ee812fb1e887fc2d62853bdb3eb29e2636b336f10899d3473f
+  data.tar.gz: e3f3d3df80f08542fa285e27fbe7d4ca9a7c217a41f0d74dfa97e737dc95e9d6742877ec08d2f5f41ccc9f28ac75bffc6b419a33ca1983d6047ea76dfe36db8f

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in composable_operations.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Konstantin Tennhard
+
+MIT License
+
+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,29 @@
+# ComposableOperations
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'composable_operations'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install composable_operations
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/composable_operations.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'composable_operations/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "composable_operations"
+  spec.version       = ComposableOperations::VERSION
+  spec.authors       = ["Konstantin Tennhard"]
+  spec.email         = ["me@t6d.de"]
+  spec.summary       = %q{Tool set for operation pipelines.}
+  spec.description   = %q{Composable Operations is a tool set for creating easy-to-use operation pipelines.}
+  spec.homepage      = "http://github.com/t6d/composable_operations"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.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.add_dependency "smart_properties", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.11"
+end

data/lib/composable_operations.rb

@@ -0,0 +1,11 @@
+require 'smart_properties'
+
+module ComposableOperations
+  # Your code goes here...
+end
+
+require_relative "composable_operations/version"
+require_relative "composable_operations/operation_error"
+require_relative "composable_operations/operation"
+require_relative "composable_operations/composed_operation"
+

data/lib/composable_operations/composed_operation.rb

@@ -0,0 +1,78 @@
+module ComposableOperations
+  class ComposedOperation < Operation
+    class << self
+
+      def operations
+        [] + Array((super if defined? super)) + Array(@operations)
+      end
+
+      def use(operation)
+        (@operations ||= []) << operation
+      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
+
+      def transitions
+        transitions = []
+        klass = self
+        while klass != Operation
+          klass = klass.superclass
+          transitions += Array(klass.instance_variable_get(:@transitions))
+        end
+        transitions += Array(@transitions)
+        transitions
+      end
+
+
+      protected
+
+        def between(&callback)
+          (@transitions ||= []) << callback
+        end
+
+    end
+
+    def operations
+      self.class.operations
+    end
+
+    protected
+
+      def execute
+        [nil, *operations, nil].each_cons(2).inject(input) do |data, operations|
+          if operation = operations.last
+            operation = operation.new(data)
+            operation.perform
+
+            if operation.failed?
+              fail operation.message, operation.result, operation.backtrace
+            elsif operation.halted?
+              halt operation.message, operation.result
+            end
+
+            transition(*operations, data) if operations.first && operations.last
+            operation.result
+          else
+            data
+          end
+        end
+      end
+
+      def transition(a, b, payload)
+        self.class.transitions.each { |transition| instance_exec(a, b, payload, &transition) }
+      end
+
+  end
+end

data/lib/composable_operations/matcher.rb

@@ -0,0 +1,4 @@
+require_relative 'matcher/fail_to_perform'
+require_relative 'matcher/succeed_to_perform'
+require_relative 'matcher/utilize_operation'
+

data/lib/composable_operations/matcher/fail_to_perform.rb

@@ -0,0 +1,83 @@
+module ComposableOperations
+  module Matcher
+    module FailToPerform
+      class Matcher
+
+        def matches?(operation)
+          self.operation = operation
+          failed? && result_as_expected? && message_as_expected?
+        end
+
+        def because(message)
+          @message = message
+          self
+        end
+
+        def and_return(result)
+          @result = result
+          self
+        end
+
+        def description
+          description = "fail to perform"
+          description += " because #{message}" if message
+          description += " and return the expected result" if result
+          description
+        end
+
+        def failure_message
+          "the operation did not fail to perform for the following reason(s):\n#{failure_reasons}"
+        end
+
+        def negative_failure_message
+          "the operation failed unexpectedly"
+        end
+
+        protected
+
+          attr_reader :operation
+          attr_reader :message
+          attr_reader :result
+
+          def operation=(operation)
+            operation.perform
+            @operation = operation
+          end
+
+        private
+
+          def failed?
+            operation.failed?
+          end
+
+          def message_as_expected?
+            return true unless message
+            operation.message == message
+          end
+
+          def result_as_expected?
+            return true unless result
+            operation.result == result
+          end
+
+          def failure_reasons
+            reasons = []
+            reasons << "it did not fail at all" unless failed?
+            reasons << "its message was not as expected" unless message_as_expected?
+            reasons << "it did not return the expected result" unless result_as_expected?
+            reasons.map { |r| "\t- #{r}" }.join("\n")
+          end
+
+      end
+
+      def fail_to_perform
+        Matcher.new
+      end
+
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ComposableOperations::Matcher::FailToPerform
+end

data/lib/composable_operations/matcher/succeed_to_perform.rb

@@ -0,0 +1,70 @@
+module ComposableOperations
+  module Matcher
+module SucceedToPerform
+      class Matcher
+
+        def matches?(operation)
+          self.operation = operation
+          succeeded? && result_as_expected?
+        end
+
+        def and_return(result)
+          @result = result
+          self
+        end
+
+        def description
+          description = "succeed to perform"
+          description += " and return the expected result" if result
+          description
+        end
+
+        def failure_message
+          "the operation failed to perform for the following reason(s):\n#{failure_reasons}"
+        end
+
+        def negative_failure_message
+          "the operation succeeded unexpectedly"
+        end
+
+        protected
+
+          attr_reader :operation
+          attr_reader :result
+
+          def operation=(operation)
+            operation.perform
+            @operation = operation
+          end
+
+        private
+
+          def succeeded?
+            operation.succeeded?
+          end
+
+          def result_as_expected?
+            return true unless result
+            operation.result == result
+          end
+
+          def failure_reasons
+            reasons = []
+            reasons << "it did not succeed at all" unless succeeded?
+            reasons << "it did not return the expected result" unless result_as_expected?
+            reasons.map { |r| "\t- #{r}" }.join("\n")
+          end
+
+      end
+
+      def succeed_to_perform
+        Matcher.new
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ComposableOperations::Matcher::SucceedToPerform
+end
+

data/lib/composable_operations/matcher/utilize_operation.rb

@@ -0,0 +1,92 @@
+module ComposableOperations
+  module Matcher
+    module UtilizeOperation
+
+      class DummyOperation
+        def initialize(*args)
+        end
+
+        def failed?
+          false
+        end
+
+        def halted?
+          false
+        end
+
+        def succeeded?
+          true
+        end
+
+        def result
+          Object.new
+        end
+
+        def perform
+          result
+        end
+      end
+
+      class Matcher
+
+        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
+
+          Operation.stub(:new => DummyOperation.new)
+          composite_operations.each do |composite_operation|
+            dummy_operation = DummyOperation.new
+            dummy_operation.should_receive(:perform).and_call_original
+            composite_operation.should_receive(:new).and_return(dummy_operation)
+          end
+          tested_instance.stub(:prepare => true, :finalize => 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 negative_failure_message
+          "Unexpected operation utilization"
+        end
+
+      end
+
+      def utilize_operation(*args)
+        Matcher.new(*args)
+      end
+      alias utilize_operations utilize_operation
+
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ComposableOperations::Matcher::UtilizeOperation
+end
+

data/lib/composable_operations/operation.rb

@@ -0,0 +1,165 @@
+module ComposableOperations
+  class Operation
+
+    include SmartProperties
+
+    class << self
+
+      def perform(*args)
+        operation = new(*args)
+        operation.perform
+
+        raise exception, operation.message, operation.backtrace if operation.failed?
+
+        operation.result
+      end
+
+      def preparators
+        preparators = []
+        klass = self
+        while klass != Operation
+          klass = klass.superclass
+          preparators += Array(klass.instance_variable_get(:@preparators))
+        end
+        preparators += Array(@preparators)
+        preparators
+      end
+
+      def finalizers
+        finalizers = []
+        klass = self
+        while klass != Operation
+          klass = klass.superclass
+          finalizers += Array(klass.instance_variable_get(:@finalizers))
+        end
+        finalizers += Array(@finalizers)
+        finalizers
+      end
+
+      def exception
+        @exception or defined?(super) ? super : OperationError
+      end
+
+      protected
+
+        def before(&callback)
+          (@preparators ||= []) << callback
+        end
+
+        def after(&callback)
+          (@finalizers ||= []) << callback
+        end
+
+        def processes(*names)
+          case names.length
+          when 0
+            raise ArgumentError, "#{self}.#{__callee__} expects at least one argument"
+          when 1
+            alias_method names[0].to_sym, :input
+          else
+            names.each_with_index do |name, index|
+              define_method(name) { input[index] }
+            end
+          end
+        end
+
+        def raises(exception)
+          @exception = exception
+        end
+
+      private
+
+        def method_added(method)
+          super
+          protected method if method == :execute
+        end
+
+    end
+
+    attr_reader :input
+    attr_reader :result
+    attr_reader :message
+    attr_reader :backtrace
+
+    def initialize(input = nil, options = {})
+      super(options)
+      @input = input
+    end
+
+    def failed?
+      state == :failed
+    end
+
+    def halted?
+      state == :halted
+    end
+
+    def succeeded?
+      state == :succeeded
+    end
+
+    def message?
+      message.present?
+    end
+
+    def name
+      self.class.name
+    end
+
+    def perform
+      self.result = catch(:halt) do
+        prepare
+        result = execute
+        self.state = :succeeded
+        result
+      end
+
+      finalize
+
+      self.result
+    end
+
+    protected
+
+      attr_accessor :state
+
+      attr_writer :message
+      attr_writer :result
+      attr_writer :backtrace
+
+      def execute
+        raise NotImplementedError, "#{name}#execute not implemented"
+      end
+
+      def fail(message = nil, return_value = nil, backtrace = caller)
+        raise "Operation execution has already been aborted" if halted? or failed?
+
+        self.state = :failed
+        self.backtrace = backtrace
+        self.message = message
+        throw :halt, return_value
+      end
+
+      def halt(message = nil, return_value = input)
+        raise "Operation execution has already been aborted" if halted? or failed?
+
+        self.state = :halted
+        self.message = message
+        throw :halt, return_value
+      end
+
+      def prepare
+        self.class.preparators.each { |preparator| instance_eval(&preparator) }
+      end
+
+      def finalize
+        self.class.finalizers.each do |finalizer|
+          self.result = catch(:halt) do
+            instance_eval(&finalizer)
+            self.result
+          end
+        end
+      end
+
+  end
+end

data/lib/composable_operations/operation_error.rb

@@ -0,0 +1,4 @@
+module ComposableOperations
+  class OperationError < RuntimeError
+  end
+end

data/lib/composable_operations/version.rb

@@ -0,0 +1,3 @@
+module ComposableOperations
+  VERSION = "0.1.0"
+end

data/spec/composable_operations/composed_operation_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+describe ComposableOperations::ComposedOperation do
+
+  let(:string_generator) do
+    Class.new(ComposableOperations::Operation) do
+      def self.name
+        "StringGenerator"
+      end
+
+      def execute
+        "chunky bacon"
+      end
+    end
+  end
+
+  let(:string_capitalizer) do
+    Class.new(ComposableOperations::Operation) do
+      def self.name
+        "StringCapitalizer"
+      end
+
+      def execute
+        input.upcase
+      end
+    end
+  end
+
+  let(:halting_operation) do
+    Class.new(ComposableOperations::Operation) do
+      def execute
+        halt
+      end
+    end
+  end
+
+  context "when composed of one operation that generates a string no matter the input" do
+
+    subject(:composed_operation) do
+      operation = string_generator
+
+      Class.new(described_class) do
+        use operation
+      end
+    end
+
+    it "should return this string as result" do
+      composed_operation.perform(nil).should be == "chunky bacon"
+    end
+
+  end
+
+  context "when composed of two operations using the factory method '#chain'" do
+
+    subject(:composed_operation) do
+      described_class.compose(string_generator, string_capitalizer).new
+    end
+
+    it { should succeed_to_perform.and_return("CHUNKY BACON") }
+
+    it { should utilize_operations(string_generator, string_capitalizer) }
+
+  end
+
+  context "when composed of two operations, one that generates a string and one that capitalizes strings, " do
+
+    subject(:composed_operation) do
+      operations = [string_generator, string_capitalizer]
+
+      Class.new(described_class) do
+        use operations.first
+        use operations.last
+      end
+    end
+
+    it "should return a capitalized version of the generated string" do
+      composed_operation.perform(nil).should be == "CHUNKY BACON"
+    end
+
+    it { should utilize_operations(string_generator, string_capitalizer) }
+
+  end
+
+  context "when composed of three operations, one that generates a string, one that halts and one that capatalizes strings" do
+
+    subject(:composed_operation) do
+      described_class.compose(string_generator, halting_operation, string_capitalizer)
+    end
+
+    it "should return a capitalized version of the generated string" do
+      composed_operation.perform.should be == "chunky bacon"
+    end
+
+    it "should only execute the first two operations" do
+      string_generator.any_instance.should_receive(:perform).and_call_original
+      halting_operation.any_instance.should_receive(:perform).and_call_original
+      string_capitalizer.any_instance.should_not_receive(:perform)
+      composed_operation.perform
+    end
+
+    it { should utilize_operations(string_generator, halting_operation, string_capitalizer) }
+  end
+
+  context "when composed of two operations and provided with a between block" do
+
+
+    let(:logger) { stub("Logger").as_null_object }
+
+    subject(:composed_operation) do
+      string_generator = string_generator()
+      string_capitalizer = string_capitalizer()
+      logger = logger()
+
+      operation = described_class.compose do
+        use string_generator
+        use string_capitalizer
+
+        between do |a, b, payload|
+          logger.info("#{a.name} -> #{b.name} with #{payload.inspect} as payload")
+        end
+      end
+
+      operation.new
+    end
+
+    it { should succeed_to_perform.and_return("CHUNKY BACON") }
+
+    it "should generate the correct log message" do
+      logger.should_receive(:info).with("StringGenerator -> StringCapitalizer with \"chunky bacon\" as payload")
+      composed_operation.perform
+    end
+
+  end
+
+end

data/spec/composable_operations/control_flow_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe "An operation with two before and two after filters =>" do
+
+  let(:test_operation) do
+    Class.new(ComposableOperations::Operation) do
+
+      processes :flow_control
+
+      attr_accessor :trace
+
+      def initialize(input = [], options = {})
+        super
+        self.trace = [:initialize]
+      end
+
+      before do
+        trace << :outer_before
+        fail "Fail in outer before" if flow_control.include?(:fail_in_outer_before)
+        halt "Halt in outer before" if flow_control.include?(:halt_in_outer_before)
+      end
+
+      before do
+        trace << :inner_before
+        fail "Fail in inner before" if flow_control.include?(:fail_in_inner_before)
+        halt "Halt in inner before" if flow_control.include?(:halt_in_inner_before)
+      end
+
+      after do
+        trace << :inner_after
+        fail "Fail in inner after" if flow_control.include?(:fail_in_inner_after)
+        halt "Halt in inner after" if flow_control.include?(:halt_in_inner_after)
+      end
+
+      after do
+        trace << :outer_after
+        fail "Fail in outer after" if flow_control.include?(:fail_in_outer_after)
+        halt "Halt in outer after" if flow_control.include?(:halt_in_outer_after)
+      end
+
+      def execute
+        trace << :execute_start
+        fail "Fail in execute" if flow_control.include?(:fail_in_execute)
+        halt "Halt in execute" if flow_control.include?(:halt_in_execute)
+        trace << :execute_stop
+        :final_result
+      end
+    end
+  end
+
+  context "when run and everything works as expected =>" do
+    subject       { test_operation.new }
+    before(:each) { subject.perform }
+
+    it ("should run 'initialize' first")                    { subject.trace[0].should eq(:initialize)    }
+    it ("should run 'outer before' after 'initialize'")     { subject.trace[1].should eq(:outer_before)  }
+    it ("should run 'inner before' after 'outer before'")   { subject.trace[2].should eq(:inner_before)  }
+    it ("should start 'execute' after 'inner before'")      { subject.trace[3].should eq(:execute_start) }
+    it ("should stop 'execute' after it started 'execute'") { subject.trace[4].should eq(:execute_stop)  }
+    it ("should run 'inner after' after 'execute'")         { subject.trace[5].should eq(:inner_after)   }
+    it ("should run 'outer after' after 'inner after'")     { subject.trace[6].should eq(:outer_after)   }
+    it ("should return :final_result as result")            { subject.result.should eq(:final_result) }
+    it { should     be_succeeded }
+    it { should_not be_failed    }
+    it { should_not be_halted    }
+  end
+
+
+  # Now: TEST ALL! the possible code flows systematically
+
+  test_vectors = [
+    {
+      :context => "no complications =>",
+      :input   => [],
+      :output  => :final_result,
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :execute_stop, :inner_after, :outer_after],
+      :state   => :succeeded
+    }, {
+      :context => "failing in outer_before filter =>",
+      :input   => [:fail_in_outer_before],
+      :output  => nil,
+      :trace   => [:initialize, :outer_before, :inner_after, :outer_after],
+      :state   => :failed
+    }, {
+      :context => "failing in inner_before filter =>",
+      :input   => [:fail_in_inner_before],
+      :output  => nil,
+      :trace   => [:initialize, :outer_before, :inner_before, :inner_after, :outer_after],
+      :state   => :failed
+    }, {
+      :context => "failing in execute =>",
+      :input   => [:fail_in_execute],
+      :output  => nil,
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :inner_after, :outer_after],
+      :state   => :failed
+    }, {
+      :context => "failing in inner_after filter =>",
+      :input   => [:fail_in_inner_after],
+      :output  => nil,
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :execute_stop, :inner_after, :outer_after],
+      :state   => :failed
+    }, {
+      :context => "failing in outer_after filter =>",
+      :input   => [:fail_in_outer_after],
+      :output  => nil,
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :execute_stop, :inner_after, :outer_after],
+      :state   => :failed
+    }, {
+      :context => "halting in outer_before filter =>",
+      :input   => [:halt_in_outer_before],
+      :output  => [:halt_in_outer_before],
+      :trace   => [:initialize, :outer_before, :inner_after, :outer_after],
+      :state   => :halted
+    }, {
+      :context => "halting in inner_before filter =>",
+      :input   => [:halt_in_inner_before],
+      :output  => [:halt_in_inner_before],
+      :trace   => [:initialize, :outer_before, :inner_before, :inner_after, :outer_after],
+      :state   => :halted
+    }, {
+      :context => "halting in execute =>",
+      :input   => [:halt_in_execute],
+      :output  => [:halt_in_execute],
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :inner_after, :outer_after],
+      :state   => :halted
+    }, {
+      :context => "halting in inner_after filter =>",
+      :input   => [:halt_in_inner_after],
+      :output  => [:halt_in_inner_after],
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :execute_stop, :inner_after, :outer_after],
+      :state   => :halted
+    }, {
+      :context => "halting in outer_after filter =>",
+      :input   => [:halt_in_outer_after],
+      :output  => [:halt_in_outer_after],
+      :trace   => [:initialize, :outer_before, :inner_before, :execute_start, :execute_stop, :inner_after, :outer_after],
+      :state   => :halted
+    }
+  ]
+
+  context "when initialized with input that leads to =>" do
+    subject { test_operation.new(input) }
+    before(:each) { subject.perform }
+
+    test_vectors.each do |tv|
+      context tv[:context] do
+        let(:input) { tv[:input] }
+        let(:trace) { subject.trace }
+
+        it("then its trace should be #{tv[:trace].inspect}") { subject.trace.should eq(tv[:trace]) }
+        it("then its result should be #{tv[:output].inspect}") { subject.result.should eq(tv[:output]) }
+        it("then its succeeded? method should return #{(tv[:state] == :succeeded).inspect}") { subject.succeeded?.should eq(tv[:state] == :succeeded) }
+        it("then its failed? method should return #{(tv[:state] == :failed).inspect}") { subject.failed?.should    eq(tv[:state] == :failed)    }
+        it("then its halted? method should return #{(tv[:state] == :halted).inspect}") { subject.halted?.should    eq(tv[:state] == :halted)    }
+      end
+    end
+  end
+
+  context "when halt and fail are used together" do
+    subject { test_operation.new([:halt_in_execute, :fail_in_inner_after]) }
+    it "should raise on calling operation.perform" do
+      expect { subject.perform }.to raise_error
+    end
+  end
+
+  context "when fail and halt are used together" do
+    subject { test_operation.new([:fail_in_execute, :halt_in_inner_after]) }
+    it "should raise on calling operation.perform" do
+      expect { subject.perform }.to raise_error
+    end
+  end
+
+  context "when halt is used twice" do
+    subject { test_operation.new([:halt_in_execute, :halt_in_inner_after]) }
+    it "should raise on calling operation.perform" do
+      expect { subject.perform }.to raise_error
+    end
+  end
+
+  context "when fail is used twice" do
+    subject { test_operation.new([:fail_in_execute, :fail_in_inner_after]) }
+    it "should raise on calling operation.perform" do
+      expect { subject.perform }.to raise_error
+    end
+  end
+
+end

data/spec/composable_operations/operation_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe ComposableOperations::Operation do
+
+  context "that always returns nil when executed" do
+
+    subject(:nil_operation) do
+      class << (operation = described_class.new(''))
+        def execute
+          nil
+        end
+      end
+      operation
+    end
+
+    it { should succeed_to_perform.and_return(nil) }
+
+  end
+
+  context "that always halts" do
+
+    let(:halting_operation) do
+      Class.new(described_class) do
+        def execute
+          halt "Full stop!"
+        end
+      end
+    end
+
+    let(:halting_operation_instance) do
+      halting_operation.new("Test")
+    end
+
+    it "should return the input value when executed using the class' method perform" do
+      halting_operation.perform("Test").should be == "Test"
+    end
+
+    it "should return the input value when executed using the instance's peform method" do
+      halting_operation_instance.perform.should be == "Test"
+    end
+
+    it "should have halted after performing" do
+      halting_operation_instance.perform
+      halting_operation_instance.should be_halted
+    end
+
+  end
+
+  context "that always fails" do
+
+    let(:failing_operation) do
+      Class.new(described_class) do
+        def execute
+          fail "Operation failed"
+        end
+      end
+    end
+
+    subject(:failing_operation_instance) do
+      failing_operation.new
+    end
+
+    before(:each) do
+      failing_operation_instance.perform
+    end
+
+    it "should have nil as result" do
+      failing_operation_instance.result.should be_nil
+    end
+
+    it "should have failed" do
+      failing_operation_instance.should be_failed
+    end
+
+    it "should have a message" do
+      failing_operation_instance.message.should_not be_nil
+    end
+
+    it "should raise an error when executed using the class method perform" do
+      expect { failing_operation.perform }.to raise_error("Operation failed")
+    end
+
+    context "when extended with a finalizer" do
+
+      let(:supervisor) { mock("Supervisor") }
+
+      let(:failing_operation_instance_with_finalizer) do
+        supervisor = supervisor()
+        Class.new(failing_operation) do
+          after { supervisor.notify }
+        end
+      end
+
+      subject(:failing_operation_instance_with_finalizer_instance) do
+        failing_operation_instance_with_finalizer.new
+      end
+
+      it "should execute the finalizers" do
+        supervisor.should_receive(:notify)
+        failing_operation_instance_with_finalizer_instance.perform
+      end
+
+    end
+
+    context "when configured to raise a custom exception" do
+
+      let(:custom_exception) { Class.new(RuntimeError) }
+
+      subject(:failing_operation_with_custom_exception) do
+        custom_exception = custom_exception()
+        Class.new(failing_operation) do
+          raises custom_exception
+        end
+      end
+
+      it "should raise the custom exeception when executed using the class method perform" do
+        expect { failing_operation_with_custom_exception.perform }.to raise_error(custom_exception, "Operation failed")
+      end
+
+    end
+
+  end
+
+  context "that always returns something when executed" do
+
+    let(:simple_operation) do
+      Class.new(described_class) do
+        def execute
+          ""
+        end
+      end
+    end
+
+    subject(:simple_operation_instance) do
+      simple_operation.new
+    end
+
+    before(:each) do
+      simple_operation_instance.perform
+    end
+
+    it "should have a result" do
+      simple_operation_instance.result.should be
+    end
+
+    it "should have succeeded" do
+      simple_operation_instance.should be_succeeded
+    end
+
+    context "when extended with a preparator and a finalizer" do
+
+      let(:logger) { double("Logger") }
+
+      subject(:simple_operation_with_preparator_and_finalizer) do
+        logger = logger()
+        Class.new(simple_operation) do
+          before { logger.info("preparing") }
+          after { logger.info("finalizing") }
+        end
+      end
+
+      it "should execute the preparator and finalizer when performing" do
+        logger.should_receive(:info).ordered.with("preparing")
+        logger.should_receive(:info).ordered.with("finalizing")
+        simple_operation_with_preparator_and_finalizer.perform
+      end
+
+    end
+
+    context "when extended with a finalizer that checks that the result is not an empty string" do
+
+      let(:simple_operation_with_sanity_check) do
+        Class.new(simple_operation) do
+          after { fail "the operational result is an empty string" if self.result == "" }
+        end
+      end
+
+      subject(:simple_operation_with_sanity_check_instance) do
+        simple_operation_with_sanity_check.new
+      end
+
+      it { should fail_to_perform.because("the operational result is an empty string") }
+
+    end
+
+  end
+
+  context "that can be parameterized" do
+
+    subject(:string_multiplier) do
+      Class.new(described_class) do
+        property :multiplier, :default => 3
+
+        def execute
+          input.to_s * multiplier
+        end
+      end
+    end
+
+    it "should operate according to the specified default value" do
+      string_multiplier.perform("-").should be == "---"
+    end
+
+    it "should allow to overwrite default settings" do
+      string_multiplier.perform("-", :multiplier => 5).should be == "-----"
+    end
+
+  end
+
+  context "that processes two values (a string and a multiplier)" do
+
+    subject(:string_multiplier) do
+      Class.new(described_class) do
+        processes :string, :multiplier
+
+        def execute
+          string * multiplier
+        end
+      end
+    end
+
+    it "should build a string that is multiplier-times long" do
+      string_multiplier.perform(["-", 3]).should be == "---"
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+require 'rspec'
+
+require 'composable_operations'
+require 'composable_operations/matcher'
+
+Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+end
+

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: composable_operations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Konstantin Tennhard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: smart_properties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: Composable Operations is a tool set for creating easy-to-use operation
+  pipelines.
+email:
+- me@t6d.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- composable_operations.gemspec
+- lib/composable_operations.rb
+- lib/composable_operations/composed_operation.rb
+- lib/composable_operations/matcher.rb
+- lib/composable_operations/matcher/fail_to_perform.rb
+- lib/composable_operations/matcher/succeed_to_perform.rb
+- lib/composable_operations/matcher/utilize_operation.rb
+- lib/composable_operations/operation.rb
+- lib/composable_operations/operation_error.rb
+- lib/composable_operations/version.rb
+- spec/composable_operations/composed_operation_spec.rb
+- spec/composable_operations/control_flow_spec.rb
+- spec/composable_operations/operation_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/t6d/composable_operations
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Tool set for operation pipelines.
+test_files:
+- spec/composable_operations/composed_operation_spec.rb
+- spec/composable_operations/control_flow_spec.rb
+- spec/composable_operations/operation_spec.rb
+- spec/spec_helper.rb