controll 0.2.0 → 0.3.0

data/lib/controll/flow/master.rb

@@ -0,0 +1,70 @@
+module Controll::Flow
+  class Master    
+    autoload :Macros,   'controll/flow/master/macros'
+    autoload :Executor, 'controll/flow/master/executor'
+
+    include Macros
+
+    attr_reader :controller, :action, :options
+
+    def initialize controller, options = {}
+      @controller = controller
+      @options    = options
+    end
+
+    # Uses Executor to execute each registered ActionHandler, such ad Renderer and Redirecter 
+    # The first ActionHandler matching the event returns an appropriate Action
+    # In case no ActionHandler matches, the Fallback action is returned
+    def execute
+      @action = executor.execute || fallback
+      @action.set_errors errors
+      @action
+    end
+
+    def executor
+      @executor ||= Executor.new controller, executor_options
+    end
+
+    def executor_options
+      {event: event, action_handlers: action_handlers}
+    end
+
+    delegate :errors, to: :executor
+
+    class << self
+      def action_handlers
+        @action_handlers ||= []
+      end
+
+      def add_action_handler name
+        @action_handlers ||= []
+        @action_handlers << name.to_s.underscore.to_sym
+      end
+
+      def valid_handler? handler_type
+        raise ArgumentError, "Must be a String or Symbol, was: #{handler_type}" if handler_type.blank?
+        valid_handlers.include? handler_type.to_sym
+      end
+
+      def valid_handlers
+        [:renderer, :redirecter]
+      end
+
+      def mapper_types
+        [:simple, :complex]
+      end      
+    end
+
+    protected
+
+    delegate :command!, to: :controller
+
+    def action_handlers
+      self.class.action_handlers
+    end
+
+    def event
+      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

data/lib/controll/flow.rb

@@ -0,0 +1,15 @@
+require 'controll/flow/errors'
+
+module Controll
+  module Flow
+    autoload :Master,         'controll/flow/master'
+    autoload :Action,         'controll/flow/action'
+    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

data/lib/controll/focused/enabler.rb

@@ -0,0 +1,31 @@
+module Controll
+  module Focused
+    module Enabler
+      include Controll::Enabler
+
+      def execute     
+        action.perform
+      end
+
+      def self.assistant_methods *names
+        delegate names, to: :assistant
+      end
+
+      protected
+
+      # the action resulting from executing the flow. 
+      # Should be an instance of either:
+      # - Fallback
+      # - Redirecter
+      # - Renderer
+      def action
+        @action ||= flow.execute
+      end    
+
+      # @flowhandler ||= Controll::Flow::Master.new self
+      def flow
+        raise NotImplementedError, '#flow must return the Controll::Flow::Master instance to be used'
+      end
+    end
+  end
+end

data/lib/controll/helper.rb

@@ -1,101 +1,7 @@
 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/macros.rb

@@ -0,0 +1,12 @@
+module Controll
+  module Macros
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def enable_controll
+        clazz = self.ancestors.include?(::Imperator::Command) ? Controll::Focused::Enabler : Controll::Enabler
+        self.send :include, clazz
+      end
+    end
+  end
+end

data/lib/controll/notify/base.rb

@@ -1,14 +1,16 @@
-require 'liquid'
 require 'controll/notify/flash'
 
 module Controll
   module Notify
     class Base < Flash
-      class NotifyMappingError < StandardError; end
+      Message = Controll::Notify::Message
+
+      attr_reader :name
 
       def notify name, options = {}      
-        @options.merge! options if options.kind_of? Hash
-        signal notify_msg(name)
+        @options.merge! options
+        @name = name
+        signal message_resolver.resolve
       end
 
       def self.inherited(base)
@@ -16,7 +18,9 @@ module Controll
       end
 
       module ClassMethods
-        attr_reader :signal_type
+        def signal_type
+          @signal_type ||= self.name.demodulize.sub(/Handler$/, '').underscore.to_sym
+        end
 
         def type name
           @signal_type = name
@@ -25,51 +29,26 @@ module Controll
 
       protected
 
-      def notify_msg name, opts = {}
-        opts = options.merge(opts).stringify_keys
-
-        msg = send(name) if respond_to? name
-        msg ||= messages[name.to_sym] if respond_to? :messages
-        msg ||= name.to_sym
-
-        # if name is not mapped to a message, it could well be, that the 
-        # event should not generate a nofification message
-        return nil if !msg
-                
-        # try various approaches!
-        case msg
-        when Symbol
-          translate msg, opts
-        when String
-          msg.strip!
-          return replace_args(msg, opts) if msg =~ /{{.*}}/
-          msg
-        else
-          msg_error!
-        end
-      rescue
+      def message_resolver
+        @message_resolver ||= Message::Resolver.new self, message
       end
 
-      def msg_error!
-        raise NotifyMappingError, "Notify message could not be generated for: #{name}"
-      end
+      def message
+        @message ||= Message.new text, options
+      end      
 
-      def translate msg, opts = {}
-        I18n.t i18n_key(msg), opts.symbolize_keys
+      def text
+        @text ||= resolve_text(name) || key
       end
 
-      def replace_args msg, opts
-         # Parses and compiles the template
-        Liquid::Template.parse(msg).render(opts)
+      def key
+        @key ||= name.to_sym
       end
 
-      def i18n_key msg
-        parts = self.class.name.split('::')
-        middle = parts[1..-2].join('.').underscore
-        type = parts.last.sub(/Msg$/, '').underscore
-        ns = [middle, type].join('.').sub /^./, ''
-        [ns,msg].join('.')
-      end        
+      def resolve_text name
+        return send(name) if respond_to? name
+        messages[name.to_sym] if respond_to? :messages
+      end
     end
   end
 end

data/lib/controll/notify/flash.rb

@@ -20,11 +20,11 @@ module Controll
         attr_writer :types
 
         def types
-          @types ||= [:notice, :error, :warning, :success]
+          @types ||= Controll::Event.valid_types
         end
 
         def add_types *types
-          @types += types.flatten
+          @types += types if types.all? {|type| type.kind_of? Symbol}
         end
         alias_method :add_type, :add_types
       end
@@ -41,7 +41,7 @@ module Controll
       end
 
       def types
-        self.class.types
+        self.class.types.map(&:to_sym)
       end
 
       def signal_type

data/lib/controll/notify/macros.rb

@@ -0,0 +1,57 @@
+module Controll::Notify
+  module Macros
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def handler type, options = {}, &block
+        unless valid_type? type
+          raise ArgumentError, "Notification type must be any of: #{types}, was: #{type}" 
+        end
+
+        clazz_name = "#{parent}::#{type.to_s.camelize}Handler"
+        parent = options[:parent] || Controll::Notify::Base
+
+        clazz = parent ? Class.new(parent) : Class.new
+        Object.const_set clazz_name, clazz
+        context = self.kind_of?(Class) ? self : self.class
+        clazz = context.const_get(clazz_name)
+
+        if block_given?
+          clazz.instance_eval &block      
+        end
+        clazz
+      end
+
+      def messages hash = nil, &block
+        unless block_given? || !hash.blank?
+          raise ArgumentError, "Must be called with non-empty Hash or block" 
+        end
+
+        define_method :messages do
+          block_given? ? instance_eval(&block) : hash
+        end
+      end
+
+      def message event_name, text = nil, &block
+        unless event_name.kind_of?(Symbol) || event_name.kind_of?(String)
+          raise ArgumentError, "First argument must be an event name, was: #{event_name}"
+        end
+        
+        unless block_given? || !text.blank?
+          raise ArgumentError, "Must be called with non-empty String or block" 
+        end
+       
+        define_method event_name do
+          block_given? ? instance_eval(&block) : hash
+        end
+      end
+      alias_method :msg, :message
+
+      protected
+
+      def valid_type? type
+        types.include? type.to_sym
+      end
+    end
+  end
+end

data/lib/controll/notify/message/handler.rb

@@ -0,0 +1,36 @@
+require 'liquid'
+
+module Controll::Notify
+  class Message
+    class Handler
+      attr_reader :message
+
+      def initialize message
+        @message = message
+      end
+
+      def handle
+        return args? ? replace_args : message.text
+      rescue StandardError
+        nil
+      end
+
+      protected
+
+      delegate :text, to: :message
+
+      def options
+        @options ||= message.options.stringify_keys
+      end
+
+      def args?
+        text =~ /{{.*}}/
+      end
+
+      def replace_args
+         # Parses and compiles the template
+        Liquid::Template.parse(text).render(options)
+      end    
+    end
+  end
+end

data/lib/controll/notify/message/resolver.rb

@@ -0,0 +1,28 @@
+module Controll::Notify
+  class Message
+    class Resolver
+      Message = Controll::Notify::Message
+
+      attr_reader :caller, :message
+
+      def initialize caller, message
+        @caller = caller
+        @message = message
+      end
+
+      def resolve
+        message.translate? ? translator.translate : message_handler.handle
+      end
+
+      protected
+
+      def message_handler
+        Message::Handler.new message
+      end
+
+      def translator
+        Message::Translator.new caller, message
+      end
+    end
+  end
+end

data/lib/controll/notify/message/translator.rb

@@ -0,0 +1,45 @@
+module Controll
+  module Notify
+    class Message
+      class Translator
+        attr_reader :caller, :key, :options
+
+        def initialize caller, message
+          @caller   = caller
+          @key      = message.text
+          @options  = message.options.symbolize_keys
+        end
+
+        def translate
+          I18n.t i18n_key, options
+        end
+
+        protected
+
+        def i18n_key
+          [namespace_key, key].join('.')
+        end
+
+        def namespace_key
+          [namespace, type].join('.').sub /^\\./, ''
+        end
+
+        def parts
+          @parts ||= caller.class.name.split('::')
+        end
+
+        def namespace
+          (parts.first == 'Notifiers' ? parts[1..-2] : parts[0..-2]).join('.').underscore          
+        end
+        
+        def type
+          parts.last.sub(/#{clazz_postfix}$/, '').underscore
+        end
+
+        def clazz_postfix
+          'Handler'
+        end
+      end
+    end
+  end
+end

data/lib/controll/notify/message.rb

@@ -0,0 +1,25 @@
+module Controll::Notify
+  class Message
+    autoload :Translator,   'controll/notify/message/translator'
+    autoload :Handler,      'controll/notify/message/handler'
+    autoload :Resolver,     'controll/notify/message/resolver'
+
+    attr_reader :text, :options
+
+    def initialize text, options = {}
+      raise ArgumentError, "Message text must be a String or Symbol" unless valid_text? text
+      @text    = text
+      @options = options
+    end
+
+    def translate?
+      text.kind_of? Symbol
+    end
+
+    protected
+
+    def valid_text? text
+      text.kind_of?(String) || text.kind_of?(Symbol)
+    end
+  end
+end

data/lib/controll/notify/typed.rb

@@ -3,36 +3,27 @@ require 'controll/notify/flash'
 module Controll
   module Notify
     class Typed < Flash
-      class MissingNotifyClass < StandardError; end
+      class MissingNotifyHandlerClass < StandardError; end
 
-      def notice        
-        raise MissingNotifyClass, "#{msg_class(:notice)} class missing" unless msg_class(:notice)
-        @notice ||= msg_class(:notice).new flash #, options
-      end
-
-      def error
-        raise MissingNotifyClass, "#{msg_class(:warning)} class missing" unless msg_class(:error)
-        @error ||= msg_class(:error).new flash #, options
-      end
-
-      def success
-        raise MissingNotifyClass, "#{msg_class(:success)} class missing" unless msg_class(:success)
-        @success ||= msg_class(:success).new flash #, options
-      end
+      include Controll::Notify::Macros
 
-      def warning
-        raise MissingNotifyClass, "#{msg_class(:warning)} class missing" unless msg_class(:warning)
-        @warning ||= msg_class(:warning).new flash #, options
+      types.each do |type|      
+        define_method type do        
+          clazz = handler_class(type)
+          raise MissingNotifyHandlerClass, "#{clazz} class missing" unless clazz
+          var = "@#{type}"
+          instance_variable_get(var) || instance_variable_set(var, clazz.new(flash))
+        end
       end
 
       protected
 
-      def msg_class name
-        msg_classes[name] ||= "#{self.class}::#{name.to_s.camelize}Msg".constantize
+      def handler_class name
+        handler_classes[name] ||= "#{self.class}::#{name.to_s.camelize}Handler".constantize
       end 
 
-      def msg_classes
-        @msg_classes ||= {}
+      def handler_classes
+        @handler_classes ||= {}
       end
     end
   end

data/lib/controll/notify.rb

@@ -1,7 +1,14 @@
 module Controll
   module Notify
-    autoload :Base,     'controll/notify/base'
-    autoload :Flash,    'controll/notify/flash'
-    autoload :Typed,    'controll/notify/typed'
+    autoload :Base,           'controll/notify/base'
+    autoload :Flash,          'controll/notify/flash'
+    autoload :Typed,          'controll/notify/typed'
+    autoload :Macros,         'controll/notify/macros'
+    autoload :Message,        'controll/notify/message'
   end
-end
+end
+
+module Notifiers
+  Typed    = Controll::Notify::Typed
+  Notifier = Controll::Notify::Typed
+end

data/lib/controll.rb

@@ -4,11 +4,17 @@ end
 require 'hashie'
 require 'imperator-ext'
 require 'controll/errors'
+require 'controll/event'
+require 'controll/events'
+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'
 require 'controll/commander'
-require 'controll/assistant'
+require 'controll/macros'
+
+require 'controll/engine' if defined?(::Rails::Engine)
 

data/lib/generators/controll/assistant_generator.rb

@@ -0,0 +1,27 @@
+module Controll
+  module Generators
+    class AssistantGenerator < ::Rails::Generators::NamedBase
+      desc 'Generates an Assitant'
+      
+      class_option :delegate, type: :boolean, default: false
+
+      def main_flow
+        template "assistant.tt", "app/controll/assistants/#{file_name}.rb"
+      end
+
+      protected
+
+      def delegate?
+        options[:delegate]
+      end
+
+      def parent_class
+        name.include?('::') ? "::Controll::#{parent_class_name}" : parent_class_name
+      end
+
+      def parent_class_name
+        delegate? 'DelegateAssistant' : 'Assistant'        
+      end
+    end
+  end
+end

data/lib/generators/controll/executor_generator.rb

@@ -0,0 +1,23 @@
+module Controll
+  module Generators
+    class ExecutorGenerator < ::Rails::Generators::NamedBase
+      desc 'Generates an Executor'
+
+      class_option :type, default: 'base', desc: 'The type of executor' 
+      
+      def main_flow
+        template 'executor.tt', "app/controll/executors/#{file_name}.rb"
+      end
+
+      protected
+
+      def parent_class
+        name.include?('::') ? "::Controll::Executor::#{parent_class_name}" : parent_class_name
+      end      
+
+      def parent_class_name
+        (options[:type] || 'base').camelize
+      end
+    end
+  end
+end