distinguish between "unignored" and "not ignored" (so results can be combined) about node-ignore HOT 10 CLOSED

async function isIgnored (workdir, pathname) {
  let pairs = [
    {
      gitignore: path.join(workdir, '.gitignore'),
      pathname
    }
  ]
  let pieces = pathname.split('/')
  for (let i = 1; i < pieces.length; i++) {
    let dir = pieces.slice(0, i).join('/')
    let file = pieces.slice(i).join('/')
    pairs.push({
      gitignore: path.join(workdir, dir, '.gitignore'),
      pathname: file
    })
  }

  let ignoredStatus = false
  for (let p of pairs) {
    let file
    try {
      file = await read(p.gitignore, 'utf8')
    } catch (err) {
      if (err.code === 'NOENT') continue
    }
    let ign = ignore().add(file)
    let unign = ignore().add(`**\n${file}`)
    // If the parent directory is excluded, we are done.
    // "It is not possible to re-include a file if a parent directory of that file is excluded. Git doesn’t list excluded directories for performance reasons, so any patterns on contained files have no effect, no matter where they are defined."
    // source: https://git-scm.com/docs/gitignore
    let parentdir = path.dirname(p.pathname)
    if (ign.ignores(parentdir)) return true
    // If the file is currently ignored, test for UNignoring.
    if (ignoredStatus) {
      ignoredStatus = unign.ignores(p.pathname)
    } else {
      ignoredStatus = ign.ignores(p.pathname)
    }
  }
  return ignoredStatus
}

    let ign = ignore().add(file)
    let unign = ignore().add(`**\n${file}`)
...
    if (ignoredStatus) {
      ignoredStatus = unign.ignores(p.pathname)
    } else {
      ignoredStatus = ign.ignores(p.pathname)
    }

/path/to/A/
          |-- .gitignore   # which contains foo.txt
          |-- foo.txt

ig.ignores('/A/foo.txt')   // WRONG !
ig.ignores('/path/to/a/foo.txt')  // WRONG!
ig.ignores('./foo.txt')  // WRONG !

ig.ignores('foo.txt')  // Right

// @flow
import ignore from 'ignore'
import * as path from 'path'
import * as R from 'ramda'

type Options = {
  // Be case-insensitive? Default is true.
  ignorecase?: boolean,
}

const joinPaths = R.apply(path.join)

function splitPath (filename: string) {
  return filename.split(path.sep).filter(s => s !== '')
}

function parsePatterns (patterns: string, opts: Options = {}) {
  const ign = ignore(opts).add(patterns)
  const unign = ignore(opts).add(`**\n${patterns}`)

  return (filename: string, defaultState: boolean = false) =>
    defaultState ? unign.ignores(filename) : ign.ignores(filename)
}

export default (patternsReader: ((dirname: string) => ?string), opts: Options = {}) => {

  const patternsMatcherFromDir = R.memoize((dirname: string) => {
    const patts = patternsReader(dirname)
    if (patts) { return parsePatterns(patts, opts) }
  })

  // (filename: string) => boolean
  return R.pipe(
    splitPath,
    // ex.: ["a", "b", "c"] -> [[".", "a"/b/c"], ["a", "b/c"], ["a/b", "c"]]
    parts => parts.map((_, idx) => {
      return R.splitAt(idx, parts).map(joinPaths)
    }),
    R.reduce((state, [dirname, filename]) => {
      const matches = patternsMatcherFromDir(dirname)
      // If there's no ignore file in dirname, go up.
      if (!matches) {
        return state
      }
      // If the parent directory is excluded, we are done.
      // It is not possible to re-include a file if a parent directory of that
      // file is excluded. - https://git-scm.com/docs/gitignore
      const parentDir = path.dirname(filename)
      if (parentDir !== '.' && matches(parentDir, false)) {
        return R.reduced(true)
      }
      return matches(filename, state)
    }, false),
  )
}