bpmachine 1.1.0

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    bpmachine (1.0.3)
+      activesupport (~> 3.2.0)
+      i18n (~> 0.6.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.2)
+    i18n (0.6.0)
+    multi_json (1.3.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bpmachine!
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 fabiokung
+
+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.rdoc

@@ -0,0 +1,18 @@
+= bpmachine
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 fabiokung. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)

data/bpmachine.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bpmachine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bpmachine"
+  s.version     = BPMachine::Version::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Cloud Team"]
+  s.email       = ["willian.molinari@locaweb.com.br"]
+  s.homepage    = "http://github.com/locaweb/bpmachine"
+  s.description = %Q{Includes a DSL for business process specification. The process state is persistent, which allows it to be be resumed if an error occurs.}
+  s.summary     = s.description
+
+  s.files         = Dir["./**/*"].reject {|file| file =~ /\.git|pkg/}
+  s.require_paths = ["lib"]
+
+  s.add_dependency "i18n", "~> 0.6.0"
+  s.add_dependency "activesupport", "~> 3.2.0"
+  s.add_development_dependency "rspec"
+end

data/lib/bpmachine/process_specification.rb

@@ -0,0 +1,135 @@
+module BPMachine
+  module ProcessSpecification
+    def self.after_processes(&block)
+      after_process_actions << block
+    end
+
+    def self.after_process_actions
+      @after_process_actions ||= []
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def change_status(new_status)
+      self.status = new_status
+      self.save!
+    end
+
+    def read_status
+      status.is_a?(Symbol) ? status : status.downcase.to_sym
+    end
+
+    private
+    def execute_transitions_from(specification)
+      while true
+        state = read_status
+        transition = specification.transition_for state
+        return state if transition.nil?
+        return state unless (transition[:if].nil? || self.send(transition[:if]))
+        self.send transition[:method]
+        change_status transition[:target]
+      end
+    end
+
+    def execute_global_after_actions
+      ProcessSpecification.after_process_actions.each do |action|
+        action.call(self)
+      end
+    end
+
+    module ClassMethods
+      def process(options = {}, &block)
+        name = options[:of].to_sym
+        load_step_definitions_for(name)
+
+        specification = transitions_from block
+        class_eval do
+          define_method(name) do
+            state = read_status
+            self.send(specification.before_action) unless specification.before_action.nil?
+            raise InvalidInitialState.new(name, specification.pre_condition, state) unless specification.applies_to? state
+            execute_transitions_from specification
+            self.send(specification.after_action) unless specification.after_action.nil?
+            execute_global_after_actions
+          end
+        end
+      end
+
+      private
+      def load_step_definitions_for(process_name)
+        begin
+          require "#{process_name}_steps"
+          begin
+            module_name = "#{process_name.to_s.camelize}Steps"
+            steps_module = const_get(module_name)
+            include(steps_module)
+          rescue NameError
+            Kernel.puts "WARNING: Error while trying to load the #{module_name} module, because it doesn't exist."
+          end
+        rescue LoadError
+          nil
+        end
+      end
+
+      def transitions_from(block)
+        specification = SpecificationContext.new
+        specification.instance_eval(&block)
+        specification
+      end
+
+      class SpecificationContext
+        attr_reader :pre_condition, :before_action, :after_action
+
+        def initialize
+          @states = {}
+          @accepted_states = {}
+        end
+
+        def transition_for(state)
+          @states[state] || @states[@accepted_states[state]]
+        end
+
+        def applies_to?(state)
+          return true if @pre_condition.nil?
+          @pre_condition == state || has_state?(state) || accept_state?(state)
+        end
+
+        def has_state?(state)
+          not @states[state].nil?
+        end
+
+        def accept_state?(state)
+          not @accepted_states[state].nil?
+        end
+
+        private
+        def before(action)
+          @before_action = action.to_sym
+        end
+
+        def after(action)
+          @after_action = action.to_sym
+        end
+
+        def must_be(state)
+          @pre_condition = state.to_sym
+        end
+
+        def accept_state(states, opts)
+          [states].flatten.each {|state| @accepted_states[state] = opts[:as]}
+        end
+
+        def transition(name, options)
+          origin = options[:from].to_sym
+          target = options[:to].to_sym
+          condition = options[:if].to_sym unless options[:if].nil?
+          @states[origin] = { :target => target, :method => name, :if => condition }
+        end
+      end
+    end
+  end
+end
+
+ProcessSpecification = BPMachine::ProcessSpecification

data/lib/bpmachine/version.rb

@@ -0,0 +1,8 @@
+module BPMachine
+  module Version
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 0
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/lib/bpmachine.rb

@@ -0,0 +1,14 @@
+require 'active_support/core_ext/string/inflections'
+require 'bpmachine/process_specification'
+
+class InvalidInitialState < Exception
+  def initialize(name, expected_status, current_status)
+    @name = name
+    @expected_status = expected_status
+    @current_status = current_status
+  end
+
+  def message
+    "Process #{@name} requires object to have initial status #{@expected_status} or any transitional status, but it is #{@current_status}"
+  end
+end

data/spec/bpmachine_spec.rb

@@ -0,0 +1,248 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "the DSL for business process" do
+  describe "automatic module loading" do
+    it "should require a file named <process_name>_steps.rb if exists" do
+      Object.should be_const_defined(:UninstallSteps)
+    end
+
+    it "should include the steps definition module named <Process>Steps in the process declaring class" do
+      Machine.included_modules.should include(UninstallSteps)
+    end
+
+    it "should ignore step definition files that doesn't exist" do
+      declaration = lambda do
+        class ClassWithProcess
+          include ProcessSpecification
+          process :of => :anything do
+            transition :some_event, :from => :initial, :to => :final
+          end
+        end
+      end
+      declaration.should_not raise_error
+    end
+
+    it "should ignore step definition files that doesn't exist" do
+      declaration = lambda do
+        class ClassWithWrongProcess
+          include ProcessSpecification
+          process :of => :wrong do
+            transition :some_event, :from => :initial, :to => :final
+          end
+        end
+      end
+      Kernel.should_receive(:puts).with(/WrongSteps/)
+      declaration.should_not raise_error
+    end
+
+  end
+
+  it "should execute all transitions described in the process" do
+    machine = Machine.new
+    machine.status = :deactivated
+    machine.should_receive(:machine_exists?).and_return true
+    machine.should_receive :remove_disks
+    machine.should_receive :destroy_vm
+    machine.should_receive :erase_data
+
+    machine.uninstall
+    machine.status.should == :uninstalled
+  end
+
+  it "should not change state if condition fails" do
+  	machine = Machine.new
+  	machine.status = :deactivated
+  	machine.should_receive(:machine_exists?).and_return false
+
+  	machine.uninstall
+  	machine.status = :deactivated
+  end
+
+  it "should stop execution when a transition fail" do
+    machine = Machine.new
+    machine.status = :deactivated
+    machine.should_receive(:machine_exists?).and_return true
+    machine.should_receive :remove_disks
+    machine.should_receive(:destroy_vm).and_raise("execution fail")
+
+    lambda { machine.uninstall }.should raise_error("execution fail")
+    machine.status.should == :diskless
+  end
+
+  it "should require the initial state" do
+    machine = Machine.new
+    machine.status = :activated
+
+    lambda { machine.uninstall }.should raise_error(InvalidInitialState,
+        "Process uninstall requires object to have initial status deactivated or any transitional status, but it is activated")
+  end
+
+  it "should accept other states as determined state" do
+    machine = Machine.new
+    machine.status = :activated
+
+    machine.should_receive(:create_disks)
+    machine.install
+  end
+
+  it "should not accept unexpected stated" do
+    machine = Machine.new
+    machine.status = :deactivated
+    lambda { machine.install }.should raise_error(InvalidInitialState,
+        "Process install requires object to have initial status initial_status or any transitional status, but it is deactivated")
+  end
+
+  it "should execute subprocess" do
+    machine = Machine.new
+    machine.status = :ready_for_subprocess
+    machine.should_receive(:step1).ordered
+    machine.should_receive(:step2).ordered
+    machine.should_receive(:step3).ordered
+    machine.execute_with_subprocess
+    machine.status.should == :all_done
+  end
+
+  it "should resume a process stopped in a subprocess" do
+    machine = Machine.new
+    machine.status = :step1_done
+    machine.should_not_receive(:step1)
+    machine.should_receive(:step2).ordered
+    machine.should_receive(:step3).ordered
+    machine.execute_with_subprocess
+    machine.status.should == :all_done
+  end
+
+  it "should allow the process to resume from a transitional state" do
+    machine = Machine.new
+    machine.status = :diskless
+    machine.should_not_receive(:remove_disks)
+    machine.should_receive(:destroy_vm).ordered
+    machine.should_receive(:erase_data).ordered
+    machine.uninstall
+    machine.status.should == :uninstalled
+  end
+
+  it "should be case insensitive with status" do
+    machine = Machine.new
+    machine.status = :deactivated
+    machine.should_receive(:machine_exists?).ordered.and_return true
+    machine.should_receive(:remove_disks).ordered
+    machine.should_receive(:destroy_vm).ordered
+    machine.should_receive(:erase_data).ordered
+
+    machine.uninstall
+    machine.status.should == :uninstalled
+  end
+
+  it "should support custom code to be run before process start" do
+    class ProcessWithBeforeAction
+      include ProcessSpecification
+
+      attr_accessor :status
+
+      process :of => :anything do
+        before :do_action
+        must_be :initial
+        transition :some_event, :from => :initial, :to => :final
+      end
+
+      def save!
+    	end
+    end
+
+    process = ProcessWithBeforeAction.new
+    process.status = :initial
+    process.should_receive(:do_action).ordered
+    process.should_receive(:some_event).ordered
+    process.anything
+  end
+
+  it "should support custom code to be run after process start" do
+    class ProcessWithBeforeAction
+      include ProcessSpecification
+
+      process :of => :anything do
+        after :do_action
+        must_be :initial
+        transition :some_event, :from => :initial, :to => :final
+      end
+    end
+
+    process = ProcessWithBeforeAction.new
+    process.status = :initial
+    process.should_receive(:some_event).ordered
+    process.should_receive(:do_action).ordered
+    process.anything
+  end
+
+  it "should accept any initial state if there isn't a must_be rule" do
+    class InitialStateNotRequired
+      include ProcessSpecification
+
+      attr_accessor :status
+
+      process :of => :anything do
+        transition :some_event, :from => :initial, :to => :final
+        transition :other_event, :from => :other, :to => :final
+      end
+
+      def save!
+    	end
+    end
+
+    process = InitialStateNotRequired.new
+    process.status = :initial
+    process.should_receive :some_event
+    process.anything
+    process.status.should == :final
+
+    second_process = InitialStateNotRequired.new
+    second_process.status = :other
+    second_process.should_receive :other_event
+    second_process.anything
+    second_process.status.should == :final
+  end
+
+  it "should accept global 'after' blocks, passing the object processing the flow" do
+    machine = Machine.new
+
+    called = false
+    ProcessSpecification.after_processes do |process_object|
+      called = true
+      process_object.should be(machine)
+    end
+
+    machine.status = :deactivated
+    machine.should_receive(:machine_exists?).and_return true
+    machine.should_receive :remove_disks
+    machine.should_receive :destroy_vm
+    machine.should_receive :erase_data
+    machine.uninstall
+
+    called.should be_true
+  end
+
+  it "should raise error when model can't be saved" do
+    class TheProcess
+      include ProcessSpecification
+
+      attr_accessor :status
+
+      process :of => :anything do
+        transition :some_event, :from => :initial, :to => :final
+        transition :other_event, :from => :other, :to => :final
+      end
+
+      def save!
+        raise "Big Error!"
+    	end
+    end
+
+    process = TheProcess.new
+    process.status = :initial
+    process.stub!(:some_event)
+    process.stub!(:other_event)
+    lambda { process.anything }.should raise_error("Big Error!")
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "bpmachine"
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/support")
+require "machine"

data/spec/support/machine.rb

@@ -0,0 +1,59 @@
+class Machine
+  include ProcessSpecification
+
+  attr_accessor :status
+
+  process :of => :uninstall do
+    must_be :deactivated
+
+    transition :remove_disks,
+      :from => :deactivated,
+      :to => :diskless,
+      :if => :machine_exists?
+
+    transition :destroy_vm,
+      :from => :diskless,
+      :to => :vm_destroyed
+
+    transition :erase_data,
+      :from => :vm_destroyed,
+      :to => :uninstalled
+  end
+
+  process :of => :install do
+    must_be :initial_status
+    accept_state [:activated, :installed], :as => :initial_status
+
+    transition :create_disks,
+      :from => :initial_status,
+      :to => :diskless
+  end
+
+  process :of => :subprocess do
+    must_be :ready_for_subprocess
+    
+    transition :step1,
+      :from => :ready_for_subprocess,
+      :to => :step1_done
+
+    transition :step2,
+      :from => :step1_done,
+      :to => :subprocess_done
+  end
+
+  process :of => :execute_with_subprocess do
+    must_be :ready_for_subprocess
+    accept_state :step1_done, :as => :ready_for_subprocess
+    
+    transition :subprocess,
+      :from => :ready_for_subprocess,
+      :to => :subprocess_done
+
+    transition :step3,
+      :from => :subprocess_done,
+      :to => :all_done
+  end
+
+  def save!
+  end
+end

data/spec/support/uninstall_steps.rb

@@ -0,0 +1,2 @@
+module UninstallSteps
+end

data/spec/support/wrong_steps.rb

@@ -0,0 +1,2 @@
+module WrongNameSteps
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: bpmachine
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Cloud Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &10268920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *10268920
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &10268140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *10268140
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &10267500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10267500
+description: Includes a DSL for business process specification. The process state
+  is persistent, which allows it to be be resumed if an error occurs.
+email:
+- willian.molinari@locaweb.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./Gemfile.lock
+- ./bpmachine.gemspec
+- ./README.rdoc
+- ./LICENSE
+- ./spec/support/machine.rb
+- ./spec/support/uninstall_steps.rb
+- ./spec/support/wrong_steps.rb
+- ./spec/spec_helper.rb
+- ./spec/bpmachine_spec.rb
+- ./Gemfile
+- ./Rakefile
+- ./lib/bpmachine.rb
+- ./lib/bpmachine/process_specification.rb
+- ./lib/bpmachine/version.rb
+homepage: http://github.com/locaweb/bpmachine
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Includes a DSL for business process specification. The process state is persistent,
+  which allows it to be be resumed if an error occurs.
+test_files: []