'use strict'
|
|
var path = require('path')
|
|
var parentRequire = require('parent-require')
|
var figlet = require('figlet')
|
var chalk = require('chalk')
|
|
module.exports = new Yargonaut()
|
|
function Yargonaut () {
|
var self = this
|
var yargs = hack()
|
var fonts = {}
|
var styles = {}
|
var fontWorkaround = {}
|
var styleWorkaround = {}
|
var ocdf = null
|
var defaultFont = 'Standard'
|
|
var yargsKeys = {
|
// supporting fonts and styles
|
'Commands:': { transform: wholeString, error: false },
|
'Options:': { transform: wholeString, error: false },
|
'Examples:': { transform: wholeString, error: false },
|
'Positionals:': { transform: wholeString, error: false },
|
'Not enough non-option arguments: got %s, need at least %s': { transform: upToFirstColon, error: true },
|
'Too many non-option arguments: got %s, maximum of %s': { transform: upToFirstColon, error: true },
|
'Missing argument value: %s': { transform: upToFirstColon, error: true, plural: 'Missing argument values: %s' },
|
'Missing required argument: %s': { transform: upToFirstColon, error: true, plural: 'Missing required arguments: %s' },
|
'Unknown argument: %s': { transform: upToFirstColon, error: true, plural: 'Unknown arguments: %s' },
|
'Invalid values:': { transform: wholeString, error: true },
|
'Argument check failed: %s': { transform: upToFirstColon, error: true },
|
'Implications failed:': { transform: wholeString, error: true },
|
'Not enough arguments following: %s': { transform: upToFirstColon, error: true },
|
'Invalid JSON config file: %s': { transform: upToFirstColon, error: true },
|
'Did you mean %s?': { transform: wholeString, error: true },
|
'Arguments %s and %s are mutually exclusive': { transform: wholeString, error: true },
|
// supporting styles only (by default)
|
'boolean': { transform: null, error: null },
|
'count': { transform: null, error: null },
|
'string': { transform: null, error: null },
|
'array': { transform: null, error: null },
|
'required': { transform: null, error: null },
|
'default:': { transform: null, error: null },
|
'choices:': { transform: null, error: null },
|
'aliases:': { transform: null, error: null },
|
'generated-value': { transform: null, error: null },
|
'Argument: %s, Given: %s, Choices: %s': { transform: null, error: true }
|
}
|
|
// chainable config API methods
|
self.help = function (font) {
|
applyFont(font, self.getHelpKeys())
|
return self
|
}
|
|
self.errors = function (font) {
|
applyFont(font, self.getErrorKeys())
|
return self
|
}
|
|
self.font = function (font, key) {
|
var keys = key ? [].concat(key) : self.getAllKeys()
|
applyFont(font, keys, key !== undefined)
|
return self
|
}
|
|
self.helpStyle = function (style) {
|
applyStyle(style, self.getHelpKeys())
|
return self
|
}
|
|
self.errorsStyle = function (style) {
|
applyStyle(style, self.getErrorKeys())
|
return self
|
}
|
|
self.style = function (style, key) {
|
var keys = key ? [].concat(key) : self.getAllKeys()
|
applyStyle(style, keys)
|
return self
|
}
|
|
self.transformWholeString = function (key) {
|
var keys = key ? [].concat(key) : self.getAllKeys()
|
applyTransform(wholeString, keys)
|
return self
|
}
|
|
self.transformUpToFirstColon = function (key) {
|
var keys = key ? [].concat(key) : self.getAllKeys()
|
applyTransform(upToFirstColon, keys)
|
return self
|
}
|
|
self.ocd = function (f) {
|
if (typeof f === 'function') ocdf = f
|
return self
|
}
|
|
// getter API methods
|
self.getAllKeys = function () {
|
return Object.keys(yargsKeys)
|
}
|
|
self.getHelpKeys = function () {
|
return self.getAllKeys().filter(function (key) {
|
return yargsKeys[key].error === false
|
})
|
}
|
|
self.getErrorKeys = function () {
|
return self.getAllKeys().filter(function (key) {
|
return yargsKeys[key].error === true
|
})
|
}
|
|
// methods for playing with fonts
|
self.asFont = function (text, font, throwErr) {
|
try {
|
return figlet.textSync(text, { font: font || defaultFont })
|
} catch (err) {
|
if (throwErr) throw err
|
return text
|
}
|
}
|
|
self.listFonts = function () {
|
return figlet.fontsSync()
|
}
|
|
self.printFont = function (font, text, throwErr) {
|
font = font || defaultFont
|
console.log('Font: ' + font + '\n' + self.asFont(text || font, font, throwErr))
|
}
|
|
self.printFonts = function (text, throwErr) {
|
self.listFonts().forEach(function (f) {
|
self.printFont(f, text, throwErr)
|
})
|
}
|
|
self.figlet = function () {
|
return figlet
|
}
|
|
self.chalk = function () {
|
return chalk
|
}
|
|
// private transforms
|
function wholeString (str) {
|
return { render: str, nonRender: '' }
|
}
|
|
function upToFirstColon (str) {
|
var firstColon = str.indexOf(':') + 1
|
return { render: str.substring(0, firstColon), nonRender: '\n ' + str.substring(firstColon) }
|
}
|
|
// private config methods
|
function applyStyle (style, keys) {
|
if (typeof style !== 'string') return
|
keys.forEach(function (k) {
|
styles[k] = style
|
})
|
if (yargs && yargs.updateLocale) applyStyleWorkaround(keys)
|
}
|
|
function applyFont (font, keys, force) {
|
if (typeof font !== 'string') font = defaultFont
|
keys.forEach(function (k) {
|
fonts[k] = font
|
if (!yargsKeys[k]) yargsKeys[k] = { transform: wholeString, error: null }
|
else if (force && yargsKeys[k].transform === null) yargsKeys[k].transform = wholeString
|
})
|
if (yargs && yargs.updateLocale) applyFontWorkaround(keys)
|
}
|
|
function applyStyleWorkaround (keys) {
|
var u = {}
|
keys.forEach(function (k) {
|
// cache non-font styled text in styleWorkaround
|
if (yargsKeys[k] && yargsKeys[k].plural) {
|
styleWorkaround[k] = {
|
one: doStyle(k, k, styles[k]),
|
other: doStyle(yargsKeys[k].plural, yargsKeys[k].plural, styles[k])
|
}
|
} else {
|
styleWorkaround[k] = doStyle(k, k, styles[k])
|
}
|
u[k] = styleWorkaround[k]
|
|
// style font-rendered text if defined
|
if (fontWorkaround[k]) {
|
if (typeof fontWorkaround[k] === 'string') u[k] = doStyle(k, fontWorkaround[k], styles[k])
|
else {
|
u[k] = {
|
one: doStyle(k, fontWorkaround[k].one, styles[k]),
|
other: doStyle(yargsKeys[k].plural, fontWorkaround[k].other, styles[k])
|
}
|
}
|
}
|
})
|
yargs.updateLocale(u)
|
}
|
|
function applyFontWorkaround (keys) {
|
var u = {}
|
keys.forEach(function (k) {
|
// cache non-styled font text in fontWorkaround
|
if (yargsKeys[k] && yargsKeys[k].plural) {
|
fontWorkaround[k] = {
|
one: doRender(k, k, fonts[k]),
|
other: doRender(yargsKeys[k].plural, yargsKeys[k].plural, fonts[k])
|
}
|
} else {
|
fontWorkaround[k] = doRender(k, k, fonts[k])
|
}
|
u[k] = fontWorkaround[k]
|
|
// render styled text if defined
|
if (styleWorkaround[k]) {
|
if (typeof styleWorkaround[k] === 'string') u[k] = doRender(k, styleWorkaround[k], fonts[k])
|
else {
|
u[k] = {
|
one: doRender(k, styleWorkaround[k].one, fonts[k]),
|
other: doRender(yargsKeys[k].plural, styleWorkaround[k].other, fonts[k])
|
}
|
}
|
}
|
})
|
yargs.updateLocale(u)
|
}
|
|
function applyTransform (transform, keys) {
|
keys.forEach(function (k) {
|
if (!yargsKeys[k]) yargsKeys[k] = { transform: transform, error: null }
|
else yargsKeys[k].transform = transform
|
})
|
}
|
|
// private logic to intercept y18n methods
|
function doStyle (key, orig, style) {
|
var chain = chalk
|
style.split('.').forEach(function (s) {
|
if (chain[s]) chain = chain[s]
|
})
|
return typeof chain === 'function' ? chain(orig) : orig
|
}
|
|
function doRender (key, orig, font) {
|
var fn = yargsKeys[key] ? yargsKeys[key].transform : upToFirstColon
|
if (fn === null) return orig
|
var split = fn(orig)
|
return self.asFont(split.render, font) + split.nonRender
|
}
|
|
function hack () {
|
var lookingFor = []
|
lookingFor.push(path.join('yargs', 'node_modules', 'y18n', 'index.js')) // npm 2 = nested
|
lookingFor.push(path.join('y18n', 'index.js')) // npm 3 = flat
|
|
var found = findInModuleCache(lookingFor)
|
|
if (found) {
|
// console.log('yargonaut: You loaded yargs before yargonaut, only default locale supported')
|
return parentRequireSafe('yargs')
|
}
|
|
var Y18n = parentRequireFirstOf(lookingFor)
|
found = findInModuleCache(lookingFor)
|
|
if (!found) {
|
// console.log('yargonaut: You\'re using a version of yargs that does not support string customization')
|
return parentRequireSafe('yargs')
|
}
|
|
require.cache[found].exports = function (opts) {
|
var z18n = new Y18n(opts)
|
var singular = z18n.__
|
var plural = z18n.__n
|
|
z18n.__ = function () {
|
var orig = singular.apply(z18n, arguments)
|
var key = arguments[0]
|
if (fonts[key] && yargsKeys[key]) {
|
return tweak(
|
key,
|
orig,
|
doRender(key, orig, fonts[key]),
|
figlet,
|
fonts[key]
|
)
|
}
|
return tweak(key, orig, orig, figlet, fonts[key])
|
}
|
|
z18n.__n = function () {
|
var orig = plural.apply(z18n, arguments)
|
var key = arguments[0]
|
if (fonts[key] && yargsKeys[key]) {
|
return tweak(
|
key,
|
orig,
|
doRender(key, orig, fonts[key]),
|
figlet,
|
fonts[key]
|
)
|
}
|
return tweak(key, orig, orig, figlet, fonts[key])
|
}
|
|
function tweak (key, origString, newString, figlet, font) {
|
if (styles[key]) newString = doStyle(key, newString, styles[key])
|
return ocdf ? ocdf(key, origString, newString, figlet, font) : newString
|
}
|
|
for (var key in z18n) {
|
if (typeof z18n[key] === 'function') {
|
z18n[key] = z18n[key].bind(z18n)
|
}
|
}
|
|
return z18n
|
}
|
|
return null
|
}
|
|
function findInModuleCache (lookingFor) {
|
var found = null
|
for (var i = 0, files = Object.keys(require.cache); i < files.length; i++) {
|
for (var j = 0; j < lookingFor.length; j++) {
|
if (~files[i].lastIndexOf(lookingFor[j])) {
|
found = files[i]
|
break
|
}
|
}
|
if (found) break
|
}
|
return found
|
}
|
|
function parentRequireFirstOf (array) {
|
var success = null
|
for (var x = 0; x < array.length; x++) {
|
success = parentRequireSafe(array[x])
|
if (success) break
|
}
|
return success
|
}
|
|
function parentRequireSafe (m) {
|
try {
|
return parentRequire(m)
|
} catch (err) {
|
return null
|
}
|
}
|
}
|
