added support for 'Object/perm' style checking.

Also some var to let/const conversions.

Author: Morgul

README.md

@@ -66,10 +66,10 @@ application.
 Defining an individual group is very simple:
 
 ```javascript
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
 // Create an 'Admins' group
-var admGroup = tp.defineGroup({ name: 'Admins', permissions: ['*/*'] });
+const admGroup = tp.defineGroup({ name: 'Admins', permissions: ['*/*'] });
 ```
 
 #### Loading Groups
@@ -81,7 +81,7 @@ More usefully, you will want to load multiple groups at once. TrivialPermissions
 (Note: You _will_ need to wait until after the loading promise resolves before attempting to use the permissions system.)
 
 ```javascript
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
 // Load from a list
 var loading = tp.loadGroups([
@@ -171,9 +171,9 @@ If your user object has it's permissions or groups under a different key name, y
 looks for using this method. Simply pass an object with the `permissions` and/or `groups` key(s) to map to your object's structure.
 
 ```javascript
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
-var user = {
+const user = {
 	name: "John Snow",
 	allowed: ["Foo/canView", "Bar/canView"],
 	roles: ["Posters"]
@@ -190,10 +190,10 @@ tp.setUserMapping({ permissions: 'allowed', groups: 'roles' });
 This is the heart of the system: checking permissions. It's very simply; you pass the user object, the permission descriptor (string), and the object descriptor (string). Here are a few examples:
 
 ```javascript
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
 // Setup
-var loading = tp.loadGroups([
+const loading = tp.loadGroups([
     {
         name: "Administrators",
         permissions: [
@@ -217,18 +217,18 @@ var loading = tp.loadGroups([
 ]);
 
 // Define Users
-var batman = {
+const batman = {
     name: 'batman',
     groups: ['Administrators']
 };
 
-var stark = {
+const stark = {
     name: 'tstark',
     permissions: ['*/*'],
     groups: ['Users']
 };
 
-var leo = {
+const leo = {
     name: 'lblume',
     groups: ['Users']
 };
@@ -260,10 +260,10 @@ about simply seeing if `groupName` is in the list of groups on the user: `hasGro
 not been defined, regardless of is the user has that group name in their list of groups.
 
 ```javascript
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
 // Setup
-var loading = tp.loadGroups([
+const loading = tp.loadGroups([
     {
         name: "Administrators",
         permissions: [
@@ -287,18 +287,18 @@ var loading = tp.loadGroups([
 ]);
 
 // Define Users
-var batman = {
+const batman = {
     name: 'batman',
     groups: ['Administrators']
 };
 
-var stark = {
+const stark = {
     name: 'tstark',
     permissions: ['*/*'],
     groups: ['Users']
 };
 
-var leo = {
+const leo = {
     name: 'lblume',
     groups: ['Users']
 };

dist/trivialperms.min.js

@@ -4,13 +4,13 @@
 /// @module
 //----------------------------------------------------------------------------------------------------------------------
 
-var tp = require('../dist/trivialperms');
+const tp = require('../dist/trivialperms');
 
 //----------------------------------------------------------------------------------------------------------------------
 // Setup
 //----------------------------------------------------------------------------------------------------------------------
 
-var loading = tp.loadGroups([
+const loading = tp.loadGroups([
     {
         name: "Administrators",
         permissions: [
@@ -35,18 +35,18 @@ var loading = tp.loadGroups([
 
 // Define Users
 
-var batman = {
+const batman = {
     name: 'batman',
     groups: ['Administrators']
 };
 
-var stark = {
+const stark = {
     name: 'tstark',
     permissions: ['*/*'],
     groups: ['Users']
 };
 
-var leo = {
+const leo = {
     name: 'lblume',
     groups: ['Users']
 };

examples/simple.js

@@ -8,7 +8,7 @@ import find from 'lodash/find';
 import uniq from 'lodash/uniq';
 import remove from 'lodash/remove';
 
-var _ = {
+const _ = {
     find,
     uniq,
     remove
@@ -29,9 +29,16 @@ class TPGroup {
 
     hasPerm(perm, obj)
     {
+        if(arguments.length === 1)
+        {
+            const parts = perm.split('/');
+            obj = parts[0];
+            perm = parts[1];
+        } // end if
+
         return !!_.find(this.permissions, (permission) =>
         {
-            if(permission == '*/*')
+            if(permission === '*/*')
             {
                 return true;
             }
@@ -60,7 +67,7 @@ class TPGroup {
 
     removePerm(perm, obj)
     {
-        return _.remove(this.permissions, (item) => item == `${ obj }/${ perm }`);
+        return _.remove(this.permissions, (item) => item === `${ obj }/${ perm }`);
     } // end removePerm
 } // end TPGroup
 

src/group.js

@@ -15,15 +15,15 @@ import TPGroup from './group';
 
 //----------------------------------------------------------------------------------------------------------------------
 
-var _ = {
+const _ = {
     map,
     find,
     some,
     includes,
     isFunction
 };
 
-var mapping = { permissions: 'permissions', groups: 'groups' };
+const mapping = {permissions: 'permissions', groups: 'groups'};
 
 //----------------------------------------------------------------------------------------------------------------------
 
@@ -38,7 +38,7 @@ class TPManager
     {
         return !!_.find(user[mapping.permissions], (permission) =>
         {
-            if(permission == '*/*')
+            if(permission === '*/*')
             {
                 return true;
             }
@@ -74,15 +74,15 @@ class TPManager
             throw new Error("Must specify a 'name' property.");
         } // end if
 
-        var group = new TPGroup(groupDef.name, groupDef.permissions, this);
+        const group = new TPGroup(groupDef.name, groupDef.permissions, this);
         this.groups[groupDef.name] = group;
 
         return group;
     } // end defineGroup
 
     loadGroups(groupsOrFunc)
     {
-        var loadPromise = Promise.resolve(groupsOrFunc);
+        let loadPromise = Promise.resolve(groupsOrFunc);
         if(_.isFunction(groupsOrFunc))
         {
             loadPromise = groupsOrFunc();
@@ -97,10 +97,17 @@ class TPManager
 
     hasPerm(user, perm, obj)
     {
-        var found = this._userHasPerm(user, perm, obj);
+        if(arguments.length === 2)
+        {
+            const parts = perm.split('/');
+            obj = parts[0];
+            perm = parts[1];
+        } // end if
+
+        let found = this._userHasPerm(user, perm, obj);
         if(!found)
         {
-            var groups = _.map(user[mapping.groups], (name) => this.groups[name]);
+            const groups = _.map(user[mapping.groups], (name) => this.groups[name]);
             found = _.some(groups, (group) => group.hasPerm(perm, obj));
         } // end if
 

src/trivialperms.js

@@ -4,15 +4,15 @@
 // @module base.spec.js
 // ---------------------------------------------------------------------------------------------------------------------
 
-var expect = require('chai').expect;
+const expect = require('chai').expect;
 
-var TPGroup = require('../src/group').default;
+const TPGroup = require('../src/group').default;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 describe('Groups', () =>
 {
-    var groupInst, god;
+    let groupInst, god;
     beforeEach(() =>
     {
         groupInst = new TPGroup('test', [
@@ -38,6 +38,11 @@ describe('Groups', () =>
 
     describe('#hasPerm()', () =>
     {
+        it('can take the `Object/perm` form', () =>
+        {
+            expect(groupInst.hasPerm('Other/canEdit')).to.be.true;
+        });
+
         it('matches exact permissions', () =>
         {
             expect(groupInst.hasPerm('canEdit', 'Other')).to.be.true;

test/group.spec.js

@@ -4,16 +4,16 @@
 // @module trivialperms.spec.js
 // ---------------------------------------------------------------------------------------------------------------------
 
-var Promise = require('bluebird');
-var expect = require('chai').expect;
+const Promise = require('bluebird');
+const expect = require('chai').expect;
 
-var tp = require('../src/trivialperms');
+const tp = require('../src/trivialperms');
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 describe('Permissions', () =>
 {
-    var batman, stark, leo;
+    let batman, stark, leo;
     beforeEach(() =>
     {
         batman = {
@@ -156,7 +156,7 @@ describe('Permissions', () =>
         it('supports setting the mapping of properties on the user object', () =>
         {
             tp.setUserMapping({ groups: 'roles' });
-            var user = {
+            const user = {
                 roles: ['Users']
             };
 
@@ -177,12 +177,20 @@ describe('Permissions', () =>
 
         it('returns false when checking the groups of a user if the group is not registered', () =>
         {
-            var user = {
+            const user = {
                 groups: ['Users', 'Fakes']
             };
 
             expect(tp.hasGroup(user, 'Fakes')).to.equal(false);
         });
+
+        describe('#hasPerm()', () =>
+        {
+            it('can take the `Object/perm` form', () =>
+            {
+                expect(tp.hasPerm(stark, 'Posts/canEdit')).to.equal(true);
+            });
+        });
     });
 });