StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics
https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
765 lines
20 KiB
765 lines
20 KiB
'use strict';
|
|
|
|
var url = require('url');
|
|
var util = require('util');
|
|
var utils = require('./utils');
|
|
var gitConfigCache = {};
|
|
|
|
/**
|
|
* Expose `repoUtils`
|
|
* @type {Object}
|
|
*/
|
|
|
|
var repo = exports = module.exports;
|
|
|
|
/**
|
|
* Get the `name` for a repository from:
|
|
* - github repository path (`owner/project-name`)
|
|
* - github URL
|
|
* - absolute file path to a directory on the local file system (`.` and `''` may be used as aliases for the current working directory)
|
|
*
|
|
* ```js
|
|
* repo.name(process.cwd());
|
|
* //=> 'repo-utils'
|
|
* repo.name('.');
|
|
* //=> 'repo-utils'
|
|
* repo.name();
|
|
* //=> 'repo-utils'
|
|
*
|
|
* repo.name('https://github.com/jonschlinkert/repo-utils');
|
|
* //=> 'repo-utils'
|
|
* repo.name('jonschlinkert/repo-utils');
|
|
* //=> 'repo-utils'
|
|
* ```
|
|
*
|
|
* @param {String} `cwd` Absolute file path or github URL
|
|
* @return {String} Project name
|
|
* @api public
|
|
*/
|
|
|
|
repo.name = function(cwd) {
|
|
if (cwd === '.' || cwd === '') {
|
|
cwd = process.cwd();
|
|
}
|
|
if (utils.isObject(cwd) || (utils.isString(cwd) && !utils.isAbsolute(cwd))) {
|
|
var repository = repo.repository.apply(repo, arguments);
|
|
return repository.split('/').pop();
|
|
}
|
|
return utils.project(cwd);
|
|
};
|
|
|
|
/**
|
|
* Create a github repository string in the form of `owner/name`, from:
|
|
* - full github repository URL
|
|
* - object returned from `url.parse`
|
|
* - list of arguments in the form of `owner, name`
|
|
*
|
|
* ```js
|
|
* repo.repository('jonschlinkert', 'micromatch');
|
|
* //=> 'jonschlinkert/micromatch'
|
|
*
|
|
* repo.repository({owner: 'jonschlinkert', repository: 'micromatch'});
|
|
* //=> 'jonschlinkert/micromatch'
|
|
*
|
|
* repo.repository('https://github.com/jonschlinkert/micromatch');
|
|
* //=> 'jonschlinkert/micromatch'
|
|
* ```
|
|
* @param {String} `owner` Repository owner
|
|
* @param {String} `name` Repository name
|
|
* @return {String} Reps
|
|
* @api public
|
|
*/
|
|
|
|
repo.repository = function(owner, name) {
|
|
if (utils.isObject(owner)) {
|
|
var obj = owner;
|
|
// support config object from parsed URL
|
|
|
|
owner = obj.owner;
|
|
name = obj.name || name;
|
|
|
|
if (!utils.isString(owner)) {
|
|
var str = obj.repository || obj.repo || obj.pathname;
|
|
if (utils.isString(str)) {
|
|
var parsed = repo.parseUrl(str);
|
|
owner = parsed.owner;
|
|
name = name || parsed.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (/\W/.test(owner)) {
|
|
var res = repo.parseUrl(owner);
|
|
if (utils.isString(res.repository)) {
|
|
owner = res.owner;
|
|
name = res.name;
|
|
}
|
|
}
|
|
|
|
if (!utils.isString(owner)) {
|
|
throw new TypeError('expected owner to be a string');
|
|
}
|
|
|
|
return owner + (name ? '/' + name : '');
|
|
};
|
|
|
|
/**
|
|
* Create a `homepage` URL from a github repository path or github
|
|
* repository URL.
|
|
*
|
|
* ```js
|
|
* repo.homepage('jonschlinkert/repo-utils');
|
|
* //=> 'https://github.com/jonchlinkert/repo-utils'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name`
|
|
* @param {Object} `options`
|
|
* @return {String} Formatted github homepage url.
|
|
* @api public
|
|
*/
|
|
|
|
repo.homepage = function(repository, options) {
|
|
options = options || {};
|
|
|
|
if (utils.isString(repository)) {
|
|
if (utils.isString(options)) {
|
|
repository += '/' + options;
|
|
options = {};
|
|
}
|
|
options.repository = repository;
|
|
}
|
|
|
|
if (utils.isObject(repository)) {
|
|
options = utils.merge({}, repository, options);
|
|
}
|
|
|
|
var opts = utils.omitEmpty(options);
|
|
opts.repository = opts.repository || opts.pathname;
|
|
|
|
if (!utils.isString(opts.repository)) {
|
|
throw new TypeError('expected a repository string in the form of "owner/repo"');
|
|
}
|
|
|
|
if (!utils.isString(opts.hostname)) {
|
|
opts.hostname = 'github.com';
|
|
}
|
|
if (!utils.isString(opts.protocol)) {
|
|
opts.protocol = 'https:';
|
|
}
|
|
|
|
if (/[:.#]/.test(opts.repository)) {
|
|
var parsed = repo.parseUrl(opts.repository, opts);
|
|
// merge opts last, but override `repository` with parsed value
|
|
opts = utils.merge({}, parsed, opts);
|
|
opts.repository = parsed.repository;
|
|
}
|
|
|
|
opts.pathname = opts.repository;
|
|
delete opts.hash;
|
|
|
|
return url.format(opts);
|
|
};
|
|
|
|
/**
|
|
* Create a GitHub `issues` URL.
|
|
*
|
|
* ```js
|
|
* repo.isses('jonschlinkert/micromatch');
|
|
* //=> 'https://github.com/jonchlinkert/micromatch/issues'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name` or full github project URL.
|
|
* @param {Object} `options`
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.issues = function(repository, options) {
|
|
return repo.homepage(repository, options) + '/issues';
|
|
};
|
|
|
|
/**
|
|
* Create a GitHub `bugs` URL. Alias for [.issues](#issues).
|
|
*
|
|
* ```js
|
|
* repo.bugs('jonschlinkert/micromatch');
|
|
* //=> 'https://github.com/jonchlinkert/micromatch/issues'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name`
|
|
* @param {Object} `options`
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.bugs = function(repository, options) {
|
|
return repo.issues(repository, options);
|
|
};
|
|
|
|
/**
|
|
* Create a github `https` URL.
|
|
*
|
|
* ```js
|
|
* repo.https('jonschlinkert/micromatch');
|
|
* //=> 'https://github.com/jonchlinkert/micromatch'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name`
|
|
* @param {Object|String} `options` Options object or optional branch
|
|
* @param {String} `branch` Optionally specify a branch
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.https = function(repository, options, branch) {
|
|
if (utils.isString(options)) {
|
|
branch = options;
|
|
options = {};
|
|
}
|
|
var homepage = repo.homepage(repository, options);
|
|
branch = !repo.isMaster(branch) ? '/blob/' + branch : '';
|
|
return homepage + branch;
|
|
};
|
|
|
|
/**
|
|
* Create a travis URL.
|
|
*
|
|
* ```js
|
|
* repo.travis('jonschlinkert/micromatch');
|
|
* //=> 'https://travis-ci.org/jonschlinkert/micromatch'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name`
|
|
* @param {Object|String} `options` Options object or optional branch
|
|
* @param {String} `branch` Optionally specify a branch
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.travis = function(repository, branch) {
|
|
branch = !repo.isMaster(branch) ? '?branch=' + branch : '';
|
|
return 'https://travis-ci.org/' + repository + branch;
|
|
};
|
|
|
|
/**
|
|
* Create a URL for a file in a github repository.
|
|
*
|
|
* ```js
|
|
* repo.file('https://github.com/jonschlinkert/micromatch', 'README.md');
|
|
* //=> 'https://raw.githubusercontent.com/jonschlinkert/micromatch/master/README.md'
|
|
*
|
|
* repo.raw('jonschlinkert/micromatch', 'README.md');
|
|
* //=> 'https://raw.githubusercontent.com/jonschlinkert/micromatch/master/README.md'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name` or full GitHub repository URL.
|
|
* @param {String} `branch` Optionally specify a branch
|
|
* @param {String} `path` Path to the file, relative to the repository root.
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.file = function(repository, branch, path) {
|
|
if (!utils.isString(path)) {
|
|
path = branch;
|
|
branch = 'master';
|
|
}
|
|
var prefix = 'https://github.com/%s/blob/%s/%s';
|
|
return util.format(prefix, repo.repository(repository), branch, path);
|
|
};
|
|
|
|
/**
|
|
* Create a github "raw" content URL.
|
|
*
|
|
* ```js
|
|
* repo.raw('https://github.com/jonschlinkert/micromatch', 'README.md');
|
|
* //=> 'https://raw.githubusercontent.com/jonschlinkert/micromatch/master/README.md'
|
|
*
|
|
* repo.raw('jonschlinkert/micromatch', 'README.md');
|
|
* //=> 'https://raw.githubusercontent.com/jonschlinkert/micromatch/master/README.md'
|
|
* ```
|
|
* @param {String} `repository` Repository in the form of `owner/project-name`
|
|
* @param {Object|String} `options` Options object or optional branch
|
|
* @param {String} `branch` Optionally specify a branch
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.raw = function(repository, branch, file) {
|
|
if (!utils.isString(file)) {
|
|
file = branch;
|
|
branch = 'master';
|
|
}
|
|
var str = 'https://raw.githubusercontent.com/%s/%s/%s';
|
|
return util.format(str, repo.repository(repository), branch, file);
|
|
};
|
|
|
|
/**
|
|
* Return true if the given string looks like a github URL.
|
|
*
|
|
* ```js
|
|
* utils.isGithubUrl('https://github.com/whatever');
|
|
* //=> true
|
|
* utils.isGithubUrl('https://foo.com/whatever');
|
|
* //=> false
|
|
* ```
|
|
* @param {String} `str` URL to test
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
repo.isGithubUrl = function(str) {
|
|
return [
|
|
'api.github.com',
|
|
'gist.github.com',
|
|
'github.com',
|
|
'github.io',
|
|
'raw.githubusercontent.com'
|
|
].indexOf(url.parse(str).host) > -1;
|
|
};
|
|
|
|
/**
|
|
* Parse a GitHub repository URL or repository `owner/project-name` into
|
|
* an object.
|
|
*
|
|
* ```js
|
|
* // see the tests for supported formats
|
|
* repo.parse('https://raw.githubusercontent.com/jonschlinkert/micromatch/master/README.md');
|
|
*
|
|
* // results in:
|
|
* { protocol: 'https:',
|
|
* slashes: true,
|
|
* hostname: 'raw.githubusercontent.com',
|
|
* host: 'raw.githubusercontent.com',
|
|
* pathname: 'https://raw.githubusercontent.com/foo/bar/master/README.md',
|
|
* path: '/foo/bar/master/README.md',
|
|
* href: 'https://raw.githubusercontent.com/foo/bar/master/README.md',
|
|
* owner: 'foo',
|
|
* name: 'bar',
|
|
* repo: 'foo/bar',
|
|
* repository: 'foo/bar',
|
|
* branch: 'master' }
|
|
* ```
|
|
* @param {String} `repositoryURL` Full repository URL, or repository path in the form of `owner/project-name`
|
|
* @param {Object} `options`
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
repo.parseUrl = function(repoUrl, options) {
|
|
if (!utils.isString(repoUrl)) {
|
|
throw new TypeError('expected repository URL to be a string');
|
|
}
|
|
|
|
var defaults = {protocol: 'https:', slashes: true, hostname: 'github.com'};
|
|
options = utils.omitEmpty(utils.extend({}, options));
|
|
|
|
// if `foo/bar` is passed, use github.com as default host
|
|
if (!/:\/\//.test(repoUrl)) {
|
|
repoUrl = (options.host || 'https://github.com/') + repoUrl;
|
|
}
|
|
|
|
var obj = utils.omitEmpty(url.parse(repoUrl));
|
|
var opts = utils.merge(defaults, options, obj);
|
|
opts.pathname = repoUrl;
|
|
|
|
var res = utils.omitEmpty(utils.parseGithubUrl(repoUrl));
|
|
return utils.merge({}, opts, res);
|
|
};
|
|
|
|
/**
|
|
* Parse a GitHub `repository` path or URL by calling `repo.parseUrl()`,
|
|
* then expands it into an object of URLs. (the object also includes
|
|
* properties returned from `.parse()`). A file path maybe be passed
|
|
* as the second argument to include `raw` and `file` properties in the
|
|
* result.
|
|
*
|
|
* ```js
|
|
* // see the tests for supported formats
|
|
* repo.expand('https://github.com/abc/xyz.git', 'README.md');
|
|
*
|
|
* // results in:
|
|
* { protocol: 'https:',
|
|
* slashes: true,
|
|
* hostname: 'github.com',
|
|
* host: 'github.com',
|
|
* pathname: 'https://github.com/abc/xyz.git',
|
|
* path: '/abc/xyz.git',
|
|
* href: 'https://github.com/abc/xyz.git',
|
|
* owner: 'abc',
|
|
* name: 'xyz',
|
|
* repo: 'abc/xyz',
|
|
* repository: 'abc/xyz',
|
|
* branch: 'master',
|
|
* host_api: 'api.github.com',
|
|
* host_raw: 'https://raw.githubusercontent.com',
|
|
* api: 'https://api.github.com/repos/abc/xyz',
|
|
* tarball: 'https://api.github.com/repos/abc/xyz/tarball/master',
|
|
* clone: 'https://github.com/abc/xyz',
|
|
* zip: 'https://github.com/abc/xyz/archive/master.zip',
|
|
* https: 'https://github.com/abc/xyz',
|
|
* travis: 'https://travis-ci.org/abc/xyz',
|
|
* file: 'https://github.com/abc/xyz/blob/master/README.md',
|
|
* raw: 'https://raw.githubusercontent.com/abc/xyz/master/README.md' }
|
|
* ```
|
|
* @param {String} `repository`
|
|
* @param {String} `file` Optionally pass a repository file path.
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.expandUrl = function(repository, file) {
|
|
var config = repo.parseUrl(repository);
|
|
|
|
repository = config.repository;
|
|
var github = 'https://github.com';
|
|
var branch = config.branch;
|
|
|
|
var raw = 'https://raw.githubusercontent.com';
|
|
var api = config.host !== 'github.com'
|
|
? config.host + '/api/v3'
|
|
: 'api.github.com';
|
|
|
|
var urls = config;
|
|
urls.host_api = api;
|
|
urls.host_raw = raw;
|
|
urls.api = 'https://' + api + '/repos/' + repository;
|
|
urls.tarball = urls.api + '/tarball/' + branch;
|
|
urls.clone = github + '/' + repository;
|
|
urls.zip = urls.clone + '/archive/' + branch + '.zip';
|
|
|
|
urls.https = repo.https(config, branch);
|
|
urls.travis = repo.travis(repository, branch);
|
|
|
|
if (utils.isString(file)) {
|
|
urls.file = repo.file(repository, branch, file);
|
|
urls.raw = repo.raw(repository, branch, file);
|
|
}
|
|
urls.name = urls.name && urls.name.split('%20').join(' ');
|
|
return urls;
|
|
};
|
|
|
|
/**
|
|
* Get the local git config path, or global if a local `.git` repository does not exist.
|
|
*
|
|
* ```js
|
|
* console.log(repo.gitConfigPath());
|
|
* //=> /Users/jonschlinkert/dev/repo-utils/.git/config
|
|
*
|
|
* // if local .git repo does not exist
|
|
* console.log(repo.gitConfigPath());
|
|
* /Users/jonschlinkert/.gitconfig
|
|
*
|
|
* // get global path
|
|
* console.log(repo.gitConfigPath('global'));
|
|
* /Users/jonschlinkert/.gitconfig
|
|
* ```
|
|
* @param {String} `type` Pass `global` to get the global git config path regardless of whether or not a local repository exists.
|
|
* @return {String} Returns the local or global git path
|
|
* @api public
|
|
*/
|
|
|
|
repo.gitConfigPath = function(type) {
|
|
return utils.gitConfigPath(type);
|
|
};
|
|
|
|
/**
|
|
* Get and parse global git config.
|
|
*
|
|
* ```js
|
|
* console.log(repo.gitConfig());
|
|
* ```
|
|
* @param {Object} `options` To get a local `.git` config, pass `{type: 'local'}`
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.gitConfig = function(options) {
|
|
var cwd = process.cwd();
|
|
if (gitConfigCache[cwd]) {
|
|
return gitConfigCache[cwd];
|
|
}
|
|
|
|
options = options || {};
|
|
if (typeof options.type === 'undefined') {
|
|
options.type = 'global';
|
|
}
|
|
|
|
var configPath = repo.gitConfigPath(options.type);
|
|
if (utils.isString(configPath)) {
|
|
var git = utils.parseGitConfig.sync({path: configPath});
|
|
if (git && git.user) {
|
|
utils.merge(git, utils.parseGitConfig.keys(git));
|
|
}
|
|
|
|
gitConfigCache[cwd] = git;
|
|
return git;
|
|
}
|
|
};
|
|
|
|
repo.gitUser = function(options) {
|
|
return utils.get(repo.gitConfig(options), 'user');
|
|
};
|
|
|
|
repo.gitUserName = function(options) {
|
|
return utils.get(repo.gitUser(options), 'name');
|
|
};
|
|
repo.gitUserEmail = function(options) {
|
|
return utils.get(repo.gitUser(options), 'email');
|
|
};
|
|
|
|
/**
|
|
* Get an owner string from the given object or string.
|
|
*
|
|
* ```js
|
|
* console.log(repo.owner(require('./package.json')));
|
|
* //=> 'jonschlinkert'
|
|
* ```
|
|
* @param {String|Object} `config` If an object is passed, it must have a `repository`, `url` or `author` propert (looked for in that order), otherwise if a string is passed it must be parse-able by the [parseUrl]() method.
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
repo.owner = function(config) {
|
|
var owner;
|
|
if (utils.isString(config)) {
|
|
config = repo.parseUrl(config);
|
|
}
|
|
if (utils.isObject(config)) {
|
|
owner = utils.get(config, 'owner');
|
|
if (typeof owner === 'undefined' && config.repository) {
|
|
var repository = config.repository;
|
|
if (utils.isObject(repository)) {
|
|
repository = repository.url;
|
|
}
|
|
config = repo.parseUrl(repository);
|
|
owner = utils.get(config, 'owner');
|
|
}
|
|
|
|
if (typeof owner === 'undefined' && config.url) {
|
|
config = repo.parseUrl(config.url);
|
|
owner = utils.get(config, 'owner');
|
|
}
|
|
|
|
if (typeof owner === 'undefined' && config.author) {
|
|
var author = repo.parseAuthor(config.author);
|
|
config = repo.parseUrl(author.url);
|
|
owner = utils.get(config, 'owner');
|
|
}
|
|
}
|
|
return owner;
|
|
};
|
|
|
|
/**
|
|
* Normalize a "person" object. If a "person" string is passed (like `author`, `contributor` etc)
|
|
* it is parsed into an object, otherwise the object is returned.
|
|
*
|
|
* ```js
|
|
* console.log(repo.person('Brian Woodward (https://github.com/doowb)'));
|
|
* //=> { name: 'Brian Woodward', url: 'https://github.com/doowb' }
|
|
* console.log(repo.person({ name: 'Brian Woodward', url: 'https://github.com/doowb' }));
|
|
* //=> { name: 'Brian Woodward', url: 'https://github.com/doowb' }
|
|
* ```
|
|
* @param {String|Object} `val`
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.person = function(val) {
|
|
var person = val;
|
|
if (utils.isString(val)) {
|
|
person = utils.parseAuthor(val);
|
|
}
|
|
if (utils.isObject(person)) {
|
|
person = utils.omitEmpty(person);
|
|
}
|
|
return person;
|
|
};
|
|
|
|
/**
|
|
* Returns an `author` object from the given given config object. If `config.author` is
|
|
* a string it will be parsed into an object.
|
|
*
|
|
* ```js
|
|
* console.log(repo.author({
|
|
* author: 'Brian Woodward (https://github.com/doowb)'
|
|
* }));
|
|
* //=> { name: 'Brian Woodward', url: 'https://github.com/doowb' }
|
|
*
|
|
* console.log(repo.author({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb'
|
|
* }));
|
|
* //=> { name: 'Brian Woodward', url: 'https://github.com/doowb' }
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.author = function(config) {
|
|
if (!utils.isObject(config)) {
|
|
throw new TypeError('expected an object');
|
|
}
|
|
return repo.person(config.author);
|
|
};
|
|
|
|
/**
|
|
* Returns the `author.name` from the given config object. If `config.author` is
|
|
* a string it will be parsed into an object first.
|
|
*
|
|
* ```js
|
|
* console.log(repo.authorName({
|
|
* author: 'Brian Woodward (https://github.com/doowb)'
|
|
* }));
|
|
* //=> 'Brian Woodward'
|
|
*
|
|
* console.log(repo.authorName({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb'
|
|
* }));
|
|
* //=> 'Brian Woodward'
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.authorName = function(config, options) {
|
|
return utils.get(repo.author(config, options), 'name');
|
|
};
|
|
|
|
/**
|
|
* Returns the `author.url` from the given config object. If `config.author` is
|
|
* a string it will be parsed into an object first.
|
|
*
|
|
* ```js
|
|
* console.log(repo.authorUrl({
|
|
* author: 'Brian Woodward (https://github.com/doowb)'
|
|
* }));
|
|
* //=> 'https://github.com/doowb'
|
|
*
|
|
* console.log(repo.authorUrl({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb'
|
|
* }));
|
|
* //=> 'https://github.com/doowb'
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.authorUrl = function(config, options) {
|
|
return utils.get(repo.author(config, options), 'url');
|
|
};
|
|
|
|
/**
|
|
* Returns the `author.email` from the given config object. If `config.author` is
|
|
* a string it will be parsed into an object first.
|
|
*
|
|
* ```js
|
|
* console.log(repo.authorEmail({
|
|
* author: 'Brian Woodward <brian.woodward@sellside.com> (https://github.com/doowb)'
|
|
* }));
|
|
* //=> 'brian.woodward@sellside.com'
|
|
*
|
|
* console.log(repo.authorEmail({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb',
|
|
* email: 'brian.woodward@sellside.com'
|
|
* }));
|
|
* //=> 'brian.woodward@sellside.com'
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.authorEmail = function(config, options) {
|
|
return utils.get(repo.author(config, options), 'email');
|
|
};
|
|
|
|
/**
|
|
* Returns the `author.username` from the given config object. If `config.author` is
|
|
* a string it will be parsed into an object first.
|
|
*
|
|
* ```js
|
|
* console.log(repo.authorUsername({
|
|
* author: 'Brian Woodward <brian.woodward@sellside.com> (https://github.com/doowb)'
|
|
* }));
|
|
* //=> 'doowb'
|
|
*
|
|
* console.log(repo.authorUsername({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb',
|
|
* email: 'brian.woodward@sellside.com'
|
|
* }));
|
|
* //=> 'doowb'
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.authorUsername = function(config, options) {
|
|
return utils.get(repo.author(config, options), 'username');
|
|
};
|
|
|
|
/**
|
|
* Returns a `username` from the given config object, by first attempting to get
|
|
* `author.username`, then
|
|
*
|
|
* ```js
|
|
* console.log(repo.username({
|
|
* author: 'Brian Woodward <brian.woodward@sellside.com> (https://github.com/doowb)'
|
|
* }));
|
|
* //=> 'doowb'
|
|
*
|
|
* console.log(repo.username({
|
|
* name: 'Brian Woodward',
|
|
* url: 'https://github.com/doowb',
|
|
* email: 'brian.woodward@sellside.com'
|
|
* }));
|
|
* //=> 'doowb'
|
|
* ```
|
|
* @param {Object} `config` Object with an `author` property
|
|
* @return {Object}
|
|
* @api public
|
|
*/
|
|
|
|
repo.username = function(config, options) {
|
|
if (!utils.isObject(config)) {
|
|
throw new TypeError('expected an object');
|
|
}
|
|
|
|
var username = repo.authorUsername(config);
|
|
if (!utils.isString(username)) {
|
|
var authorUrl = repo.authorUrl(config, options);
|
|
if (/github\.com/.test(authorUrl)) {
|
|
username = utils.get(utils.parseGithubUrl(authorUrl), 'owner');
|
|
}
|
|
}
|
|
|
|
if (!utils.isString(username)) {
|
|
username = repo.gitUserName(options);
|
|
}
|
|
|
|
if (!utils.isString(username)) {
|
|
var str = config.repository || config.homepage;
|
|
username = utils.get(utils.parseGithubUrl(str), 'owner');
|
|
}
|
|
return username;
|
|
};
|
|
|
|
/**
|
|
* Returns true if the given value is `master` or `undefined`. Used in other
|
|
* methods.
|
|
*
|
|
* @param {String} `branch`
|
|
* @return {Boolean}
|
|
*/
|
|
|
|
repo.isMaster = function(branch) {
|
|
return typeof branch === 'undefined' || branch === 'master';
|
|
};
|
|
|
|
/**
|
|
* Expose `parseAuthor`
|
|
*/
|
|
|
|
repo.parseAuthor = utils.parseAuthor;
|
|
|