ignore

What is ignore?

The ignore npm package is a utility for filtering files and directories according to the particular rules specified in .gitignore files. It can be used to create ignore patterns similar to how git handles .gitignore files, allowing developers to programmatically determine which files should be ignored based on these patterns.

What are ignore's main functionalities?

Add ignore rules

This feature allows you to add ignore rules, which can be a single string or an array of strings representing the patterns to ignore. The example demonstrates adding rules to ignore the .git directory and any files ending with .test.js.

const ignore = require('ignore');
const ig = ignore().add(['.git', '*.test.js']);
console.log(ig.ignores('example.test.js')); // true

Filter file paths

This feature provides a way to filter an array of file paths, removing any that match the ignore patterns. The code sample filters out 'example.test.js' because it matches the '*.test.js' pattern.

const ignore = require('ignore');
const ig = ignore().add('*.test.js');
const files = ['test.js', 'example.test.js', 'README.md'];
const filtered = files.filter(ig.createFilter());
console.log(filtered); // ['test.js', 'README.md']

Check if a file is ignored

This feature checks if a particular file would be ignored based on the current ignore rules. The code sample checks if 'example.test.js' is ignored (true) and if 'README.md' is ignored (false).

const ignore = require('ignore');
const ig = ignore().add('*.test.js');
console.log(ig.ignores('example.test.js')); // true
console.log(ig.ignores('README.md')); // false

Other packages similar to ignore

globby

Globby is a package that provides methods for matching files using glob patterns. It is built on top of the 'glob' package and supports multiple patterns. It is similar to ignore in that it can filter out files, but it uses glob patterns instead of .gitignore-style patterns.

minimatch

Minimatch is a minimal matching utility that implements the same wildcard rules as used by gitignore. It is similar to ignore in that it can be used to test if file paths match specified patterns, but it does not directly handle .gitignore files.

anymatch

Anymatch is a package that allows you to match strings against a list of patterns, which can be strings, regexes, or functions. It is similar to ignore in the sense that it can be used to determine if a string should be ignored or not, but it is more flexible in terms of the types of patterns it accepts.

README

ignore

ignore is a manager and filter which implemented in pure JavaScript according to the .gitignore spec.

Pay attention that minimatch does not work in the gitignore way. To filter filenames according to .gitignore file, I recommend this module.

Tested on

• Linux + Node: 0.8 - 5.x
• Windows + Node: 0.10 - 5.x, node < 0.10 is not tested due to the lack of support of appveyor.

Table Of Main Contents

• Usage
• Guide for 2.x -> 3.x
• Contributing

Usage

const ignore = require('ignore')
var ig = ignore().add(['.abc/*', '!.abc/d/'])

Filter the given paths

var paths = [
  '.abc/a.js',    // filtered out
  '.abc/d/e.js'   // included
]

ig.filter(paths)  // ['.abc/d/e.js']

As the filter function

paths.filter(ig.createFilter()); // ['.abc/d/e.js']

Win32 paths will be handled

ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
// if the code above runs on windows, the result will be
// ['.abc\\d\\e.js']

Why another ignore?

1. ignore is a standalone module, and is much simpler so that it could easy work with other programs, unlike isaacs's fstream-ignore which must work with the modules of the fstream family.

2. ignore only contains utility methods to filter paths according to the specified ignore rules, so

• ignore never try to find out ignore rules by traversing directories or fetching from git configurations.
• ignore don't cares about sub-modules of git projects.

1. Exactly according to gitignore man page, fixes some known matching issues of fstream-ignore, such as:

• '/*.js' should only match 'a.js', but not 'abc/a.js'.
• '**/foo' should match 'foo' anywhere.
• prevent re-including a file if a parent directory of that file is excluded.
• handle trailing whitespaces:
  • 'a '(one space) should not match 'a '(two spaces).
  • 'a \ ' matches 'a '

Methods

.add(pattern)

.add(patterns)

• pattern String|Ignore An ignore pattern string, or the Ignore instance
• patterns Array.<pattern> Array of ignore patterns.

Adds a rule or several rules to the current manager.

Returns this

Notice that a line starting with '#'(hash) is treated as a comment. Put a backslash ('\') in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.

ignore().add('#abc').filter(['#abc'])   // ['#abc']
ignore().add('\#abc').filter(['#abc'])  // []

pattern could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just ignore().add() the content of a ignore file:

ignore().add(fs.readFileSync(filenameOfGitignore).toString()).filter(filenames)

pattern could also be an ignore instance, so that we could easily inherit the rules of another Ignore instance.

.addIgnoreFile(path)

REMOVED in 3.x for now.

To upgrade ignore@2.x up to 3.x, use

const fs = require('fs')

if (fs.existsSync(filename)) {
  ignore().add(fs.readFileSync(filename).toString())
}

instead.

.filter(paths)

Filters the given array of pathnames, and returns the filtered array.

• paths Array.<path> The array of paths to be filtered.

NOTICE that each path here should be a relative path to the root of your repository. Suppose the dir structure is:

/path/to/your/repo
    |-- a
    |   |-- a.js
    |
    |-- .b
    |
    |-- .c
         |-- .DS_store

Then the paths might be like this:

[
  'a/a.js'
  '.b',
  '.c/.DS_store'
]

Usually, you could use glob with option.mark = true to fetch the structure of the current directory:

const glob = require('glob')

glob('**', {
  // Adds a / character to directory matches.
  mark: true
}, (err, files) => {
  if (err) {
    return console.error(err)
  }

  var filtered = ignore().add(patterns).filter(files)
  console.log(filtered)
})

.createFilter()

Creates a filter function which could filter an array of paths with Array.prototype.filter.

Returns function(path) the filter function.

---

Upgrade 2.x -> 3.x

• All options of 2.x are unnecessary and removed, so just remove them.
• ignore() instance is no longer an EventEmitter, and all events are unnecessary and removed.
• .addIgnoreFile() is removed, see the .addIgnoreFile section for details.

---

Contributing

The code of node-ignore is based on es6 and babel, but babel and its preset is not included in the dependencies field of package.json, so that the installation process of test cases will not fail in older versions of node.

So use bash install.sh to install dependencies and bash test.sh to run test cases in your local machine.

Collaborators

• SamyPesse Samy Pessé
• azproduction Mikhail Davydov
• TrySound Bogdan Chadkin
• JanMattner Jan Mattner