ruby_valve 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7b2f4de1638c09da9c95d2c18ffe1f84e0c0ff5
+  data.tar.gz: ec03254b2ccb35abc87a5f147a0583f3ad7cdce6
+SHA512:
+  metadata.gz: 3a21595eeb9fd52ff4ca46017adcbf5c018c52188f34a9dbea04b256e20785e8693255625c620d1dee55cf59a047ba54402f669266195a788619b28eb420f712
+  data.tar.gz: 2ac42dbffe38ae921ef4e79d58d278f36ff6c0c2bf797b6d82582771a56bea55f96f94e314c7582e88801aeb1c1e2abe3748e01fa8fb0cf35441d02affb3fd5a

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,16 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Capybara features specs
+  # watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  # watch(%r{^spec/acceptance/(.+)\.feature$})
+  # watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Juan Leal
+
+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,361 @@
+# RubyValve
+
+This gem provide a mechanism for doing easy flow type code pattern. Similar to what's done in 
+the template design pattern.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby_valve'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_valve
+
+## Usage
+
+
+To use RubyValve you need to subclass the base class:
+
+    require 'ruby_valve'
+
+    class Foo < RubyValve::Base
+    end
+    
+    
+####\#step_n methods
+Next you define a number steps using the naming convention of #step_n for the method name.
+
+    class Foo < RubyValve::Base
+    
+      def step_1
+        puts "A"
+      end
+      
+      def step_2
+        puts "B"  
+      end 
+    end
+
+After defining #step_n methods you can execute then all by running the #execute method.
+
+    Foo.new.execute
+    
+    A
+    B
+
+####\#skip
+You can skip a step by using the #skip method
+
+    def step_1
+      puts "A"
+      skip :step_2, :step_3
+    end
+    
+    def step_2
+      puts "B"
+    end
+    
+    def step_3
+      puts "C"
+    end
+    
+    def step_4
+      puts "D"
+    end        
+    
+    
+    Foo.new.execute
+    
+    A
+    D
+    
+####\#abort
+You can have it abort at a certain step and it will not execute the remainder of the steps.
+
+    def step_1
+      puts "A"
+    end
+    
+    def step_2
+      abort "Ug, again?"
+    end
+    
+    def step_3
+      puts "C"
+    end
+    
+    def step_4
+      puts "D"
+    end        
+    
+    
+    Foo.new.execute
+    
+    A
+    
+You can also have #abort raise an error as well.
+
+    def step_1
+      puts "A"
+    end
+    
+    def step_2
+      abort "Ug, again?", raise: true
+    end
+    
+    def step_3
+      puts "C"
+    end
+    
+    def step_4
+      puts "D"
+    end        
+    
+    
+    Foo.new.execute
+    
+    A
+    RubyValve::AbortError: 
+      Ug
+      
+####\#step_n_result
+The result of each #step_n method can be accessed by calling #step_n_result. This allows the sharing of data between methods.
+
+    def step_1
+      "A"
+    end
+    
+    def step_2
+      puts "step 1's result was: #{step_1_result}"
+    end
+    
+    Foo.new.execute
+    
+    step 1's result was: A
+    
+    
+####\#response
+The response for each step is recorded in a hash that can be accessed by this method
+
+      def step_1
+        "A"
+      end
+      
+      def step_2
+        "B"  
+      end 
+
+      foo = Foo.new
+      foo.execute
+      foo.result
+      
+      {:step_1_result=>"A", :step_2_result=>"B"}
+        
+        
+###Callbacks
+RubyValve provides a number of callbacks.
+
+####\#before_all
+
+Executes code once before all the steps.
+
+    def before_all
+      puts "..BA"
+    end
+    
+    def step_1
+      "A"
+    end
+      
+    def step_2
+      "B"  
+    end     
+    
+    Foo.new.execute
+    
+    ..BA
+    A
+    B
+
+####\#before_each
+Executes code before each step method
+
+    def before_each
+      puts "..BE"
+    end
+    
+    def step_1
+      "A"
+    end
+      
+    def step_2
+      "B"  
+    end      
+    
+    Foo.new.execute
+    
+    ..BE
+    A
+    ..BE
+    B
+
+####\#after_each
+Executes code after each step method.
+
+    def after_each
+      puts "..AE"
+    end
+
+    def step_1
+      "A"
+    end
+      
+    def step_2
+      "B"  
+    end  
+    
+    Foo.new.execute
+    
+    A
+    ..AE
+    B
+    ..AE    
+    
+####\#after_success
+Executes if no abort was triggered or exceptions raised.
+
+    def step_1
+      puts "E"
+    end
+    
+    def after_success
+      puts "Yay!"
+    end
+    
+    
+    Foo.new.execute
+    
+    E
+    Yay!
+    
+####\#after_abort
+Executes if an abort, without a raise, was triggered.
+
+    def step_1
+      abort "call it off"
+    end
+    
+    def step_2
+      puts "E"
+    end
+    
+    def after_abort
+      puts "aborted!"
+    end
+    
+    Foo.new.execute
+    
+    aborted!  
+
+####\#after_raise and #exeception
+Creating an after_raise method will trigger an automatic rescue when an error is raised. The exception is stored in the **exception** method.
+
+    def step_1
+      abort "call it off", raise: true
+    end
+    
+    def step_2
+      puts "E"
+    end
+    
+    def after_raise
+      puts exception.message
+    end
+    
+    Foo.new.execute
+    
+    call it off
+    
+###execution logs
+There are a couple of methods that can be used to look at what was executed.
+
+####\#executed_steps
+
+This will display each #step_n method that was actually executed.
+
+    def step_1
+      "A"
+    end
+    
+    def step_2
+      "B"
+    end
+    
+    def after_each
+      puts "..AE"
+    end
+    
+    foo = Foo.new
+    foo.execute
+    foo.executed_steps
+    
+    [:step_1, :step_2]
+    
+####\#executed
+This will display each step and callback method that was executed.
+
+    def step_1
+      "A"
+    end
+    
+    def step_2
+      "B"
+    end
+    
+    def after_each
+      puts "..AE"
+    end
+    
+    foo = Foo.new
+    foo.execute
+    foo.executed_steps
+    
+    [:step_1, :after_each, :step_2, :after_each]
+    
+##Suggestions
+
+I would recommend encapsulating the logic of what is to be done into methods with names that clearly state the intention of the code. The calling these methods within the steps.
+
+####Example
+
+    def step_1
+      post_paypal_transaction
+    end
+    
+    def step_2
+      store_paypal_result(step_1_result)
+    end
+    
+    def step_3
+      update_transaction_records
+    end
+    
+    #=> ACTIONS
+    def post_paypal_transaction
+      #code
+    end
+    
+    def store_paypal_result(paypal_results)
+      #code
+    end
+    
+    def post_paypal_transaction
+      #code
+    end       

data/Rakefile

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

data/lib/ruby_valve/base.rb

@@ -0,0 +1,130 @@
+require 'ruby_valve/errors'
+
+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
+
+  end  
+end

data/lib/ruby_valve/errors.rb

@@ -0,0 +1,4 @@
+
+module RubyValve
+  AbortError = Class.new(RuntimeError)
+end

data/lib/ruby_valve/version.rb

@@ -0,0 +1,3 @@
+module RubyValve
+  VERSION = "0.0.2"
+end

data/lib/ruby_valve.rb

@@ -0,0 +1,4 @@
+require "ruby_valve/version"
+require "ruby_valve/base"
+
+

data/ruby_valve.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_valve/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_valve"
+  spec.version       = RubyValve::VERSION
+  spec.authors       = ["monochromicorn"]
+  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.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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry-debugger"
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,298 @@
+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
+      @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
+
+      @valve.execute
+      @valve.executed_steps.should eql([:step_0])      
+    end
+  end
+
+  describe "#skip" do
+    before(:each) do
+
+      class SkipValve < RubyValve::Base 
+        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 
+
+      @skip_valve = SkipValve.new
+    end
+
+    it "should not execute skipped steps" do
+      @skip_valve.execute
+      @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
+
+  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
+
+
+end

data/spec/lib/ruby_valve/base_spec.rb

@@ -0,0 +1,43 @@
+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
+
+  it "should execute all step methods in order" do
+    @valve.execute
+    @valve.executed_steps.should eql([:step_1, :step_2, :step_3])
+  end
+
+  context "#skip should make it skip a step" do
+    before(:each) do
+
+      class SkipValve < RubyValve::Base 
+        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 
+
+      @skip_valve = SkipValve.new
+    end
+
+    it "should not execute skipped steps" do
+      @skip_valve.execute
+      @skip_valve.executed_steps.should eql([])  
+    end
+  end
+  # context ".executed_steps" do
+  #   it "should re"
+  # end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+#require 'byebug'
+require 'pry-debugger'
+
+require 'ruby_valve' 
+
+RSpec.configure do |config|
+  # some (optional) config here
+end
+

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: ruby_valve
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- monochromicorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-25 00:00:00.000000000 Z
+dependencies:
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  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: pry-debugger
+  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'
+description: This gem provide a mechanism for doing easy flow type code pattern
+email:
+- necrocommit@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby_valve.rb
+- lib/ruby_valve/base.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/spec_helper.rb
+homepage: http://github.com/monochromicorn/ruby_valve#step_n-methods
+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.1.11
+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/spec_helper.rb
+has_rdoc: