controll 0.2.0 → 0.3.0

data/lib/generators/controll/flow_handler_generator.rb

@@ -0,0 +1,21 @@
+module Controll
+  module Generators
+    class FlowGenerator < ::Rails::Generators::NamedBase
+      desc 'Generates a Flow'
+      
+      def main_flow
+        template 'flow.tt', "app/controll/flows/#{file_name}.rb"
+      end
+
+      protected
+
+      def parent_class
+        name.include?('::') ? "::Controll::Flow::#{parent_class_name}" : parent_class_name
+      end      
+
+      def parent_class_name
+        'Control'
+      end      
+    end
+  end
+end

data/lib/generators/controll/notifier_generator.rb

@@ -0,0 +1,21 @@
+module Controll
+  module Generators
+    class NotifierGenerator < ::Rails::Generators::NamedBase
+      desc 'Generates a Notifier'
+      
+      def main_flow
+        template 'notifier.tt', "app/controll/notifiers/#{file_name}.rb"
+      end
+
+      protected
+
+      def parent_class
+        name.include?('::') ? "::Controll::Notify::#{parent_class_name}" : parent_class_name
+      end      
+
+      def parent_class_name
+        'Typed'
+      end       
+    end
+  end
+end

data/lib/generators/controll/setup_generator.rb

@@ -0,0 +1,37 @@
+module Controll
+  module Generators
+    class SetupGenerator < ::Rails::Generators::Base
+      desc 'Sets up a Rails 3 prooject with a folder structure in app for controll artifacts'
+
+      argument :folders, type: :array, required: false, desc: 'creates specific folders for controll artifacts'
+
+      def main_flow
+        empty_directory "app/controll"
+        inside "app/controll" do
+          create_folders.each do |folder|
+            empty_directory folder
+          end
+        end
+      end
+
+      protected
+
+      def create_folders
+        return mapper_folders unless folders.empty?
+        valid_folders
+      end
+
+      def mapper_folders
+        @mapper_folders ||= folders.map {|f| f.to_s.underscore }.select{|f| valid_artifact? f }
+      end
+
+      def valid_folder? folder
+        valid_folders.include? folder.to_s.underscore
+      end
+
+      def valid_folders
+        %w{executors flows notifiers commanders assistants}
+      end
+    end
+  end
+end

data/lib/generators/controll/templates/assistant.tt

@@ -0,0 +1,10 @@
+module Assistants
+  class <%= class_name %> < <%= parent_class %>
+    # public methods here
+    # def do_stuff
+    # ...  if current_user 
+    # end
+
+    # controller_methods :current_user
+  end
+end

data/lib/generators/controll/templates/commander.tt

@@ -0,0 +1,15 @@
+module Commanders
+  class <%= class_name %> < <%= parent_class %>
+    # create basic command methods
+    # command_methods :cancel_commit, :create_account, :signout
+
+    # create custom command method with custom argument hash
+
+    # command_method :sign_out do
+    # end
+
+    # controller delegations
+    # controller_methods :auth_hash, :user_id
+  end
+end
+```

data/lib/generators/controll/templates/executor.tt

@@ -0,0 +1,14 @@
+module Executors
+  class <%= class_name %> < <%= parent_class %>
+    def execute
+      # creates an error notification named :error
+      error and return unless valid_params?
+
+      # creates an error notification named :auth_invalid
+      # error(:auth_invalid) and return unless auth_valid?
+
+      # command! :sign_in
+      # result      
+    end
+  end
+end

data/lib/generators/controll/templates/flow_handler.tt

@@ -0,0 +1,26 @@
+module Flows
+  class <%= class_name %> < <%= parent_class %>
+    fallback do
+      # event == :no_auth ? do_render(:text => omniauth.to_yaml) : fallback_action
+    end      
+
+    event do
+      # Executors::Authenticator.new(controller).execute
+    end
+
+    renderer do
+      # default_path :signup_services_path
+      # events       :signed_in_new_user, :signed_in
+    end
+
+    redirecter do
+      redirections :notice do
+        {        
+          # signup_services_path: :signed_in_new_user
+        }
+      end
+
+      # redirections :error, signin_path: [:error, :invalid, :auth_error]
+    end  
+  end
+end

data/lib/generators/controll/templates/notifier.tt

@@ -0,0 +1,31 @@
+module Notifiers
+  class <%= class_name %> < <%= parent_class %>
+    handler :notice do
+      # ...
+    end
+
+    handler :error do
+      messages do
+        {
+          must_sign_in: 'You need to sign in before accessing this page!',
+          
+          auth_service_error: %q{There was an error at the remote authentication service.
+You have not been signed in.},
+          
+          cant_delete_current_account: 'You are currently signed in with this account!',
+          user_save_error: 'This is embarrassing! There was an error while creating your account from which we were not able to recover.',
+        }
+      end
+
+      msg :auth_error! do
+        "Error while authenticating via #{service_name}. The service did not return valid data."
+      end
+
+      msg :auth_invalid! do
+        'Error while authenticating via {{full_route}}. The service returned invalid data for the user id.'
+      end
+    end
+  end
+end
+
+    

data/spec/acceptance/app_test.rb

@@ -22,7 +22,7 @@ Capybara.app_host   = "http://127.0.0.1:#{FocusedController::Test.port}"
 
 describe 'acceptance test' do
   def app_root
-    TEST_ROOT + '/app'
+    TEST_ROOT + '/controll_app'
   end
 
   def within_test_app

data/spec/controll/assistant/param_assistant_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class ParamAssistant < Controll::ParamAssistant
+  param_methods :id
+end
+
+class MyController
+  include Controll::ParamAssistant::Helper
+
+  def params
+    {:id => 7}
+  end
+
+  param_assistant ::ParamAssistant
+end
+
+describe Controll::Assistant do
+  context 'Param assistant' do
+    subject { ParamAssistant.new controller }
+
+    let(:controller) { MyController.new }
+
+    its(:controller) { should == controller }
+    its(:params) { should == {:id => 7} }
+    its(:id) { should == 7 }
+
+    specify do
+      controller.param(:id).should == 7
+    end
+  end
+end

data/spec/controll/assistant/session_assistant_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class SessionAssistant < Controll::SessionAssistant
+  session_methods :name
+end
+
+class MyController
+  include Controll::SessionAssistant::Helper
+
+  def session
+    {:name => 'kris'}
+  end
+
+  session_assistant ::SessionAssistant
+end
+
+describe Controll::Assistant do
+  context 'Session assistant' do
+    subject { SessionAssistant.new controller }
+
+    let(:controller) { MyController.new }
+
+    its(:controller) { should == controller }
+    its(:session) { should == {:name => 'kris'} }
+    its(:name) { should == 'kris' }
+
+    specify do
+      controller.sess(:name).should == 'kris'
+    end
+  end
+end

data/spec/controll/assistant_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class MyAssistant < Controll::Assistant
+  controller_methods :params
+end
+
+class MyController
+  def params
+    {:id => 7}
+  end
+
+  def my_assistant
+    @my_assistant ||= MyAssistant.new self
+  end
+end
+
+describe Controll::Assistant do
+  context 'My assistant with params delegation' do
+    subject { MyAssistant.new controller }
+
+    let(:controller) { MyController.new }
+
+    its(:controller) { should == controller }
+    its(:params) { should == {:id => 7} }
+  end
+end

data/spec/controll/command_spec.rb

@@ -6,7 +6,7 @@ class NiceController
   end
 end
 
-class SignInCommand < Controll::Command
+class SignOffCommand < Controll::Command
   attribute :parent_id, String
 
   def perform
@@ -15,7 +15,7 @@ class SignInCommand < Controll::Command
 end
 
 class NiceCommander < Controll::Commander
-  command_method(:sign_in, name: 'kris') { {parent_id: parent_id} }
+  command_method(:sign_off, name: 'kris') { {parent_id: parent_id} }
 
   def params
     {:id => 7}
@@ -43,13 +43,13 @@ describe Controll::Command do
 
     describe '.command name, *args' do 
       specify do
-        subject.command(:sign_in).should be_a Controll::Command
+        subject.command(:sign_off).should be_a Controll::Command
       end
     end
 
     describe '.command! name, *args' do
       specify do
-        subject.command!(:sign_in).should == {id: 7, parent: 'my parent', user_id: 1 }
+        subject.command!(:sign_off).should == {id: 7, parent: 'my parent', user_id: 1 }
       end
     end
   end

data/spec/controll/enabler/macros_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+class MyController
+  include Controll::Enabler::Macros
+
+  # Mocking!
+  def render path
+    path
+  end
+  alias_method :redirect_to, :render  
+end
+
+module Executors
+  class Services < Controlled
+  end
+end
+
+module Commanders
+  class Services < Commander
+  end
+end
+
+module Notifiers
+  class Services < Typed
+  end
+end
+
+module Assistants
+  class Services < Assistant
+  end
+end
+
+module Flows
+  class Services < Master
+  end
+end
+
+describe Controll::Enabler do
+  subject { controller.new }
+  let(:controller) { MyController }
+
+  describe 'class level macros' do
+
+    describe '.commander name, options = {}' do
+      before :all do
+        controller.commander :services
+      end
+
+      its(:commander) { should be_a Commanders::Services }
+    end
+
+    describe '.commander name, options = {}' do
+      before :all do
+        controller.notifier :services
+      end
+
+      its(:notifier) { should be_a Notifiers::Services }
+    end
+
+    describe '.assistant name, options = {}' do
+      before :all do
+        controller.assistant :services
+      end
+
+      its(:assistant) { should be_a Assistants::Services }
+    end
+
+    describe '.flow name, options = {}' do
+      before :all do
+        controller.flow :services
+      end
+
+      its(:flow) { should be_a Flows::Services }
+    end
+  end
+end

data/spec/controll/enabler/maps_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class SweetController
+  include Controll::Enabler::Maps
+end
+
+describe Controll::Enabler::Maps do
+  subject { controller.new }
+
+  let(:controller) { SweetController }
+
+  describe '.redirect_map {}' do
+    before :all do
+      controller.redirect_map :index => %w{alpha beta}
+    end
+
+    specify do
+      controller.redirect_map.should == {:index => ['alpha', 'beta'] }
+    end
+  end
+
+  describe '.render_map {}' do
+    before :all do
+      controller.render_map :index => %w{alpha zeta}
+    end
+
+    specify do
+      controller.render_map.should == {:index => ['alpha', 'zeta'] }
+    end
+  end
+end

data/spec/controll/{helper → enabler}/notify_spec.rb

@@ -1,31 +1,21 @@
 require 'spec_helper'
 
 class Notifier
-  include Controll::Helper::Notify
+  include Controll::Enabler::Notify
 end  
 
-describe Controll::Helper::Notify do
+describe Controll::Enabler::Notify do
   subject { Notifier.new }
 
   context 'initial state' do
-    describe '.notifications' do
-      its(:notifications) { should be_empty }      
-    end
-
     describe '.main_event' do
-      its(:main_event) { should be_a Hashie::Mash }
-    end
-
-    describe '.create_notification' do
-      specify { subject.send(:create_notification, :updated).should be_a Hashie::Mash }
+      its(:main_event) { should be_a Controll::Event }
     end
 
-    describe '.create_event' do
-      specify { subject.send(:create_event, :updated).should be_a Hashie::Mash }
-    end
-
-    describe '.create_notice' do
-      specify { subject.send(:create_notice,:updated).should be_a Hashie::Mash }
+    Controll::Event.valid_types.each do |type|
+      describe ".create_#{type}" do
+        specify { subject.send(:"create_#{type}",:updated).should be_a Controll::Event }
+      end
     end
 
     describe '.notify' do 

data/spec/controll/enabler/path_handler_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class MySweetController
+  include Controll::Enabler
+
+  redirect_map :index => %w{success}
+
+  render_map :show => %w{success}
+
+  # Mocking!
+  def render path
+    path
+  end
+  alias_method :redirect_to, :render
+end
+
+describe Controll::Enabler::PathHandler do
+  subject { Controll::Enabler::PathHandler.new controller }
+
+  let(:controller) { MySweetController.new }
+
+  describe '.execute *args' do
+  end
+end

data/spec/controll/enabler/path_resolver_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+class MySweetController
+  include Controll::Enabler
+
+  def fallback_path
+    'root'
+  end
+
+  def away
+    'away'
+  end
+
+  def perfect
+    'perfect'
+  end
+end
+
+ActionMapper = Controll::Flow::ActionMapper
+Action = Controll::Flow::Action
+
+class Redirecter < ActionMapper::Complex
+  event_map 'inperfect' => [:cool, :sweet], 'away' => [:success]
+end
+
+class Renderer < ActionMapper::Simple
+  events %w{perfect}
+end
+
+describe Controll::Enabler::PathResolver 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
+
+  let(:controller) { MySweetController.new }
+
+  let(:render_map)    { {'perfect' => [:cool, :sweet], 'home' => [:success] }}
+  let(:redirect_map)  { {'inperfect' => [:cool, :sweet], 'away' => [:success] } }
+
+  let(:fallback_action) { Action::Fallback.new controller }
+
+  context 'initialize controller, render_map' do
+    subject { Controll::Enabler::PathResolver.new controller, render_map }
+
+    its(:caller)      { should == controller }
+    its(:controller)  { should == controller }
+    its(:event_map)   { should == render_map }
+
+    describe '.resolve' do
+      specify do
+        subject.resolve.should == 'home'
+      end
+      
+      describe '.resolve :cool' do
+        specify do
+          subject.resolve(:cool).should == 'perfect'
+        end
+      end
+
+      describe '.resolve sweet' do
+        specify do
+          subject.resolve(:sweet).should == 'perfect'
+        end
+      end
+
+      describe '.resolve :uncool' do
+        specify do
+          subject.resolve(:uncool).should_not == 'perfect'
+        end
+
+        specify do
+          subject.resolve(:uncool).should == nil
+        end
+      end
+
+      describe '.resolve Fallback Action' do
+        specify do
+          subject.resolve(fallback_action).should == nil
+        end
+      end
+    end
+  end
+end

data/spec/controll/enabler_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+class MyController
+  include Controll::Enabler
+
+  # Mocking!
+  def render path
+    path
+  end
+  alias_method :redirect_to, :render  
+end
+
+describe Controll::Enabler do
+  subject { controller.new }
+  let(:controller) { MyController }
+
+  context 'instance' do
+    describe 'do_redirect' do
+      specify do
+        expect { subject.do_redirect }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'do_render' do
+      specify do
+        expect { subject.do_render }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/controll/event/helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class Container
+  include Controll::Event::Helper  
+end
+
+describe Controll::Event::Helper do
+  subject { Container.new }
+
+  let(:events)      { %w{sign_in sign_out} }
+  let(:bad_events)  { %w{bad stuff} }
+
+  let(:event)       { 'sign_in' }
+  let(:bad_event)   { 'unknown' }
+
+  describe '.normalize event' do
+    context 'Controll::Event' do
+      specify { subject.normalize(Controll::Event.new(:x)).should be_a Controll::Event  }
+    end
+
+    context 'Symbol' do
+      specify { subject.normalize(:x).should be_a Controll::Event  }
+    end
+
+    context 'Hash' do
+      specify { subject.normalize(:name => :y).should be_a Controll::Event  }
+    end    
+  end
+
+  describe '.create_event' do
+    specify { subject.create_event(:x).should be_a Controll::Event }
+  end
+end

data/spec/controll/{helper/event_matcher_spec.rb → event/matcher_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Controll::Helper::EventMatcher do
-  subject { Controll::Helper::EventMatcher.new event }
+describe Controll::Event::Matcher do
+  subject { Controll::Event::Matcher.new event }
 
   let(:events)      { %w{sign_in sign_out} }
   let(:bad_events)  { %w{bad stuff} }
@@ -10,7 +10,8 @@ describe Controll::Helper::EventMatcher do
   let(:bad_event)   { 'unknown' }
 
   describe '.initialize event' do
-    its(:event) { should == 'sign_in' }
+    its(:event) { should be_a Controll::Event }
+    its('event.name') { should == :sign_in }
   end
 
   describe '.match? events' do