@beezydev/create-files-from-template-cli

v1.7.3

Published

7 days ago

A simple but powerful CLI to generate a list of files from template.

Downloads

1,125

0High
0Medium
0Low

beezydev

CLI generate create files template templates scaffolding bootstrap boilerplate skeleton replace search

CFFT - Create Files From Template CLI

CFFT CLI is a simple but powerful CLI to generate a list of files from templates.

Stop copying/pasting and renaming files and folders or creating these manually, repeating the same file structures every time. CFFT CLI generates custom file structure easily and quickly.

You can use this CLI for any language or framework (JavaScript, Node, React, Angular, .NET, Java, Python, ...)

Features

Create a custom file structure using a terminal
Search and replace - Replace file content with a custom text or file name (text, regex, inject files, ...)
Create multiple templates
Set options directly as a CLI argument, or answering on CLI questions, or:
Set defaults by configuring a CLI using a .config JSON file for each template - cfft.config.json

Releases

See Releases to see what is changed in the latest version.

Related repositories

Create Files From Template VS Code Extension - Visual Studio Extension - Use the context menu command to create a list of files from templates.
Create Files From Template Base - Includes core utilities required for CFFT apps to work.

Getting started (Tutorial)

Install the package globally:

npm install -g @beezydev/create-files-from-template-cli

The next step is to create a configuration file - cfft.config.json. It can be done automatically (recommended), or you can do it manually. Navigate your terminal to the root folder of your application.
Execute the cfft command to create a configuration file:

cfft

You should see the message that cfft.config.json is created with a default values prefilled:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "FileName",
            "replace": "{fileName}"
          }
        ]
      }
    }
  ]
}

You can edit these values however you want. See the Options section where it is explained which options exist.

Note: From version 1.5.10 onwards this command also creates the .cfft.templates directory and the component files for demo purposes. Feel free to edit or remove these files.

The next step is to create your templates (you can create one or more templates). Let's use a default templatePath. In your root folder, create the following structure:

├── .cfft.templates
│   ├── component
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts

Note: You can also create inner folders. For example:

├── .cfft.templates
│   ├── component
│   │   ├── component-inner
│   │   │   ├── component-inner.styles.tsx
│   │   │   ├── component-inner.tsx
│   │   │   ├── index.ts
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts

Note: If you use GIT, you can ignore cfft.config.json and your templates if you wish to.

Insert some content into your newly created files component.tsx, component.styles.ts and index.ts:

component.styles.ts

export const style = {
  backgroundColor: "black",
  color: "white",
};

component.tsx

import React, { FC } from "react";
import { style } from "./FileName.styles";

const FileName: FC = () => {
  return (
    <div style={style}>
      <p>TODO: FileName</p>
    </div>
  );
};

export default FileName;

index.ts

export { default } from "./FileName";

Doing so, the CFFT CLI is ready for use. Let's test it.

Create a src folder manually:

├── src

Navigate your terminal to the src folder:

cd src

Execute the cfft command:

cfft

Enter a file name. For example MyFile.
CFFT CLI created new files. The src folder has the following structure:

├── src
│   ├── MyFile
│   │   ├── MyFile.tsx
│   │   ├── MyFile.styles.ts
│   │   ├── index.ts

Additionally, the CLI replaced the FileName text with the entered file name:

MyFile.styles.ts (unchanged)

export const style = {
  backgroundColor: "black",
  color: "white",
};

MyFile.tsx

import React, { FC } from "react";
import { style } from "./MyFile.styles";

const MyFile: FC = () => {
  return (
    <div style={style}>
      <p>TODO: MyFile</p>
    </div>
  );
};

export default MyFile;

index.ts

export { default } from "./MyFile";

Filling the missing configuration options

CFFT CLI is interactive. You can remove all default options from your template, and CLI will ask you for missing information every time you run it.

Example

If you were following the previous example, remove the MyFile folder.

Remove all options from your cfft.config.json file:

{}

Execute the cfft command:

cfft

Answer questions:

? Enter template name: component
? Enter file name: MyFile
? Enter dir path: ./MyFile
? Enter template path: /.cfft.templates/component
? Should replace file name text? Yes
? Enter file name text to be replaced: component
? Should replace text? Yes
? Enter text to be replaced: FileName
? Replace text with: MyFile

The CLI will create files using the provided options.

Filling the missing configuration options using the CLI arguments

CFFT CLI allows you to specify almost all options using the terminal arguments.

Example

If you were following one of the previous examples, remove the MyFile folder.

Update your cfft.config.json file:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "shouldReplaceFileContent": true,
        "shouldReplaceFileName": true
      }
    }
  ]
}

Execute the cfft command and add arguments:

cfft --fileName MyFile --textToBeReplaced FileName --replaceTextWith Test

The CLI will create files without asking additional questions - since it has all necessary information.

Search and replace - replace multiple placeholders

CFFT CLI allows you to search and replace multiple placeholders. This is possible by adding the additional items in the searchAndReplace array.

Example

If you were following one of the previous examples, remove the MyFile folder.

Update the searchAndReplace in the cfft.config.json:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "FileName",
            "replace": "{fileName}"
          },
          {
            "search": "FC",
            "replace": "FunctionComponent"
          }
        ]
      }
    }
  ]
}

An alternative is to enter the list of placeholders and replacement values separated by the searchAndReplaceSeparator character to both textToBeReplaced and replaceTextWith:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplaceSeparator": ";",
        "textToBeReplaced": "FileName;FC",
        "replaceTextWith": "{fileName};FunctionComponent"
      }
    }
  ]
}

Note: It is important that textToBeReplaced and replaceTextWith have the same number of segments.

Execute the cfft command:

cfft --fileName MyFile

The CLI will create files and replace both, FileName with MyFile and FC with FunctionComponent.

import React, { FunctionComponent } from "react";
import { style } from "./MyFile.styles";

const MyFile: FunctionComponent = () => {
  return (
    <div style={style}>
      <p>TODO: MyFile</p>
    </div>
  );
};

export default MyFile;

Add additional templates

While you can use only one template, it is also possible to create and use multiple templates. To achieve this, you need to create the template folder and files, to update the cfft.config.json and to use the --template CLI argument.

Note: If the defaultTemplateName is not specified in the configuration, the CLI will ask for the template name.

Example

If you were following one of the previous examples, remove the MyFile folder.

Add a new template folder next to the existing one - css, and add a file inside it main.scss (in the .cfft.templates folder):

├── .cfft.templates
│   ├── component
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts
│   ├── css
│   │   ├── main.scss

Fill the file content:

main.scss

#root {
  box-sizing: border-box;
}

Update the cfft.config.json file:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "FileName",
            "replace": "{fileName}"
          },
          {
            "search": "FC",
            "replace": "FunctionComponent"
          }
        ]
      }
    },
    {
      "name": "css",
      "options": {
        "templatePath": "/.cfft.templates/css",
        "dirPath": "./{fileName}",
        "shouldReplaceFileContent": false,
        "shouldReplaceFileName": false
      }
    }
  ]
}

Execute the cfft command:

cfft --template css --fileName my-styles

The CFFT CLI will generate the following folder and file in your src folder:

├── src
│   ├── my-styles
│   │   ├── main.scss

The main.scss, will be exactly the same, since we were not replacing the file content.

Injecting a file content

Besides replacing the placeholders with text, it is possible to do the replacement with the file content. To inject the file content, set the injectFile to true.

Example

If you were following one of the previous examples, remove the MyFile folder.

Add the table.html file to .cfft.templates directory:

├── .cfft.templates
│   ├── component
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts
│   ├──table.html

table.html

<table>
  <thead>
    <tr>
      <th>Head 1</th>
      <th>Head 2</th>
      <th>Head 3</th>
      <th>Head 4</th>
      <th>Head 5</th>
    </tr>
  </thead>
  <tr>
    <td>Cell 1.1</td>
    <td>Cell 1.2</td>
    <td>Cell 1.3</td>
    <td>Cell 1.4</td>
    <td>Cell 1.5</td>
  </tr>
  <tr>
    <td>Cell 2.1</td>
    <td>Cell 2.2</td>
    <td>Cell 2.3</td>
    <td>Cell 2.4</td>
    <td>Cell 2.5</td>
  </tr>
</table>

Update the template file:

component.tsx

import { FC } from "react";
import { style } from "./FileName.styles";

const FileName: FC = () => {
  return (
    <div style={style}>
      <p>TODO: FileName</p>

      {table}
    </div>
  );
};

export default FileName;

Update the cfft.config.json:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "{table}",
            "replace": "/.cfft.templates/table.html",
            "injectFile": true
          }
        ]
      }
    }
  ]
}

Execute the cfft command:

cfft --fileName MyFile

The CLI will create files and inject the table in the MyFile.tsx file:

import { FC } from "react";
import { style } from "./FileName.styles";

const FileName: FC = () => {
  return (
    <div style={style}>
      <p>TODO: FileName</p>

      <table>
        <thead>
          <tr>
            <th>Head 1</th>
            <th>Head 2</th>
            <th>Head 3</th>
            <th>Head 4</th>
            <th>Head 5</th>
          </tr>
        </thead>
        <tr>
          <td>Cell 1.1</td>
          <td>Cell 1.2</td>
          <td>Cell 1.3</td>
          <td>Cell 1.4</td>
          <td>Cell 1.5</td>
        </tr>
        <tr>
          <td>Cell 2.1</td>
          <td>Cell 2.2</td>
          <td>Cell 2.3</td>
          <td>Cell 2.4</td>
          <td>Cell 2.5</td>
        </tr>
      </table>
    </div>
  );
};

export default FileName;

The order of the search and replace execution

In some cases, the replacement order may matter. For example, you may want to inject file content and after that to replace parts of it.

Default orders

Example

If you were following one of the previous examples, remove the MyFile folder.

Update the cfft.config.json file:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "{table}",
            "replace": "/.cfft.templates/table.html",
            "injectFile": true,
            "order": -2
          },
          { "search": "Cell 1.5", "replace": "HELLO!", "order": -1 }
        ]
      }
    }
  ]
}

Execute the cfft command:

cfft --fileName MyFile

The CLI will create files and inject the table in the MyFile.tsx file:

import { FC } from "react";
import { style } from "./FileName.styles";

const FileName: FC = () => {
  return (
    <div style={style}>
      <p>TODO: FileName</p>

      <table>
        <thead>
          <tr>
            <th>Head 1</th>
            <th>Head 2</th>
            <th>Head 3</th>
            <th>Head 4</th>
            <th>Head 5</th>
          </tr>
        </thead>
        <tr>
          <td>Cell 1.1</td>
          <td>Cell 1.2</td>
          <td>Cell 1.3</td>
          <td>Cell 1.4</td>
          <td>HELLO!</td>
        </tr>
        <tr>
          <td>Cell 2.1</td>
          <td>Cell 2.2</td>
          <td>Cell 2.3</td>
          <td>Cell 2.4</td>
          <td>Cell 2.5</td>
        </tr>
      </table>
    </div>
  );
};

export default FileName;

Ignoring the case of the letters on text searching

By default, searching by text is case-sensitive. You can change this behavior by using the ignoreCase option. For example:

"searchAndReplace": [
  { "search": "FileName", "replace": "{fileName}", "ignoreCase": true }
]

Using the special replacement placeholders

The special replacement placeholders (for example: {env:ENV_VARIABLE_NAME} or {dateTimeNow:DNS_FORMAT}) are replaced as the last replacement task. See the Special replacement placeholders table for more info. This allows you to add specific or dynamic values during the file creation.

Example

If you were following one of the previous examples, remove the MyFile folder.

Add environment variables or use the existing ones. In this example, we are going to use TEST_ENV=myEnv and ANOTHER_ENV=anotherEnv.
Update your template by adding the following tags:

component.tsx

import { FC } from "react";
import { style } from "./FileName.styles";

const FileName: FC = () => {
  return (
    <div style={style}>
      <p>My env variable: {env:TEST_ENV} and {env:ANOTHER_ENV}</p>
      <p>{dateTimeNow:yyyy-MM-dd}</p>
    </div>
  );
};

export default FileName;

Execute the cfft command:

cfft --fileName MyFile

The CLI will create files and replace the special tags with the values in the MyFile.tsx file:

import { FC } from "react";
import { style } from "./MyFile.styles";

const MyFile: FC = () => {
  return (
    <div style={style}>
      <p>My env variable: myEnv and anotherEnv</p>
      <p>2023-05-06</p>
    </div>
  );
};

export default MyFile;

Custom hooks

onFileCreated

CFFT allows you to specify the custom logic to be executed after each file creation. To achieve so, you should create a custom .js file and implement and export the onFileCreated() function. This can be used for various tasks, but one logical and useful task is to use the prettier.

Example

If you were following one of the previous examples, remove the MyFile folder.

Note: If you want to implement the same behavior make sure to install and configure the prettier for your project.

Update your package.json by adding the node script:

package.json

"scripts": {
  "prettier:only": "prettier",
}

Update the cfft.config.json file:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "hooksPath": "/.cfft.templates/hooks/component.js",
        "searchAndReplace": [
          {
            "search": "{table}",
            "replace": "/.cfft.templates/table.html",
            "injectFile": true,
            "order": -2
          },
          { "search": "Cell 1.5", "replace": "HELLO!", "order": -1 }
        ]
      }
    }
  ]
}

Add the component.js file:

├── .cfft.templates
│   ├── component
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts
│   ├── hooks
│   │   ├── component.js
│   ├──table.html

component.js

const { execSync } = require("child_process");

const onFileCreated = ({ filePath, templatePath }) => {
  // Run prettier on a created file
  execSync(`npm run prettier:only -- ${filePath} --write`);
};

module.exports = {
  onFileCreated,
};

Note: In this example, we are executing the prettier, but you can specify whatever logic you want.

Execute the cfft command:

cfft --fileName MyFile

The CLI will create files and execute the onFileCreated() hook for each created file!

Creating a single file

It is also useful to create a single file. To achieve that, the templatePath must point to a file. To create a file in the current folder, update the dirPath to ..

Example

Add a component.styles.tsx file to you templates folder:

├── .cfft.templates
│   ├── component
│   │   ├── component.tsx
│   │   ├── component.styles.ts
│   │   ├── index.ts
│   ├── hooks
│   │   ├── component.js
│   ├──table.html
│   ├──component.styles.tsx

component.styles.tsx

import { styled } from "@mui/material";

const COMPONENT_NAME = "FileName";

export const FileNameRoot = styled("div", {
  name: COMPONENT_NAME,
  slot: "Root",
})(({ theme }) => ({}));

Add a new template to the cfft.config.json file:

{
  "defaultTemplateName": "component-styles-file",
  "templates": [
    {
      "name": "component-styles-file",
      "options": {
        "templatePath": "/.cfft.templates/component.styles.tsx",
        "dirPath": ".",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [{ "search": "FileName", "replace": "{fileName}" }]
      }
    }
  ]
}

Execute the cfft command:

cfft -t component-styles-file -n MyComponent

The CLI will create the MyComponent.styles.tsx file and replace the FileName with the provided name (MyComponent) file:

MyComponent.styles.tsx

import { styled } from "@mui/material";

const COMPONENT_NAME = "MyComponent";

export const MyComponentRoot = styled("div", {
  name: COMPONENT_NAME,
  slot: "Root",
})(({ theme }) => ({}));

Convert placeholder cases

CFFT allows you to convert the string from your template to a different case. This is especially powerful if you want to convert the "file name" placeholder.

The available convertors

Camel case - param-case -> paramCase
Snake case - camelCase -> camel_case
Pascal case - param-case -> ParamCase
Dot case - Title Case -> title.case
Path case - camelCase -> camel/case
Text case - camelCase -> camel case
Sentence case - camelCase -> Camel case
Header case - param-case -> Param Case
Lower case - Title Case -> title case
Upper case - param-case -> PARAM-CASE
Kebab case - Title Case -> title-case
Lower snake case ParamCase -> param-case
Upper snake case ParamCase -> PARAM-CASE

Usage

To apply the case converter to any string from you template, just wrap it with #(, ).

The option can be applied in a several ways. Options are case insensitive, and characters such as , _, -, ., /, \ are ignored. For example, if you want to provide the Pascal case, you can provide it in one of the following ways:

#(TextToBeConverted, PascalCase),
#(TextToBeConverted, Pascal case),
#(TextToBeConverted, pascalcase),
#(TextToBeConverted, PASCAL_CASE),
#(TextToBeConverted, PASCAL-CASE),
...

Example

Add the constants.ts file to your template folder (.cfft.templates):

├── .cfft.templates
│   ├── constants.ts

File the file content:

constants.ts

import { routes } from 'constants/routes';

// Routes 1 to 15 demonstrate available converters
const route1 = routes.#(param-case, CAMEL_CASE).route;
const route2 = routes.#(param-case, SNAKE_CASE).route;
const route3 = routes.#(param-case, PASCAL_CASE).route;
const route4 = routes.#(param-case, DOT_CASE).route;
const route5 = routes.#(param-case, PATH_CASE).route;
const route6 = routes.#(param-case, TEXT_CASE).route;
const route7 = routes.#(param-case, SENTENCE_CASE).route;
const route8 = routes.#(param-case, HEADER_CASE).route;
const route9 = routes.#(paRam-case, LOWER_CASE).route;
const route10 = routes.#(param-case, UPPER_CASE).route;
const route11 = routes.#(param-case, KEBAB_CASE).route;
const route12 = routes.#(ParamCase, UPPER_SNAKE_CASE).route;
const route13 = routes.#(ParamCase, LOWER_SNAKE_CASE).route;
const route14 = routes.#(FileName, LOWER_SNAKE_CASE).route;
const route15 = routes.#(FileName,UPPER_SNAKE_CASE).route;

// Routes 16 to 26 demonstrate different ways to apply the same option
const route16 = routes.#(param-case, PASCAL_CASE).route;
const route17 = routes.#(param-case, PASCALCASE).route;
const route18 = routes.#(param-case, pascalcase).route;
const route19 = routes.#(param-case, PascalCase).route;
const route20 = routes.#(param-case, pascalCase).route;
const route21 = routes.#(param-case, pascal.Case).route;
const route22 = routes.#(param-case, pascal/case).route;
const route23 = routes.#(param-case, pascal\case).route;
const route24 = routes.#(param-case, PASCAL-case).route;
const route25 = routes.#(param-case, PASCAL case).route;
const route26 = routes.#(param-case, pascal case).route;

Update your cfft.config.json by adding the following configuration to the templates array:

{
  "name": "constants",
  "description": "Creates a constants file",
  "options": {
    "templatePath": "/.cfft.templates/constants.ts",
    "dirPath": ".",
    "fileNameTextToBeReplaced": "constants",
    "shouldReplaceFileContent": true,
    "searchAndReplace": [{ "search": "FileName", "replace": "{fileName}" }]
  }
}

Execute the cfft command:

cfft --template constants --fileName MyConstants

The CLI will create the MyConstants.ts file with the following content:

import { routes } from 'constants/routes';

// Routes 1 to 15 demonstrate available converters
const route1 = routes.paramCase.route;
const route2 = routes.param_case.route;
const route3 = routes.ParamCase.route;
const route4 = routes.param.case.route;
const route5 = routes.param/case.route;
const route6 = routes.param case.route;
const route7 = routes.Param case.route;
const route8 = routes.Param Case.route;
const route9 = routes.param-case.route;
const route10 = routes.PARAM-CASE.route;
const route11 = routes.param-case.route;
const route12 = routes.PARAM_CASE.route;
const route13 = routes.param_case.route;
const route14 = routes.my_constants.route;
const route15 = routes.MY_CONSTANTS.route;

// Routes 16 to 26 demonstrate different ways to apply the same option
const route16 = routes.ParamCase.route;
const route17 = routes.ParamCase.route;
const route18 = routes.ParamCase.route;
const route19 = routes.ParamCase.route;
const route20 = routes.ParamCase.route;
const route21 = routes.ParamCase.route;
const route22 = routes.ParamCase.route;
const route23 = routes.ParamCase.route;
const route24 = routes.ParamCase.route;
const route25 = routes.ParamCase.route;
const route26 = routes.ParamCase.route;

List all templates

To list all registered template, you could use the --list or -l command.

To add description to your template and list all registered templates including descriptions, use the --listDetailed command.

Example

Update the cfft.config.json file:

{
  "defaultTemplateName": "component",
  "templates": [
    {
      "name": "component",
      "description": "Creates a component",
      "options": {
        "templatePath": "/.cfft.templates/component",
        "dirPath": "./{fileName}",
        "fileNameTextToBeReplaced": "component",
        "searchAndReplace": [
          {
            "search": "FileName",
            "replace": "{fileName}"
          },
          {
            "search": "FC",
            "replace": "FunctionComponent"
          }
        ]
      }
    },
    {
      "name": "css",
      "description": "Creates a css file",
      "options": {
        "templatePath": "/.cfft.templates/css",
        "dirPath": "./{fileName}",
        "shouldReplaceFileContent": false,
        "shouldReplaceFileName": false
      }
    }
  ]
}

Execute the --list command to list all templates:

cfft --list

The result:

component
css

Now execute the --listDetailed command to list all templates including description:

cfft --listDetailed

The result:

┌───────────┬─────────────────────┐
│ Name      │ Description         │
├───────────┼─────────────────────┤
│ component │ Creates a component │
├───────────┼─────────────────────┤
│ css       │ Creates a css file  │
└───────────┴─────────────────────┘

Options

| Description | Command | Alias | Default | CLI | cfft.config | | :----------------------------------------------------------------------------- | :---------------------------- | :-------: | :------------------------- | :-----: | :-------------: | | File name to be used | fileName | -n | | ✓ | ❌ | | Path to the location where to generate files | dirPath | | ./{fileName} | ✓ | ✓ | | Name of the template to use | template | -t | | ✓ | ❌ | | Path to the specific template folder | templatePath | | /.cfft.templates/component | ✓ | ✓ | | Default template name to be used every time when --template is not specified | defaultTemplateName | | component | ❌ | ✓ | | Should or not CLI replace a file name | shouldReplaceFileName | | true | ✓ | ✓ | | Which part of the file name should be replaced | fileNameTextToBeReplaced | | component | ✓ | ✓ | | Should or not CLI replace a file content | shouldReplaceFileContent | | true | ✓ | ✓ | | Text (or regex) to be replaced separated by a search and replace separator | textToBeReplaced | | FileName | ✓ | ✓ | | Text to be used for replacement separated by a separator | replaceTextWith | | {fileName} | ✓ | ✓ | | Custom separator for search and replace | searchAndReplaceSeparator | | ; | ✓ | ✓ | | Add additional search and replace items through config (with extended options) | searchAndReplace | | | ❌ | ✓ | | Path to the hooks file relative to cfft.config.json | hooksPath | | | ❌ | ✓ | | List all templates | list | -l | | ✓ | ❌ | | List all templates with additional info | listDetailed | | | ✓ | ❌ | | See the package version | version | -v | | ✓ | ❌ | | Get help | help | | | ✓ | ❌ |

Note: When specifying an option in a terminal, always add -- as prefix. Example:

cfft --template MyTemplate

Search and replace options

Special replacement placeholders

| Tag | Description | | :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ | | {env:ENV_VARIABLE_NAME} | Replaces the placeholder with the specified environment variable | | {dateTimeNow:DATE_FNS_FORMAT} | Replaces the placeholder with the current date and time using the date-fns format. See: date-fns format |

Placeholders

{fileName} is a special value to indicate that specific text should be replaced with a specified file name (--fileName)

License

MIT

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

CFFT - Create Files From Template CLI

Features

Releases

Related repositories

Table of contents

Getting started (Tutorial)

Filling the missing configuration options

Example

Filling the missing configuration options using the CLI arguments

Example

Search and replace - replace multiple placeholders

Example

Add additional templates

Example

Injecting a file content

Example

The order of the search and replace execution

Default orders

Example

Ignoring the case of the letters on text searching

Using the special replacement placeholders

Example

Custom hooks

onFileCreated

Example

Creating a single file

Example

Convert placeholder cases

The available convertors

Usage

Example

List all templates

Example

Options

Search and replace options

Special replacement placeholders

Placeholders

License