composable_operations 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d17a3973dfaed0b5b30509929d4c0feb1192b67c
-  data.tar.gz: 48212703d7bae494d648fbfeeda89d8abb50d488
+  metadata.gz: e322ef724df070ae4f606346ec732d0931174a49
+  data.tar.gz: 7119c160bc2d4cb1bc4138bd6c2fe4f321ebfc89
 SHA512:
-  metadata.gz: c70bf2fdcfb3bdec7cc72beba16ab3c44b447c26d39dbbb3b90cdb7acfb345776deab40ea4cb7342037b28c5fdc49238fc002b48eae84a159f74de3792ef89be
-  data.tar.gz: bbe6ecb31c85f915bc791d81b11499bb724ac7249f6296025c12a6fc516ebcb1ba04728596be6c2d06a2edb0e4e79ed76194736c067e6b88e281f23d2464d0c7
+  metadata.gz: 22589a1c44ebf3c74e564f3286d2aa9136516ef29698047632f4124e9171caeb03bc2bc9a0d9d20de2645b9b727b1807e0d9c0e01cd5de9f69b38092a78746bf
+  data.tar.gz: 609dc3b474ea1d374dd705422d1a95129e309b31d5fabb70479a3f42a8d95d89dcf63ae13c83a4facf62a7a5c493e7d5bdce109c04233fad7ddeef9550acda0f

data/.travis.yml

@@ -0,0 +1,7 @@
+script: bundle exec rake
+rvm:
+  - "2.1.2"
+  - "2.0.0"
+  - "1.9.3"
+  - jruby-19mode
+  - rbx-2.2.7

data/composable_operations.gemspec

@@ -24,5 +24,5 @@ multiple of these operations in operation pipelines.}
   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.14"
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/composable_operations/matcher/execution.rb

@@ -75,9 +75,10 @@ module ComposableOperations
           "the operation failed to perform for the following reason(s):\n#{failure_reasons}"
         end
 
-        def negative_failure_message
+        def failure_message_when_negated
           "the operation succeeded unexpectedly"
         end
+        alias negative_failure_message failure_message_when_negated
 
         private
 
@@ -120,9 +121,10 @@ module ComposableOperations
           "the operation did not fail to perform for the following reason(s):\n#{failure_reasons}"
         end
 
-        def negative_failure_message
+        def failure_message_when_negated
           "the operation failed unexpectedly"
         end
+        alias negative_failure_message failure_message_when_negated
 
         protected
 

data/lib/composable_operations/matcher/utilize_operation.rb

@@ -28,6 +28,7 @@ module ComposableOperations
       end
 
       class Matcher
+        include RSpec::Mocks::ExampleMethods
 
         attr_reader :composite_operations
         attr_reader :tested_operation
@@ -46,13 +47,14 @@ module ComposableOperations
             @tested_instance = class_or_instance
           end
 
-          Operation.stub(:new => DummyOperation.new)
+          allow(Operation).to receive(:new).and_return(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)
+            expect(dummy_operation).to receive(:perform).and_call_original
+            expect(composite_operation).to receive(:new).and_return(dummy_operation)
           end
-          tested_instance.stub(:prepare => true, :finalize => true)
+          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
@@ -71,9 +73,10 @@ module ComposableOperations
           message.join("\n\t")
         end
 
-        def negative_failure_message
+        def failure_message_when_negated
           "Unexpected operation utilization"
         end
+        alias negative_failure_message failure_message_when_negated
 
       end
 

data/lib/composable_operations/version.rb

@@ -1,3 +1,3 @@
 module ComposableOperations
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/spec/composable_operations/composed_operation_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 
 describe ComposableOperations::ComposedOperation do
-
   let(:string_generator) do
     Class.new(ComposableOperations::Operation) do
       def self.name
@@ -52,7 +51,6 @@ describe ComposableOperations::ComposedOperation do
   end
 
   context "when composed of one operation that generates a string no matter the input" do
-
     subject(:composed_operation) do
       operation = string_generator
 
@@ -62,13 +60,11 @@ describe ComposableOperations::ComposedOperation do
     end
 
     it "should return this string as result" do
-      composed_operation.perform(nil).should be == "chunky bacon"
+      expect(composed_operation.perform(nil)).to eq("chunky bacon")
     end
-
   end
 
   context "when composed of two operations, one that generates a string and one that multiplies it" do
-
     subject(:composed_operation) do
       string_generator = self.string_generator
       string_multiplier = self.string_multiplier
@@ -81,24 +77,19 @@ describe ComposableOperations::ComposedOperation do
       end.new
     end
 
-    it { should succeed_to_perform.and_return('chunky bacon - chunky bacon - chunky bacon') }
-
+    it { is_expected.to succeed_to_perform.and_return('chunky bacon - chunky bacon - chunky bacon') }
   end
 
   context "when composed of two operations using the factory method '.compose'" 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) }
-
+    it { is_expected.to succeed_to_perform.and_return("CHUNKY BACON") }
+    it { is_expected.to 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]
 
@@ -109,31 +100,28 @@ describe ComposableOperations::ComposedOperation do
     end
 
     it "should return a capitalized version of the generated string" do
-      composed_operation.perform(nil).should be == "CHUNKY BACON"
+      expect(composed_operation.perform(nil)).to eq("CHUNKY BACON")
     end
 
-    it { should utilize_operations(string_generator, string_capitalizer) }
-
+    it { is_expected.to 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 == nil
+      expect(composed_operation.perform).to eq(nil)
     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)
+      expect_any_instance_of(string_generator).to receive(:perform).and_call_original
+      expect_any_instance_of(halting_operation).to receive(:perform).and_call_original
+      expect_any_instance_of(string_capitalizer).not_to receive(:perform)
       composed_operation.perform
     end
-
-    it { should utilize_operations(string_generator, halting_operation, string_capitalizer) }
+    it { is_expected.to utilize_operations(string_generator, halting_operation, string_capitalizer) }
   end
-
 end
+

data/spec/composable_operations/control_flow_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe "An operation with two before and two after filters =>" do
-
   let(:test_operation) do
     Class.new(ComposableOperations::Operation) do
 
@@ -52,22 +51,20 @@ describe "An operation with two before and two after filters =>" 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    }
+    it ("should run 'initialize' first")                    { expect(subject.trace[0]).to eq(:initialize)    }
+    it ("should run 'outer before' after 'initialize'")     { expect(subject.trace[1]).to eq(:outer_before)  }
+    it ("should run 'inner before' after 'outer before'")   { expect(subject.trace[2]).to eq(:inner_before)  }
+    it ("should start 'execute' after 'inner before'")      { expect(subject.trace[3]).to eq(:execute_start) }
+    it ("should stop 'execute' after it started 'execute'") { expect(subject.trace[4]).to eq(:execute_stop)  }
+    it ("should run 'inner after' after 'execute'")         { expect(subject.trace[5]).to eq(:inner_after)   }
+    it ("should run 'outer after' after 'inner after'")     { expect(subject.trace[6]).to eq(:outer_after)   }
+    it ("should return :final_result as result")            { expect(subject.result).to eq(:final_result) }
+    it { is_expected.to     be_succeeded }
+    it { is_expected.not_to be_failed    }
+    it { is_expected.not_to be_halted    }
   end
 
-
   # Now: TEST ALL! the possible code flows systematically
-
   test_vectors = [
     {
       :context => "no complications =>",
@@ -147,11 +144,11 @@ describe "An operation with two before and two after filters =>" 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)    }
+        it("then its trace should be #{tv[:trace].inspect}") { expect(subject.trace).to eq(tv[:trace]) }
+        it("then its result should be #{tv[:output].inspect}") { expect(subject.result).to eq(tv[:output]) }
+        it("then its succeeded? method should return #{(tv[:state] == :succeeded).inspect}") { expect(subject.succeeded?).to eq(tv[:state] == :succeeded) }
+        it("then its failed? method should return #{(tv[:state] == :failed).inspect}") { expect(subject.failed?).to    eq(tv[:state] == :failed)    }
+        it("then its halted? method should return #{(tv[:state] == :halted).inspect}") { expect(subject.halted?).to    eq(tv[:state] == :halted)    }
       end
     end
   end
@@ -183,5 +180,5 @@ describe "An operation with two before and two after filters =>" do
       expect { subject.perform }.to raise_error
     end
   end
-
 end
+

data/spec/composable_operations/exception_handling_spec.rb

@@ -22,25 +22,25 @@ describe ComposableOperations::Operation, "that always fails:" do
       end
 
       it "should have nil as result" do
-        failing_operation_instance.result.should be_nil
+        expect(failing_operation_instance.result).to be_nil
       end
 
       it "should have failed" do
-        failing_operation_instance.should be_failed
+        expect(failing_operation_instance).to be_failed
       end
 
       it "should have a message" do
-        failing_operation_instance.message.should_not be_nil
+        expect(failing_operation_instance.message).not_to be_nil
       end
 
       it "should have an exception of type OperationError whose message is 'Operation failed'" do
-        failing_operation_instance.exception.should be_kind_of(ComposableOperations::OperationError)
-        failing_operation_instance.exception.message.should be == 'Operation failed'
+        expect(failing_operation_instance.exception).to be_kind_of(ComposableOperations::OperationError)
+        expect(failing_operation_instance.exception.message).to eq('Operation failed')
       end
     end
 
     context "when extended with a finalizer" do
-      let(:supervisor) { mock("Supervisor") }
+      let(:supervisor) { double("Supervisor") }
 
       let(:failing_operation_with_finalizer) do
         supervisor = supervisor()
@@ -54,7 +54,7 @@ describe ComposableOperations::Operation, "that always fails:" do
       end
 
       it "should execute the finalizers" do
-        supervisor.should_receive(:notify)
+        expect(supervisor).to receive(:notify)
         failing_operation_with_finalizer_instance.perform
       end
     end
@@ -83,8 +83,8 @@ describe ComposableOperations::Operation, "that always fails:" do
       end
 
       it "should have an exception of the custom exception type whose message is 'Operation failed'" do
-        failing_operation_with_custom_default_exception_instance.exception.should be_kind_of(custom_exception)
-        failing_operation_with_custom_default_exception_instance.exception.message.should be == 'Operation failed'
+        expect(failing_operation_with_custom_default_exception_instance.exception).to be_kind_of(custom_exception)
+        expect(failing_operation_with_custom_default_exception_instance.exception.message).to eq('Operation failed')
       end
     end
 
@@ -124,8 +124,8 @@ describe ComposableOperations::Operation, "that always fails:" do
       end
 
       it "should have an exception of the custom exception type whose message is 'Operation failed'" do
-        failing_operation_with_custom_exception_instance.exception.should be_kind_of(custom_exception)
-        failing_operation_with_custom_exception_instance.exception.message.should be == 'Operation failed'
+        expect(failing_operation_with_custom_exception_instance.exception).to be_kind_of(custom_exception)
+        expect(failing_operation_with_custom_exception_instance.exception.message).to eq('Operation failed')
       end
     end
 
@@ -147,8 +147,8 @@ describe ComposableOperations::Operation, "that always fails:" do
         end
 
         it "should have an exception of the custom exception type whose message is 'Operation failed'" do
-          failing_composed_operation_instance.exception.should be_kind_of(custom_exception)
-          failing_composed_operation_instance.exception.message.should be == 'Operation failed'
+          expect(failing_composed_operation_instance.exception).to be_kind_of(custom_exception)
+          expect(failing_composed_operation_instance.exception.message).to eq('Operation failed')
         end
       end
     end

data/spec/composable_operations/operation_input_forwarding_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe ComposableOperations::ComposedOperation, "input forwarding:" do
-
   describe "An operation pipeline that first constructs an array with two elements and then passes it to an operation that accepts two input parameters and returns the second one" do
 
     let(:array_generator) do
@@ -27,12 +26,11 @@ describe ComposableOperations::ComposedOperation, "input forwarding:" do
 
     it "should return the correct element" do
       result = pipeline.perform
-      result.should == :second_element
+      expect(result).to eq(:second_element)
     end
   end
 
   describe "An operation pipeline that first constructs an enumerator, then passes it from operation to operation and finally returns it as the result" do
-
     let(:enum_generator) do
       Class.new(ComposableOperations::Operation) do
         def execute
@@ -56,12 +54,11 @@ describe ComposableOperations::ComposedOperation, "input forwarding:" do
 
     it "should actually return an enumerator" do
       result = pipeline.perform
-      result.should be_kind_of(Enumerator)
+      expect(result).to be_kind_of(Enumerator)
     end
   end
 
   describe "An operation pipeline that first constructs an object that responds #to_a, then passes it from operation to operation and finally returns it as the result" do
-
     let(:dummy) do
       Object.new.tap do |o|
         def o.to_a
@@ -94,8 +91,8 @@ describe ComposableOperations::ComposedOperation, "input forwarding:" do
 
     it "should actually return this object" do
       result = pipeline.perform
-      result.should == dummy
+      expect(result).to eq(dummy)
     end
   end
-
 end
+

data/spec/composable_operations/operation_input_processing_spec.rb

@@ -1,9 +1,7 @@
 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
@@ -15,12 +13,10 @@ describe ComposableOperations::Operation, "input processing:" do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with(input).and_return(input) }
-
+    it { is_expected.to 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
@@ -29,13 +25,11 @@ describe ComposableOperations::Operation, "input processing:" do
       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]) }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with(key: :value).and_return([]) }
+    it { is_expected.to 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
@@ -49,13 +43,11 @@ describe ComposableOperations::Operation, "input processing:" do
       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") }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with(input, default_food: "bananas").and_return(food: "bananas") }
+    it { is_expected.to 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
@@ -65,12 +57,10 @@ describe ComposableOperations::Operation, "input processing:" do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with(1, 2).and_return(3) }
-
+    it { is_expected.to 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
@@ -80,13 +70,11 @@ describe ComposableOperations::Operation, "input processing:" do
       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]) }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with(1, 2).and_return([1, 2]) }
+    it { is_expected.to 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
@@ -97,13 +85,11 @@ describe ComposableOperations::Operation, "input processing:" do
       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) }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with(1, 2).and_return(3) }
+    it { is_expected.to 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
@@ -113,12 +99,10 @@ describe ComposableOperations::Operation, "input processing:" do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with(1, 2, {food: "chunky bacon"}, { additional: :options }).and_return(food: "chunky bacon") }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with(1, 2, {food: "chunky bacon"}, { additional: :options }).and_return(food: "chunky bacon") }
   end
 
   describe "An operation that takes a named argument and uses the setter for the named argument" do
-
     subject(:operation) do
       Class.new(described_class) do
         processes :some_value
@@ -129,16 +113,12 @@ describe ComposableOperations::Operation, "input processing:" do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with("unchanged").and_return("changed") }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with("unchanged").and_return("changed") }
   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
@@ -166,8 +146,7 @@ describe ComposableOperations::ComposedOperation, "input processing:" do
       end
     end
 
-    it { should succeed_to_perform.and_return(3) }
-
+    it { is_expected.to succeed_to_perform.and_return(3) }
   end
-
 end
+

data/spec/composable_operations/operation_spec.rb

@@ -1,9 +1,7 @@
 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
@@ -13,12 +11,10 @@ describe ComposableOperations::Operation do
       operation
     end
 
-    it { should succeed_to_perform.and_return(nil) }
-
+    it { is_expected.to succeed_to_perform.and_return(nil) }
   end
 
   context "that always halts and returns its original input" do
-
     let(:halting_operation) do
       Class.new(described_class) do
         def execute
@@ -32,22 +28,20 @@ describe ComposableOperations::Operation do
     end
 
     it "should return the input value when executed using the class' method perform" do
-      halting_operation.perform("Test").should be == "Test"
+      expect(halting_operation.perform("Test")).to 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"
+      expect(halting_operation_instance.perform).to be == "Test"
     end
 
     it "should have halted after performing" do
       halting_operation_instance.perform
-      halting_operation_instance.should be_halted
+      expect(halting_operation_instance).to be_halted
     end
-
   end
 
   context "that always returns something when executed" do
-
     let(:simple_operation) do
       Class.new(described_class) do
         def execute
@@ -65,15 +59,14 @@ describe ComposableOperations::Operation do
     end
 
     it "should have a result" do
-      simple_operation_instance.result.should be
+      expect(simple_operation_instance.result).to be
     end
 
     it "should have succeeded" do
-      simple_operation_instance.should be_succeeded
+      expect(simple_operation_instance).to 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
@@ -85,29 +78,24 @@ describe ComposableOperations::Operation do
       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")
+        expect(logger).to receive(:info).ordered.with("preparing")
+        expect(logger).to 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
-
       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
 
-      it { should fail_to_perform.because("the operational result is an empty string") }
-
+      it { is_expected.to 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
         processes :text
@@ -119,13 +107,11 @@ describe ComposableOperations::Operation do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with("-").and_return("---") }
-    it { should succeed_to_perform.when_initialized_with("-", multiplier: 5).and_return("-----") }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with("-").and_return("---") }
+    it { is_expected.to succeed_to_perform.when_initialized_with("-", multiplier: 5).and_return("-----") }
   end
 
   context "that processes two values (a string and a multiplier)" do
-
     subject(:string_multiplier) do
       Class.new(described_class) do
         processes :string, :multiplier
@@ -136,9 +122,7 @@ describe ComposableOperations::Operation do
       end
     end
 
-    it { should succeed_to_perform.when_initialized_with("-", 3).and_return("---") }
-
+    it { is_expected.to succeed_to_perform.when_initialized_with("-", 3).and_return("---") }
   end
-
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composable_operations
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Konstantin Tennhard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-25 00:00:00.000000000 Z
+date: 2014-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: smart_properties
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
 description: |-
   Composable Operations is a tool set for creating operations and assembling
   multiple of these operations in operation pipelines.
@@ -90,6 +90,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -142,4 +143,3 @@ test_files:
 - spec/composable_operations/operation_input_processing_spec.rb
 - spec/composable_operations/operation_spec.rb
 - spec/spec_helper.rb
-has_rdoc: