HORIZON PROJECT

exports.alphasort = alphasort

exports.alphasorti = alphasorti

exports.setopts = setopts

exports.ownProp = ownProp

exports.makeAbs = makeAbs

exports.finish = finish

exports.mark = mark

exports.isIgnored = isIgnored

exports.childrenIgnored = childrenIgnored

function ownProp (obj, field) {

  return Object.prototype.hasOwnProperty.call(obj, field)

}

var path = require("path")

var minimatch = require("minimatch")

var isAbsolute = require("path-is-absolute")

var Minimatch = minimatch.Minimatch

function alphasorti (a, b) {

  return a.toLowerCase().localeCompare(b.toLowerCase())

}

function alphasort (a, b) {

  return a.localeCompare(b)

}

function setupIgnores (self, options) {

  self.ignore = options.ignore || []

  if (!Array.isArray(self.ignore))

    self.ignore = [self.ignore]

  if (self.ignore.length) {

    self.ignore = self.ignore.map(ignoreMap)

  }

}

// ignore patterns are always in dot:true mode.

function ignoreMap (pattern) {

  var gmatcher = null

  if (pattern.slice(-3) === '/**') {

    var gpattern = pattern.replace(/(\/\*\*)+$/, '')

    gmatcher = new Minimatch(gpattern, { dot: true })

  }

  return {

    matcher: new Minimatch(pattern, { dot: true }),

    gmatcher: gmatcher

  }

}

function setopts (self, pattern, options) {

  if (!options)

    options = {}

  // base-matching: just use globstar for that.

  if (options.matchBase && -1 === pattern.indexOf("/")) {

    if (options.noglobstar) {

      throw new Error("base matching requires globstar")

    }

    pattern = "**/" + pattern

  }

  self.silent = !!options.silent

  self.pattern = pattern

  self.strict = options.strict !== false

  self.realpath = !!options.realpath

  self.realpathCache = options.realpathCache || Object.create(null)

  self.follow = !!options.follow

  self.dot = !!options.dot

  self.mark = !!options.mark

  self.nodir = !!options.nodir

  if (self.nodir)

    self.mark = true

  self.sync = !!options.sync

  self.nounique = !!options.nounique

  self.nonull = !!options.nonull

  self.nosort = !!options.nosort

  self.nocase = !!options.nocase

  self.stat = !!options.stat

  self.noprocess = !!options.noprocess

  self.maxLength = options.maxLength || Infinity

  self.cache = options.cache || Object.create(null)

  self.statCache = options.statCache || Object.create(null)

  self.symlinks = options.symlinks || Object.create(null)

  setupIgnores(self, options)

  self.changedCwd = false

  var cwd = process.cwd()

  if (!ownProp(options, "cwd"))

    self.cwd = cwd

  else {

    self.cwd = options.cwd

    self.changedCwd = path.resolve(options.cwd) !== cwd

  }

  self.root = options.root || path.resolve(self.cwd, "/")

  self.root = path.resolve(self.root)

  if (process.platform === "win32")

    self.root = self.root.replace(/\\/g, "/")

  self.nomount = !!options.nomount

  // disable comments and negation in Minimatch.

  // Note that they are not supported in Glob itself anyway.

  options.nonegate = true

  options.nocomment = true

  self.minimatch = new Minimatch(pattern, options)

  self.options = self.minimatch.options

}

function finish (self) {

  var nou = self.nounique

  var all = nou ? [] : Object.create(null)

  for (var i = 0, l = self.matches.length; i < l; i ++) {

    var matches = self.matches[i]

    if (!matches || Object.keys(matches).length === 0) {

      if (self.nonull) {

        // do like the shell, and spit out the literal glob

        var literal = self.minimatch.globSet[i]

        if (nou)

          all.push(literal)

        else

          all[literal] = true

      }

    } else {

      // had matches

      var m = Object.keys(matches)

      if (nou)

        all.push.apply(all, m)

      else

        m.forEach(function (m) {

          all[m] = true

        })

    }

  }

  if (!nou)

    all = Object.keys(all)

  if (!self.nosort)

    all = all.sort(self.nocase ? alphasorti : alphasort)

  // at *some* point we statted all of these

  if (self.mark) {

    for (var i = 0; i < all.length; i++) {

      all[i] = self._mark(all[i])

    }

    if (self.nodir) {

      all = all.filter(function (e) {

        return !(/\/$/.test(e))

      })

    }

  }

  if (self.ignore.length)

    all = all.filter(function(m) {

      return !isIgnored(self, m)

    })

  self.found = all

}

function mark (self, p) {

  var abs = makeAbs(self, p)

  var c = self.cache[abs]

  var m = p

  if (c) {

    var isDir = c === 'DIR' || Array.isArray(c)

    var slash = p.slice(-1) === '/'

    if (isDir && !slash)

      m += '/'

    else if (!isDir && slash)

      m = m.slice(0, -1)

    if (m !== p) {

      var mabs = makeAbs(self, m)

      self.statCache[mabs] = self.statCache[abs]

      self.cache[mabs] = self.cache[abs]

    }

  }

  return m

}

// lotta situps...

function makeAbs (self, f) {

  var abs = f

  if (f.charAt(0) === '/') {

    abs = path.join(self.root, f)

  } else if (isAbsolute(f) || f === '') {

    abs = f

  } else if (self.changedCwd) {

    abs = path.resolve(self.cwd, f)

  } else {

    abs = path.resolve(f)

  }

  return abs

}

// Return true, if pattern ends with globstar '**', for the accompanying parent directory.

// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents

function isIgnored (self, path) {

  if (!self.ignore.length)

    return false

  return self.ignore.some(function(item) {

    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))

  })

}

function childrenIgnored (self, path) {

  if (!self.ignore.length)

    return false

  return self.ignore.some(function(item) {

    return !!(item.gmatcher && item.gmatcher.match(path))

  })

}