cpy-flex v0.0.7

CPY-FLEX

A flexible copy module that extend the normal glob pattern to include regex searches.

Install

npm install cpy-flex

Usage

const { cpyFlexSync, cpyFlex } = require('cpy-flex');

const fromArr = ['./a/b.js', '**/c/d.js', '*(a|c)/d.js'];

const toFolder = './bin';
const options = {};

const opied = cpyFlexSync(fromArr, toFolder, options);
console.log(copied); // prints the total copies made.

// OR ASYNC...

cpyFlex(cfomrArr, toFolder, options).then(copied => console.log(copied));

Params

Options

The following options can be used. The groups are merely for ease of reading.

General Options

Filter Options

The following set of values relate to Filtering or parsing through the "from" string (i.e. what to get):

Folder Builder Options

The following set of values relating to gathering the current directory and file structure (i.e. the current available options):

The following should only be set if getFoldersSync or getFolders function is used and may be overwritten by cpyFlex or cpyFlexSync:

Option Objects

PreserveState

An enum to indicate what the file structure should look like when it is copied to output directory. The options are:

usage

const { PreserveState } = require('cpy-flex').objects;

const options = {
	preserve: PreserveState.none,
};

cpyFlexSync('./folder/file.js', './bin', options);
// file will be output: bin/file.js

RenameOptions

This is an object that allows for renaming of a file and extension name. The following is a set of available properties relating to the fileName:

The following is a set of available property options for changing the extension value (please also refer to 'longExtension' option that can be set):

Please note if removeExt is used all extension values above is ignored.

usage

const options = {
    rename: {
        preFix: 'changed-',
        extPre: '.done.',
        namePat: '\\.js',
        extPat: 'ile.p',
    }
};

const from = 'file.pdf'
const result = cpyFlexSync(from, './bin', options);)
// output bill be file.done.pdf

OverWrightEnum

This is an enum to assist with duplicate file names being written. The available options are as follows:

Patterns

The following is a set of general rules when referencing folders:

• !./some folder -> will be included in "ignoreList" when cpyFlex(Sync) is used.
• /some folder -> will resolve to rootDir. i.e. C:/some.
• C:/... -> will not be alterered and will be accepted as absolute path.
• ./some Folder -> will resolve to root or current working directory.
• some Folder -> will resolve to root or current working directory.

Pure Regex

There are 2 main ways to add regex queries to a query string:

• The first is a hard Regex string approach with the use of <..REGEX..>. Whatever is placed between < and > will be used as is in regex query without attempting some filtering. i.e. code should be escaped and will not be escaped by the function.
• The Second is the use of other brackets which should be preceded by a iterator character (i.e. +(...REGEX...)). Any bracket pair could be used with any iterator character. The regex between these strings will be escaped by the function. Some escaping might occur within this REGEX string.

Potential brackets is the following: { ... } or ( ... ) or ...

The following is possible iterator characters:

• + -> regex must have between one and many occurences -> +(REGEX) => (REGEX)+
• * -> regex must have between zero and many occurences -> *(REGEX) => (REGEX)*
• @ -> regex will occur exactly once -> @{REGEX} => (REGEX)
• \$ -> is the same as using @ -> \${REGEX} => (REGEX)
• ? -> regex may occur once or not at all -> ?(REGEX) => (REGEX)?
• ! -> will result in:
  • Negative lokahead (?!=REGEX) if used with (..) or {..}
  • Exclusion pattern ^regex if used with ..

Square brackets will always remain square brackets: REGEX ~> REGEX Round brackets and Curly brackets will always be round brackets: {REGEX} ~> (REGEX)

e.g.

const fromA = 'folder+{up}/file<d*>.js?(x)';
// will result in regex string as follows:
const regA = /folder(up)+\\file\d.js(x)?/;

This example should return:

• a file with a name which is followed by a number.
• an extension wich is either js or jsx.
• inside a directory of: folderup or folderupup or folderupupup etc.

and

const fromB = 'fo?[le]d![e]r.js
// will result in regex string as follows:
const regB = 'fo[le]?d[^e]r.js

the example should:

• return any file with name of foldar or foedbr.
• but will not return folder as a possible name (folder will be excluded)

DOT (.)

The following is a set of general rules using dot in files:

• ./Some Folder -> will resolve to root or current working directory.
• ../Some/folder/../file.js -> will resolve to C:\Some\file.js if root is C:\src as example. (remove previous directory path).
• some..folder or somefolder../ or ..somefolder/ -> Will be considered a regex dot (i.e. any character).
• some.folder -> is considered an ordinary dot and will be escaped in search string / regex objects.

STAR (*)

The use of wildcard * character should be the same with current glob patterns with the extension of the following rules:

• double star:

  • within a folder structure will mean any sub directory. i.e. a/ will result in all files in 'a' directory and its subfolders will be copied. will result in all files inside root folder and it's subfolders will be copied.
  • if there are any othercharacter before or after double star (i.e. a**/ or a**b) will result in a REGEX star being used in the folder structure. Therefore a**b will mean return results for folder ab or aab or aaaab etc.
  • However if double star is the first character in a directory structure it will always be a literal * (i.e. escaped *). i.e. a/**b/c will result in a\\\*b\c to be outputted (* can never be the first charcter in regexp, so it is assumed a literal * should be added)
  • The rule above is changed on the file name or ext. Double star in this place will mean an escaped as the usual glob pattern is that single star's in file name or ext is any file pattern. Therefore inside file name or ext (the last path part) double star will result in escaped star (\) to be used in regex string.

• single star:

  • within folder structure will be a normal star (i.e. should a folder name include a * character, this could be used normally).
  • In the last variable in the structure (file name or ext) a star means any string pattern can be followed (i.e. a/*.*) will result in any file name and any extension to be returned.

• Before brackets:

  • As explained before a star character infront of a ( .. ) or { ... } will result in regex string to include ( ... )*
  • A single star character infront of a ... will result in regex string to include ... *
  • A single or double star infront of < ... > will have the same meaning as if < ... > was never there.

Contributions

Contributions are welcome. I hope you enjoy, and feel free to contact me for any advice, enhancement.

Change Log

0.0.4

• Fixed spelling error
• Just for testing (nothing in the code has changed much).

0.0.3

• Fixed execution of code in linux based systems.
• Fixed tests to run on linux system.
• Adding readme and keywords inside Package.json.