@dev-sergeev/datalab-kit 0.1.2 → 0.1.4

package/node_modules/section-matter/README.md

@@ -0,0 +1,236 @@
+# section-matter [![NPM version](https://img.shields.io/npm/v/section-matter.svg?style=flat)](https://www.npmjs.com/package/section-matter) [![NPM monthly downloads](https://img.shields.io/npm/dm/section-matter.svg?style=flat)](https://npmjs.org/package/section-matter) [![NPM total downloads](https://img.shields.io/npm/dt/section-matter.svg?style=flat)](https://npmjs.org/package/section-matter) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/section-matter.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/section-matter) 
+
+> Like front-matter, but supports multiple sections in a document.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save section-matter
+```
+
+## Usage
+
+**Params**
+
+* `input` **{String|Buffer|Object}**: If input is an object, it's `content` property must be a string or buffer.    
+* **{Object}**: options    
+* `returns` **{Object}**: Returns an object with a `content` string and an array of `sections` objects.  
+
+**Example**
+
+```js
+var sections = require('{%= name %}');
+var result = sections(input, options);
+// { content: 'Content before sections', sections: [] }
+```
+
+See available [options](#options).
+
+## Example
+
+_With the exception of front-matter, **which must be the very first thing in the string**, the opening delimiter of all other sections must be followed by a string to be used as the `key` for the section._
+
+Given the following string:
+
+```
+Content before the sections.
+
+---
+
+More content.
+
+---one
+title: One
+---
+
+This is the first section.
+```
+
+The following code:
+
+```js
+console.log(sections(input));
+```
+
+Results in:
+
+```js
+{ 
+  content: 'Content before the sections.\n\n---\n\nMore content.\n',
+  sections: [
+    { 
+      key: 'one',
+      data: 'title: One',
+      content: '\nThis is the first section.' 
+    } 
+  ] 
+}
+```
+
+## Options
+
+### options.section_parse
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Function to be called on each section after it's parsed from the string.
+
+**Example**
+
+Given the following string (`foo.md`):
+
+```
+This is content before the sections.
+
+---one
+title: First section
+---
+
+This is section one.
+
+---two
+title: Second section
+---
+
+This is section two.
+```
+
+Using the following custom `section_parse` function:
+
+```js
+var fs = require('fs');
+var path = require('path');
+var yaml = require('js-yaml');
+var sections = require('section-matter');
+
+var str = fs.readFileSync('foo.md');
+var options = {
+  section_parse: function(section) {
+    console.log(section)
+    section.key = 'section-' + section.key;
+    section.data = yaml.safeLoad(section.data);
+  }
+};
+
+var result = sections(str, options);
+console.log(result);
+```
+
+Results in:
+
+```js
+{
+  content: 'This is content before the sections.\n',
+  sections: [
+    {
+      key: 'section-one',
+      data: { title: 'First section' },
+      content: '\nThis is section one.\n'
+    },
+    {
+      key: 'section-two',
+      data: { title: 'Second section' },
+      content: '\nThis is section two.\n'
+    }
+  ]
+}
+```
+
+### options.section_delimiter
+
+**Type**: `string`
+
+**Default**: `---`
+
+Delimiter to use as the separator for sections. _With the exception of front-matter, which must be the very first thing in the string, the opening delimiter of all other sections must be followed by a string to be used as the `key` for the section._
+
+**Example**
+
+```js
+var input = '~~~\ntitle: bar\n~~~\n\nfoo\n~~~one\ntitle: One\n~~~\nThis is one';
+console.log(sections(input, {section_delimiter: '~~~'}));
+```
+
+Results in:
+
+```js
+{
+  content: '',
+  sections: [
+    {
+      key: '',
+      data: 'title: bar',
+      content: '\nfoo'
+    },
+    {
+      key: 'one',
+      data: 'title: One',
+      content: 'This is one'
+    }
+  ]
+}
+```
+
+## About
+<details>
+  <summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+  <summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+  <summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects: 
+
+- [assemble](https://www.npmjs.com/package/assemble): Get the rocks out of your socks! Assemble makes you fast at creating web projects… [more](https://github.com/assemble/assemble) | [homepage](https://github.com/assemble/assemble "Get the rocks out of your socks! Assemble makes you fast at creating web projects. Assemble is used by thousands of projects for rapid prototyping, creating themes, scaffolds, boilerplates, e-books, UI components, API documentation, blogs, building websit")
+- [gray-matter](https://www.npmjs.com/package/gray-matter): Parse front-matter from a string or file. Fast, reliable and easy to use. Parses YAML… [more](https://github.com/jonschlinkert/gray-matter) | [homepage](https://github.com/jonschlinkert/gray-matter "Parse front-matter from a string or file. Fast, reliable and easy to use. Parses YAML front matter by default, but also has support for YAML, JSON, TOML or Coffee Front-Matter, with options to set custom delimiters. Used by metalsmith, assemble, verb and ")
+- [verb](https://www.npmjs.com/package/verb): Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used… [more](https://github.com/verbose/verb) | [homepage](https://github.com/verbose/verb "Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used on hundreds of projects of all sizes to generate everything from API docs to readmes.")  
+
+### Contributors
+
+### Author
+**Jon Schlinkert**
+
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on October 23, 2017._
+

package/node_modules/section-matter/index.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var typeOf = require('kind-of');
+var extend = require('extend-shallow');
+
+/**
+ * Parse sections in `input` with the given `options`.
+ *
+ * ```js
+ * var sections = require('{%= name %}');
+ * var result = sections(input, options);
+ * // { content: 'Content before sections', sections: [] }
+ * ```
+ * @param {String|Buffer|Object} `input` If input is an object, it's `content` property must be a string or buffer.
+ * @param {Object} options
+ * @return {Object} Returns an object with a `content` string and an array of `sections` objects.
+ * @api public
+ */
+
+module.exports = function(input, options) {
+  if (typeof options === 'function') {
+    options = { parse: options };
+  }
+
+  var file = toObject(input);
+  var defaults = {section_delimiter: '---', parse: identity};
+  var opts = extend({}, defaults, options);
+  var delim = opts.section_delimiter;
+  var lines = file.content.split(/\r?\n/);
+  var sections = null;
+  var section = createSection();
+  var content = [];
+  var stack = [];
+
+  function initSections(val) {
+    file.content = val;
+    sections = [];
+    content = [];
+  }
+
+  function closeSection(val) {
+    if (stack.length) {
+      section.key = getKey(stack[0], delim);
+      section.content = val;
+      opts.parse(section, sections);
+      sections.push(section);
+      section = createSection();
+      content = [];
+      stack = [];
+    }
+  }
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var len = stack.length;
+    var ln = line.trim();
+
+    if (isDelimiter(ln, delim)) {
+      if (ln.length === 3 && i !== 0) {
+        if (len === 0 || len === 2) {
+          content.push(line);
+          continue;
+        }
+        stack.push(ln);
+        section.data = content.join('\n');
+        content = [];
+        continue;
+      }
+
+      if (sections === null) {
+        initSections(content.join('\n'));
+      }
+
+      if (len === 2) {
+        closeSection(content.join('\n'));
+      }
+
+      stack.push(ln);
+      continue;
+    }
+
+    content.push(line);
+  }
+
+  if (sections === null) {
+    initSections(content.join('\n'));
+  } else {
+    closeSection(content.join('\n'));
+  }
+
+  file.sections = sections;
+  return file;
+};
+
+function isDelimiter(line, delim) {
+  if (line.slice(0, delim.length) !== delim) {
+    return false;
+  }
+  if (line.charAt(delim.length + 1) === delim.slice(-1)) {
+    return false;
+  }
+  return true;
+}
+
+function toObject(input) {
+  if (typeOf(input) !== 'object') {
+    input = { content: input };
+  }
+
+  if (typeof input.content !== 'string' && !isBuffer(input.content)) {
+    throw new TypeError('expected a buffer or string');
+  }
+
+  input.content = input.content.toString();
+  input.sections = [];
+  return input;
+}
+
+function getKey(val, delim) {
+  return val ? val.slice(delim.length).trim() : '';
+}
+
+function createSection() {
+  return { key: '', data: '', content: '' };
+}
+
+function identity(val) {
+  return val;
+}
+
+function isBuffer(val) {
+  if (val && val.constructor && typeof val.constructor.isBuffer === 'function') {
+    return val.constructor.isBuffer(val);
+  }
+  return false;
+}

package/node_modules/section-matter/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "section-matter",
+  "description": "Like front-matter, but supports multiple sections in a document.",
+  "version": "1.0.0",
+  "homepage": "https://github.com/jonschlinkert/section-matter",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/section-matter",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/section-matter/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=4"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "extend-shallow": "^2.0.1",
+    "kind-of": "^6.0.0"
+  },
+  "devDependencies": {
+    "gulp-format-md": "^1.0.0",
+    "js-yaml": "^3.10.0",
+    "mocha": "^4.0.1"
+  },
+  "keywords": [
+    "matter",
+    "section"
+  ],
+  "verb": {
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "related": {
+      "list": [
+        "gray-matter",
+        "assemble",
+        "verb"
+      ]
+    },
+    "lint": {
+      "reflinks": true
+    }
+  }
+}

package/node_modules/signal-exit/LICENSE.txt

@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) 2015, Contributors
+
+Permission to use, copy, modify, and/or distribute this software
+for any purpose with or without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/signal-exit/README.md

@@ -0,0 +1,39 @@
+# signal-exit
+
+[![Build Status](https://travis-ci.org/tapjs/signal-exit.png)](https://travis-ci.org/tapjs/signal-exit)
+[![Coverage](https://coveralls.io/repos/tapjs/signal-exit/badge.svg?branch=master)](https://coveralls.io/r/tapjs/signal-exit?branch=master)
+[![NPM version](https://img.shields.io/npm/v/signal-exit.svg)](https://www.npmjs.com/package/signal-exit)
+[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version)
+
+When you want to fire an event no matter how a process exits:
+
+* reaching the end of execution.
+* explicitly having `process.exit(code)` called.
+* having `process.kill(pid, sig)` called.
+* receiving a fatal signal from outside the process
+
+Use `signal-exit`.
+
+```js
+var onExit = require('signal-exit')
+
+onExit(function (code, signal) {
+  console.log('process exited!')
+})
+```
+
+## API
+
+`var remove = onExit(function (code, signal) {}, options)`
+
+The return value of the function is a function that will remove the
+handler.
+
+Note that the function *only* fires for signals if the signal would
+cause the process to exit.  That is, there are no other listeners, and
+it is a fatal signal.
+
+## Options
+
+* `alwaysLast`: Run this handler after any other signal or exit
+  handlers.  This causes `process.emit` to be monkeypatched.

package/node_modules/signal-exit/index.js

@@ -0,0 +1,202 @@
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process = global.process
+
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+}
+
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process)) {
+  module.exports = function () {
+    return function () {}
+  }
+} else {
+  var assert = require('assert')
+  var signals = require('./signals.js')
+  var isWin = /^win/i.test(process.platform)
+
+  var EE = require('events')
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter
+  }
+
+  var emitter
+  if (process.__signal_exit_emitter__) {
+    emitter = process.__signal_exit_emitter__
+  } else {
+    emitter = process.__signal_exit_emitter__ = new EE()
+    emitter.count = 0
+    emitter.emitted = {}
+  }
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity)
+    emitter.infinite = true
+  }
+
+  module.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(global.process)) {
+      return function () {}
+    }
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
+
+    if (loaded === false) {
+      load()
+    }
+
+    var ev = 'exit'
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit'
+    }
+
+    var remove = function () {
+      emitter.removeListener(ev, cb)
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload()
+      }
+    }
+    emitter.on(ev, cb)
+
+    return remove
+  }
+
+  var unload = function unload () {
+    if (!loaded || !processOk(global.process)) {
+      return
+    }
+    loaded = false
+
+    signals.forEach(function (sig) {
+      try {
+        process.removeListener(sig, sigListeners[sig])
+      } catch (er) {}
+    })
+    process.emit = originalProcessEmit
+    process.reallyExit = originalProcessReallyExit
+    emitter.count -= 1
+  }
+  module.exports.unload = unload
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
+    }
+    emitter.emitted[event] = true
+    emitter.emit(event, code, signal)
+  }
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {}
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(global.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process.listeners(sig)
+      if (listeners.length === emitter.count) {
+        unload()
+        emit('exit', null, sig)
+        /* istanbul ignore next */
+        emit('afterexit', null, sig)
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT'
+        }
+        /* istanbul ignore next */
+        process.kill(process.pid, sig)
+      }
+    }
+  })
+
+  module.exports.signals = function () {
+    return signals
+  }
+
+  var loaded = false
+
+  var load = function load () {
+    if (loaded || !processOk(global.process)) {
+      return
+    }
+    loaded = true
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1
+
+    signals = signals.filter(function (sig) {
+      try {
+        process.on(sig, sigListeners[sig])
+        return true
+      } catch (er) {
+        return false
+      }
+    })
+
+    process.emit = processEmit
+    process.reallyExit = processReallyExit
+  }
+  module.exports.load = load
+
+  var originalProcessReallyExit = process.reallyExit
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(global.process)) {
+      return
+    }
+    process.exitCode = code || /* istanbul ignore next */ 0
+    emit('exit', process.exitCode, null)
+    /* istanbul ignore next */
+    emit('afterexit', process.exitCode, null)
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process, process.exitCode)
+  }
+
+  var originalProcessEmit = process.emit
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(global.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process.exitCode = arg
+      }
+      var ret = originalProcessEmit.apply(this, arguments)
+      /* istanbul ignore next */
+      emit('exit', process.exitCode, null)
+      /* istanbul ignore next */
+      emit('afterexit', process.exitCode, null)
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
+  }
+}