unix-permissions/build/src/types/symbolic/parse.js

Swiss Army knife for Unix permissions

import{CATEGORIES,PERMISSIONS}from"../../constants.js";
import{hasDuplicate}from"../../utils.js";

import{tokenize}from"./tokenize.js";


export const parse=(symbolic)=>{
const tokens=tokenize(symbolic);

if(tokens===undefined||hasDuplicates({tokens})){
return
}

const nodes=tokens.
map(addDefaultCategories).
map(normalizeX).
flatMap(splitCategories).
flatMap(splitAll).
flatMap(normalizeOperator).
flatMap(splitPermissions);
return nodes
};




const hasDuplicates=({tokens})=>tokens.some(hasDuplicatePermissions);

const hasDuplicatePermissions=({permissions})=>
hasDuplicate([...permissions]);


const addDefaultCategories=(node)=>{
if(node.categories!==""){
return node
}

return{...node,categories:DEFAULT_CATEGORIES}
};

const DEFAULT_CATEGORIES="a";



const normalizeX=({permissions,...node})=>{
const permissionsA=permissions.replaceAll("X","x");
return{...node,permissions:permissionsA}
};



const splitCategories=({categories,operator,permissions})=>
[...categories].map((category)=>({
category,
operator,
permissions
}));


const splitAll=({category,operator,permissions})=>{
if(category!=="a"){
return{category,operator,permissions}
}

return CATEGORIES.map((categoryA)=>({
category:categoryA,
operator,
permissions
}))
};


const normalizeOperator=({operator,permissions,...node})=>{
if(operator==="+"){
return[{...node,permissions,add:true}]
}

if(operator==="-"){
return[{...node,permissions,add:false}]
}


return PERMISSIONS.map((permission)=>({
...node,
permissions:permission,
add:permissions.includes(permission)
}))
};


const splitPermissions=({permissions,add,...node})=>{
if(permissions===""){
return[]
}

return[...permissions].map((permission)=>({...node,permission,add}))
};