git-tools.js

var spawn = require('spawnback')

function extend (a, b) {
  for (var prop in b) {
    a[prop] = b[prop]
  }

  return a
}

function copy (obj) {
  return extend({}, obj)
}

function Repo (path) {
  this.path = path
}

Repo.parsePerson = (function () {
  var rPerson = /^(\S+)\s(.+)$/

  return function (person) {
    var matches = rPerson.exec(person)
    return {
      email: matches[1],
      name: matches[2]
    }
  }
})()

Repo.clone = function (options, callback) {
  var dir = options.dir
  var args = ['clone', options.repo, dir]
  options = copy(options)
  delete options.repo
  delete options.dir

  Object.keys(options).forEach(function (option) {
    args.push('--' + option)

    var value = options[option]
    if (value !== true) {
      args.push(value)
    }
  })

  args.push(function (error) {
    if (error) {
      return callback(error)
    }

    callback(null, new Repo(dir))
  })

  var repo = new Repo(process.cwd())
  repo.exec.apply(repo, args)
}

Repo.isRepo = function (path, callback) {
  var repo = new Repo(path)
  repo.isRepo(callback)
}

Repo.prototype.exec = function () {
  var args = [].slice.call(arguments)
  var callback = args.pop()
  spawn('git', args, { cwd: this.path }, function (error, stdout) {
    if (error) {
      return callback(error)
    }

    // Remove trailing newline
    stdout = stdout.replace(/\n$/, '')

    callback(null, stdout)
  })
}

Repo.prototype.activeDays = function (committish, callback) {
  if (!callback) {
    callback = committish
    committish = 'master'
  }

  this.exec('log', '--format=%at', committish, function (error, dates) {
    if (error) {
      return callback(error)
    }

    var dateMap = {
      activeDays: 0,
      commits: 0,
      dates: {},
      years: {}
    }

    dates.split('\n').sort().forEach(function (timestamp) {
      var date = new Date(timestamp * 1000)
      var year = date.getFullYear()
      var month = date.getMonth() + 1
      var day = date.getDate()

      date = year + '-' +
        (month < 10 ? '0' : '') + month + '-' +
        (day < 10 ? '0' : '') + day

      if (!dateMap.dates[date]) {
        dateMap.dates[date] = 0
      }
      dateMap.commits++
      dateMap.dates[date]++

      if (!dateMap.years[year]) {
        dateMap.years[year] = {
          activeDays: 0,
          commits: 0,
          months: {}
        }
      }
      dateMap.years[year].commits++

      if (!dateMap.years[year].months[month]) {
        dateMap.years[year].months[month] = {
          activeDays: 0,
          commits: 0,
          days: {}
        }
      }
      dateMap.years[year].months[month].commits++

      if (!dateMap.years[year].months[month].days[day]) {
        dateMap.years[year].months[month].days[day] = {
          commits: 0
        }
        dateMap.activeDays++
        dateMap.years[year].activeDays++
        dateMap.years[year].months[month].activeDays++
      }
      dateMap.years[year].months[month].days[day].commits++
    })

    callback(null, dateMap)
  })
}

Repo.prototype.age = function (callback) {
  this.exec('log', '--reverse', '--format=%cr', function (error, stdout) {
    if (error) {
      return callback(error)
    }

    callback(null, stdout.split('\n')[0].replace(/\sago/, ''))
  })
}

Repo.prototype.authors = function (committish, callback) {
  if (!callback) {
    callback = committish
    committish = 'master'
  }

  this.exec('log', '--format=%aE %aN', committish, function (error, data) {
    if (error) {
      return callback(error)
    }

    // Logs on a boundary commit will have no output
    var authors = data.length ? data.split('\n') : []
    var authorMap = {}
    var totalCommits = 0

    authors.forEach(function (author) {
      if (!authorMap[author]) {
        authorMap[author] = 0
      }

      authorMap[author]++
      totalCommits++
    })

    authors = Object.keys(authorMap).map(function (author) {
      var commits = authorMap[author]
      return extend(Repo.parsePerson(author), {
        commits: commits,
        commitsPercent: (commits * 100 / totalCommits).toFixed(1)
      })
    }).sort(function (a, b) {
      return b.commits - a.commits
    })

    callback(null, authors)
  })
}

Repo.prototype.blame = function (options, callback) {
  var args = ['blame', '-s']

  if (options.committish) {
    args.push(options.committish)
  }

  args.push('--', options.path)

  var rBlame = /^(\^?\w+)(\s(\S+))?\s+(\d+)\)\s(.*)$/

  args.push(function (error, blame) {
    if (error) {
      return callback(error)
    }

    var lines = blame.split(/\r?\n/)
    lines = lines.map(function (line) {
      var matches = rBlame.exec(line)
      var commit = matches[1]
      var boundary = /^\^/.test(commit)

      if (boundary) {
        commit = commit.substring(1)
      }

      return {
        commit: matches[1],
        boundary: boundary,
        path: matches[3] || options.path,
        lineNumber: parseInt(matches[4], 10),
        content: matches[5]
      }
    })

    callback(null, lines)
  })

  this.exec.apply(this, args)
}

Repo.prototype.branches = function (callback) {
  this.exec('for-each-ref',
    '--format=' +
      '%(refname:short)%0a' +
      '%(authordate:rfc2822)%0a' +
      '%(authoremail) %(authorname)%0a' +
      '%(subject)%0a' +
      '%(objectname)%0a',
    'refs/heads',
  function (error, data) {
    if (error) {
      return callback(error)
    }

    var branches = data.split('\n\n').map(function (branch) {
      var lines = branch.split('\n')
      var name = lines[0]
      var date = new Date(lines[1])
      var author = Repo.parsePerson(lines[2])
      var subject = lines[3]
      var sha = lines[4]

      return {
        name: name,
        sha: sha,
        date: date,
        subject: subject,
        author: author
      }
    }).sort(function (a, b) {
      return b.date - a.date
    })

    callback(null, branches)
  })
}

Repo.prototype.config = function (name, callback) {
  this.exec('config', '--get', name, function (error, stdout) {
    if (error) {
      if (/^Command failed:\s+$/.test(error.message)) {
        return callback(null, null)
      }

      return callback(error)
    }

    callback(null, stdout.trim())
  })
}

Repo.prototype.currentBranch = function (callback) {
  this.exec('rev-parse', '--abbrev-ref', 'HEAD', function (error, data) {
    if (error) {
      return callback(error)
    }

    var branch = data === 'HEAD' ? null : data
    callback(null, branch)
  })
}

Repo.prototype.describe = function (options, callback) {
  if (!callback) {
    callback = options
    options = {}
  }

  var args = ['describe']
  if (options.committish) {
    args.push(options.committish)
    delete options.committish
  }
  Object.keys(options).forEach(function (option) {
    var arg = '--' + option.replace(/[A-Z]/g, function (c) {
      return '-' + c.toLowerCase()
    })

    if (option === 'abbrev' || option === 'cadidates') {
      arg += '=' + options[option]
      args.push(arg)
      return
    }

    args.push(arg)

    var value = options[option]
    if (value !== true) {
      args.push(value)
    }
  })
  args.push(callback)

  this.exec.apply(this, args)
}

Repo.prototype.isRepo = function (callback) {
  this.exec('rev-parse', '--git-dir', function (error) {
    if (error) {
      if (error.message.indexOf('Not a git repository')) {
        return callback(null, false)
      }

      // If the path doesn't exist, don't return an error
      if (error.code === 'ENOENT') {
        return callback(null, false)
      }

      return callback(error)
    }

    callback(null, true)
  })
}

Repo.prototype.remotes = function (callback) {
  this.exec('remote', '-v', function (error, data) {
    if (error) {
      return callback(error)
    }

    var remotes = data.split('\n')
    var rRemote = /^(\S+)\s(\S+)/
    var remoteMap = {}

    remotes.forEach(function (remote) {
      var matches = rRemote.exec(remote)

      // New repositories with no remotes will have `origin` but no URL
      if (!matches) {
        return
      }

      var name = matches[1]
      var url = matches[2]

      remoteMap[name] = url
    })

    remotes = Object.keys(remoteMap).map(function (remote) {
      return {
        name: remote,
        url: remoteMap[remote]
      }
    })

    callback(null, remotes)
  })
}

Repo.prototype.resolveCommittish = function (committish, callback) {
  this.exec('rev-parse', committish, callback)
}

Repo.prototype.tags = function (callback) {
  this.exec('for-each-ref',
    '--format=' +
      '%(refname:short)%0a' +
      '%(authordate)%(taggerdate)%0a' +
      '%(objectname)%0a',
    'refs/tags',
  function (error, data) {
    if (error) {
      return callback(error)
    }

    if (!data) {
      return callback(null, [])
    }

    var tags = data.split('\n\n').map(function (tag) {
      var lines = tag.split('\n')
      var name = lines[0]
      var date = new Date(lines[1])
      var sha = lines[2]

      return {
        name: name,
        sha: sha,
        date: date
      }
    }).sort(function (a, b) {
      return b.date - a.date
    })

    callback(null, tags)
  })
}

module.exports = Repo