step_machine 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bef3877ea59535b62e02fe0bf0abfb5fb04a3ed1
+  data.tar.gz: 4d5489faf7ff54e3939dc6b061f43cf94b179b6c
+SHA512:
+  metadata.gz: 5e87e732a0d7dfa89573a2d972bf47f62a8b1ea91e5449473f715415189e04fd7f9dff48b73425dc25e0801dd109d7c655420d25d59eed611b40beb1904f21dd
+  data.tar.gz: 0b31754b61675dc2646b4c2dc4656686007f0a8a2988b7ac1f772fd7267d00d3fc958278ab82021a082e442d2082a6513ba9f0f1031aaa7ffda990646c268b77

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# ruby '1.9.3'
+# Specify your gem's dependencies in step_machine.gemspec
+gemspec
+
+group :development, :test do
+	gem 'rspec'
+	gem 'guard-rspec'
+	gem 'pry'
+	gem 'simplecov'
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# 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" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # 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 Rafael Vettori and Geison Biazus
+
+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,163 @@
+# StepMachine
+
+step_machine is a simple gem for executing code based in steps. Each step can be validated and if a step fails, the execution is aborted. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'step_machine'
+
+    or 
+    
+    gem 'step_machine', git: git@bitbucket.org:geisonbiazus/step_machine.git
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+## Creating and running steps:
+	include StepMachine
+	
+	step(:step_1) do
+		# code for step 1
+	end
+	
+	step(:step_2) do
+		# code for step 2
+	end
+	
+	run_steps
+
+This code will run the steps in the created order
+
+## Changing the execution order
+
+	step(:step_1).next_step = step(:step_2)
+
+or:
+
+	step(:step_1).next_step do
+		step(:step_2)
+	end
+
+## Validating steps
+
+	step(:step_1).validate do |step|
+		step.result == "OK"
+	end
+	
+	step(step_1).validate(/^OK/)
+	
+	step(step_1).validate('OK')
+
+## Validating steps error message
+
+	step(:step_1).validate do |step|
+		step.result == "OK"
+		step.errors << 'This is a array error message forced to false validate'
+	end
+	
+	step(step_1).errors({}) << 'This is a hash error message forced to false validate'
+
+	step(step_1).errors('') << 'This is a string error message forced to false validate'
+
+## Callbacks
+
+	on_step_failure do |f|
+		f.go_to :step_2		
+	end
+	
+	on_step_failure :only => [:step_2] do |f|
+		f.restart
+	end
+	
+	on_step_failure :except => [:step_1] do |f|
+		if contition
+			f.repeat
+		else
+			f.continue
+		end
+	end
+	
+	before_each_step do |step|
+		# code
+	end
+	
+	after_each_step do |step|
+		# code
+	end
+
+## Executing code if a step runs successful
+
+	step(:step_1).success do |step|
+		# code
+	end
+
+## Conditional Steps
+
+	step(:step_1).condition do 
+		true
+	end
+
+## Executing a step depending on other step condition
+
+	step(:step_2) do
+		# code
+	end.condition do 
+		step(:step_1).performed?
+	end
+
+## Grouping steps
+
+	group :group_1 do
+
+		step :step_1 do
+			#code
+		end
+
+		step :step_2 do
+			#code
+		end
+
+	end
+
+	step :step_3 do
+		#code
+	end
+
+	run_steps( {:group => :group_1} ) # only the steps 1 and 2 will be performed
+
+## Group with condition
+
+	group(:group_1)
+		
+		step(:step_2) do
+			# code
+		end
+	
+	end.condition do 
+			step(:step_1).performed?
+	end
+
+	run_steps # only if was performed
+
+## Execute from and/or upto defined step
+
+	step :step_1 { ... }
+	step :step_2 { ... }
+	step :step_3 { ... }
+	step :step_4 { ... }
+	run_steps :upto => :step_2                   # should execute :step_1 end :step_2
+	run_steps :from => :step_3                   # should execute :step_3 end :step_4
+	run_steps :from => :step2, :upto => :step_3  # should execute :step_2 end :step_3
+	
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/step_machine.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require "step_machine/version"
+require "step_machine/group"
+require "step_machine/step"
+require "step_machine/runner"
+
+module StepMachine
+
+  module ClassMethods
+  end
+
+  module InstanceMethods
+
+    def group(name, &block)
+      @step_machine_runner ||= Runner.new
+      @step_machine_runner.group(name, &block)
+    end
+
+    def step(name, &block)
+      @step_machine_runner ||= Runner.new
+      @step_machine_runner.step(name, &block)
+    end
+
+    def on_step_failure(options = {}, &block)
+      @step_machine_runner.on_step_failure(options, &block)
+    end
+
+    def before_each_step(options = {}, &block)
+      @step_machine_runner.before_each_step(options, &block)
+    end
+
+    def after_each_step(options = {}, &block)
+      @step_machine_runner.after_each_step(options, &block)
+    end
+
+    def run_steps(options = {})
+      @step_machine_runner.run(options)
+    end
+
+    def first_step(step)
+      @step_machine_runner.first_step = step
+    end
+
+    def run_status
+      @step_machine_runner.status
+    end
+
+    def failed_step
+      @step_machine_runner.failed_step
+    end
+
+  end
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end

data/lib/step_machine/group.rb

@@ -0,0 +1,17 @@
+module StepMachine
+
+	class Group
+		attr_accessor :name, :first_step
+    attr_reader :condition_block
+
+		def initialize(name)
+			@name = name
+		end
+
+    def condition(&block)
+      @condition_block = block if block      
+      self
+    end
+
+	end
+end

data/lib/step_machine/runner.rb

@@ -0,0 +1,201 @@
+module StepMachine
+	class Runner
+
+		attr_accessor :first_step, :continue, :next_step, :times_to_repeat, :repeat_what
+		attr_reader :status, :failed_step
+
+		def initialize
+			@steps = []
+      @groups = []
+			@failure_treatments = []
+			@before_each_step = []
+			@after_each_step = []	
+			@times_to_repeat = -1
+		end
+
+		def step(name, &block)
+  		step = get_step(name) || create_step(name)  
+      step.block = block if block      
+      @first_step ||= step
+      @next_step ||= @first_step
+
+      step
+		end
+
+    def group(name)
+      return nil if name.nil?
+      @current_group = group = @groups.detect {|g| g.name == name} || create_group(name)    
+      yield if block_given?
+      @current_group = nil
+      group
+    end
+
+		def on_step_failure(options = {}, &block)			
+			@failure_treatments << FailureTreatment.new(self, block, options)
+		end
+
+		def before_each_step(options = {}, &block)
+			@before_each_step << options.merge(:block => block)
+		end	
+
+		def after_each_step(options = {}, &block)
+			@after_each_step << options.merge(:block => block)
+		end
+
+		def first_step=(step)
+			@next_step = @first_step = step
+		end
+
+    def run(options = {})
+      if group = group(options[:group])
+        assign_group_first_step(group)
+        return if @next_step.group != group
+      end
+
+      assign_from_step(options[:from]) unless options[:from].nil?
+
+      @continue = nil
+			step = @next_step
+
+			@status ||= :success
+      
+      execute_before_each_step(step)
+
+      unless step.perform      	
+        @failed_step = step
+
+        return repeat if repeat?        
+
+        execute_step_failures(step)
+
+        return run if @continue
+        @status = :failure
+        return
+      end
+      execute_after_each_step(step)
+      
+      return if step.name == options[:upto]
+
+      run(options) if @next_step = step.next
+		end
+
+		private
+
+    def assign_from_step(step)
+      if !@from_first_step
+        @next_step = get_step(step)
+        @from_first_step = true
+      end
+    end
+
+    def assign_group_first_step(group)
+     if !@group_first_step
+        @next_step = group.first_step
+        @group_first_step = true
+      end
+    end
+
+		def execute_before_each_step(step)
+			@before_each_step.each do |before|
+				next if before.has_key?(:only) && !before[:only].include?(step.name)
+				next if before.has_key?(:except) && before[:except].include?(step.name)
+				before[:block].call(step)
+			end
+		end
+
+		def execute_after_each_step(step)
+			@after_each_step.each do |after|
+				next if after.has_key?(:only) && !after[:only].include?(step.name)
+				next if after.has_key?(:except) && after[:except].include?(step.name)
+				after[:block].call(step)
+			end
+		end
+
+    def execute_step_failures(step)
+      @failure_treatments.each do |failure_treatment|
+      	failure_treatment.treat(step)        
+      end
+    end
+
+    def get_step(name)
+      @steps.find { |step| step.name == name }
+    end
+
+    def create_step(name)
+      step = Step.new(name)
+      step.group = @current_group
+      @current_group.first_step ||= step if @current_group
+      @steps << step
+      @steps[-2].next_step = step if @steps.length > 1
+      step
+    end
+
+    def create_group(name)
+      group = Group.new(name)
+      @groups << group
+      group
+    end
+
+    def repeat?
+    	@times_to_repeat >= 0
+    end
+
+    def repeat
+    	@times_to_repeat -= 1
+
+    	if @times_to_repeat == -1
+        @status = :failure
+        return 
+      end
+
+      @next_step = @repeat_what == :process ? @first_step : @failed_step
+      return run
+    end
+
+
+    class FailureTreatment
+    	attr_accessor :step
+    	
+    	def initialize(runner, block, options)
+    		@runner = runner
+    		@block = block
+    		@options = options
+    	end
+
+    	def treat(step)    		
+    		return if @options.has_key?(:only) && !@options[:only].include?(step.name)
+        return if @options.has_key?(:except) && @options[:except].include?(step.name)
+        @step = step
+
+        @block.call(self)
+    	end
+
+    	def go_to(step_name)    		
+    		@runner.next_step = @runner.step(step_name)
+    		@runner.continue = true
+    	end
+
+    	def repeat
+    		go_to(@step.name)
+    		@runner.repeat_what = :step
+    		self
+    	end
+
+    	def continue
+    		go_to(@step.next.name)
+    	end
+
+    	def restart
+    		go_to(@runner.first_step.name)
+    		@runner.repeat_what = :process
+    		self
+    	end
+
+    	def times(number)
+    		@runner.times_to_repeat = number - 1
+    	end
+
+    end
+
+	end	
+end