controll 0.2.0 → 0.3.0

data/lib/controll/flow_handler/base.rb

@@ -1,19 +0,0 @@
-module Controll::FlowHandler
-  class Base
-    attr_reader :path
-
-    def initialize path
-      @path = path.to_s
-    end
-
-    def perform controller
-      raise NotImplementedError, 'You must implement the #perform method'
-    end
-
-    class << self
-      def action event
-        raise NotImplementedError, 'You must implement the #action class method'
-      end
-    end
-  end
-end

data/lib/controll/flow_handler/control.rb

@@ -1,85 +0,0 @@
-module Controll::FlowHandler
-  class Control
-    class ActionEventError < StandardError; end
-
-    attr_reader :controller, :action_handlers
-
-    def initialize controller, action_handlers = []
-      @controller = controller
-      @action_handlers = action_handlers unless action_handlers.blank?
-    end
-
-    def execute
-      use_action_handlers
-      use_alternatives
-      use_fallback if !executed?
-      self
-    end
-
-    def action_handlers
-      @action_handlers ||= [:redirect, :render]
-    end
-
-    def executed? 
-      @executed
-    end
-
-    protected
-
-    delegate :command!, to: :controller
-
-    # can be used to set up control logic that fall outside what can be done
-    # with the basic action_handlers but can not be considered fall-back.
-    def use_alternatives
-    end
-
-    def use_fallback  
-    end    
-
-    def event
-      raise NotImplementedError, 'You must define an #event method that at least returns an event (Symbol). You can use an Executor for this.'
-    end
-
-    def fallback_action
-      do_redirect root_url
-    end
-
-    NoEventsDefinedError    = Controll::FlowHandler::Render::NoEventsDefinedError
-    NoRedirectionFoundError = Controll::FlowHandler::Redirect::NoRedirectionFoundError    
-
-    def use_action_handlers
-      errors = []
-      action_handlers.each do |action_handler|
-        begin          
-          action_handler_clazz = handler_class(action_handler)
-          next unless action_handler_clazz
-          action = action_handler_clazz.action(event)
-          execute_with action
-          return if executed?
-        rescue NoEventsDefinedError => e
-          errors << e
-        rescue NoRedirectionFoundError => e
-          errors << e
-        end
-      end
-      raise ActionEventError, "#{errors.join ','}" unless errors.empty?
-    end
-
-    def handler_class action_handler
-      clazz = "#{self.class}::#{action_handler.to_s.camelize}"
-      clazz.constantize
-    rescue NameError
-      nil
-    end
-
-    def execute_with action
-      return if !action
-      action.perform(controller)
-      executed!      
-    end
-
-    def executed!
-      @executed = true
-    end
-  end
-end

data/lib/controll/flow_handler/errors.rb

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

data/lib/controll/flow_handler/event_helper.rb

@@ -1,18 +0,0 @@
-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/action.rb

@@ -1,45 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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/redirect.rb

@@ -1,51 +0,0 @@
-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/render.rb

@@ -1,51 +0,0 @@
-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/flow_handler.rb

@@ -1,11 +0,0 @@
-require 'controll/flow_handler/errors'
-
-module Controll
-  module FlowHandler
-    autoload :Base,         'controll/flow_handler/base'
-    autoload :Control,      'controll/flow_handler/control'
-    autoload :Redirect,     'controll/flow_handler/redirect'
-    autoload :Render,       'controll/flow_handler/render'    
-    autoload :EventHelper,  'controll/flow_handler/event_helper'    
-  end
-end

data/lib/controll/helper/notify.rb

@@ -1,74 +0,0 @@
-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

data/lib/controll/helper/path_resolver.rb

@@ -1,45 +0,0 @@
-module Controll
-  module Helper
-    class PathResolver
-      class PathResolverError < StandardError; end
-
-      attr_reader :caller
-
-      def initialize caller
-        @caller = caller
-      end
-
-      def extract_path type, *args
-        if args.first.kind_of?(Symbol)
-          raise "Caller must have a notice method" unless caller.respond_to? :notice
-          caller.notice args.first
-          resolve_path type
-        else      
-          args.empty? ? resolve_path(type) : args.first
-        end
-      end
-
-      def resolve_path type
-        raise "Caller must have a #main_event method" unless caller.respond_to? :main_event
-        caller.send(type).each do |path, events|
-          return path.to_s if matches? events
-        end
-        raise PathResolverError, "Path could not be resolved for: #{event_name}"
-      end
-
-      protected
-
-      def matches? events
-        event_matcher.match?(events)
-      end
-
-      def event_matcher
-        @event_matcher ||= EventMatcher.new event
-      end
-
-      def event
-        @event ||= caller.main_event
-      end
-    end
-  end
-end

data/spec/app/app/controllers/posts_controller.rb

@@ -1,52 +0,0 @@
-module PostsController
-  class Action < ApplicationController
-  end
-
-  class Index < Action
-    expose(:posts) { Post.all }
-  end
-
-  class Initializer < Action
-    expose(:post) { Post.new params[:post] }
-  end
-
-  class New < Initializer
-  end
-
-  class Create < Initializer
-    def run
-      if post.save
-        redirect_to post, :notice => 'Post was successfully created.'
-      else
-        render :action => "new"
-      end
-    end
-  end
-
-  class Finder < Action
-    expose(:post) { Post.find params[:id] }
-  end
-
-  class Show < Finder
-  end
-
-  class Edit < Finder
-  end
-
-  class Update < Finder
-    def run
-      if post.update_attributes(params[:post])
-        redirect_to post, :notice => 'Post was successfully updated.'
-      else
-        render :action => "edit"
-      end
-    end
-  end
-
-  class Destroy < Finder
-    def run
-      post.destroy
-      redirect_to posts_url
-    end
-  end
-end

data/spec/app/config/routes.rb

@@ -1,62 +0,0 @@
-App::Application.routes.draw do
-  focused_controller_routes do
-    resources :posts
-  end
-
-  # The priority is based upon order of creation:
-  # first created -> highest priority.
-
-  # Sample of regular route:
-  #   match 'products/:id' => 'catalog#view'
-  # Keep in mind you can assign values other than :controller and :action
-
-  # Sample of named route:
-  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
-  # This route can be invoked with purchase_url(:id => product.id)
-
-  # Sample resource route (maps HTTP verbs to controller actions automatically):
-  #   resources :products
-
-  # Sample resource route with options:
-  #   resources :products do
-  #     member do
-  #       get 'short'
-  #       post 'toggle'
-  #     end
-  #
-  #     collection do
-  #       get 'sold'
-  #     end
-  #   end
-
-  # Sample resource route with sub-resources:
-  #   resources :products do
-  #     resources :comments, :sales
-  #     resource :seller
-  #   end
-
-  # Sample resource route with more complex sub-resources
-  #   resources :products do
-  #     resources :comments
-  #     resources :sales do
-  #       get 'recent', :on => :collection
-  #     end
-  #   end
-
-  # Sample resource route within a namespace:
-  #   namespace :admin do
-  #     # Directs /admin/products/* to Admin::ProductsController
-  #     # (app/controllers/admin/products_controller.rb)
-  #     resources :products
-  #   end
-
-  # You can have the root of your site routed with "root"
-  # just remember to delete public/index.html.
-  # root :to => 'welcome#index'
-
-  # See how all your routes lay out with "rake routes"
-
-  # This is a legacy wild controller route that's not recommended for RESTful applications.
-  # Note: This route will make all actions in every controller accessible via GET requests.
-  # match ':controller(/:action(/:id))(.:format)'
-end

data/spec/app/script/rails

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'

data/spec/app/spec/controllers/posts_controller_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe PostsController do
-  include FocusedController::RSpecFunctionalHelper
-
-  before do
-    @post = Post.create(:title => 'Hello', :body => 'Omg')
-  end
-
-  describe PostsController::Index do
-    it "should get index" do
-      get
-      response.should be_success
-      subject.posts.should_not be_nil
-    end
-  end
-
-  describe PostsController::New do
-    it "should get new" do
-      get
-      response.should be_success
-    end
-  end
-
-  describe PostsController::Create do
-    it "should create post" do
-      expect { post :post => @post.attributes }.to change(Post, :count).by(1)
-      response.should redirect_to(post_path(subject.post))
-    end
-  end
-
-  describe PostsController::Show do
-    it "should show post" do
-      get :id => @post.id
-      response.should be_success
-    end
-  end
-
-  describe PostsController::Edit do
-    it "should get edit" do
-      get :id => @post.id
-      response.should be_success
-    end
-  end
-
-  describe PostsController::Update do
-    it "should update post" do
-      put :id => @post.id, :post => @post.attributes
-      response.should redirect_to(post_path(subject.post))
-    end
-  end
-
-  describe PostsController::Destroy do
-    it "should destroy post" do
-      expect { delete :id => @post.id }.to change(Post, :count).by(-1)
-      response.should redirect_to(posts_path)
-    end
-  end
-end

data/spec/app/spec/isolated_spec_helper.rb

@@ -1,6 +0,0 @@
-require 'bundler/setup'
-require 'rspec'
-require 'focused_controller/rspec_helper'
-
-APP_ROOT = File.expand_path('../../app', __FILE__)
-POSTS    = []

data/spec/app/spec/spec_helper.rb

@@ -1,5 +0,0 @@
-require 'rails/application'
-require File.expand_path("../../config/environment", __FILE__)
-require 'rspec'
-require 'focused_controller/rspec_helper'
-require 'focused_controller/rspec_functional_helper'