diff options
Diffstat (limited to 'node_modules/base/README.md')
| -rw-r--r-- | node_modules/base/README.md | 491 |
1 files changed, 491 insertions, 0 deletions
diff --git a/node_modules/base/README.md b/node_modules/base/README.md new file mode 100644 index 0000000..c77cdaf --- /dev/null +++ b/node_modules/base/README.md @@ -0,0 +1,491 @@ +<p align="center"> + <a href="https://github.com/node-base/base"> + <img height="250" width="250" src="https://raw.githubusercontent.com/node-base/base/master/docs/logo.png"> + </a> +</p> + +# base [](https://www.npmjs.com/package/base) [](https://npmjs.org/package/base) [](https://npmjs.org/package/base) [](https://travis-ci.org/node-base/base) + +> base is the foundation for creating modular, unit testable and highly pluggable node.js applications, starting with a handful of common methods, like `set`, `get`, `del` and `use`. + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +$ npm install --save base +``` + +## What is Base? + +Base is a framework for rapidly creating high quality node.js applications, using plugins like building blocks. + +### Guiding principles + +The core team follows these principles to help guide API decisions: + +* **Compact API surface**: The smaller the API surface, the easier the library will be to learn and use. +* **Easy to extend**: Implementors can use any npm package, and write plugins in pure JavaScript. If you're building complex apps, Base simplifies inheritance. +* **Easy to test**: No special setup should be required to unit test `Base` or base plugins + +### Minimal API surface + +[The API](#api) was designed to provide only the minimum necessary functionality for creating a useful application, with or without [plugins](#plugins). + +**Base core** + +Base itself ships with only a handful of [useful methods](#api), such as: + +* `.set`: for setting values on the instance +* `.get`: for getting values from the instance +* `.has`: to check if a property exists on the instance +* `.define`: for setting non-enumerable values on the instance +* `.use`: for adding plugins + +**Be generic** + +When deciding on method to add or remove, we try to answer these questions: + +1. Will all or most Base applications need this method? +2. Will this method encourage practices or enforce conventions that are beneficial to implementors? +3. Can or should this be done in a plugin instead? + +### Composability + +**Plugin system** + +It couldn't be easier to extend Base with any features or custom functionality you can think of. + +Base plugins are just functions that take an instance of `Base`: + +```js +var base = new Base(); + +function plugin(base) { + // do plugin stuff, in pure JavaScript +} +// use the plugin +base.use(plugin); +``` + +**Inheritance** + +Easily inherit Base using `.extend`: + +```js +var Base = require('base'); + +function MyApp() { + Base.call(this); +} +Base.extend(MyApp); + +var app = new MyApp(); +app.set('a', 'b'); +app.get('a'); +//=> 'b'; +``` + +**Inherit or instantiate with a namespace** + +By default, the `.get`, `.set` and `.has` methods set and get values from the root of the `base` instance. You can customize this using the `.namespace` method exposed on the exported function. For example: + +```js +var Base = require('base'); +// get and set values on the `base.cache` object +var base = Base.namespace('cache'); + +var app = base(); +app.set('foo', 'bar'); +console.log(app.cache.foo); +//=> 'bar' +``` + +## API + +**Usage** + +```js +var Base = require('base'); +var app = new Base(); +app.set('foo', 'bar'); +console.log(app.foo); +//=> 'bar' +``` + +### [Base](index.js#L44) + +Create an instance of `Base` with the given `config` and `options`. + +**Params** + +* `config` **{Object}**: If supplied, this object is passed to [cache-base](https://github.com/jonschlinkert/cache-base) to merge onto the the instance upon instantiation. +* `options` **{Object}**: If supplied, this object is used to initialize the `base.options` object. + +**Example** + +```js +// initialize with `config` and `options` +var app = new Base({isApp: true}, {abc: true}); +app.set('foo', 'bar'); + +// values defined with the given `config` object will be on the root of the instance +console.log(app.baz); //=> undefined +console.log(app.foo); //=> 'bar' +// or use `.get` +console.log(app.get('isApp')); //=> true +console.log(app.get('foo')); //=> 'bar' + +// values defined with the given `options` object will be on `app.options +console.log(app.options.abc); //=> true +``` + +### [.is](index.js#L107) + +Set the given `name` on `app._name` and `app.is*` properties. Used for doing lookups in plugins. + +**Params** + +* `name` **{String}** +* `returns` **{Boolean}** + +**Example** + +```js +app.is('foo'); +console.log(app._name); +//=> 'foo' +console.log(app.isFoo); +//=> true +app.is('bar'); +console.log(app.isFoo); +//=> true +console.log(app.isBar); +//=> true +console.log(app._name); +//=> 'bar' +``` + +### [.isRegistered](index.js#L145) + +Returns true if a plugin has already been registered on an instance. + +Plugin implementors are encouraged to use this first thing in a plugin +to prevent the plugin from being called more than once on the same +instance. + +**Params** + +* `name` **{String}**: The plugin name. +* `register` **{Boolean}**: If the plugin if not already registered, to record it as being registered pass `true` as the second argument. +* `returns` **{Boolean}**: Returns true if a plugin is already registered. + +**Events** + +* `emits`: `plugin` Emits the name of the plugin being registered. Useful for unit tests, to ensure plugins are only registered once. + +**Example** + +```js +var base = new Base(); +base.use(function(app) { + if (app.isRegistered('myPlugin')) return; + // do stuff to `app` +}); + +// to also record the plugin as being registered +base.use(function(app) { + if (app.isRegistered('myPlugin', true)) return; + // do stuff to `app` +}); +``` + +### [.use](index.js#L175) + +Define a plugin function to be called immediately upon init. Plugins are chainable and expose the following arguments to the plugin function: + +* `app`: the current instance of `Base` +* `base`: the [first ancestor instance](#base) of `Base` + +**Params** + +* `fn` **{Function}**: plugin function to call +* `returns` **{Object}**: Returns the item instance for chaining. + +**Example** + +```js +var app = new Base() + .use(foo) + .use(bar) + .use(baz) +``` + +### [.define](index.js#L197) + +The `.define` method is used for adding non-enumerable property on the instance. Dot-notation is **not supported** with `define`. + +**Params** + +* `key` **{String}**: The name of the property to define. +* `value` **{any}** +* `returns` **{Object}**: Returns the instance for chaining. + +**Example** + +```js +// arbitrary `render` function using lodash `template` +app.define('render', function(str, locals) { + return _.template(str)(locals); +}); +``` + +### [.mixin](index.js#L222) + +Mix property `key` onto the Base prototype. If base is inherited using `Base.extend` this method will be overridden by a new `mixin` method that will only add properties to the prototype of the inheriting application. + +**Params** + +* `key` **{String}** +* `val` **{Object|Array}** +* `returns` **{Object}**: Returns the `base` instance for chaining. + +**Example** + +```js +app.mixin('foo', function() { + // do stuff +}); +``` + +### [.base](index.js#L268) + +Getter/setter used when creating nested instances of `Base`, for storing a reference to the first ancestor instance. This works by setting an instance of `Base` on the `parent` property of a "child" instance. The `base` property defaults to the current instance if no `parent` property is defined. + +**Example** + +```js +// create an instance of `Base`, this is our first ("base") instance +var first = new Base(); +first.foo = 'bar'; // arbitrary property, to make it easier to see what's happening later + +// create another instance +var second = new Base(); +// create a reference to the first instance (`first`) +second.parent = first; + +// create another instance +var third = new Base(); +// create a reference to the previous instance (`second`) +// repeat this pattern every time a "child" instance is created +third.parent = second; + +// we can always access the first instance using the `base` property +console.log(first.base.foo); +//=> 'bar' +console.log(second.base.foo); +//=> 'bar' +console.log(third.base.foo); +//=> 'bar' +// and now you know how to get to third base ;) +``` + +### [#use](index.js#L293) + +Static method for adding global plugin functions that will be added to an instance when created. + +**Params** + +* `fn` **{Function}**: Plugin function to use on each instance. +* `returns` **{Object}**: Returns the `Base` constructor for chaining + +**Example** + +```js +Base.use(function(app) { + app.foo = 'bar'; +}); +var app = new Base(); +console.log(app.foo); +//=> 'bar' +``` + +### [#extend](index.js#L337) + +Static method for inheriting the prototype and static methods of the `Base` class. This method greatly simplifies the process of creating inheritance-based applications. See [static-extend](https://github.com/jonschlinkert/static-extend) for more details. + +**Params** + +* `Ctor` **{Function}**: constructor to extend +* `methods` **{Object}**: Optional prototype properties to mix in. +* `returns` **{Object}**: Returns the `Base` constructor for chaining + +**Example** + +```js +var extend = cu.extend(Parent); +Parent.extend(Child); + +// optional methods +Parent.extend(Child, { + foo: function() {}, + bar: function() {} +}); +``` + +### [#mixin](index.js#L379) + +Used for adding methods to the `Base` prototype, and/or to the prototype of child instances. When a mixin function returns a function, the returned function is pushed onto the `.mixins` array, making it available to be used on inheriting classes whenever `Base.mixins()` is called (e.g. `Base.mixins(Child)`). + +**Params** + +* `fn` **{Function}**: Function to call +* `returns` **{Object}**: Returns the `Base` constructor for chaining + +**Example** + +```js +Base.mixin(function(proto) { + proto.foo = function(msg) { + return 'foo ' + msg; + }; +}); +``` + +### [#mixins](index.js#L401) + +Static method for running global mixin functions against a child constructor. Mixins must be registered before calling this method. + +**Params** + +* `Child` **{Function}**: Constructor function of a child class +* `returns` **{Object}**: Returns the `Base` constructor for chaining + +**Example** + +```js +Base.extend(Child); +Base.mixins(Child); +``` + +### [#inherit](index.js#L420) + +Similar to `util.inherit`, but copies all static properties, prototype properties, and getters/setters from `Provider` to `Receiver`. See [class-utils](https://github.com/jonschlinkert/class-utils#inherit) for more details. + +**Params** + +* `Receiver` **{Function}**: Receiving (child) constructor +* `Provider` **{Function}**: Providing (parent) constructor +* `returns` **{Object}**: Returns the `Base` constructor for chaining + +**Example** + +```js +Base.inherit(Foo, Bar); +``` + +## In the wild + +The following node.js applications were built with `Base`: + +* [assemble](https://github.com/assemble/assemble) +* [verb](https://github.com/verbose/verb) +* [generate](https://github.com/generate/generate) +* [scaffold](https://github.com/jonschlinkert/scaffold) +* [boilerplate](https://github.com/jonschlinkert/boilerplate) + +## Test coverage + +``` +Statements : 98.91% ( 91/92 ) +Branches : 92.86% ( 26/28 ) +Functions : 100% ( 17/17 ) +Lines : 98.9% ( 90/91 ) +``` + +## History + +### v0.11.2 + +* fixes https://github.com/micromatch/micromatch/issues/99 + +### v0.11.0 + +**Breaking changes** + +* Static `.use` and `.run` methods are now non-enumerable + +### v0.9.0 + +**Breaking changes** + +* `.is` no longer takes a function, a string must be passed +* all remaining `.debug` code has been removed +* `app._namespace` was removed (related to `debug`) +* `.plugin`, `.use`, and `.define` no longer emit events +* `.assertPlugin` was removed +* `.lazy` was removed + +## About + +### Related projects + +* [base-cwd](https://www.npmjs.com/package/base-cwd): Base plugin that adds a getter/setter for the current working directory. | [homepage](https://github.com/node-base/base-cwd "Base plugin that adds a getter/setter for the current working directory.") +* [base-data](https://www.npmjs.com/package/base-data): adds a `data` method to base-methods. | [homepage](https://github.com/node-base/base-data "adds a `data` method to base-methods.") +* [base-fs](https://www.npmjs.com/package/base-fs): base-methods plugin that adds vinyl-fs methods to your 'base' application for working with the file… [more](https://github.com/node-base/base-fs) | [homepage](https://github.com/node-base/base-fs "base-methods plugin that adds vinyl-fs methods to your 'base' application for working with the file system, like src, dest, copy and symlink.") +* [base-generators](https://www.npmjs.com/package/base-generators): Adds project-generator support to your `base` application. | [homepage](https://github.com/node-base/base-generators "Adds project-generator support to your `base` application.") +* [base-option](https://www.npmjs.com/package/base-option): Adds a few options methods to base, like `option`, `enable` and `disable`. See the readme… [more](https://github.com/node-base/base-option) | [homepage](https://github.com/node-base/base-option "Adds a few options methods to base, like `option`, `enable` and `disable`. See the readme for the full API.") +* [base-pipeline](https://www.npmjs.com/package/base-pipeline): base-methods plugin that adds pipeline and plugin methods for dynamically composing streaming plugin pipelines. | [homepage](https://github.com/node-base/base-pipeline "base-methods plugin that adds pipeline and plugin methods for dynamically composing streaming plugin pipelines.") +* [base-pkg](https://www.npmjs.com/package/base-pkg): Plugin for adding a `pkg` method that exposes pkg-store to your base application. | [homepage](https://github.com/node-base/base-pkg "Plugin for adding a `pkg` method that exposes pkg-store to your base application.") +* [base-plugins](https://www.npmjs.com/package/base-plugins): Adds 'smart plugin' support to your base application. | [homepage](https://github.com/node-base/base-plugins "Adds 'smart plugin' support to your base application.") +* [base-questions](https://www.npmjs.com/package/base-questions): Plugin for base-methods that adds methods for prompting the user and storing the answers on… [more](https://github.com/node-base/base-questions) | [homepage](https://github.com/node-base/base-questions "Plugin for base-methods that adds methods for prompting the user and storing the answers on a project-by-project basis.") +* [base-store](https://www.npmjs.com/package/base-store): Plugin for getting and persisting config values with your base-methods application. Adds a 'store' object… [more](https://github.com/node-base/base-store) | [homepage](https://github.com/node-base/base-store "Plugin for getting and persisting config values with your base-methods application. Adds a 'store' object that exposes all of the methods from the data-store library. Also now supports sub-stores!") +* [base-task](https://www.npmjs.com/package/base-task): base plugin that provides a very thin wrapper around [https://github.com/doowb/composer](https://github.com/doowb/composer) for adding task methods to… [more](https://github.com/node-base/base-task) | [homepage](https://github.com/node-base/base-task "base plugin that provides a very thin wrapper around <https://github.com/doowb/composer> for adding task methods to your application.") + +### Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +### Contributors + +| **Commits** | **Contributor** | +| --- | --- | +| 141 | [jonschlinkert](https://github.com/jonschlinkert) | +| 30 | [doowb](https://github.com/doowb) | +| 3 | [charlike](https://github.com/charlike) | +| 1 | [criticalmash](https://github.com/criticalmash) | +| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) | + +### Building docs + +_(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 +``` + +### Running tests + +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 +``` + +### 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 September 07, 2017._
\ No newline at end of file |