controll 0.2.0

data/lib/controll/flow_handler/errors.rb

@@ -0,0 +1,5 @@
+module Controll::FlowHandler
+  class NoRedirectionFoundError < StandardError; end
+  class NoEventsDefinedError < StandardError; end
+  class BadPathError < StandardError; end
+end

data/lib/controll/flow_handler/event_helper.rb

@@ -0,0 +1,18 @@
+module Controll::FlowHandler
+  module EventHelper
+    def types
+      @types ||= [:notice, :error]
+    end
+
+    def normalize event
+      case event
+      when Symbol
+        Hashie::Mash.new name: event, type: :notice
+      when Hash, Hashie::Mash
+        event
+      else
+        raise Controll::InvalidEvent, "Event: #{event} could not be normalized, must be a Hash or Symbol"
+      end
+    end
+  end
+end

data/lib/controll/flow_handler/redirect.rb

@@ -0,0 +1,51 @@
+require 'controll/flow_handler/base'
+
+module Controll::FlowHandler
+  class Redirect < Base    
+    autoload :Action, 'controll/flow_handler/redirect/action'
+    autoload :Mapper, 'controll/flow_handler/redirect/mapper'
+
+    def initialize path
+      super path
+    end
+
+    def perform controller
+      controller.do_redirect controller.send(path)
+    end
+
+    class << self
+      attr_accessor :redirections
+      attr_writer   :redirect_maps, :action_clazz
+
+      def action event
+        path = action_clazz.new(event, redirections, types).map
+        self.new path unless path.blank?
+      end
+
+      def types
+        @types ||= [:notice, :error]
+      end
+
+      def redirections_for type = :notice
+        @redirections ||= {}
+        @redirections[type.to_sym] || {}
+      end
+
+      def set_redirections *args
+        type = args.first.kind_of?(Symbol) ? args.shift : :notice
+        @redirections ||= {}
+        @redirections[type.to_sym] = args.first
+      end 
+
+      def set_types *names
+        @redirect_maps ||= names.flatten
+      end  
+
+      protected
+
+      def action_clazz
+        @action_clazz ||= Controll::FlowHandler::Redirect::Action
+      end
+    end
+  end
+ end

data/lib/controll/flow_handler/redirect/action.rb

@@ -0,0 +1,45 @@
+module Controll::FlowHandler
+  class Redirect < Base
+    class Action
+      attr_accessor :event, :redirections, :types
+
+      # event is a Hashie::Mash or simply a Symbol (default notice event)
+      def initialize event, redirections, types = []
+        raise ArgumentError, "Must take :event option, was: #{event}" if event.blank?
+        raise ArgumentError, "Must take non-empty :redirections option, was: #{redirections}" if redirections.blank?
+        @event = normalize event
+        @types = types unless types.blank?
+        @redirections = redirections
+      end
+
+      def map        
+        if redirect.blank?
+          raise Controll::FlowHandler::NoRedirectionFoundError, "No redirection could be found for: #{event} in: #{redirections}"
+        end
+        redirect        
+      end
+
+      protected
+
+      include Controll::FlowHandler::EventHelper
+
+      def redirect
+        @redirect ||= mapper(redirect_map).map 
+      rescue StandardError => e
+        raise Controll::FlowHandler::NoRedirectionFoundError, "No redirection could be found for: #{event} in: #{redirections}. Cause: #{e}"
+      end
+
+      def redirect_map
+        @redirect_map ||= redirections[event.type] || {}
+      end
+
+      def mapper redirect_map
+        @mapper ||= mapper_class.new event, redirect_map
+      end      
+
+      def mapper_class
+        Controll::FlowHandler::Redirect::Mapper
+      end
+    end
+  end
+end

data/lib/controll/flow_handler/redirect/mapper.rb

@@ -0,0 +1,41 @@
+module Controll::FlowHandler
+  class Redirect < Base
+    class Mapper
+      attr_reader :redirect_map, :event
+
+      def initialize event, redirect_map
+        @event ||= normalize event
+
+        unless valid_map? redirect_map
+          raise ArgumentError, "Invalid redirect map: #{redirect_map}, must be a Hash" 
+        end
+        @redirect_map ||= redirect_map
+      end
+
+      # An events can also be a Symbol,
+      # in which case it is a :notice event
+      def map
+        redirect_map.each do |path, events|            
+          return path.to_s if valid? events
+        end
+        raise Controll::FlowHandler::NoRedirectionFoundError, "No path could be found for event: #{event} in map: #{redirect_map}" 
+      end
+
+      protected
+
+      include Controll::FlowHandler::EventHelper
+
+      def valid_map? redirect_map
+        redirect_map.kind_of?(Hash) && !redirect_map.blank?
+      end
+
+      def valid? events
+        matcher(event).match?(events)
+      end
+
+      def matcher event
+        @matcher ||= Controll::Helper::EventMatcher.new event
+      end        
+    end
+  end
+end

data/lib/controll/flow_handler/render.rb

@@ -0,0 +1,51 @@
+require 'controll/flow_handler/base'
+
+module Controll::FlowHandler
+  class Render < Base
+    class NoEventsDefinedError < StandardError; end
+    class BadPathError < StandardError; end
+
+    def initialize path #, events = []
+      super path
+      # @events = events
+    end
+
+    def perform controller
+      raise BadPathError, "Bad path: #{path}" if path.blank?
+      controller.render controller.send(path)
+    end
+
+    class << self
+      def action event, path = nil
+        raise Controll::FlowHandler::NoEventsDefinedError, "You must define a #{self}#events class method that returns a render map" unless respond_to?(:events)
+        raise Controll::FlowHandler::NoEventsDefinedError, "The #{self}#events class method must return a render map, was #{events}" if events.blank?      
+        event = normalize event
+        self.new(path || default_path) if events.include? event.name
+      end
+
+      def default_path
+        raise NotImplementedError, "You must set a default_path or override the #{self}#action class method"
+      end
+
+      # http://bugs.ruby-lang.org/issues/1082
+      #   hello.singleton_class
+      # Instead of always having to write:
+      #   (class << hello; self; end)
+      def set_default_path str = nil, &block
+        (class << self; self; end).send :define_method, :default_path do 
+          block_given? ? yield : str
+        end
+      end 
+
+      def set_events *args, &block
+        (class << self; self; end).send :define_method, :events do 
+          block_given? ? yield : args.flatten
+        end
+      end 
+
+      protected
+
+      include Controll::FlowHandler::EventHelper      
+    end
+  end
+end

data/lib/controll/helper.rb

@@ -0,0 +1,101 @@
+module Controll
+  module Helper
+    autoload :Notify,       'controll/helper/notify'
+    autoload :HashAccess,   'controll/helper/hash_access'
+    autoload :Params,       'controll/helper/params'
+    autoload :Session,      'controll/helper/session'
+    autoload :PathResolver, 'controll/helper/path_resolver'
+    autoload :EventMatcher, 'controll/helper/event_matcher'
+
+    include Controll::Helper::Notify
+    include Controll::Helper::Params
+
+    extend ActiveSupport::Concern
+
+    delegate :command, :command!, :use_command, to: :commander
+
+    module ClassMethods
+      # TODO: refactor - all use exactly the same pattern - can be generated!
+      def commander name, options = {}
+        define_method :commander do
+          unless instance_variable_get("@commander")
+            clazz = "#{name.to_s.camelize}Commander".constantize        
+            instance_variable_set "@commander", clazz.new(self, options)
+          end
+        end
+      end
+
+      def message_handler name, options = {}
+        define_method :message_handler do
+          unless instance_variable_get("@message_handler")
+            clazz = "#{name.to_s.camelize}MessageHandler".constantize        
+            instance_variable_set "@message_handler", clazz.new(self, options)
+          end
+        end
+      end
+
+      def assistant name, options = {}
+        define_method :assistant do
+          unless instance_variable_get("@assistant")
+            clazz = "#{name.to_s.camelize}Assistant".constantize        
+            instance_variable_set "@assistant", clazz.new(self, options)
+          end
+        end
+      end
+
+      def flow_handler name, options = {}
+        define_method :flow_handler do
+          unless instance_variable_get("@flow_handler")
+            clazz = "#{name.to_s.camelize}FlowHandler".constantize        
+            instance_variable_set "@flow_handler", clazz.new(self, options)
+          end
+        end
+      end
+
+      def delegate_assistant name, options = {}
+        define_method :assistant do
+          unless instance_variable_get("@assistant")
+            clazz = "#{name.to_s.camelize}DelegateAssistant".constantize        
+            instance_variable_set "@assistant", clazz.new(self, options)
+          end
+        end
+      end
+
+      def redirect_map map = {}
+        @redirect_map ||= map
+      end
+
+      def render_map map = {}
+        @render_map ||= map
+      end
+    end
+
+    def do_redirect *args
+      options = args.extract_options!
+      path = path_resolver.extract_path(:redirect_map, *args)
+      process_notifications
+      redirect_to path, *args
+    end
+
+    def do_render *args
+      options = args.extract_options!
+      path = path_resolver.extract_path :render_paths, *args
+      process_notifications
+      render path, *args
+    end
+
+    protected
+
+    def redirect_map
+      self.class.redirect_map
+    end
+
+    def render_paths
+      self.class.render_map
+    end
+
+    def path_resolver
+      @path_resolver ||= PathResolver.new self
+    end
+  end
+end

data/lib/controll/helper/event_matcher.rb

@@ -0,0 +1,21 @@
+module Controll::Helper
+  class EventMatcher
+    attr_reader :event
+
+    def initialize event
+      @event = normalize event
+    end
+
+    def match? events
+      normalized(events).include? event.name
+    end
+
+    protected
+
+    include Controll::FlowHandler::EventHelper
+
+    def normalized events
+      [events].flatten.map(&:to_sym)
+    end
+  end
+end

data/lib/controll/helper/hash_access.rb

@@ -0,0 +1,26 @@
+module Controll::Helper
+  module HashAccess
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def hash_access_methods *args
+        options = args.extract_options!
+        hash_name = options[:hash]
+        names = args
+
+        raise ArgumentError, "Must take a :hash option indicating the hash name to access" unless hash_name
+        raise ArgumentError, "Must take one or more names of methods to create" if names.blank? 
+
+        names.each do |name|
+          define_method name do            
+            unless instance_variable_get("@#{name}")
+              instance_variable_set "@#{name}", (send(hash_name)[name.to_sym]) || options[:default]
+            end
+          end
+        end
+      end
+
+      alias_method :hash_access_method, :hash_access_methods
+    end
+  end
+end

data/lib/controll/helper/notify.rb

@@ -0,0 +1,74 @@
+module Controll
+  module Helper
+    module Notify
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :notification_types
+
+        notification_types.each do |type|
+          define_method "create_#{type}" do |*args|
+            create_notification args.first, type.to_sym, args.extract_options!
+          end
+        end
+      end
+
+      # msg stack
+      def notifications
+        @notifications ||= []
+      end
+
+      def main_event
+        notifications.last || create_notice(:success)
+      end
+
+      def notify name, type = nil, options = {}        
+        notifications << create_notification(name, type, options)
+        self # enable method chaining on controller
+      end
+
+      protected
+
+      def error name = :error, options = {}
+        notify name, :error, options
+      end
+
+      def success name = :success, options = {}
+        notify name, :success, options
+      end
+
+      def create_notification name, type = nil, options = {}
+        type ||= :notice
+        raise ArgumentError, "Not a valid notification type: #{type}, must be one of: #{valid_notification_types}" unless valid_notification_type?(type)
+        Hashie::Mash.new(name: name, type: type, options: options)
+      end
+      alias_method :create_event, :create_notification
+
+      def valid_notification_type? type
+        notification_types.include? type.to_sym
+      end
+
+      def notification_types
+        return self.class.notification_types if self.class.respond_to? :notification_types
+        Controll::Notify::Flash.types
+      end 
+
+      # allows customization of notification types
+      module ClassMethods
+        def notification_types
+          @notification_types ||= default_notification_types
+        end
+
+        def default_notification_types 
+          Controll::Notify::Flash.types
+        end
+      end
+      
+      def process_notifications
+        notifications.each do |message|
+          message_handler.send(message.type).notify message.name, message.options
+        end
+      end
+    end
+  end
+end