composable_operations 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81ead7b2ae4c840da890083408658b4fd9dcdc04
-  data.tar.gz: 465aad013d3ccc83c7f3d6796c2e211751224296
+  metadata.gz: 658fbfd45d7aed7d7589d0603270cbac1b3fea39
+  data.tar.gz: bb95ff34e25b6df75249604c9e606ffe2046c136
 SHA512:
-  metadata.gz: e4875e2b1b96e1a3fba4b1dc6543343beb3142c2c66fbaea464f6d33c3966c13e2bc3ed8ba311ed504cf55868731d42d2caaef5e43a11a51cd7e18f3bbbae113
-  data.tar.gz: a8f1a7f56b581e21fb88728f9bad4565db606d033de28cc17dfea1a6c400ab21ef24fadc473079451f559117d1af87e37eef80c23e3dce6ececb1c8cf871d858
+  metadata.gz: 091483e197ccab3c020d27ecfe4e040a9fed7c0b8a0f90a08dbff8d97e75ed80545a642c64b86fab4ea995dea4f1e2d3dee4e9335bfd08b6df85a10a8542332a
+  data.tar.gz: 66b9beda48a6df81f21eddee06f83d0bb0c6f3bdb9c60b6954000fcb0ed59402c277eb5f2a7c0e1ac6a8679285d781cf0457e33a523579e9f1deada49426ffcc

data/README.md

@@ -217,13 +217,15 @@ to the initializer.
 ```ruby
 class Indention < ComposableOperations::Operation
 
+  processes :text
+
   property :indent, default: 2,
                     converts: lambda { |value| value.to_s.to_i },
                     accepts: lambda { |value| value >= 0 },
                     required: true
 
   def execute
-    input.split("\n").map { |line| " " * indent + line }.join("\n")
+    text.split("\n").map { |line| " " * indent + line }.join("\n")
   end
 
 end

data/composable_operations.gemspec

@@ -22,6 +22,7 @@ multiple of these operations in operation pipelines.}
   spec.add_dependency "smart_properties", "~> 1.0"
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry", "~> 0.9.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.13"
 end

data/lib/composable_operations/matcher.rb

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

data/lib/composable_operations/matcher/execution.rb

@@ -0,0 +1,166 @@
+module ComposableOperations
+  module Matcher
+    module Execution
+
+      class Base
+
+        def and_return(result)
+          @result = result
+          self
+        end
+
+        def when_initialized_with(*input)
+          @input = input
+          self
+        end
+
+        protected
+
+          attr_reader :operation
+          attr_reader :result
+          attr_reader :input
+
+          def operation=(operation)
+            operation = operation.new(*input) if operation.kind_of?(Class)
+            operation.perform
+            @operation = operation
+          end
+
+          def failed?
+            operation.failed?
+          end
+
+          def succeeded?
+            operation.succeeded?
+          end
+
+          def result_as_expected?
+            return true unless result
+            operation.result == result
+          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 negative_failure_message
+          "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 FailToPerform < Base
+
+        def matches?(operation)
+          self.operation = operation
+          failed? && result_as_expected? && message_as_expected?
+        end
+
+        def because(message)
+          @message = message
+          self
+        end
+
+        def description
+          description = "fail to perform"
+          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 fail to perform for the following reason(s):\n#{failure_reasons}"
+        end
+
+        def negative_failure_message
+          "the operation failed unexpectedly"
+        end
+
+        protected
+
+          attr_reader :message
+
+          def message_as_expected?
+            return true unless message
+            operation.message == message
+          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?
+            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 fail_to_perform
+        FailToPerform.new
+      end
+
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ComposableOperations::Matcher::Execution
+end

data/lib/composable_operations/operation.rb

@@ -5,6 +5,12 @@ module ComposableOperations
 
     class << self
 
+      attr_writer :arity
+
+      def arity
+        @arity || 0
+      end
+
       def perform(*args)
         operation = new(*args)
         operation.perform
@@ -51,11 +57,11 @@ module ComposableOperations
         end
 
         def processes(*names)
+          self.arity = names.length
+
           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] }
@@ -82,13 +88,12 @@ module ComposableOperations
     attr_reader :backtrace
 
     def initialize(*args)
-      super(args.last.kind_of?(Hash) ? args.pop : {})
-      @input = case args.length
-               when 0 then nil
-               when 1 then args.first
-               else
-                 args
-               end
+      named_input_parameters   = args.shift(self.class.arity)
+      options                  = args.last.kind_of?(Hash) ? args.pop : {}
+      unnamed_input_parameters = args
+
+      @input = named_input_parameters + unnamed_input_parameters
+      super(options)
     end
 
     def failed?

data/lib/composable_operations/version.rb

@@ -1,3 +1,3 @@
 module ComposableOperations
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/spec/composable_operations/composed_operation_spec.rb

@@ -16,12 +16,14 @@ describe ComposableOperations::ComposedOperation do
 
   let(:string_capitalizer) do
     Class.new(ComposableOperations::Operation) do
+      processes :text
+
       def self.name
         "StringCapitalizer"
       end
 
       def execute
-        input.upcase
+        text.upcase
       end
     end
   end

data/spec/composable_operations/operation_input_processing_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe ComposableOperations::Operation, "input processing:" do
+
+  describe "An operation that takes a Hash as input" do
+
+    let(:input) { {food: "chunky bacon" } }
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :some_hash
+        def execute
+          some_hash
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(input).and_return(input) }
+
+  end
+
+  describe "An operation that takes no arguments except for a Hash of additional options" do
+
+    subject(:operation) do
+      Class.new(described_class) do
+        def execute
+          input
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(key: :value).and_return([]) }
+    it { should succeed_to_perform.when_initialized_with(1, 2, 3, key: :value).and_return([1, 2, 3]) }
+
+  end
+
+  describe "An operation that takes a Hash as input and an Hash of additional options" do
+
+    let(:input) { { food: nil } }
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :some_hash
+        property :default_food, default: "chunky bacon"
+        def execute
+          some_hash[:food] ||= default_food
+          some_hash
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(input, default_food: "bananas").and_return(food: "bananas") }
+    it { should succeed_to_perform.when_initialized_with(input).and_return(food: "chunky bacon") }
+
+  end
+
+  describe "An operation that takes two named arguments as input and sums them up" do
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :first_operand, :second_operand
+        def execute
+          first_operand + second_operand
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(1, 2).and_return(3) }
+
+  end
+
+  describe "An operation that takes two named arguments as input and simply returns all input arguments as output" do
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :first_operand, :second_operand
+        def execute
+          input
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(1, 2).and_return([1, 2]) }
+    it { should succeed_to_perform.when_initialized_with(1, 2, 3).and_return([1, 2, 3]) }
+
+  end
+
+  describe "An operation that takes multiple arguments as input where the last of these arguments is a Hash" do
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :first_operand, :second_operand
+        property :operator, default: :+, converts: :to_sym, required: true
+        def execute
+          first_operand.public_send(operator, second_operand)
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(1, 2).and_return(3) }
+    it { should succeed_to_perform.when_initialized_with(1, 2, operator: :*).and_return(2) }
+
+  end
+
+  describe "An operation that takes multiple arguments as input where the last of these arguments is a Hash, as well as, a Hash of additional options" do
+
+    subject(:operation) do
+      Class.new(described_class) do
+        processes :some_value, :yet_another_value, :a_hash
+        def execute
+          a_hash
+        end
+      end
+    end
+
+    it { should succeed_to_perform.when_initialized_with(1, 2, {food: "chunky bacon"}, { additional: :options }).and_return(food: "chunky bacon") }
+
+  end
+
+end
+
+describe ComposableOperations::ComposedOperation, "input processing:" do
+
+  describe "A composed operation that consists of a producer and a consumer" do
+
+    let(:producer) do
+      Class.new(ComposableOperations::Operation) do
+        def execute
+          return 1, 2
+        end
+      end
+    end
+
+    let(:consumer) do
+      Class.new(ComposableOperations::Operation) do
+        processes :first_operand, :second_operand
+        def execute
+          first_operand + second_operand
+        end
+      end
+    end
+
+    subject(:operation) do
+      producer = self.producer
+      consumer = self.consumer
+
+      Class.new(described_class) do
+        use producer
+        use consumer
+      end
+    end
+
+    it { should succeed_to_perform.and_return(3) }
+
+  end
+
+end

data/spec/composable_operations/operation_spec.rb

@@ -22,7 +22,7 @@ describe ComposableOperations::Operation do
     let(:halting_operation) do
       Class.new(described_class) do
         def execute
-          halt "Full stop!", input
+          halt "Full stop!", input.first
         end
       end
     end
@@ -169,16 +169,12 @@ describe ComposableOperations::Operation do
 
     context "when extended with a finalizer that checks that the result is not an empty string" do
 
-      let(:simple_operation_with_sanity_check) do
+      subject(: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
@@ -189,21 +185,17 @@ describe ComposableOperations::Operation do
 
     subject(:string_multiplier) do
       Class.new(described_class) do
+        processes :text
         property :multiplier, :default => 3
 
         def execute
-          input.to_s * multiplier
+          text.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
+    it { should succeed_to_perform.when_initialized_with("-").and_return("---") }
+    it { should succeed_to_perform.when_initialized_with("-", multiplier: 5).and_return("-----") }
 
   end
 
@@ -219,9 +211,7 @@ describe ComposableOperations::Operation do
       end
     end
 
-    it "should build a string that is multiplier-times long" do
-      string_multiplier.perform(["-", 3]).should be == "---"
-    end
+    it { should succeed_to_perform.when_initialized_with("-", 3).and_return("---") }
 
   end
 

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'bundler/setup'
 require 'rspec'
+require 'pry'
 
 require 'composable_operations'
 require 'composable_operations/matcher'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composable_operations
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Konstantin Tennhard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-01 00:00:00.000000000 Z
+date: 2013-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: smart_properties
@@ -38,6 +38,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -84,14 +98,14 @@ files:
 - 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/execution.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_input_processing_spec.rb
 - spec/composable_operations/operation_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/t6d/composable_operations
@@ -114,12 +128,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.6
 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_input_processing_spec.rb
 - spec/composable_operations/operation_spec.rb
 - spec/spec_helper.rb

data/lib/composable_operations/matcher/fail_to_perform.rb

@@ -1,83 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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
-