flowchart 0.0.1 → 1.0.1

data/README.rdoc

@@ -1,16 +1,23 @@
 = FlowChart
   
-  - Flowchart is a rubygem for State Machine(state-action-transition) workflow.
-  - Flowchart works out of the box both for ActiveRecord and Non-ActiveRecord Models.
-  - It provides an easy DSL to create a state machine flow for your model's object.
+  - Flowchart is a rubygem for StateFlow(state-action-transition) and WorkFlow(user-assigned-assigner) workflow.
+  - Flowchart(Stateflow) works out of the box both for ActiveRecord and Non-ActiveRecord Models.
+  - Flowchart(Workflow) works out of the box both for ActiveRecord
+  - It provides an easy DSL to create a workflow for your model's object.
+  - State Flow + Work FLow = Process Flow
+  - You can not only define states-action-transitions but also do a lot more with pre-process and post-process steps
+  - You can independently use either of StateFlow and WorkFlow or together, the way you need it
 
 == INSTALLATION
 
   gem install flowchart
 
-  # No other gem dependencies! Tested on Ruby 1.8.7 and Ruby 1.9.3
+  # No other gem dependencies! Tested on Ruby 1.8.7 and Ruby 1.9.3 | Rails 3.2.13 and Rails 2.3.8
 
-== SYNTAX & OPTIONS
+= SYNTAX & OPTIONS
+
+
+== STATEFLOW only
 
   flowchart do
     init_flowstate :init
@@ -30,34 +37,331 @@
     end
   end
 
-  # OPTIONS
-    1. By Default flowchart assumes that the model attribute it works on is "process_status. If you want to override it then :
-    flowchart do
-      state_column :some_other_column
-      .....
+=== OPTIONS
+  1. By Default flowchart assumes that the model attribute it works on is "process_status. 
+  If you want to override it then :
+  flowchart do
+    state_column :some_other_column
+    .....
+  end
+
+  2. Every flowstate can have options preprocess and postprocess blocks. 
+  You can mention any instance methods or Procs/lamdas to execute.
+
+  3. In Actions you can mention :condition with evaluate truth or falsity based on which the 
+  transition action(:from -> :to) is possible or not is determined. 
+  If :condition is not given transition is always evaluated to truth.
+
+  4. In Actions you can also mention :branch, when you have multiple :to states from one single :from state 
+  then you can mention a ":branch" condition which you can execute and determine 
+  which branch state will be the next! Useful in decision trees.
+
+=== Methods
+  1. obj.{state_name}? returns boolean true/false if object is in that that state
+
+  2. obj.{action} returns the transtion to next state on executing the action
+
+  3. obj.{action}! returns the transition to next state on executing the action and save after call
+
+  4. obj.current_state returns the current_state of the object
+    e.g  #<FlowChart::State:0x9e6e3f4 @flowstatename=:uploaded, @before_and_after_works={:postprocess=>#<Proc:0x099dc28c@(irb):30>, :preprocess=>#<Proc:0x099dc3e0@(irb):29>}>
+
+  5. obj.flowprocessor returns the complete tree of flowchart for the object!
+    e.g. #<FlowChart::FlowProcessor:0x9e6e5e8
+         @actions=
+          {:close=>
+            #<FlowChart::Action:0x9e6df80
+             @flowprocessor=#<FlowChart::FlowProcessor:0x9e6e5e8 ...>,
+             @name=:close,
+             @transitions=
+              [#<FlowChart::Transition:0x9e6dea4
+                @branch=nil,
+                @condition=:file_close?,
+                @from=[:init, :uploaded, :open],
+                @to=:closed>]>,
+           :upload=>
+            #<FlowChart::Action:0x9e6e110
+             @flowprocessor=#<FlowChart::FlowProcessor:0x9e6e5e8 ...>,
+             @name=:upload,
+             @transitions=
+              [#<FlowChart::Transition:0x9e6e084
+                @branch=nil,
+                @condition=:file_parsable?,
+                @from=[:init],
+                @to=:uploaded>]>,
+           :process=>
+            #<FlowChart::Action:0x9e6e070
+             @flowprocessor=#<FlowChart::FlowProcessor:0x9e6e5e8 ...>,
+             @name=:process,
+             @transitions=
+              [#<FlowChart::Transition:0x9e6df94
+                @branch=:choose_branch,
+                @condition=nil,
+                @from=[:uploaded],
+                @to=[:open, :closed]>]>},
+         @flowstates=
+          {:init=>
+            #<FlowChart::State:0x9e6e4f8
+             @before_and_after_works=
+              {:postprocess=>:notify_user, :preprocess=>#<Proc:0x099dca84@(irb):24>},
+             @flowstatename=:init>,
+           :open=>
+            #<FlowChart::State:0x9e6e2dc
+             @before_and_after_works={:postprocess=>#<Proc:0x099db8f0@(irb):35>},
+             @flowstatename=:open>,
+           :uploaded=>
+            #<FlowChart::State:0x9e6e3f4
+             @before_and_after_works=
+              {:postprocess=>#<Proc:0x099dc28c@(irb):30>,
+               :preprocess=>#<Proc:0x099dc3e0@(irb):29>},
+             @flowstatename=:uploaded>,
+           :closed=>
+            #<FlowChart::State:0x9e6e1d8
+             @before_and_after_works=
+              {:postprocess=>:notify_user, :preprocess=>#<Proc:0x099daf18@(irb):39>},
+             @flowstatename=:closed>},
+         @starting_flowstate=
+          #<FlowChart::State:0x9e6e4f8
+           @before_and_after_works=
+            {:postprocess=>:notify_user, :preprocess=>#<Proc:0x099dca84@(irb):24>},
+           @flowstatename=:init>,
+         @starting_flowstate_name=:init,
+         @state_column=:process_status>
+
+
+
+== WORKFLOW only
+
+  # Example of a Non-ActiveRecord Class using FlowChart in Ruby - showing only Work Machine
+  # Require 'active_record'
+  class User
+    attr_accessor :email
+    def initialize(email)
+      @email=email
     end
+  end
+  u1=User.new("1@gmail.com")
+  u2=User.new("2@gmail.com")
+  u3=User.new("3@gmail.com")
+  u4=User.new("4@gmail.com")
 
-    2. Every flowstate can have options preprocess and postprocess blocks. You can mention any instance methods or Procs/lamdas to execute.
+  class SampleWork
+    include FlowChart
+    require 'active_record'
+    attr_accessor :assigned_to,:assigned_by
+    workchart do
 
-    3. In Actions you can mention :condition with evaluate truth or falsity based on which the transition action(:from -> :to) is possible or not is determined. If :condition is not given transition is always evaluated to truth.
+      assigned_to_column :assigned_to
+      assigned_by_column :assigned_by
 
-    4. In Actions you can also mention :branch, when you have multiple :to states from one single :from state then you can mention a ":branch" condition which you can execute and determine which branch state will be the next! Useful in decision trees.
+      workowner :user do
+        goal_time lambda{ 2.days }
+        dead_line lambda{ 3.days }
+      end
 
-  # Methods
+      delegate :feed_pairing_work
+      delegate :feed_publishing_work
+      delegate :confirmation_work
+    end
 
-    1. obj.{state_name}? returns boolean true/false if object is in that that state
+  end
 
-    2. obj.{action} returns the transtion to next state on executing the action
 
-    3. obj.{action}! returns the transition to next state on executing the action and save after call
+  === OPTIONS
+    1. By Default flowchart assumes that the model attributes for work_assignments are 'assigned_to' & assigned_by'
+    If you want to override it then :
+      flowchart do
+        assigned_to_column :some_other_column1
+        assigned_by_column :some_other_column2
+        .....
+      end
 
-    4. obj.current_state returns the current_state of the object
+    2. Every Workchart belongs to a workowner, here it is User Model. goal_time and dead_line are default SLA you can mention
+    for the work! You can call these procs later to monitor the SLA in your Application.
+      ...
+      workowner :user do
+        goal_time lambda{ 2.days }
+        dead_line lambda{ 3.days }
+      end
+      ...
+
+    3. There can be multiple tasks associated with a work. Each task here is knows as 'delegate'
+      ...
+      delegate :feed_pairing_work
+      ...
+
+    4. Once the object of SampleWork is created you can use your delegate tasks and assign users to them\
+      ...
+       obj.feed_pairing_work(u1,u2)
+       # or obj.feed_pairing_work!(u1,u2)
+       # mentioning ! will save the obj object after callbacks
+      ...
+
+    5. We cav have multiple delegates(tasks) which means each of these tasks can have completely separate set of WorkOwners(assigned_by, assigned_to). At any given point 'obj.current_work_owners' should give the work_owners at the moment for each delegates!
+
+    6. If you want to see the trace of WorkOwners for each delegates go through the tree 'obj.workprocessor'. You will see for every delegate actions we keep the trace of work_owners which changes i.e yesterday it might be u1,u2 today it might be u3,u4 for a delegate. Keeping trace can be an added feature that can be used for logging in your Application.
+
+
+  === Methods
+    1. obj.{current_work_owners} returns the set of current_work_owners for each delegate task
+      e.g. [{:feed_pairing_work=>{:assigned_to=>#<User:0x99e3d84 @email="1@gmail.com">, :assigned_by=>#<User:0x9a027d4 @email="2@gmail.com">}}, {:feed_publishing_work=>{}}, {:confirmation_work=>{}}]
+
+    2. YAML.load(obj.assigned_by) returns the set of work_owners(assiged_by) for each delegate task
+      e.g. [{:feed_pairing_work=>#<User:0x9eac744 @email="2@gmail.com">}, {:feed_publishing_work=>""}, {:confirmation_work=>""}]
+
+    3. YAML.load(obj.assigned_to) returns the set of work_owners(assiged_to) for each delegate task
+      e.g. [{:feed_pairing_work=>#<User:0x9ea9db4 @email="1@gmail.com">}, {:feed_publishing_work=>""}, {:confirmation_work=>""}]
+
+    3. obj.{delegate}(user1obj,user2obj) assigns the delegate task where 'user2obj' is assigner and user1.obj is assigned_to
+
+    4. obj.workprocessor.work_owners returns the Hash of owner types for this work item with sla configs
+      e.g. {:user=>#<FlowChart::WorkOwner:0x9e6d760 @sla={:goal_time=>#<Proc:0x099d86b4@(irb):63>, :dead_line=>#<Proc:0x099d859c@(irb):64>}, @work_owner_model=User>}
+
+    5. obj.workprocessor.delegate_actions returns all the delegates actions for this work that has been defined
+      e.g. {:feed_pairing_work=>
+            #<FlowChart::WorkDelegateAction:0x9e6d404
+             @current_work_owners=
+              {:assigned_to=>#<User:0x99e3d84 @email="1@gmail.com">,
+               :assigned_by=>#<User:0x9a027d4 @email="2@gmail.com">},
+             @delegate_action_name=:feed_pairing_work,
+             @work_owners_trace=
+              [{:assigned_to=>#<User:0x99e3d84 @email="1@gmail.com">,
+                :assigned_by=>#<User:0x9a027d4 @email="2@gmail.com">}]>,
+           :feed_publishing_work=>
+            #<FlowChart::WorkDelegateAction:0x9e6d3f0
+             @current_work_owners={},
+             @delegate_action_name=:feed_publishing_work,
+             @work_owners_trace=[]>,
+           :confirmation_work=>
+            #<FlowChart::WorkDelegateAction:0x9e6d3b4
+             @current_work_owners={},
+             @delegate_action_name=:confirmation_work,
+             @work_owners_trace=[]>}
+
+    5. obj.workprocessor returns the complete tree of flowchart for the object!
+      e.g. #<FlowChart::WorkProcessor:0x9e6d814
+             @assigned_by_column=:assigned_by,
+             @assigned_to_column=:assigned_to,
+             @delegate_actions=
+              {:feed_pairing_work=>
+                #<FlowChart::WorkDelegateAction:0x9e6d404
+                 @current_work_owners=
+                  {:assigned_to=>#<User:0x99e3d84 @email="1@gmail.com">,
+                   :assigned_by=>#<User:0x9a027d4 @email="2@gmail.com">},
+                 @delegate_action_name=:feed_pairing_work,
+                 @work_owners_trace=
+                  [{:assigned_to=>#<User:0x99e3d84 @email="1@gmail.com">,
+                    :assigned_by=>#<User:0x9a027d4 @email="2@gmail.com">}]>,
+               :feed_publishing_work=>
+                #<FlowChart::WorkDelegateAction:0x9e6d3f0
+                 @current_work_owners={},
+                 @delegate_action_name=:feed_publishing_work,
+                 @work_owners_trace=[]>,
+               :confirmation_work=>
+                #<FlowChart::WorkDelegateAction:0x9e6d3b4
+                 @current_work_owners={},
+                 @delegate_action_name=:confirmation_work,
+                 @work_owners_trace=[]>},
+             @work_owners=
+              {:user=>
+                #<FlowChart::WorkOwner:0x9e6d760
+                 @sla=
+                  {:goal_time=>#<Proc:0x099d86b4@(irb):63>,
+                   :dead_line=>#<Proc:0x099d859c@(irb):64>},
+                 @work_owner_model=User>}>
+
+
+== WORKFLOW+STATEFLOW (Complete Flowchart)
+  # Example of a Non-ActiveRecord Class using FlowChart in Ruby - showing State Machine & Work Machine = Flowchart
+  # requires 'active_record' for Workflow
+  class User
+    attr_accessor :email
+    def initialize(email)
+      @email=email
+    end
+  end
+  u1=User.new("1@gmail.com")
+  u2=User.new("2@gmail.com")
+  u3=User.new("3@gmail.com")
+  u4=User.new("4@gmail.com")
 
-    5. obj.flowprocessor returns the complete tree of flowchart for the object!
+  class SampleFlowchart
+    include FlowChart
+    require 'active_record'
+    attr_accessor :process_status
+    attr_accessor :assigned_to,:assigned_by
 
+    flowchart do
+      init_flowstate :init
 
+      flowstate :init do
+        preprocess Proc.new { |o| p "Initializing File" }
+        postprocess :notify_user
+      end
 
-== Sample Use
+      flowstate :uploaded do
+        preprocess Proc.new  { |o| p "Validating File" }
+        postprocess Proc.new  { |o| p "File has been uploaded in system" }
+      end
+
+      flowstate :open do
+        postprocess :notify_user
+        postprocess Proc.new  { |o| p "File has been closed" }
+      end
+
+      flowstate :closed do
+        preprocess Proc.new  { |o| p "File closed" }
+        postprocess :notify_user
+      end
+
+      action :upload do
+        transitions :from => :init, :to => :uploaded, :condition => :file_parsable?
+      end
+
+      action :process do
+        transitions :from => :uploaded, :to => [:open, :closed], :branch => :choose_branch
+      end
+
+      action :close do
+        transitions :from => [:init,:uploaded,:open], :to => :closed, :condition => :file_close?
+      end
+
+    end
+
+    workchart do
+
+      assigned_to_column :assigned_to
+      assigned_by_column :assigned_by
+
+      workowner :user do
+        goal_time lambda{ 2.days }
+        dead_line lambda{ 3.days }
+      end
+
+      delegate :feed_pairing_work
+      delegate :feed_publishing_work
+      delegate :confirmation_work
+    end
+
+    def choose_branch
+      6 > 5 ? :open : :closed
+    end
+
+    def notify_user
+      p "Notifying User!"
+    end
+
+    def file_parsable?
+      3 > 2 ? true : false
+    end
+
+    def file_close?
+      1 > 0 ? true : false 
+    end
+  end
+
+
+== Sample showing Stateflow only
 
   # Example of a Non-ActiveRecord Class using FlowChart in Ruby
   # in irb console
@@ -153,6 +457,9 @@
   t.current_state
      #<FlowChart::State:0x9a3fbfc @flowstatename=:closed, @before_and_after_works={:preprocess=>#<Proc:0x09a41024@(irb):26>, :postprocess=>:notify_user}>
 
+== Samples
+  You can refer to the example codes mentioned here in 'samples' directory
+
 == Save! in ActiveRecord Model
 
-For any action if you choose to follow it up with a '!' then the model object is saved after action call. Similarly for an action if you choose to not follow it up with a '!' it will only update the attributes for the model object
+For any action in Stateflow and any delgate action in Work Flow if you choose to follow it up with a '!' then the model object is saved after action call. Similarly for an action in Stateflow and any delgate action in Work Flow if you choose to not follow it up with a '!' it will only update the attributes for the model object, not save it.

data/flowchart.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |f|
   f.name          = 'flowchart'
-  f.version       = '0.0.1'
+  f.version       = '1.0.1'
   f.date          = %q{2013-09-27}
-  f.summary       = %q{State Machine and State Flow for Ruby}
-  f.description   = %q{Flowchart is a State Machine(state-action-transition) workflow for Non-ActiveRecord and ActiveRecord Model in Ruby or Rails}
+  f.summary       = %q{State Flow and Work Flow Process gem in Ruby}
+  f.description   = %q{Flowchart is a StateFlow(states-actions-transitions) and WorkFlow(users-assigned-assigners) process design for Non-ActiveRecord and ActiveRecord Model in Ruby or Rails}
   f.authors       = %q{Shuddhashil Ray}
   f.email         = %q{rayshuddhashil@gmail.com}
-  f.files         = ["README.rdoc","LICENSE.txt","flowchart.gemspec","lib/flow_chart.rb","lib/flowchart/flow_processor.rb","sample/sample_one.rb"]
+  f.files         = ["README.rdoc","LICENSE.txt","flowchart.gemspec","lib/flow_chart.rb","lib/flowchart/flow_processor.rb","lib/flowchart/work_processor.rb","sample/sample_state.rb","sample/sample_work.rb","sample/sample_flowchart.rb"]
   f.require_paths = ["lib"]
   f.homepage      = %q{http://github.com/raycoding/flowchart}
   f.license       = "MIT"

data/lib/flow_chart.rb

@@ -1,4 +1,7 @@
+require 'rubygems'
+require 'yaml'
 require 'flowchart/flow_processor'
+require 'flowchart/work_processor'
 module FlowChart
   def self.included(base)
     base.extend ClassMethods
@@ -6,7 +9,7 @@ module FlowChart
   end
 
   module ClassMethods
-    attr_reader :flowprocessor
+    attr_reader :flowprocessor,:workprocessor
     
     def flowchart(&block)
       @flowprocessor = FlowChart::FlowProcessor.new(&block)
@@ -29,11 +32,31 @@ module FlowChart
         end
       end
     end
+
+    def workchart(&block)
+      @workprocessor = FlowChart::WorkProcessor.new(&block)
+
+      #Driver Instance Methods for each evet for triggering the delegation action!
+      @workprocessor.delegate_actions.keys.each do |key|
+        define_method "#{key}" do |assigned_to,assigned_by|
+          process_delegate_action(key,assigned_to,assigned_by,:save_object=>false)
+        end
+        
+        define_method "#{key}!" do |assigned_to,assigned_by|
+          process_delegate_action(key,assigned_to,assigned_by,:save_object=>true)
+        end
+      end
+    end
+
   end
 
   module InstanceMethods
     attr_accessor :previous_state
 
+    def workprocessor
+      self.class.workprocessor
+    end
+
     def flowprocessor
       self.class.flowprocessor
     end
@@ -57,7 +80,21 @@ module FlowChart
         self.save
       end
     end
-    
+
+    def current_work_owners
+      @current_work_owners ||= workprocessor.delegate_actions.map{|work_name,work_owners| {work_name=>work_owners.current_work_owners}}
+      @current_work_owners
+    end
+
+    def set_current_work_owners(options = {})
+      @current_work_owners = workprocessor.delegate_actions.map{|work_name,work_owners| {work_name=>work_owners.current_work_owners}}
+      send("#{workprocessor.assigned_to_column}=".to_sym, YAML.dump(current_work_owners.map{|work| work.map{|work_name,owners| {work_name=>owners[workprocessor.assigned_to_column.to_sym]||""}}}.flatten))
+      send("#{workprocessor.assigned_by_column}=".to_sym, YAML.dump(current_work_owners.map{|work| work.map{|work_name,owners| {work_name=>owners[workprocessor.assigned_by_column.to_sym]||""}}}.flatten))
+      if options[:save_object] and !(defined?(ActiveRecord::Base).nil?) and self.class.ancestors.include? ActiveRecord::Base 
+        self.save
+      end
+    end
+
     private
     def process_action(action_name,options_for_action = {})
       action = flowprocessor.actions[action_name.to_sym]
@@ -67,5 +104,14 @@ module FlowChart
       end
       action.process_action!(self,current_state,options_for_action)
     end
+
+    def process_delegate_action(action_name,assigned_to,assigned_by,options_for_delegate_action={})
+      delegate_action = workprocessor.delegate_actions[action_name.to_sym]
+      if delegate_action.nil?
+        p "Error: #{action_name} not found!"
+        raise FlowChart::InvalidWorkDelegateAction.new("Error: #{delegate_action} not found!")
+      end
+      delegate_action.process_delegate_action!(self,current_work_owners,assigned_to,assigned_by,options_for_delegate_action)
+    end
   end
 end

data/lib/flowchart/work_processor.rb

@@ -0,0 +1,85 @@
+module FlowChart
+  class InvalidWorkDelegateAction < NoMethodError; end
+
+  class WorkOwner
+  	attr_accessor :work_owner_model,:sla
+    
+    def initialize(work_owner_model, &workownerblock)
+    	@work_owner_model,@sla = work_owner_model.to_s.classify.constantize,Hash.new
+      instance_eval(&workownerblock) if block_given?
+    end
+
+    def goal_time(method = nil, &block)
+      @sla[:goal_time] = method.nil? ? block : method
+    end
+
+    def dead_line(method = nil, &block)
+      @sla[:dead_line] = method.nil? ? block : method
+    end
+
+    def self.work_assign(to,by)
+    	assigned_to,assigned_by = to,by
+    	return Hash[:assigned_to=> assigned_to, :assigned_by=>assigned_by]
+    end
+  end
+
+  class WorkDelegateAction
+  	attr_accessor :delegate_action_name
+  	attr_accessor :current_work_owners
+  	attr_accessor :work_owners_trace
+  	
+  	def initialize(delegate_action_name,workprocessor=nil,&block)
+  		@current_work_owners = Hash.new
+  		@work_owners_trace = []
+  		@delegate_action_name = delegate_action_name
+  	end
+
+  	def process_delegate_action!(implementor_class,current_work_owners,assigned_to,assigned_by,options_for_delegate_action)
+  		puts @delegate_action_name
+  		new_work_owners = WorkOwner.work_assign(assigned_to,assigned_by)
+  		@work_owners_trace << new_work_owners
+  		@current_work_owners = new_work_owners
+  		implementor_class.set_current_work_owners(options_for_delegate_action)
+  	end
+
+  end
+
+   # Main Driver for WorkChart
+  class WorkProcessor
+  	attr_accessor :work_owners,:delegate_actions
+
+  	def initialize(&workprocessor)
+  		@work_owners, @delegate_actions = Hash.new, Hash.new
+      begin
+        instance_eval(&workprocessor)
+      rescue => e
+        p e.backtrace
+      end
+    end
+
+    ## Default state_column is assumed to be assigned_to if not mentioned
+    # You can override the default state_column by mentioning in your class
+    # assigned_to_column :something_else
+    def assigned_to_column(name = :assigned_to)
+      @assigned_to_column ||= name
+    end
+
+    ## Default state_column is assumed to be assigned_by if not mentioned
+    # You can override the default state_column by mentioning in your class
+    # assigned_by_column :something_else
+    def assigned_by_column(name = :assigned_by)
+      @assigned_by_column ||= name
+    end
+
+    def workowner(work_owner_model, &block)
+      work_owner = FlowChart::WorkOwner.new(work_owner_model,&block)
+      @work_owners[work_owner_model.to_sym] = work_owner
+    end
+
+    def delegate(delegate_action_name, &block)
+    	delegate_action = FlowChart::WorkDelegateAction.new(delegate_action_name,self,&block)
+      @delegate_actions[delegate_action_name.to_sym] = delegate_action
+    end
+
+  end
+end

data/sample/sample_flowchart.rb

@@ -0,0 +1,87 @@
+# Example of a Non-ActiveRecord Class using FlowChart in Ruby - showing State Machine & Work Machine = Flowchart
+# requires 'active_record' for Workflow
+class User
+  attr_accessor :email
+  def initialize(email)
+    @email=email
+  end
+end
+u1=User.new("1@gmail.com")
+u2=User.new("2@gmail.com")
+u3=User.new("3@gmail.com")
+u4=User.new("4@gmail.com")
+
+class SampleFlowchart
+  include FlowChart
+  require 'active_record'
+  attr_accessor :process_status
+  attr_accessor :assigned_to,:assigned_by
+
+  flowchart do
+    init_flowstate :init
+
+    flowstate :init do
+      preprocess Proc.new { |o| p "Initializing File" }
+      postprocess :notify_user
+    end
+
+    flowstate :uploaded do
+      preprocess Proc.new  { |o| p "Validating File" }
+      postprocess Proc.new  { |o| p "File has been uploaded in system" }
+    end
+
+    flowstate :open do
+      postprocess :notify_user
+      postprocess Proc.new  { |o| p "File has been closed" }
+    end
+
+    flowstate :closed do
+      preprocess Proc.new  { |o| p "File closed" }
+      postprocess :notify_user
+    end
+
+    action :upload do
+      transitions :from => :init, :to => :uploaded, :condition => :file_parsable?
+    end
+
+    action :process do
+      transitions :from => :uploaded, :to => [:open, :closed], :branch => :choose_branch
+    end
+
+    action :close do
+      transitions :from => [:init,:uploaded,:open], :to => :closed, :condition => :file_close?
+    end
+
+  end
+
+  workchart do
+
+    assigned_to_column :assigned_to
+    assigned_by_column :assigned_by
+
+    workowner :user do
+      goal_time lambda{ 2.days }
+      dead_line lambda{ 3.days }
+    end
+
+    delegate :feed_pairing_work
+    delegate :feed_publishing_work
+    delegate :confirmation_work
+  end
+
+  def choose_branch
+    6 > 5 ? :open : :closed
+  end
+
+  def notify_user
+    p "Notifying User!"
+  end
+
+  def file_parsable?
+    3 > 2 ? true : false
+  end
+
+  def file_close?
+    1 > 0 ? true : false 
+  end
+end

data/sample/{sample_one.rb → sample_state.rb}

@@ -1,6 +1,6 @@
-# Example of a Non-ActiveRecord Class using FlowChart in Ruby
+# Example of a Non-ActiveRecord Class using FlowChart in Ruby - showing only State Machine
 
-class SampleOne
+class SampleState
   include FlowChart
   attr_accessor :process_status
 

data/sample/sample_work.rb

@@ -0,0 +1,33 @@
+# Example of a Non-ActiveRecord Class using FlowChart in Ruby - showing only Work Machine
+# Require 'active_record'
+class User
+  attr_accessor :email
+  def initialize(email)
+    @email=email
+  end
+end
+u1=User.new("1@gmail.com")
+u2=User.new("2@gmail.com")
+u3=User.new("3@gmail.com")
+u4=User.new("4@gmail.com")
+
+class SampleWork
+	include FlowChart
+  require 'active_record'
+	attr_accessor :assigned_to,:assigned_by
+  workchart do
+
+    assigned_to_column :assigned_to
+    assigned_by_column :assigned_by
+
+    workowner :user do
+      goal_time lambda{ 2.days }
+      dead_line lambda{ 3.days }
+    end
+
+    delegate :feed_pairing_work
+    delegate :feed_publishing_work
+    delegate :confirmation_work
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: flowchart
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 21
   prerelease: 
   segments: 
-  - 0
+  - 1
   - 0
   - 1
-  version: 0.0.1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Shuddhashil Ray
@@ -19,7 +19,7 @@ date: 2013-09-27 00:00:00 +05:30
 default_executable: 
 dependencies: []
 
-description: Flowchart is a State Machine(state-action-transition) workflow for Non-ActiveRecord and ActiveRecord Model in Ruby or Rails
+description: Flowchart is a StateFlow(states-actions-transitions) and WorkFlow(users-assigned-assigners) process design for Non-ActiveRecord and ActiveRecord Model in Ruby or Rails
 email: rayshuddhashil@gmail.com
 executables: []
 
@@ -33,7 +33,10 @@ files:
 - flowchart.gemspec
 - lib/flow_chart.rb
 - lib/flowchart/flow_processor.rb
-- sample/sample_one.rb
+- lib/flowchart/work_processor.rb
+- sample/sample_state.rb
+- sample/sample_work.rb
+- sample/sample_flowchart.rb
 has_rdoc: true
 homepage: http://github.com/raycoding/flowchart
 licenses: 
@@ -67,6 +70,6 @@ rubyforge_project:
 rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
-summary: State Machine and State Flow for Ruby
+summary: State Flow and Work Flow Process gem in Ruby
 test_files: []