paloma 3.0.2 → 4.0.0

data/test_app/spec/javascripts/router_spec.js

@@ -1,6 +1,6 @@
 
 describe('Paloma.Router', function(){
-  var delimiter = {namespace: '/', action: '#'},
+  var delimiter = '/',
       router = new Paloma.Router(delimiter);
 
   describe('#parse(path)', function(){
@@ -9,7 +9,7 @@ describe('Paloma.Router', function(){
       var result;
 
       beforeEach(function(){
-        result = router.parse('Foo/Bar/Baz/Controller#action');
+        result = router.parse('Foo/Bar/Baz/Controller');
       });
 
       it('returns the array of the namespaces', function(){
@@ -20,10 +20,6 @@ describe('Paloma.Router', function(){
         expect(result.controller).toEqual('Controller');
       });
 
-      it('returns the action', function(){
-        expect(result.action).toEqual('action');
-      });
-
       it('returns the controllerPath', function(){
         expect(result.controllerPath).toEqual(['Foo', 'Bar', 'Baz', 'Controller']);
       });
@@ -35,7 +31,7 @@ describe('Paloma.Router', function(){
       var result;
 
       beforeEach(function(){
-        result = router.parse('Controller#action');
+        result = router.parse('Controller');
       });
 
       it('returns an empty array of namespaces', function(){
@@ -46,10 +42,6 @@ describe('Paloma.Router', function(){
         expect(result.controller).toEqual('Controller');
       });
 
-      it('returns the action', function(){
-        expect(result.action).toEqual('action');
-      });
-
       it('returns the controllerPath', function(){
         expect(result.controllerPath).toEqual(['Controller']);
       });
@@ -57,65 +49,4 @@ describe('Paloma.Router', function(){
 
   });
 
-
-
-
-
-  describe('#controllerFor(resource)', function(){
-
-    var resource = 'MySuperResource';
-
-    describe('when no route is found', function(){
-      it('returns the resource', function(){
-        var controller = router.controllerFor(resource);
-        expect(controller).toEqual(resource);
-      });
-    });
-
-
-    describe('when route is found', function(){
-      it('returns the set controller', function(){
-        router.resource(resource, {controller: 'MyController'});
-
-        var controller = router.controllerFor(resource);
-        expect(controller).toEqual('MyController');
-      });
-    });
-  });
-
-
-
-
-
-  describe('#redirectFor(resource, action)', function(){
-    var router = new Paloma.Router(delimiter),
-        result;
-
-    describe('when has a redirect', function(){
-      beforeEach(function(){
-        router.redirect('Foo#edit', {to: 'Bar#revise'});
-        result = router.redirectFor('Foo', 'edit');
-      });
-
-      it('returns controller of the redirect', function(){
-        expect(result.controller).toEqual('Bar');
-      });
-
-      it('returns action of the redirect', function(){
-        expect(result.action).toEqual('revise');
-      });
-    });
-
-
-    describe('when has no redirect', function(){
-      var router = new Paloma.Router(delimiter),
-          result = router.redirectFor('Foo', 'edit');
-
-      it('returns null', function(){
-        expect(result).toBeNull();
-      });
-    });
-
-  });
-
 });

data/test_app/spec/spec_helper.rb

@@ -30,3 +30,8 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = "random"
 end
+
+
+def request
+  page.evaluate_script 'Paloma.engine.lastRequest'
+end

data/test_app/spec/units/controller_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+
+describe Paloma::Controller do
+
+  let(:controller){ Paloma::Controller.new }
+
+
+  before do
+    controller.resource = 'Test'
+    controller.action = 'new'
+    controller.params = {:x => 1, :y => 2}
+  end
+
+
+
+  shared_examples 'request is cleared' do
+    it 'assigns nil to resource' do
+      expect(controller.resource).to be_nil
+    end
+
+
+    it 'assigns nil to action' do
+      expect(controller.action).to be_nil
+    end
+
+
+    it 'assigns an empty hash to params' do
+      expect(controller.params).to be_empty
+    end
+
+
+    it 'returns true' do
+      expect(@return).to be_true
+    end
+  end
+
+
+
+  shared_examples 'request is not cleared' do
+    it 'returns false' do
+      expect(@return).to be_false
+    end
+
+
+    it 'has a request' do
+      expect(controller.has_request?).to be_true
+    end
+  end
+
+
+
+
+
+  describe '#clear_request' do
+    before { @return = controller.clear_request }
+    it_behaves_like 'request is cleared'
+  end
+
+
+
+  describe '#request' do
+    it 'returns a hash object' do
+      expect(controller.request).to be_an_instance_of Hash
+    end
+
+
+    it 'returns the current value of resource' do
+      expect(controller.request[:resource]).to eq 'Test'
+    end
+
+
+    it 'returns the current value of action' do
+      expect(controller.request[:action]).to eq 'new'
+    end
+
+
+    it 'returns the current value of params' do
+      expect(controller.request[:params]).to eq ({:x => 1, :y => 2})
+    end
+  end
+
+
+
+  describe '#has_request?' do
+    context 'when resource is nil' do
+      it 'returns false' do
+        controller.resource = nil
+        expect(controller.has_request?).to be_false
+      end
+    end
+
+
+    context 'when action is nil' do
+      it 'returns false' do
+        controller.action = nil
+        expect(controller.has_request?).to be_false
+      end
+    end
+
+
+    context 'when resource and action is present' do
+      it 'returns true' do
+        expect(controller.has_request?).to be_true
+      end
+    end
+  end
+
+end

data/test_app/spec/units/utilities_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+
+describe Paloma::Utilities do
+
+  let(:utilities){ Paloma::Utilities }
+
+
+
+  describe '.get_resource(path)' do
+    context 'when path is only 1 word' do
+      it 'returns the controller resource name' do
+        expect(utilities.get_resource('test')).to eq 'Test'
+      end
+    end
+
+
+    context 'when path is more than 1 word' do
+      it 'returns the controller resource name' do
+        expect(utilities.get_resource('my_super_resources')).to eq 'MySuperResources'
+      end
+    end
+
+
+    context 'when path has namespace' do
+      it 'returns "Namespace/Resource"' do
+        expect(utilities.get_resource('admin/my_mega_test')).to eq 'Admin/MyMegaTest'
+      end
+    end
+
+
+    context 'when path has 2 or more namespace' do
+      it 'returns "Namespace1/NamespaceN/Resource' do
+        expect(utilities.get_resource('admin/test/my_resources')).to eq 'Admin/Test/MyResources'
+      end
+    end
+  end
+
+
+
+
+
+  shared_examples 'resource is passed' do |resource|
+    it 'returns its returned as the resource' do
+      expect(route[:resource]).to eq resource
+    end
+  end
+
+
+  shared_examples 'action is passed' do |action|
+    it 'returns the action' do
+      expect(route[:action]).to eq action
+    end
+  end
+
+
+  shared_examples 'resource is not passed' do
+    it 'returns a nil resource' do
+      expect(route[:resource]).to be_nil
+    end
+  end
+
+
+  shared_examples 'action is not passed' do
+    it 'returns a nil action' do
+      expect(route[:action]).to be_nil
+    end
+  end
+
+
+
+
+
+  describe '.interpret_route(route_string)' do
+    context 'when route_string is empty' do
+      it 'raises an error' do
+        expect { utilities.interpret_route }.to raise_error 'Empty route cannot be interpreted'
+      end
+    end
+
+
+    context 'when route_string has a word' do
+      let(:route){ utilities.interpret_route 'MyResources' }
+
+      it_behaves_like 'resource is passed', 'MyResources'
+      it_behaves_like 'action is not passed'
+    end
+
+
+    context 'when route_string has a namespace' do
+      let(:route){ utilities.interpret_route 'Namespace/MyResource' }
+
+      it_behaves_like 'resource is passed', 'Namespace/MyResource'
+      it_behaves_like 'action is not passed'
+    end
+
+
+    context 'when route_string has an action' do
+      let(:route){ utilities.interpret_route 'Namespace/MyResources#action' }
+
+      it_behaves_like 'resource is passed', 'Namespace/MyResources'
+      it_behaves_like 'action is passed', 'action'
+    end
+
+
+    context 'when route_string has action only' do
+      let(:route){ utilities.interpret_route '#edit' }
+
+      it_behaves_like 'resource is not passed'
+      it_behaves_like 'action is passed', 'edit'
+    end
+  end
+
+end

data/vendor/assets/javascripts/paloma/engine.js

@@ -1,62 +1,32 @@
 (function(Paloma){
 
   var Engine = function(config){
-    this.router = config.router;
     this.factory = config.factory;
-    this.restart();
+    this.lastRequest = null;
   };
 
 
-  Engine.prototype.start = function(){
-    for (var i = 0, n = this.requests.length; i < n; i++){
-      var request = this.requests[i];
-
-      console.log('Processing request with params:');
-      console.log(request.params);
-
-      var controllerName = this.router.controllerFor(request.resource),
-          action = request.action,
-          redirect = this.router.redirectFor(request.resource, action);
-
-      if (redirect){
-        controllerName = redirect['controller'];
-        action = redirect['action'];
-      }
-
-      console.log('mapping <' + request.resource + '> to controller <' + controllerName + '>');
-      console.log('mapping action <' + request.action + '> to controller action <' + action + '>');
-
-      var Controller = this.factory.get(controllerName);
-
-      if (!Controller){
-        console.warn('Paloma: undefined controller -> ' + controllerName);
-        continue;
-      }
-
-      var controller = new Controller(request.params);
+  Engine.prototype.request = function(resource, action, params){
+    this.lastRequest = null;
 
-      if (!controller[action]){
-        console.warn('Paloma: undefined action <' + action +
-          '> for <' + controllerName + '> controller');
-        continue;
-      }
+    var Controller = this.factory.get(resource);
 
-      controller[action]();
+    if (!Controller){
+      return Paloma.warn('Paloma: undefined controller -> ' + resource);
     }
 
-    this.restart();
-  };
-
+    var controller = new Controller(params);
 
-  Engine.prototype.restart = function(){
-    this.requests = [];
-  };
+    if (!controller[action]){
+      return Paloma.warn('Paloma: undefined action <' + action +
+        '> for <' + resource + '> controller');
+    }
 
+    Paloma.log('Paloma: Execute ' + resource + '#' + action + ' with');
+    Paloma.log(params);
 
-  Engine.prototype.request = function(resource, action, params){
-    this.requests.push({resource: resource,
-                        action: action,
-                        params: params});
+    controller[action]();
+    this.lastRequest = {controller: resource, action: action, params: params};
   };
 
 

data/vendor/assets/javascripts/paloma/init.js

@@ -1 +1,17 @@
-window.Paloma = window.Paloma || {};
+window.Paloma = window.Paloma || {};
+
+//
+// Do nothing if there is no available console.
+//
+if (!window['console']){ Paloma.log = Paloma.warn = function(msg){}; }
+else {
+  Paloma.warn = function(msg){
+    if(Paloma.env != 'development') return;
+    console.warn(msg);
+  };
+
+  Paloma.log = function(msg){
+    if(Paloma.env != 'development') return;
+    console.log(msg);
+  };
+}

data/vendor/assets/javascripts/paloma/paloma.js

@@ -1,17 +1,19 @@
 (function(Paloma){
 
+  Paloma._router = new Paloma.Router('/');
+  Paloma._controllerFactory = new Paloma.ControllerFactory(Paloma._router);
 
-  Paloma.router = new Paloma.Router({namespace: '/', action: '#'});
-  Paloma._controllerFactory = new Paloma.ControllerFactory(Paloma.router);
-
-
+  //
+  // Declare Paloma controllers using this method.
+  // Will return a new constructor if the no controller with the passed name
+  // is found, else it will just return the current constructor.
+  //
   Paloma.controller = function(name){
     return Paloma._controllerFactory.get(name) ||
             Paloma._controllerFactory.make(name);
   };
 
 
-  Paloma.engine = new Paloma.Engine({router: Paloma.router,
-                                    factory: Paloma._controllerFactory});
+  Paloma.engine = new Paloma.Engine({factory: Paloma._controllerFactory});
 
 })(window.Paloma);