Add not(), remove flip|invert|unset()

README.md

@@ -19,7 +19,7 @@ It also allows you to perform operations on them including:
 - [setting](#setpermission-permissions) and
   [unsetting](#unsetpermission-permissions). Using bitwise operations can be
   tedious and error-prone.
-- [inverting](#flippermission). For example a
+- [inverting](#notpermission). For example a
   [`umask`](https://linux.die.net/man/2/umask) of `117` means new files will be
   created with `661` permissions.
 - checking the [minimal](#minpermissions) or
@@ -351,31 +351,26 @@ unixPermissions.unset('---------', 'a-x') // '--x--x--x'
 unixPermissions.unset('a+xr', 'a+r') // 'a+x,a-r'
 ```
 
-## `invert(permission)`
+## `not(permission)`
 
-Inverts `permission` and unsets the special permissions.
+Inverts `permission`.
 
 For example a [`umask`](https://linux.die.net/man/2/umask) of `117` means new
 files will be created with `661` permissions.
 
-<!-- eslint-disable line-comment-position, no-inline-comments -->
-
-```js
-unixPermissions.invert('660') // '=0117'
-unixPermissions.invert('7660') // '=0117'
-unixPermissions.invert('rws-ws-w-') // '---r--r-x'
-```
-
-## `flip(permission)`
-
-Inverts `permission` including the special permissions.
+Special permissions are only inverted to a positive value when `permission`
+explicitly negates them.
 
 <!-- eslint-disable line-comment-position, no-inline-comments -->
 
 ```js
-unixPermissions.flip('660') // '=7117'
-unixPermissions.flip('7660') // '=0117'
-unixPermissions.flip('rws-ws-w-') // '---r--r-t'
+unixPermissions.not('u+xs') // 'u-xs'
+unixPermissions.not('u-xs') // 'u+xs'
+unixPermissions.not('u=x') // 'u=rws'
+unixPermissions.not('a=x') // 'a=rw'
+unixPermissions.not('rws-ws-w-') // '---r--r-x'
+unixPermissions.not('0660') // '0117'
+unixPermissions.not('1660') // '0117'
 ```
 
 ## `min(permissions...)`

src/cli/commands.json

@@ -39,11 +39,6 @@
     "describe": "Returns the result of setting `permissions` on `permission`.",
     "examples": [["set a=w a+r", "Output: a=rw"]]
   },
-  {
-    "command": "unset <permission> [permissions...]",
-    "describe": "Returns the result of unsetting `permissions` on `permission`.",
-    "examples": [["unset a=wr a+r", "Output: a=w"]]
-  },
   {
     "command": "contain <permission> <permissions...>",
     "describe": "Tests whether `permission` includes `permissions`. Returns `true` or `false` or (on the CLI) use the exit code `0` or `1`.",
@@ -73,14 +68,9 @@
     "examples": [["positive a=rw", "Output: a+rw"]]
   },
   {
-    "command": "invert <permission>",
-    "describe": "Inverts permission and unsets the special permissions",
-    "examples": [["invert 744", "Output: =0033"]]
-  },
-  {
-    "command": "flip <permission>",
-    "describe": "Inverts permission including the special permissions",
-    "examples": [["flip 744", "Output: =7033"]]
+    "command": "not <permission>",
+    "describe": "Inverts permission",
+    "examples": [["not 744", "Output: =0033"]]
   },
   {
     "command": "min <permission> [permissions...]",

src/functions/main.js

@@ -6,9 +6,7 @@ const { positive } = require('./positive')
 const { contain } = require('./contain')
 const { equal } = require('./equal')
 const { set } = require('./set')
-const { unset } = require('./unset')
-const { flip } = require('./flip')
-const { invert } = require('./invert')
+const { not } = require('./not')
 const { min, max } = require('./min_max')
 
 module.exports = {
@@ -18,9 +16,7 @@ module.exports = {
   contain,
   equal,
   set,
-  unset,
-  flip,
-  invert,
+  not,
   min,
   max,
 }

src/functions/not.js

@@ -1,20 +1,50 @@
 'use strict'
 
+const { unaryMap } = require('../helpers')
+const { SPECIAL_PERMISSIONS } = require('../constants')
+const { NODES_MAP } = require('../nodes')
 const { mapValues } = require('../utils')
 
-// Similar to invert() except keep omitted permissions as is.
-// We do not export not() because:
-//  - on types that do not support `add:false` like `stat` or `number`, it
-//    would always result in 0, which is confusing.
-//  - `unset()`, `invert()` and `flip()` should cover most use cases
+// Invert a permission's `+` and `-`.
+// Missing permissions are not inverted.
+// Special flags are unset unless the permission is partial. This is because:
+//  - `not()` or `unset()` on `u+s` should be `u-s`, `-1555` should be `+1555`
+//  - but `not()` or `unset()` on `1555` should be `0222`
+// I.e. setting special flags as part of `not()` or `unset()` should only be
+// done when explicit.
 const notMap = function(nodesMap) {
-  return mapValues(nodesMap, invertAdd)
+  const nodesMapA = mapValues(nodesMap, node => notNode({ node }))
+
+  if (isPartial({ nodesMap })) {
+    return nodesMapA
+  }
+
+  const nodesMapB = mapValues(nodesMapA, unsetSpecial)
+  return nodesMapB
 }
 
-const invertAdd = function({ add, ...node }) {
+const notNode = function({ node, node: { add } }) {
   return { ...node, add: !add }
 }
 
+const isPartial = function({ nodesMap }) {
+  return Object.keys(nodesMap).length !== Object.keys(NODES_MAP).length
+}
+
+const unsetSpecial = function(node) {
+  if (!isSpecial(node)) {
+    return node
+  }
+
+  return { ...node, add: false }
+}
+
+const isSpecial = function({ permission }) {
+  return SPECIAL_PERMISSIONS.includes(permission)
+}
+
+const not = unaryMap.bind(null, notMap)
+
 module.exports = {
-  notMap,
+  not,
 }

src/parse.js

@@ -11,7 +11,7 @@ const { isPlainObject, omitBy } = require('./utils')
 // the first one that does not return `undefined`
 const parse = function(perm) {
   const { type, nodes } = parsePerm({ perm, funcName: 'parse' })
-  const nodesMap = getNodesMap(nodes)
+  const nodesMap = normalizeNodes({ nodes })
   return { type, nodesMap }
 }
 
@@ -22,9 +22,8 @@ const parseCategory = function(perm, category) {
     category,
   })
   const nodes = catNodes.map(catNode => addCategory({ catNode, category }))
-  const nodesMap = getNodesMap(nodes)
-  const nodesMapA = omitBy(nodesMap, isInvalidNode)
-  return { type, nodesMap: nodesMapA }
+  const nodesMap = normalizeNodes({ nodes })
+  return { type, nodesMap }
 }
 
 const parsePerm = function({ perm, funcName, category }) {
@@ -66,6 +65,12 @@ const addCategory = function({
   return { ...catNode, category }
 }
 
+const normalizeNodes = function({ nodes }) {
+  const nodesMap = getNodesMap(nodes)
+  const nodesMapA = omitBy(nodesMap, isInvalidNode)
+  return nodesMapA
+}
+
 // Exclude special flags not valid for current category
 const isInvalidNode = function(node, nodeKey) {
   return NODES_MAP[nodeKey] === undefined

test/helpers/data/contain.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { BASE_SET_DATA } = require('./set_unset')
+const { BASE_SET_DATA } = require('./set')
 
 const CONTAIN_DATA = [
   ...BASE_SET_DATA,

test/helpers/data/index.js

@@ -10,5 +10,5 @@ module.exports = {
   ...require('./min_max'),
   ...require('./contain'),
   ...require('./equal'),
-  ...require('./set_unset'),
+  ...require('./set'),
 }

test/helpers/data/set_unset.js → test/helpers/data/set.js

@@ -21,7 +21,7 @@ const BASE_SET_DATA = [
   ['o-x', 'o+'],
 ]
 
-const SET_UNSET_DATA = [
+const SET_DATA = [
   ...BASE_SET_DATA,
 
   // Equal operator
@@ -50,5 +50,5 @@ const SET_UNSET_DATA = [
 
 module.exports = {
   BASE_SET_DATA,
-  SET_UNSET_DATA,
+  SET_DATA,
 }

test/invert.js → test/not.js

@@ -4,6 +4,6 @@ const { SIMPLE_DATA, performTests } = require('./helpers')
 
 performTests({
   title: args => `should invert ${args}`,
-  command: 'invert',
+  command: 'not',
   data: SIMPLE_DATA,
 })

test/set.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const { SET_UNSET_DATA, performTests } = require('./helpers')
+const { SET_DATA, performTests } = require('./helpers')
 
 performTests({
   title: ([arg, ...args]) => `should set ${arg} with ${args.join(' ')}`,
   command: 'set',
-  data: SET_UNSET_DATA,
+  data: SET_DATA,
 })