ruby_valve 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b8f2c19f9c27eb98876a7d17762a72bd3aabe6e
-  data.tar.gz: c2464b0627d5b46a1258483ebf08de8ebc43af9c
+  metadata.gz: f4d50d81c326d8a6f9697ecca411d1c93e55e1b8
+  data.tar.gz: 40067d0f4e20b60631aa0a266902163ee18d12f9
 SHA512:
-  metadata.gz: 89314afbeab98957cc74e86902ab0a051c7ced0e416a77fbcd6082640e4f56231a9a7f243888fccad362ea2e7934dbba60dea990af0a0b4e0508e8c32dec101a
-  data.tar.gz: 74242411a418b50dfb041d65fd52ded3d352271820d1ab1ad8de21bea27bdc3b904105c5e8479f8d6864371c45fc6d829709cea25b088fbd969e267a9d4e391b
+  metadata.gz: 4e50b22481aad6156bd1a24a706638874cd6a08f255353da7025c9800d7b1a0f1885a82dd2f9c77ec57b36331dcf6975cff28a59465e16a994733137a09a190b
+  data.tar.gz: 9daf1e21a4ee2de2e30c256b25d6f74f0a20c52cc3f271e98af945b9f5c6b399e7c45a45d1cc7c2732d48ef05d04bd837aad07605d7aef1d77c4acfa62f53024

data/README.md

@@ -21,13 +21,21 @@ Or install it yourself as:
 ## Usage
 
 
-To use RubyValve you need to subclass the base class:
+To use RubyValve you can subclass the base class:
 
     require 'ruby_valve'
 
     class Foo < RubyValve::Base
     end
     
+Or, you can include RubyValve::Core
+
+    require 'ruby_valve'
+
+    class Foo 
+      include RubyValve::Core
+      
+    end    
     
 ####\#step_n methods
 Next you define a number steps using the naming convention of #step_n for the method name.
@@ -43,7 +51,7 @@ Next you define a number steps using the naming convention of #step_n for the me
       end 
     end
 
-After defining #step_n methods you can execute then all by running the #execute method.
+After defining #step_n methods you can execute them all by running the #execute method.
 
     Foo.new.execute
     
@@ -358,4 +366,9 @@ I would recommend encapsulating the logic of what is to be done into methods wit
     
     def post_paypal_transaction
       #code
-    end       
+    end       
+    
+###Tests
+Test are implemented in Rspec and use guard as well.
+
+    ruby_valve > bundle exec rspec spec    

data/lib/ruby_valve/base.rb

@@ -1,130 +1,8 @@
-require 'ruby_valve/errors'
+require 'ruby_valve/core'
 
 module RubyValve
   class Base
-    attr_reader :executed_steps, :executed, :exception
-    
-    def init
-      @skip_list = []
-    end
-
-    def execute
-      init
-
-      if respond_to?(:after_exception)
-        begin
-          execute_methods
-        rescue => e
-          @exception = e
-          send(:after_exception)
-        end
-      else
-        execute_methods
-      end
-
-    end
-
-    def response
-      @response
-    end
-
-    protected 
-
-      def execute_methods
-        # begin
-        @response = {}
-        
-        if respond_to?(:before_all)
-          send(:before_all) 
-          log_execution(:before_all)
-        end
-
-        execution_order.each do |_method|
-          if !self.skip?(_method)
-          
-            if respond_to?(:before_each)
-              send(:before_each)    
-              log_execution(:before_each)           
-            end
-
-            #create method to store step results
-            self.class.class_eval {attr_accessor :"#{_method}_result"}
-            result = send(_method)
-
-            #assign step result information
-            @response[:"#{_method}_result"] = result
-            send(:"#{_method}_result=", result) 
-
-            #log step exec
-            log_step_execution(_method)
-
-            if respond_to?(:after_each)    
-              send(:after_each)        
-              log_execution(:after_each)
-            end
-          end
-        end
-
-        if respond_to?(:after_success) && !abort_triggered?
-          send(:after_success) 
-          log_execution(:after_success)
-        end
-
-        if respond_to?(:after_abort) && abort_triggered?
-          send(:after_abort)  
-          log_execution(:after_abort)
-        end        
-      end
-
-      #=> logging methods
-      def log_step_execution(_method)
-        (@executed_steps ||= []) << _method
-        log_execution(_method)
-      end
-
-      def log_execution(_method)
-        (@executed ||= []) << _method
-      end
-
-      def abort(message, options = {})
-        @abort_triggered = true
-        @abort_message = message 
-        raise(AbortError, @abort_message) if options[:raise]
-      end
-
-      #=> skip methods
-      def skip_all_steps?
-        abort_triggered?
-      end
-
-      def skip(*step_names)
-        skip_list.push *step_names
-      end
-
-      def skip_list
-        @skip_list
-      end
-
-      def abort_triggered?
-        @abort_triggered
-      end
-
-      def skip?(method_name)
-        return true if skip_all_steps?
-
-        skip_list.include?(method_name)
-      end
-    
-      def execution_order
-        step_methods = methods.select {|meth| meth.to_s.match(/^step_[0-9]*$/)}
-
-        step_methods.sort do |x,y|
-          ordinal_x = x.to_s.split("_").last.to_i
-          ordinal_y = y.to_s.split("_").last.to_i
-
-          ordinal_x <=> ordinal_y
-        end
-      end
+    include Core
 
   end  
 end

data/lib/ruby_valve/core.rb

@@ -0,0 +1,129 @@
+require 'ruby_valve/errors'
+
+module RubyValve
+  module Core
+    attr_reader :executed_steps, :executed, :exception
+    
+    def init
+      @skip_list = []
+    end
+
+    def execute
+      init
+
+      if respond_to?(:after_exception)
+        begin
+          execute_methods
+        rescue => e
+          @exception = e
+          send(:after_exception)
+        end
+      else
+        execute_methods
+      end
+
+    end
+
+    def response
+      @response
+    end
+
+    protected 
+
+      def execute_methods
+        # begin
+        @response = {}
+        
+        if respond_to?(:before_all)
+          send(:before_all) 
+          log_execution(:before_all)
+        end
+
+        execution_order.each do |_method|
+          if !self.skip?(_method)
+          
+            if respond_to?(:before_each)
+              send(:before_each)    
+              log_execution(:before_each)           
+            end
+
+            #create method to store step results
+            self.class.class_eval {attr_accessor :"#{_method}_result"}
+            result = send(_method)
+
+            #assign step result information
+            @response[:"#{_method}_result"] = result
+            send(:"#{_method}_result=", result) 
+
+            #log step exec
+            log_step_execution(_method)
+
+            if respond_to?(:after_each)    
+              send(:after_each)        
+              log_execution(:after_each)
+            end
+          end
+        end
+
+        if respond_to?(:after_success) && !abort_triggered?
+          send(:after_success) 
+          log_execution(:after_success)
+        end
+
+        if respond_to?(:after_abort) && abort_triggered?
+          send(:after_abort)  
+          log_execution(:after_abort)
+        end        
+      end
+
+      #=> logging methods
+      def log_step_execution(_method)
+        (@executed_steps ||= []) << _method
+        log_execution(_method)
+      end
+
+      def log_execution(_method)
+        (@executed ||= []) << _method
+      end
+
+      def abort(message, options = {})
+        @abort_triggered = true
+        @abort_message = message 
+        raise(RubyValve::AbortError, @abort_message) if options[:raise]
+      end
+
+      #=> skip methods
+      def skip_all_steps?
+        abort_triggered?
+      end
+
+      def skip(*step_names)
+        skip_list.push *step_names
+      end
+
+      def skip_list
+        @skip_list
+      end
+
+      def abort_triggered?
+        @abort_triggered
+      end
+
+      def skip?(method_name)
+        return true if skip_all_steps?
+
+        skip_list.include?(method_name)
+      end
+    
+      def execution_order
+        step_methods = methods.select {|meth| meth.to_s.match(/^step_[0-9]*$/)}
+
+        step_methods.sort do |x,y|
+          ordinal_x = x.to_s.split("_").last.to_i
+          ordinal_y = y.to_s.split("_").last.to_i
+
+          ordinal_x <=> ordinal_y
+        end
+      end
+  end  
+end

data/lib/ruby_valve/version.rb

@@ -1,3 +1,3 @@
 module RubyValve
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/ruby_valve.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["necrocommit@gmail.com"]
   spec.description   = %q{This gem provide a mechanism for doing easy flow type code pattern}
   spec.summary       = %q{Programming execution flow control}
-  spec.homepage      = "http://github.com/monochromicorn/ruby_valve#step_n-methods"
+  spec.homepage      = "http://github.com/monochromicorn/ruby_valve"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/spec/lib/ruby_valve/base_spec.rb

@@ -1,22 +1,38 @@
 require 'spec_helper'
 
-DummyValve = Class.new(RubyValve::Base) do
-  define_method(:step_1) {}
-  define_method(:step_2) {}
-  define_method(:step_3) {}
-end
+
 
 describe RubyValve::Base do
-  before(:each) do
-    @valve = DummyValve.new
-  end
+  describe "#execute" do
+    before(:each) do
+
+      class DummyValve 
+        include RubyValve::Core 
+        
+        define_method(:step_1) {}
+        define_method(:step_2) {}
+        define_method(:step_3) {}
+      end
+
+      @valve = DummyValve.new
+    end
+
+    it "should execute all step methods in order" do
+      @valve.execute
+      @valve.executed_steps.should eql([:step_1, :step_2, :step_3])
+    end    
+
+    it "should not execute steps after an abort" do
+      def @valve.step_0
+        abort "Ug, I give up"
+      end
 
-  it "should execute all step methods in order" do
-    @valve.execute
-    @valve.executed_steps.should eql([:step_1, :step_2, :step_3])
+      @valve.execute
+      @valve.executed_steps.should eql([:step_0])      
+    end
   end
 
-  context "#skip should make it skip a step" do
+  describe "#skip" do
     before(:each) do
 
       class SkipValve < RubyValve::Base 
@@ -32,12 +48,300 @@ describe RubyValve::Base do
 
     it "should not execute skipped steps" do
       @skip_valve.execute
-      @skip_valve.executed_steps.should eql([])  
+      @skip_valve.executed_steps.should eql([:step_1, :step_3])  
+    end
+  end
+
+  describe "#response" do
+    before(:each) do
+
+      class Res < RubyValve::Base 
+        define_method(:step_1) {"apple"}
+        define_method(:step_2) {"banana"}
+      end 
+
+      @res = Res.new
+    end    
+
+    it "should contain the method results" do
+      @res.execute
+      @res.response.should eql({:step_1_result=>"apple", :step_2_result=>"banana"})
+    end
+  end
+
+  describe "#step_x_result" do
+    before(:each) do
+
+      class Res1 < RubyValve::Base 
+        define_method(:step_1) {"apple"}
+        define_method(:step_2) {"banana"}
+      end 
+
+      @res1 = Res1.new
+    end     
+
+    it "should equal the result of #step_x" do
+      @res1.execute
+      @res1.step_1_result.should eql "apple"
+      @res1.step_2_result.should eql "banana"
     end
   end
-  # context ".executed_steps" do
-  #   it "should re"
-  # end
 
+  describe "#abort" do
+    before(:each) do
+
+      class AfterAbort < RubyValve::Base 
+        define_method(:after_abort) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {abort "Ug", :raise => true}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+      end 
+    
+      @after_abort = AfterAbort.new
+    end   
+    
+    it "should raise AbortError when :raise => true" do
+      expect {@after_abort.execute}.to raise_error(RubyValve::AbortError, "Ug")
+    end
+  end  
+
+  #==> BEFORE HOOKS
+  describe "#before_each" do
+    before(:each) do
+
+      class BeforeEach < RubyValve::Base 
+        define_method(:before_each) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {skip :step_4, :step_5}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+      end 
+    
+      @before_each = BeforeEach.new
+    end
+
+    it "should execute when defined" do
+      @before_each.should_receive(:before_each).exactly(2)
+      @before_each.execute 
+    end
+
+    it "should execute before each step_x" do
+      @before_each.execute
+      @before_each.executed.should eql([:before_each, :step_1, :before_each, :step_3])
+    end      
+
+    it "should not show up in executed_steps" do
+      @before_each.execute
+      @before_each.executed_steps.should eql([:step_1, :step_3])  
+    end
+
+  end  
+
+  describe "#before_all" do
+    before(:each) do
+
+      class BeforeAll < RubyValve::Base 
+        define_method(:before_all) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {skip :step_4, :step_5}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+      end 
+
+      @before_all = BeforeAll.new
+    end
+
+    it "should execute when defined" do
+      @before_all.should_receive(:before_all).exactly(1)
+      @before_all.execute 
+    end
+
+    it "should execute before all steps" do
+      @before_all.execute
+      @before_all.executed.should eql([:before_all, :step_1, :step_3])
+    end    
+
+    it "should not show up in executed_steps" do
+      @before_all.execute
+      @before_all.executed_steps.should eql([:step_1, :step_3])  
+    end
+
+  end    
+
+  #==> AFTER HOOKS
+  describe "#after_each" do
+    before(:each) do
+
+      class AfterEach < RubyValve::Base 
+        define_method(:after_each) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {skip :step_4, :step_5}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+      end 
+    
+      @after_each = AfterEach.new
+    end
+
+    it "should execute when defined" do
+      @after_each.should_receive(:after_each).exactly(2)
+      @after_each.execute 
+    end
+
+    it "should execute after each step_x" do
+      @after_each.execute
+      @after_each.executed.should eql([:step_1, :after_each, :step_3, :after_each])
+    end
+
+    it "should not show up in executed_steps" do
+      @after_each.execute
+      @after_each.executed_steps.should eql([:step_1, :step_3])  
+    end
+
+  end  
+
+  describe "#after_success" do
+    before(:each) do
+
+      class AfterSuccess < RubyValve::Base 
+        define_method(:after_success) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {skip :step_4, :step_5}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+      end 
+    
+      @after_success = AfterSuccess.new
+    end
+
+    context "when no abort is triggered" do
+
+      it "should execute when defined" do
+        @after_success.should_receive(:after_success).exactly(1)
+        @after_success.execute 
+      end
+
+      it "should execute after all steps" do
+        @after_success.execute
+        @after_success.executed.should eql([:step_1, :step_3, :after_success])
+      end
+
+      it "should not execute after an abort" do
+        def @after_success.step_1
+          abort "Ug"
+        end
+
+        @after_success.execute
+        @after_success.executed.should eql([:step_1])      
+      end
+
+      it "should not show up in executed_steps" do
+        @after_success.execute
+        @after_success.executed_steps.should eql([:step_1, :step_3])  
+      end
+
+    end
+
+    context "when an abort is triggered" do
+      it "should not execute when defined" do
+        def @after_success.step_1
+          abort "Ug"
+        end
+
+        @after_success.should_receive(:after_success).exactly(0)
+        @after_success.execute 
+      end      
+    end
+  end    
+
+  describe "#after_abort" do
+    context "after an abort is triggered" do
+      before(:each) do
+
+        class AfterAbort < RubyValve::Base 
+          define_method(:after_abort) {}
+          define_method(:step_1) {skip :step_2}
+          define_method(:step_2) {}
+          define_method(:step_3) {abort "Ug"}
+          define_method(:step_4) {}
+          define_method(:step_5) {}
+        end 
+      
+        @after_abort = AfterAbort.new
+      end
+
+      it "should execute when defined" do
+        @after_abort.should_receive(:after_abort).exactly(1)
+        @after_abort.execute 
+      end
+
+      it "should execute after all the steps" do
+        @after_abort.execute
+        @after_abort.executed.should eql([:step_1, :step_3, :after_abort])        
+      end
+
+      it "should not execute steps after an abort" do
+        @after_abort.execute
+        @after_abort.executed_steps.should eql([:step_1, :step_3])      
+      end
+
+      it "should not show up in executed_steps" do
+        @after_abort.execute
+        @after_abort.executed_steps.should eql([:step_1, :step_3])  
+      end
+
+    end  
+  end
+
+  describe "#after_exception" do
+    before(:each) do
+
+      class AfterRaise < RubyValve::Base 
+        define_method(:after_exception) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {abort "Ug", :raise => true}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+
+      end 
+    
+      @after_raise = AfterRaise.new
+    end   
+        
+    it "should not raise AbortError when :raise => true" do
+      expect {@after_raise.execute}.to_not raise_error
+    end    
+
+  end
+
+  describe "#exception" do
+    before(:each) do
+
+      class AfterRaise < RubyValve::Base 
+        define_method(:after_exception) {}
+        define_method(:step_1) {skip :step_2}
+        define_method(:step_2) {}
+        define_method(:step_3) {abort "Ug", :raise => true}
+        define_method(:step_4) {}
+        define_method(:step_5) {}
+
+      end 
+    
+      @after_raise = AfterRaise.new
+    end   
+    
+    it "should contain the raised exception" do
+      @after_raise.execute
+      @after_raise.exception.should be_a_kind_of(RubyValve::AbortError)
+      @after_raise.exception.message.should eql("Ug")
+    end    
 
+  end  
 end

data/spec/lib/{base_spec.rb → ruby_valve/core_spec.rb}

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
-DummyValve = Class.new(RubyValve::Base) do
-  define_method(:step_1) {}
-  define_method(:step_2) {}
-  define_method(:step_3) {}
-end
-
 describe RubyValve::Base do
   describe "#execute" do
     before(:each) do
+      class DummyValve 
+        include RubyValve::Core
+        define_method(:step_1) {}
+        define_method(:step_2) {}
+        define_method(:step_3) {}
+      end
+
       @valve = DummyValve.new
     end
 
@@ -30,7 +31,8 @@ describe RubyValve::Base do
   describe "#skip" do
     before(:each) do
 
-      class SkipValve < RubyValve::Base 
+      class SkipValve 
+        include RubyValve::Core 
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
         define_method(:step_3) {skip :step_4, :step_5}
@@ -50,7 +52,9 @@ describe RubyValve::Base do
   describe "#response" do
     before(:each) do
 
-      class Res < RubyValve::Base 
+      class Res  
+        include RubyValve::Core
+
         define_method(:step_1) {"apple"}
         define_method(:step_2) {"banana"}
       end 
@@ -67,7 +71,9 @@ describe RubyValve::Base do
   describe "#step_x_result" do
     before(:each) do
 
-      class Res1 < RubyValve::Base 
+      class Res1 
+        include RubyValve::Core
+
         define_method(:step_1) {"apple"}
         define_method(:step_2) {"banana"}
       end 
@@ -85,7 +91,9 @@ describe RubyValve::Base do
   describe "#abort" do
     before(:each) do
 
-      class AfterAbort < RubyValve::Base 
+      class AfterAbort 
+        include RubyValve::Core
+
         define_method(:after_abort) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -106,7 +114,9 @@ describe RubyValve::Base do
   describe "#before_each" do
     before(:each) do
 
-      class BeforeEach < RubyValve::Base 
+      class BeforeEach 
+        include RubyValve::Core
+
         define_method(:before_each) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -138,7 +148,8 @@ describe RubyValve::Base do
   describe "#before_all" do
     before(:each) do
 
-      class BeforeAll < RubyValve::Base 
+      class BeforeAll
+        include RubyValve::Core
         define_method(:before_all) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -171,7 +182,9 @@ describe RubyValve::Base do
   describe "#after_each" do
     before(:each) do
 
-      class AfterEach < RubyValve::Base 
+      class AfterEach 
+        include RubyValve::Core
+
         define_method(:after_each) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -203,7 +216,9 @@ describe RubyValve::Base do
   describe "#after_success" do
     before(:each) do
 
-      class AfterSuccess < RubyValve::Base 
+      class AfterSuccess 
+        include RubyValve::Core
+
         define_method(:after_success) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -259,7 +274,9 @@ describe RubyValve::Base do
     context "after an abort is triggered" do
       before(:each) do
 
-        class AfterAbort < RubyValve::Base 
+        class AfterAbortTest 
+          include RubyValve::Core
+
           define_method(:after_abort) {}
           define_method(:step_1) {skip :step_2}
           define_method(:step_2) {}
@@ -268,7 +285,7 @@ describe RubyValve::Base do
           define_method(:step_5) {}
         end 
       
-        @after_abort = AfterAbort.new
+        @after_abort = AfterAbortTest.new
       end
 
       it "should execute when defined" do
@@ -297,7 +314,9 @@ describe RubyValve::Base do
   describe "#after_exception" do
     before(:each) do
 
-      class AfterRaise < RubyValve::Base 
+      class AfterRaise 
+        include RubyValve::Core
+
         define_method(:after_exception) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -319,7 +338,9 @@ describe RubyValve::Base do
   describe "#exception" do
     before(:each) do
 
-      class AfterRaise < RubyValve::Base 
+      class ExceptionTest 
+        include RubyValve::Core
+
         define_method(:after_exception) {}
         define_method(:step_1) {skip :step_2}
         define_method(:step_2) {}
@@ -329,7 +350,7 @@ describe RubyValve::Base do
 
       end 
     
-      @after_raise = AfterRaise.new
+      @after_raise = ExceptionTest.new
     end   
     
     it "should contain the raised exception" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_valve
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - monochromicorn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-25 00:00:00.000000000 Z
+date: 2013-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,13 +96,14 @@ files:
 - Rakefile
 - lib/ruby_valve.rb
 - lib/ruby_valve/base.rb
+- lib/ruby_valve/core.rb
 - lib/ruby_valve/errors.rb
 - lib/ruby_valve/version.rb
 - ruby_valve.gemspec
-- spec/lib/base_spec.rb
 - spec/lib/ruby_valve/base_spec.rb
+- spec/lib/ruby_valve/core_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/monochromicorn/ruby_valve#step_n-methods
+homepage: http://github.com/monochromicorn/ruby_valve
 licenses:
 - MIT
 metadata: {}
@@ -127,7 +128,7 @@ signing_key:
 specification_version: 4
 summary: Programming execution flow control
 test_files:
-- spec/lib/base_spec.rb
 - spec/lib/ruby_valve/base_spec.rb
+- spec/lib/ruby_valve/core_spec.rb
 - spec/spec_helper.rb
 has_rdoc: