controll 0.2.0 → 0.3.0

data/spec/controll/event_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Controll::Event do
+  let(:clazz) { Controll::Event }
+
+  describe '.initialize name, *args' do
+    context 'implicit notice' do
+      subject { Controll::Event.new 'sign_in' }  
+
+      its(:name)    { should == :sign_in }
+      its(:type)    { should == :notice }
+      its(:options) { should be_blank }
+    end
+
+    context 'explicit notice' do
+      subject { Controll::Event.new 'sign_in', :notice }  
+
+      its(:name)    { should == :sign_in }
+      its(:type)    { should == :notice }
+      its(:options) { should be_blank }
+    end
+
+    context 'explicit error and options' do
+      subject { Controll::Event.new 'sign_in', :error, {:a => 7} }  
+
+      its(:name)    { should == :sign_in }
+      its(:type)    { should == :error }
+      its(:options) { should == {:a => 7} }
+    end
+
+    context 'explicit warning type in options' do
+      subject { Controll::Event.new 'sign_in', {:type => :warning, :a => 7} }  
+
+      its(:name)    { should == :sign_in }
+      its(:type)    { should == :warning }
+      its(:options) { should == {:a => 7} }
+
+      describe '.warning?' do
+        its(:warning?) { should be_true }
+        its(:notice?) { should be_false }
+      end
+    end
+  end
+
+  context 'class methods' do
+    subject { clazz }
+
+    describe '.valid_types' do
+      its(:valid_types) { should = %w{notice error warning success} }
+    end
+
+    describe '.valid_types=' do
+      before do
+        clazz.valid_types = [:notice]
+      end
+      its(:valid_types) { should = [:notice] }
+    end
+
+    describe '.add_valid_type' do
+      before do
+        clazz.add_valid_types :remote, :invalid
+      end
+      its(:valid_types) { should include(:remote, :invalid) }
+    end
+  end
+end

data/spec/controll/events_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Controll::Events do
+  subject { clazz.new }
+  let(:clazz) { Controll::Events }
+
+  include Controll::Event::Helper
+
+  let(:a_success) { create_event :success } 
+  let(:a_warning) { create_event :warning }
+
+  describe 'class methods' do
+    subject { clazz }  
+
+    its(:valid_types) { should == Controll::Event.valid_types }
+  end
+
+  describe 'last' do
+    subject { Controll::Events.new a_success, a_warning }  
+
+    its(:last) { should == a_warning }
+  end
+end

data/spec/controll/executor/controlled_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+class MyControlledExec < Controll::Executor::Controlled
+  controller_methods :hello
+end
+
+class MyAwesomeController
+  def hello
+    "hello"
+  end  
+end
+
+describe Controll::Executor::Controlled do
+  subject { MyControlledExec.new controller }
+
+  let(:controller) { MyAwesomeController.new }
+
+  describe '.method_missing' do
+    specify do
+      subject.hello.should == 'hello'
+    end
+
+    specify do
+      expect { subject.bye }.to raise_error
+    end
+  end
+
+  describe '.execute' do
+  end
+
+  describe '.result' do
+  end
+
+  describe 'self.execute &block' do
+  end  
+end

data/spec/controll/executor/{notificator_spec.rb → delegator_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-
-class MyExec < Controll::Executor::Notificator
+class MyDelegator < Controll::Executor::Delegator
+  controller_methods :hello
 end
 
 class MyAwesomeController
@@ -10,8 +10,8 @@ class MyAwesomeController
   end
 end
 
-describe Controll::Executor::Notificator do
-  subject { MyExec.new controller }
+describe Controll::Executor::Delegator do
+  subject { MyDelegator.new controller }
 
   let(:controller) { MyAwesomeController.new }
 

data/spec/controll/flow/action_mapper/complex_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+class HelloToWelcomeRedirect < Controll::Flow::ActionMapper::Complex
+  event_map :welcome => [:hello, :hi]
+end
+
+class ErrorBadRedirect < Controll::Flow::ActionMapper::Complex  
+  event_map :error, bad: ['bad_payment', 'wrong_payment']
+end
+
+class TheController
+end
+
+describe Controll::Flow::ActionMapper::Complex do
+
+  def notification name
+    Hashie::Mash.new(name: name.to_sym, type: :notice)
+  end
+
+  def error name
+    Hashie::Mash.new(name: name.to_sym, type: :error)
+  end
+
+  let(:controller) { TheController.new }
+
+  describe 'class macros' do
+    before :all do
+      ErrorBadRedirect.event_map :error, crap: ['bad_payment', 'wrong_payment']
+    end
+
+    specify {
+      ErrorBadRedirect.event_map_for(:error).should == {crap: ['bad_payment', 'wrong_payment']}
+    }
+
+    specify {
+      ErrorBadRedirect.event_maps.should == {error: {crap: ['bad_payment', 'wrong_payment']} }
+    }
+  end
+
+  context 'use directly without subclassing' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { Controll::Flow::ActionMapper::Complex }
+
+    let(:hello) { notification :hello }
+
+    describe '.action event' do
+      specify do
+        expect { clazz.action(controller, :hello) }.to raise_error(Controll::Flow::NoMappingFoundError)
+      end
+    end
+  end
+
+  context 'HelloToWelcomeRedirect subclass' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { HelloToWelcomeRedirect }
+
+    context 'has redirections' do
+      describe '.action event' do
+        specify do
+          expect { clazz.action(controller, :hello) }.to_not raise_error(Controll::Flow::NoMappingFoundError)
+        end
+
+        specify do
+          clazz.action(controller, :hello).should be_a Controll::Flow::Action::PathAction
+        end
+
+        specify do
+          clazz.action(controller, :hi).path.should == 'welcome'
+        end
+      end
+    end
+  end
+
+  context 'ErrorBadRedirect subclass' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { ErrorBadRedirect }
+
+    before do
+      Controll::Event.reset_types
+    end
+
+    context 'has error redirections' do
+      describe '.action event' do
+        specify do
+          expect { clazz.action(controller, :hello) }.to raise_error(Controll::Flow::NoMappingFoundError)
+        end
+
+        specify do
+          clazz.action(controller, error(:bad_payment)).should be_a Controll::Flow::Action::PathAction
+        end
+
+        specify do
+          clazz.action(controller, error(:wrong_payment)).path.should == 'crap'
+        end
+      end
+    end
+  end
+
+end

data/spec/controll/flow/action_mapper/fallback_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class FallbackController
+  def do_fallback fallback
+    "did a nice fallback :) - #{fallback.event.name}"
+  end
+end
+
+class BasicFallbackAction < Controll::Flow::Action::Fallback
+end
+
+describe Controll::Flow::Action::Fallback do
+  context 'Basic default fallback' do
+    subject { clazz.new controller, event }
+
+    let(:controller)  { FallbackController.new }
+    let(:clazz)       { BasicFallbackAction }
+    let(:event)       { create_event :unknown, :notice }
+
+    include Controll::Event::Helper
+
+    describe '.action controller, event' do
+      specify do
+        clazz.action(controller, event).should be_a Controll::Flow::Action::Fallback
+      end
+    end
+
+    describe '.perform' do
+      specify do
+        clazz.action(controller, event).perform.should == "did a nice fallback :) - #{event.name}"
+      end
+    end
+  end
+end

data/spec/controll/{flow_handler/render_spec.rb → flow/action_mapper/simple_spec.rb}

@@ -1,38 +1,45 @@
 require 'spec_helper'
 
-class NoEventsRender < Controll::FlowHandler::Render
+class NoEventsRender < Controll::Flow::ActionMapper::Simple
   def self.events
     []
   end
 end
 
-class HiRender < Controll::FlowHandler::Render
+class HiRender < Controll::Flow::ActionMapper::Simple
   def self.events
     [:hi]
   end
 end
 
-class HelloRender < Controll::FlowHandler::Render
-  set_events :hello, :damn
-  set_default_path '/default'
+class HelloRender < Controll::Flow::ActionMapper::Simple
+  events :hello, :damn
+  default_path '/default'
+end
+
+class NiceController
 end
 
 def notification name
-  Hashie::Mash.new(name: name.to_sym, type: :notification)
+  Hashie::Mash.new(name: name.to_sym, type: :notice)
 end
 
-describe Controll::FlowHandler::Render do
+describe Controll::Flow::ActionMapper::Simple do
+
+  Simple  = Controll::Flow::ActionMapper::Simple
+  Complex = Controll::Flow::ActionMapper::Complex
+
+  let(:controller) { NiceController }
+  let(:hello) { notification :hello }  
 
   context 'use directly without sublclassing' do
     subject { clazz.new '/' }
 
-    let(:clazz) { Controll::FlowHandler::Render }
-
-    let(:hello) { notification :hello }
+    let(:clazz) { Simple }
 
     describe '.action event' do
       specify do
-        expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::NoEventsDefinedError)
+        expect { clazz.action(controller, hello) }.to raise_error(Controll::Flow::NoEventsDefinedError)
       end
     end
   end
@@ -45,7 +52,7 @@ describe Controll::FlowHandler::Render do
     context 'empty events' do
       describe '.action event' do
         specify do
-          expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::NoEventsDefinedError)
+          expect { clazz.action(controller, hello) }.to raise_error(Controll::Flow::NoEventsDefinedError)
         end
       end
     end
@@ -62,22 +69,18 @@ describe Controll::FlowHandler::Render do
 
         describe 'does not respond to hello' do
           specify do
-            expect { clazz.action(:hello) }.to_not raise_error(Controll::FlowHandler::Render::NoEventsDefinedError)
-          end
-
-          specify do
-            clazz.action(event).should == nil
+            expect { clazz.action(controller, event) }.to_not raise_error(Controll::Flow::NoEventsDefinedError)
           end
 
           specify do
-            clazz.action(:hello).should == nil
+            expect { clazz.action(controller, event) }.to raise_error Controll::Flow::NoDefaultPathDefinedError
           end
         end
 
         describe 'responds to hi' do
           # default_path not implemented!
           specify do
-            expect { clazz.action(:hi) }.to raise_error NotImplementedError
+            expect { clazz.action(controller, :hi) }.to raise_error Controll::Flow::NoDefaultPathDefinedError
           end
         end
       end
@@ -94,15 +97,15 @@ describe Controll::FlowHandler::Render do
     context 'has events and default_path' do
       describe '.action event' do
         specify do
-          clazz.action(event).should be_a HelloRender
+          clazz.action(controller, event).should be_a Controll::Flow::Action::PathAction
         end        
 
         specify do
-          clazz.action(event).path.should == default_path
+          clazz.action(controller, event).path.should == default_path
         end        
 
         specify do
-          clazz.action(event, 'other_path').path.should == 'other_path'
+          clazz.action(controller, event, 'other_path').path.should == 'other_path'
         end        
       end
     end

data/spec/controll/{flow_handler/redirect/action_spec.rb → flow/event_mapper/path_finder_spec.rb}

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-def notice name
-  Hashie::Mash.new(name: name.to_sym, type: :notice)
-end
+describe Controll::Flow::EventMapper::PathFinder do
+  def notice name
+    Hashie::Mash.new(name: name.to_sym, type: :notice)
+  end
 
-def error name
-  Hashie::Mash.new(name: name.to_sym, type: :error)
-end
+  def error name
+    Hashie::Mash.new(name: name.to_sym, type: :error)
+  end
 
-describe Controll::FlowHandler::Redirect::Action do
   let(:redirections) do
     { 
       :error => error_map, :notice => notice_map
@@ -29,7 +29,7 @@ describe Controll::FlowHandler::Redirect::Action do
   let(:types) { [:notice, :error] }
 
   context 'use' do    
-    let(:clazz)       { Controll::FlowHandler::Redirect::Action }
+    let(:clazz)       { Controll::Flow::EventMapper::PathFinder }
     let(:hello)       { notice :hello }
     let(:bad_payment) { error :bad_payment }
 
@@ -37,11 +37,11 @@ describe Controll::FlowHandler::Redirect::Action do
       subject { clazz.new hello, redirections, types  }
 
       specify do
-        expect { subject.map }.to_not raise_error(Controll::FlowHandler::NoRedirectionFoundError)
+        expect { subject.map }.to_not raise_error(Controll::Flow::NoMappingFoundError)
       end
 
       specify do
-        subject.map.should == 'welcome'
+        subject.path.should == 'welcome'
       end
     end
   end

data/spec/controll/{flow_handler/redirect/mapper_spec.rb → flow/event_mapper/util_spec.rb}

@@ -8,7 +8,7 @@ def error name
   Hashie::Mash.new(name: name.to_sym, type: :error)
 end
 
-describe Controll::FlowHandler::Redirect::Mapper do
+describe Controll::Flow::EventMapper::Util do
   let(:redirections) do
     { 
       :error => error_map, :notice => notice_map
@@ -31,28 +31,28 @@ describe Controll::FlowHandler::Redirect::Mapper do
   context 'use' do    
     subject { clazz.new hello, notice_map }
 
-    let(:clazz)         { Controll::FlowHandler::Redirect::Mapper }
+    let(:clazz)         { Controll::Flow::EventMapper::Util }
     let(:hello)         { notice :hello }
     let(:bad_payment)   { error :bad_payment }
 
     describe '.initialize' do
-      its(:event) { should == hello }
-      its(:redirect_map) { should == notice_map }
+      its(:event) { should be_a Controll::Event }
+      its(:event_map) { should == notice_map }
     end
 
-    describe '.map' do
+    describe '.map_event' do
       specify do
-        subject.map.should == 'welcome'
+        subject.map_event.should == 'welcome'
       end
     end
 
-    describe '.matcher event' do
+    describe '.matcher' do
       specify do
-        subject.send(:matcher, hello).should be_a Controll::Helper::EventMatcher
+        subject.send(:matcher).should be_a Controll::Event::Matcher
       end      
 
       specify do
-        subject.send(:matcher, hello).event.should == hello
+        subject.send(:matcher).event.should be_a Controll::Event
       end      
     end
 

data/spec/controll/flow/master/executor_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module MyOwnController
+  class Update
+    def render path
+      send(path) if path
+    end
+
+    def default
+      'default'
+    end
+  end
+end
+
+describe Controll::Flow::Master::Executor do
+  include Controll::Event::Helper
+
+  let(:executor)        { Controll::Flow::Master::Executor }
+  let(:controller)      { MyOwnController::Update.new }
+
+  let(:fallback_event)  { create_event :unknown, :notice }
+  let(:render_event)    { create_event :hello,   :notice }
+  let(:redirect_event)  { create_event :exit,    :error }
+
+  let(:action_handlers) { [:renderer, :redirecter] }
+
+  let(:options) do
+    {event: event, action_handlers: action_handlers}
+  end
+
+  describe '.initialize with fallback_event' do
+    let(:event) { fallback_event }
+    subject { executor.new controller, options }
+
+    specify do
+      subject.controller.should == controller
+    end
+
+    specify do
+      subject.event.should == event
+    end
+  end
+
+  describe '.initialize with render_event' do
+    let(:event) { render_event }
+    subject { executor.new controller, options }
+
+    specify do
+      subject.controller.should == controller
+    end
+
+    specify do
+      subject.event.should == event
+    end
+  end
+end

data/spec/controll/flow/master_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+module MasterController
+  class Update
+    def render path
+      send(path) if path
+    end
+
+    def default
+      'default'
+    end
+  end
+end
+
+module Flows
+  class EmptyEvent < Master
+    def event
+    end
+  end
+
+  class UpdateEventWithoutHandler < Master
+    def event
+      :update
+    end
+  end
+
+
+  class UpdateEvent < Master
+    def event
+      :update
+    end
+
+    renderer :simple do
+      events :update
+      default_path 'default'
+    end
+  end
+
+  class UpdateEventNoMatch < Master
+    def event
+      :update
+    end
+
+    renderer :simple do
+      events :create
+      default_path '/default'
+    end
+  end
+end
+
+describe Controll::Flow::Master do
+  Fallback = Controll::Flow::Action::Fallback
+
+  context 'use directly without sublclassing' do
+    subject             { flow.new controller }
+
+    let(:flow)          { Controll::Flow::Master }
+    let(:controller)    { MasterController::Update.new }
+
+    describe '.initialize' do
+      specify do
+        subject.controller.should == controller
+      end
+    end
+
+    describe '.execute' do
+      specify do
+        expect { subject.execute }.to raise_error(Controll::Flow::EventNotImplementedError)
+      end
+    end
+  end
+
+  context 'A Control Flow with empty #event method' do
+    subject           { flow.new controller }
+
+    let(:flow)        { Flows::EmptyEvent }
+    let(:controller)  { MasterController::Update.new }
+
+    describe '.initialize' do
+      specify do
+        subject.controller.should == controller
+      end
+    end
+
+    describe '.execute' do    
+      # since event is nil
+      specify do
+        expect { subject.execute }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'A Control Flow where #event returns :update notice event' do
+    subject             { flow.new controller }
+
+    let(:flow)          { Flows::UpdateEventWithoutHandler }
+    let(:controller)    { MasterController::Update.new }
+
+    describe '.initialize' do
+      specify do
+        subject.controller.should == controller
+      end
+    end
+
+    describe '.execute' do    
+      # since event returns nil
+      specify do
+        subject.execute.should be_a Fallback
+      end
+    end
+  end  
+
+  context 'A Control Flow where #event returns :update notice event and has a Render class with matching mapping' do
+    subject { flow.new controller }
+
+    let(:flow)  { Flows::UpdateEvent }
+    let(:controller)    { MasterController::Update.new }
+
+    describe '.initialize' do
+      specify do
+        subject.controller.should == controller
+      end
+    end
+
+    describe '.execute' do    
+      # since event returns nil
+      specify do
+        expect { subject.execute }.to_not raise_error(Controll::Flow::ActionEventError)
+      end
+
+      specify do
+        subject.execute.should be_a Fallback
+      end
+    end
+  end  
+
+  context 'A Control Flow where #event returns :update notice event and has a Render class with NO matching mapping' do
+    subject { flow.new controller }
+
+    let(:flow)  { Flows::UpdateEventNoMatch }
+    let(:controller)    { MasterController::Update.new }
+
+    describe '.initialize' do
+      specify do
+        subject.controller.should == controller
+      end
+    end
+
+    describe '.execute' do    
+      # since event returns nil
+      specify do
+        expect { subject.execute }.to_not raise_error
+      end
+    end
+  end  
+
+end