jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/config-chain/index.js

@@ -0,0 +1,282 @@
+var ProtoList = require('proto-list')
+  , path = require('path')
+  , fs = require('fs')
+  , ini = require('ini')
+  , EE = require('events').EventEmitter
+  , url = require('url')
+  , http = require('http')
+
+var exports = module.exports = function () {
+  var args = [].slice.call(arguments)
+    , conf = new ConfigChain()
+
+  while(args.length) {
+    var a = args.shift()
+    if(a) conf.push
+          ( 'string' === typeof a
+            ? json(a)
+            : a )
+  }
+
+  return conf
+}
+
+//recursively find a file...
+
+var find = exports.find = function () {
+  var rel = path.join.apply(null, [].slice.call(arguments))
+
+  function find(start, rel) {
+    var file = path.join(start, rel)
+    try {
+      fs.statSync(file)
+      return file
+    } catch (err) {
+      if(path.dirname(start) !== start) // root
+        return find(path.dirname(start), rel)
+    }
+  }
+  return find(__dirname, rel)
+}
+
+var parse = exports.parse = function (content, file, type) {
+  content = '' + content
+  // if we don't know what it is, try json and fall back to ini
+  // if we know what it is, then it must be that.
+  if (!type) {
+    try { return JSON.parse(content) }
+    catch (er) { return ini.parse(content) }
+  } else if (type === 'json') {
+    if (this.emit) {
+      try { return JSON.parse(content) }
+      catch (er) { this.emit('error', er) }
+    } else {
+      return JSON.parse(content)
+    }
+  } else {
+    return ini.parse(content)
+  }
+}
+
+var json = exports.json = function () {
+  var args = [].slice.call(arguments).filter(function (arg) { return arg != null })
+  var file = path.join.apply(null, args)
+  var content
+  try {
+    content = fs.readFileSync(file,'utf-8')
+  } catch (err) {
+    return
+  }
+  return parse(content, file, 'json')
+}
+
+var env = exports.env = function (prefix, env) {
+  env = env || process.env
+  var obj = {}
+  var l = prefix.length
+  for(var k in env) {
+    if(k.indexOf(prefix) === 0)
+      obj[k.substring(l)] = env[k]
+  }
+
+  return obj
+}
+
+exports.ConfigChain = ConfigChain
+function ConfigChain () {
+  EE.apply(this)
+  ProtoList.apply(this, arguments)
+  this._awaiting = 0
+  this._saving = 0
+  this.sources = {}
+}
+
+// multi-inheritance-ish
+var extras = {
+  constructor: { value: ConfigChain }
+}
+Object.keys(EE.prototype).forEach(function (k) {
+  extras[k] = Object.getOwnPropertyDescriptor(EE.prototype, k)
+})
+ConfigChain.prototype = Object.create(ProtoList.prototype, extras)
+
+ConfigChain.prototype.del = function (key, where) {
+  // if not specified where, then delete from the whole chain, scorched
+  // earth style
+  if (where) {
+    var target = this.sources[where]
+    target = target && target.data
+    if (!target) {
+      return this.emit('error', new Error('not found '+where))
+    }
+    delete target[key]
+  } else {
+    for (var i = 0, l = this.list.length; i < l; i ++) {
+      delete this.list[i][key]
+    }
+  }
+  return this
+}
+
+ConfigChain.prototype.set = function (key, value, where) {
+  var target
+
+  if (where) {
+    target = this.sources[where]
+    target = target && target.data
+    if (!target) {
+      return this.emit('error', new Error('not found '+where))
+    }
+  } else {
+    target = this.list[0]
+    if (!target) {
+      return this.emit('error', new Error('cannot set, no confs!'))
+    }
+  }
+  target[key] = value
+  return this
+}
+
+ConfigChain.prototype.get = function (key, where) {
+  if (where) {
+    where = this.sources[where]
+    if (where) where = where.data
+    if (where && Object.hasOwnProperty.call(where, key)) return where[key]
+    return undefined
+  }
+  return this.list[0][key]
+}
+
+ConfigChain.prototype.save = function (where, type, cb) {
+  if (typeof type === 'function') cb = type, type = null
+  var target = this.sources[where]
+  if (!target || !(target.path || target.source) || !target.data) {
+    // TODO: maybe save() to a url target could be a PUT or something?
+    // would be easy to swap out with a reddis type thing, too
+    return this.emit('error', new Error('bad save target: '+where))
+  }
+
+  if (target.source) {
+    var pref = target.prefix || ''
+    Object.keys(target.data).forEach(function (k) {
+      target.source[pref + k] = target.data[k]
+    })
+    return this
+  }
+
+  var type = type || target.type
+  var data = target.data
+  if (target.type === 'json') {
+    data = JSON.stringify(data)
+  } else {
+    data = ini.stringify(data)
+  }
+
+  this._saving ++
+  fs.writeFile(target.path, data, 'utf8', function (er) {
+    this._saving --
+    if (er) {
+      if (cb) return cb(er)
+      else return this.emit('error', er)
+    }
+    if (this._saving === 0) {
+      if (cb) cb()
+      this.emit('save')
+    }
+  }.bind(this))
+  return this
+}
+
+ConfigChain.prototype.addFile = function (file, type, name) {
+  name = name || file
+  var marker = {__source__:name}
+  this.sources[name] = { path: file, type: type }
+  this.push(marker)
+  this._await()
+  fs.readFile(file, 'utf8', function (er, data) {
+    if (er) this.emit('error', er)
+    this.addString(data, file, type, marker)
+  }.bind(this))
+  return this
+}
+
+ConfigChain.prototype.addEnv = function (prefix, env, name) {
+  name = name || 'env'
+  var data = exports.env(prefix, env)
+  this.sources[name] = { data: data, source: env, prefix: prefix }
+  return this.add(data, name)
+}
+
+ConfigChain.prototype.addUrl = function (req, type, name) {
+  this._await()
+  var href = url.format(req)
+  name = name || href
+  var marker = {__source__:name}
+  this.sources[name] = { href: href, type: type }
+  this.push(marker)
+  http.request(req, function (res) {
+    var c = []
+    var ct = res.headers['content-type']
+    if (!type) {
+      type = ct.indexOf('json') !== -1 ? 'json'
+           : ct.indexOf('ini') !== -1 ? 'ini'
+           : href.match(/\.json$/) ? 'json'
+           : href.match(/\.ini$/) ? 'ini'
+           : null
+      marker.type = type
+    }
+
+    res.on('data', c.push.bind(c))
+    .on('end', function () {
+      this.addString(Buffer.concat(c), href, type, marker)
+    }.bind(this))
+    .on('error', this.emit.bind(this, 'error'))
+
+  }.bind(this))
+  .on('error', this.emit.bind(this, 'error'))
+  .end()
+
+  return this
+}
+
+ConfigChain.prototype.addString = function (data, file, type, marker) {
+  data = this.parse(data, file, type)
+  this.add(data, marker)
+  return this
+}
+
+ConfigChain.prototype.add = function (data, marker) {
+  if (marker && typeof marker === 'object') {
+    var i = this.list.indexOf(marker)
+    if (i === -1) {
+      return this.emit('error', new Error('bad marker'))
+    }
+    this.splice(i, 1, data)
+    marker = marker.__source__
+    this.sources[marker] = this.sources[marker] || {}
+    this.sources[marker].data = data
+    // we were waiting for this.  maybe emit 'load'
+    this._resolve()
+  } else {
+    if (typeof marker === 'string') {
+      this.sources[marker] = this.sources[marker] || {}
+      this.sources[marker].data = data
+    }
+    // trigger the load event if nothing was already going to do so.
+    this._await()
+    this.push(data)
+    process.nextTick(this._resolve.bind(this))
+  }
+  return this
+}
+
+ConfigChain.prototype.parse = exports.parse
+
+ConfigChain.prototype._await = function () {
+  this._awaiting++
+}
+
+ConfigChain.prototype._resolve = function () {
+  this._awaiting--
+  if (this._awaiting === 0) this.emit('load', this)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/config-chain/package.json

@@ -0,0 +1,62 @@
+{
+  "_from": "config-chain@~1.1.11",
+  "_id": "config-chain@1.1.11",
+  "_integrity": "sha1-q6CXR9++TD5w52am5BWG4YWfxvI=",
+  "_location": "/config-chain",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "config-chain@~1.1.11",
+    "name": "config-chain",
+    "escapedName": "config-chain",
+    "rawSpec": "~1.1.11",
+    "saveSpec": null,
+    "fetchSpec": "~1.1.11"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.11.tgz",
+  "_shasum": "aba09747dfbe4c3e70e766a6e41586e1859fc6f2",
+  "_shrinkwrap": null,
+  "_spec": "config-chain@~1.1.11",
+  "_where": "/Users/zkat/Documents/code/npm",
+  "author": {
+    "name": "Dominic Tarr",
+    "email": "dominic.tarr@gmail.com",
+    "url": "http://dominictarr.com"
+  },
+  "bin": null,
+  "bugs": {
+    "url": "https://github.com/dominictarr/config-chain/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "ini": "^1.3.4",
+    "proto-list": "~1.2.1"
+  },
+  "deprecated": false,
+  "description": "HANDLE CONFIGURATION ONCE AND FOR ALL",
+  "devDependencies": {
+    "tap": "0.3.0"
+  },
+  "homepage": "http://github.com/dominictarr/config-chain",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://raw.githubusercontent.com/dominictarr/config-chain/master/LICENCE"
+    }
+  ],
+  "name": "config-chain",
+  "optionalDependencies": {},
+  "peerDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dominictarr/config-chain.git"
+  },
+  "scripts": {
+    "test": "tap test/"
+  },
+  "version": "1.1.11"
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/config-chain/readme.markdown

@@ -0,0 +1,237 @@
+#config-chain
+
+USE THIS MODULE TO LOAD ALL YOUR CONFIGURATIONS
+
+## NOTE: Feature Freeze
+
+[![locked](http://badges.github.io/stability-badges/dist/locked.svg)](http://github.com/badges/stability-badges)
+
+This module is frozen.
+
+In general, I'd recommend using [rc](https://github.com/dominictarr/rc) instead,
+but as [npm](https://github.com/npmjs/npm) depends on this, it cannot be changed.
+
+``` js
+
+  //npm install config-chain
+
+  var cc = require('config-chain')
+    , opts = require('optimist').argv //ALWAYS USE OPTIMIST FOR COMMAND LINE OPTIONS.
+    , env = opts.env || process.env.YOUR_APP_ENV || 'dev' //SET YOUR ENV LIKE THIS.
+
+  // EACH ARG TO CONFIGURATOR IS LOADED INTO CONFIGURATION CHAIN
+  // EARLIER ITEMS OVERIDE LATER ITEMS
+  // PUTS COMMAND LINE OPTS FIRST, AND DEFAULTS LAST!
+
+  //strings are interpereted as filenames.
+  //will be loaded synchronously
+
+  var conf =
+  cc(
+    //OVERRIDE SETTINGS WITH COMMAND LINE OPTS
+    opts,
+
+    //ENV VARS IF PREFIXED WITH 'myApp_'
+
+    cc.env('myApp_'), //myApp_foo = 'like this'
+
+    //FILE NAMED BY ENV
+    path.join(__dirname,  'config.' + env + '.json'),
+
+    //IF `env` is PRODUCTION
+    env === 'prod'
+      ? path.join(__dirname, 'special.json') //load a special file
+      : null //NULL IS IGNORED!
+
+    //SUBDIR FOR ENV CONFIG
+    path.join(__dirname,  'config', env, 'config.json'),
+
+    //SEARCH PARENT DIRECTORIES FROM CURRENT DIR FOR FILE
+    cc.find('config.json'),
+
+    //PUT DEFAULTS LAST
+    {
+      host: 'localhost'
+      port: 8000
+    })
+
+  var host = conf.get('host')
+
+  // or
+
+  var host = conf.store.host
+
+```
+
+FINALLY, EASY FLEXIBLE CONFIGURATIONS!
+
+##see also: [proto-list](https://github.com/isaacs/proto-list/)
+
+WHATS THAT YOU SAY?
+
+YOU WANT A "CLASS" SO THAT YOU CAN DO CRAYCRAY JQUERY CRAPS?
+
+EXTEND WITH YOUR OWN FUNCTIONALTY!?
+
+## CONFIGCHAIN LIVES TO SERVE ONLY YOU!
+
+```javascript
+var cc = require('config-chain')
+
+// all the stuff you did before
+var config = cc({
+      some: 'object'
+    },
+    cc.find('config.json'),
+    cc.env('myApp_')
+  )
+  // CONFIGS AS A SERVICE, aka "CaaS", aka EVERY DEVOPS DREAM OMG!
+  .addUrl('http://configurator:1234/my-configs')
+  // ASYNC FTW!
+  .addFile('/path/to/file.json')
+
+  // OBJECTS ARE OK TOO, they're SYNC but they still ORDER RIGHT
+  // BECAUSE PROMISES ARE USED BUT NO, NOT *THOSE* PROMISES, JUST
+  // ACTUAL PROMISES LIKE YOU MAKE TO YOUR MOM, KEPT OUT OF LOVE
+  .add({ another: 'object' })
+
+  // DIE A THOUSAND DEATHS IF THIS EVER HAPPENS!!
+  .on('error', function (er) {
+    // IF ONLY THERE WAS SOMETHIGN HARDER THAN THROW
+    // MY SORROW COULD BE ADEQUATELY EXPRESSED.  /o\
+    throw er
+  })
+
+  // THROW A PARTY IN YOUR FACE WHEN ITS ALL LOADED!!
+  .on('load', function (config) {
+    console.awesome('HOLY SHIT!')
+  })
+```
+
+# BORING API DOCS
+
+## cc(...args)
+
+MAKE A CHAIN AND ADD ALL THE ARGS.
+
+If the arg is a STRING, then it shall be a JSON FILENAME.
+
+SYNC I/O!
+
+RETURN THE CHAIN!
+
+## cc.json(...args)
+
+Join the args INTO A JSON FILENAME!
+
+SYNC I/O!
+
+## cc.find(relativePath)
+
+SEEK the RELATIVE PATH by climbing the TREE OF DIRECTORIES.
+
+RETURN THE FOUND PATH!
+
+SYNC I/O!
+
+## cc.parse(content, file, type)
+
+Parse the content string, and guess the type from either the
+specified type or the filename.
+
+RETURN THE RESULTING OBJECT!
+
+NO I/O!
+
+## cc.env(prefix, env=process.env)
+
+Get all the keys on the provided env object (or process.env) which are
+prefixed by the specified prefix, and put the values on a new object.
+
+RETURN THE RESULTING OBJECT!
+
+NO I/O!
+
+## cc.ConfigChain()
+
+The ConfigChain class for CRAY CRAY JQUERY STYLE METHOD CHAINING!
+
+One of these is returned by the main exported function, as well.
+
+It inherits (prototypically) from
+[ProtoList](https://github.com/isaacs/proto-list/), and also inherits
+(parasitically) from
+[EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter)
+
+It has all the methods from both, and except where noted, they are
+unchanged.
+
+### LET IT BE KNOWN THAT chain IS AN INSTANCE OF ConfigChain.
+
+## chain.sources
+
+A list of all the places where it got stuff.  The keys are the names
+passed to addFile or addUrl etc, and the value is an object with some
+info about the data source.
+
+## chain.addFile(filename, type, [name=filename])
+
+Filename is the name of the file.  Name is an arbitrary string to be
+used later if you desire.  Type is either 'ini' or 'json', and will
+try to guess intelligently if omitted.
+
+Loaded files can be saved later.
+
+## chain.addUrl(url, type, [name=url])
+
+Same as the filename thing, but with a url.
+
+Can't be saved later.
+
+## chain.addEnv(prefix, env, [name='env'])
+
+Add all the keys from the env object that start with the prefix.
+
+## chain.addString(data, file, type, [name])
+
+Parse the string and add it to the set.  (Mainly used internally.)
+
+## chain.add(object, [name])
+
+Add the object to the set.
+
+## chain.root {Object}
+
+The root from which all the other config objects in the set descend
+prototypically.
+
+Put your defaults here.
+
+## chain.set(key, value, name)
+
+Set the key to the value on the named config object.  If name is
+unset, then set it on the first config object in the set.  (That is,
+the one with the highest priority, which was added first.)
+
+## chain.get(key, [name])
+
+Get the key from the named config object explicitly, or from the
+resolved configs if not specified.
+
+## chain.save(name, type)
+
+Write the named config object back to its origin.
+
+Currently only supported for env and file config types.
+
+For files, encode the data according to the type.
+
+## chain.on('save', function () {})
+
+When one or more files are saved, emits `save` event when they're all
+saved.
+
+## chain.on('load', function (chain) {})
+
+When the config chain has loaded all the specified files and urls and
+such, the 'load' event fires.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/debuglog/LICENSE

@@ -0,0 +1,19 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/debuglog/README.md

@@ -0,0 +1,40 @@
+# debuglog - backport of util.debuglog() from node v0.11
+
+To facilitate using the `util.debuglog()` function that will be available when
+node v0.12 is released now, this is a copy extracted from the source.
+
+## require('debuglog')
+
+Return `util.debuglog`, if it exists, otherwise it will return an internal copy
+of the implementation from node v0.11.
+
+## debuglog(section)
+
+* `section` {String} The section of the program to be debugged
+* Returns: {Function} The logging function
+
+This is used to create a function which conditionally writes to stderr
+based on the existence of a `NODE_DEBUG` environment variable.  If the
+`section` name appears in that environment variable, then the returned
+function will be similar to `console.error()`.  If not, then the
+returned function is a no-op.
+
+For example:
+
+```javascript
+var debuglog = util.debuglog('foo');
+
+var bar = 123;
+debuglog('hello from foo [%d]', bar);
+```
+
+If this program is run with `NODE_DEBUG=foo` in the environment, then
+it will output something like:
+
+    FOO 3245: hello from foo [123]
+
+where `3245` is the process id.  If it is not run with that
+environment variable set, then it will not print anything.
+
+You may separate multiple `NODE_DEBUG` environment variables with a
+comma.  For example, `NODE_DEBUG=fs,net,tls`.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/debuglog/debuglog.js

@@ -0,0 +1,22 @@
+var util = require('util');
+
+module.exports = (util && util.debuglog) || debuglog;
+
+var debugs = {};
+var debugEnviron = process.env.NODE_DEBUG || '';
+
+function debuglog(set) {
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = util.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};