renamed flow_handler to flow

README.md

@@ -96,9 +96,9 @@ class ServicesController < ApplicationController
 end
 ```
 
-A `FlowHandler` can use Executors to encapsulate execution logic, which again can execute Commands that encapsulate business logic related to the user Session or models (data).
+A `Flow` can use Executors to encapsulate execution logic, which again can execute Commands that encapsulate business logic related to the user Session or models (data).
 
-The FlowHandler takes the last event on the event stack and consults the ActionPaths registered, usually a Redirecter and Renderer. An ActionPath is a type of Action which can return a path. The FlowHandler initiates an Executor which iterates the ActionPaths to find the first one which can match the event.
+The Flow takes the last event on the event stack and consults the ActionPaths registered, usually a Redirecter and Renderer. An ActionPath is a type of Action which can return a path. The Flow initiates an Executor which iterates the ActionPaths to find the first one which can match the event.
 
 The first one with a match is returned as the Action, which the controller can then perform in order to either render or redirect.
 
@@ -117,14 +117,14 @@ Using these Controll artifacts/systems, you can avoid the typical Rails anti-pat
 The recommended approach to handle complex Controller logic using Controll:
 
 * Enable Controll on Controller
-* Configure Controller with FlowHandler, Commander and Notifier
+* Configure Controller with Flow, Commander and Notifier
 
 * Create Commands for Commander
 * Define events corresponding to commands
 * Configure Commander with Command methods
 
-* Create FlowHandler
-* Configure FlowHandler with Render and Redirect event mappings
+* Create Flow
+* Configure Flow with Render and Redirect event mappings
 
 * Create Notifier
 * Configure Notifier with Event handlers and event -> message mappings
@@ -192,7 +192,7 @@ class ServicesController < ApplicationController
   protected
 
   def create_action
-    @create_action ||= FlowHandlers::CreateService.new(self)
+    @create_action ||= Flows::CreateService.new(self)
   end
 
   fallback do |event|
@@ -217,7 +217,7 @@ class ServicesController
     extend ActiveSupport::Concern
 
     included do
-      controll :notifier, :commander, :flow_handler
+      controll :notifier, :commander, :flow
     end
 
     def fallback_action
@@ -274,12 +274,12 @@ The `Commander class extends `Imperator::Command::MethodFactory` making `#comman
 
 For how to implement the Commands themselves, see the [imperator-ext](https://github.com/kristianmandrup/imperator-ext) gem. 
 
-## FlowHandlers
+## Flows
 
-For Controller actions that require complex flow control, use a FlowHandler:
+For Controller actions that require complex flow control, use a Flow:
 
 ```ruby
-module FlowHandlers
+module Flows
   class CreateService < Master
 
     # event method that returns the event to be processed by the flow handler
@@ -314,22 +314,22 @@ module FlowHandlers
 end
 ```
 
-The `#renderer` and `#redirector` macros will each create a Class of the same name that inherit from Controll::FlowHandler::ActionMapper::Simple or Controll::FlowHandler::ActionMapper::Complex. 
+The `#renderer` and `#redirector` macros will each create a Class of the same name that inherit from Controll::Flow::ActionMapper::Simple or Controll::Flow::ActionMapper::Complex. 
 You can also define these classes directly yourself instead of using the macros.
 The *simple* action mapper maps a list of events to a single path and otherwise falls back.
 The complex action mapper maps the event to an event hash for each registered event type.
 
 In the `Redirecter` class we are setting up a mapping for various paths, for each path specifying which events should cause a redirect to that path.
 
-If you are rendering or redirecting to paths that take arguments, you can either extend the `#action` class method of your Redirect or Render class implementation or you can define a `#use_alternatives` method in your `FlowHandler` that contains this particular flow logic.
+If you are rendering or redirecting to paths that take arguments, you can either extend the `#action` class method of your Redirect or Render class implementation or you can define a `#use_alternatives` method in your `Flow` that contains this particular flow logic.
 
 Note: For mapping paths that take arguments, there should be an option to take a block (closure) to be late-evaluated on the controller context ;)
 
 ## The Executor
 
-The `Authenticator` class shown below inherits from `Executor::Notificator` which uses `#method_missing` in order to delegate any missing method back to the controller of the Executor. The FlowHandler passed in the controller. This means that calls can be executed directly on the controller, such as making notifications etc.
+The `Authenticator` class shown below inherits from `Executor::Notificator` which uses `#method_missing` in order to delegate any missing method back to the controller of the Executor. The Flow passed in the controller. This means that calls can be executed directly on the controller, such as making notifications etc.
 
-The `#result` call at the end of `#execute` ensures that the last notification event is returned, to be used for deciding what to render or where to redirect (see FlowHandler).
+The `#result` call at the end of `#execute` ensures that the last notification event is returned, to be used for deciding what to render or where to redirect (see Flow).
 
 ```ruby
 module Executors
@@ -450,12 +450,12 @@ Generate only specific controll folders
 
 * assistant
 * executor
-* flow_handler
+* flow
 * notifier
 
 Example usage:
 
-`$ rails g controll:flow_handler create_service`
+`$ rails g controll:flow create_service`
 
 Use `-h` for help on any specific controller for more usage options and info.
 

Rakefile

@@ -18,7 +18,7 @@ Jeweler::Tasks.new do |gem|
   gem.homepage = "http://github.com/kristianmandrup/controll"
   gem.license = "MIT"
   gem.summary = %Q{Utils for handling complex Controller/Business logic}
-  gem.description = %Q{FlowHandler, Executor, Notifier and more, all tied together tool pack}
+  gem.description = %Q{Flow, Executor, Notifier and more, all tied together tool pack}
   gem.email = "kmandrup@gmail.com"
   gem.authors = ["Kristian Mandrup"]
   # dependencies defined in Gemfile

controll.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kristian Mandrup"]
   s.date = "2012-08-16"
-  s.description = "FlowHandler, Executor, Notifier and more, all tied together tool pack"
+  s.description = "Flow, Executor, Notifier and more, all tied together tool pack"
   s.email = "kmandrup@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -34,15 +34,15 @@ Gem::Specification.new do |s|
     "lib/controll/executor.rb",
     "lib/controll/executor/base.rb",
     "lib/controll/executor/notificator.rb",
-    "lib/controll/flow_handler.rb",
-    "lib/controll/flow_handler/base.rb",
-    "lib/controll/flow_handler/control.rb",
-    "lib/controll/flow_handler/errors.rb",
-    "lib/controll/flow_handler/event_helper.rb",
-    "lib/controll/flow_handler/redirect.rb",
-    "lib/controll/flow_handler/redirect/action.rb",
-    "lib/controll/flow_handler/redirect/mapper.rb",
-    "lib/controll/flow_handler/render.rb",
+    "lib/controll/flow.rb",
+    "lib/controll/flow/base.rb",
+    "lib/controll/flow/control.rb",
+    "lib/controll/flow/errors.rb",
+    "lib/controll/flow/event_helper.rb",
+    "lib/controll/flow/redirect.rb",
+    "lib/controll/flow/redirect/action.rb",
+    "lib/controll/flow/redirect/mapper.rb",
+    "lib/controll/flow/render.rb",
     "lib/controll/helper.rb",
     "lib/controll/helper/event_matcher.rb",
     "lib/controll/helper/hash_access.rb",
@@ -115,11 +115,11 @@ Gem::Specification.new do |s|
     "spec/controll/command_spec.rb",
     "spec/controll/commander_spec.rb",
     "spec/controll/executor/notificator_spec.rb",
-    "spec/controll/flow_handler/control_spec.rb",
-    "spec/controll/flow_handler/redirect/action_spec.rb",
-    "spec/controll/flow_handler/redirect/mapper_spec.rb",
-    "spec/controll/flow_handler/redirect_spec.rb",
-    "spec/controll/flow_handler/render_spec.rb",
+    "spec/controll/flow/control_spec.rb",
+    "spec/controll/flow/redirect/action_spec.rb",
+    "spec/controll/flow/redirect/mapper_spec.rb",
+    "spec/controll/flow/redirect_spec.rb",
+    "spec/controll/flow/render_spec.rb",
     "spec/controll/helper/event_matcher_spec.rb",
     "spec/controll/helper/hash_access_spec.rb",
     "spec/controll/helper/notify_spec.rb",

lib/controll.rb

@@ -9,7 +9,7 @@ module Controll
 require 'controll/assistant'
 require 'controll/executor'
 require 'controll/notify'
-require 'controll/flow_handler'
+require 'controll/flow'
 require 'controll/helper'
 require 'controll/enabler'
 require 'controll/command'

lib/controll/enabler/macros.rb

@@ -46,11 +46,11 @@ def notifier name, options = {}
           end
         end
 
-        def flow_handler name, options = {}
-          define_method :flow_handler do
-            unless instance_variable_get("@flow_handler")
-              clazz = "FlowHandlers::#{name.to_s.camelize}".constantize        
-              instance_variable_set "@flow_handler", clazz.new(self, options)
+        def flow name, options = {}
+          define_method :flow do
+            unless instance_variable_get("@flow")
+              clazz = "Flows::#{name.to_s.camelize}".constantize        
+              instance_variable_set "@flow", clazz.new(self, options)
             end
           end
         end

lib/controll/enabler/path_resolver.rb

@@ -2,7 +2,7 @@ module Controll::Enabler
   class PathResolver
     attr_reader :caller, :event_map
 
-    ActionMapper = Controll::FlowHandler::ActionMapper
+    ActionMapper = Controll::Flow::ActionMapper
 
     def initialize caller, event_map
       @caller     = caller
@@ -30,7 +30,7 @@ def handle action
       else
         resolve_event
       end      
-    rescue Controll::FlowHandler::PathActionError
+    rescue Controll::Flow::PathActionError
       nil            
     end
 
@@ -40,7 +40,7 @@ def resolve_event event = nil
     end
 
     def mapper
-      @mapper ||= Controll::FlowHandler::EventMapper::Util.new main_event, event_map
+      @mapper ||= Controll::Flow::EventMapper::Util.new main_event, event_map
     end      
   end
 end

lib/controll/flow.rb

@@ -0,0 +1,14 @@
+require 'controll/flow/errors'
+
+module Controll
+  module Flow
+    autoload :Master,         'controll/flow/master'
+    autoload :EventMapper,    'controll/flow/event_mapper'    
+    autoload :ActionMapper,   'controll/flow/action_mapper'
+  end
+end
+
+module Flows
+  Master      = Controll::Flow::Master
+  Flow        = Controll::Flow::Master
+end

lib/controll/flow/action_mapper.rb

@@ -0,0 +1,10 @@
+module Controll::Flow
+  module ActionMapper
+    autoload :Action,       'controll/flow/action_mapper/action'
+    autoload :PathAction,   'controll/flow/action_mapper/path_action'
+    autoload :Fallback,     'controll/flow/action_mapper/fallback'
+
+    autoload :Simple,       'controll/flow/action_mapper/simple'
+    autoload :Complex,      'controll/flow/action_mapper/complex'
+  end
+end

lib/controll/flow_handler/action_mapper/action.rb → lib/controll/flow/action_mapper/action.rb

@@ -1,4 +1,4 @@
-module Controll::FlowHandler::ActionMapper
+module Controll::Flow::ActionMapper
   class Action
     attr_reader :path, :controller, :errors
 

lib/controll/flow_handler/action_mapper/complex.rb → lib/controll/flow/action_mapper/complex.rb

@@ -1,4 +1,4 @@
-module Controll::FlowHandler::ActionMapper
+module Controll::Flow::ActionMapper
   class Complex < PathAction
     attr_reader :maps
 
@@ -43,7 +43,7 @@ def path_finder event
       end
 
       def path_finder_class
-        Controll::FlowHandler::EventMapper::PathFinder
+        Controll::Flow::EventMapper::PathFinder
       end
     end
   end

lib/controll/flow_handler/action_mapper/fallback.rb → lib/controll/flow/action_mapper/fallback.rb

@@ -1,4 +1,4 @@
-module Controll::FlowHandler::ActionMapper
+module Controll::Flow::ActionMapper
   class Fallback < Action
     attr_reader :controller, :event
 

lib/controll/flow_handler/action_mapper/path_action.rb → lib/controll/flow/action_mapper/path_action.rb

@@ -1,4 +1,4 @@
-module Controll::FlowHandler::ActionMapper
+module Controll::Flow::ActionMapper
   class PathAction < Action
     def perform
       raise BadPathError, "Bad path: #{path}" if path.blank?

lib/controll/flow_handler/action_mapper/simple.rb → lib/controll/flow/action_mapper/simple.rb

@@ -1,7 +1,7 @@
-module Controll::FlowHandler::ActionMapper
+module Controll::Flow::ActionMapper
   class Simple < PathAction
-    NoEventsDefinedError      = Controll::FlowHandler::NoEventsDefinedError
-    NoDefaultPathDefinedError = Controll::FlowHandler::NoDefaultPathDefinedError
+    NoEventsDefinedError      = Controll::Flow::NoEventsDefinedError
+    NoDefaultPathDefinedError = Controll::Flow::NoDefaultPathDefinedError
 
     # TODO: Should combine with Redirecter style, allowing for multiple render path mappings!
     # This is fx useful for Wizards etc. where one Controller can render to many views, depending on state

lib/controll/flow_handler/errors.rb → lib/controll/flow/errors.rb

@@ -1,4 +1,4 @@
-module Controll::FlowHandler
+module Controll::Flow
   class ActionEventError          < StandardError; end
 
   class EventNotImplementedError  < StandardError; end

lib/controll/flow/event_mapper.rb

@@ -0,0 +1,6 @@
+module Controll::Flow
+  module EventMapper
+    autoload :Util,         'controll/flow/event_mapper/util'
+    autoload :PathFinder,   'controll/flow/event_mapper/path_finder'
+  end
+end

lib/controll/flow_handler/event_mapper/path_finder.rb → lib/controll/flow/event_mapper/path_finder.rb

@@ -1,9 +1,9 @@
-module Controll::FlowHandler
+module Controll::Flow
   class EventMapper
     class PathFinder
       attr_accessor :event, :maps, :types
 
-      NoMappingFoundError = Controll::FlowHandler::NoMappingFoundError
+      NoMappingFoundError = Controll::Flow::NoMappingFoundError
 
       # event <Event>
       def initialize event, maps, types = []
@@ -22,14 +22,14 @@ def path
 
       protected
 
-      include Controll::FlowHandler::EventHelper
+      include Controll::Flow::EventHelper
 
       def event_map
         @event_map ||= maps[event.type] || {}
       end
 
       def mapper
-        @mapper ||= Controll::FlowHandler::EventMapper::Util.new event, event_map
+        @mapper ||= Controll::Flow::EventMapper::Util.new event, event_map
       end      
     end
   end

lib/controll/flow_handler/event_mapper/util.rb → lib/controll/flow/event_mapper/util.rb

@@ -1,9 +1,9 @@
-module Controll::FlowHandler
+module Controll::Flow
   module EventMapper
     class Util        
       attr_reader :event_map, :event
 
-      NoMappingFoundError = Controll::FlowHandler::NoMappingFoundError
+      NoMappingFoundError = Controll::Flow::NoMappingFoundError
 
       def initialize event, event_map
         @event ||= normalize event

lib/controll/flow_handler/master.rb → lib/controll/flow/master.rb

@@ -1,7 +1,7 @@
-module Controll::FlowHandler
+module Controll::Flow
   class Master    
-    autoload :Macros,   'controll/flow_handler/master/macros'
-    autoload :Executor, 'controll/flow_handler/master/executor'
+    autoload :Macros,   'controll/flow/master/macros'
+    autoload :Executor, 'controll/flow/master/executor'
 
     include Macros
 
@@ -64,7 +64,7 @@ def action_handlers
     end
 
     def event
-      raise Controll::FlowHandler::EventNotImplementedError, 'You must define an #event method that returns an event (or Symbol). You can use an Executor for this.'
+      raise Controll::Flow::EventNotImplementedError, 'You must define an #event method that returns an event (or Symbol). You can use an Executor for this.'
     end
   end
 end

lib/controll/flow_handler/master/executor.rb → lib/controll/flow/master/executor.rb

@@ -1,10 +1,10 @@
-module Controll::FlowHandler
+module Controll::Flow
   class Master    
     class Executor < Controll::Executor::Base
-      FlowHandler = Controll::FlowHandler
+      Flow = Controll::Flow
 
-      NoEventsDefinedError  = FlowHandler::NoEventsDefinedError
-      NoMappingFoundError   = FlowHandler::NoMappingFoundError
+      NoEventsDefinedError  = Flow::NoEventsDefinedError
+      NoMappingFoundError   = Flow::NoMappingFoundError
 
       def initialize initiator, options = {}
         super
@@ -40,7 +40,7 @@ def fallback
       end
 
       def fallback_class
-        FlowHandler::ActionMapper::Fallback
+        Flow::ActionMapper::Fallback
       end
 
       def action_handlers