pax_global_header 0000666 0000000 0000000 00000000064 12733117470 0014517 g ustar 00root root 0000000 0000000 52 comment=d860297eb6b98f6f5b10b40ec43d8550eba07499 base-d860297eb6b98f6f5b10b40ec43d8550eba07499/ 0000775 0000000 0000000 00000000000 12733117470 0017370 5 ustar 00root root 0000000 0000000 base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.editorconfig 0000664 0000000 0000000 00000000612 12733117470 0022044 0 ustar 00root root 0000000 0000000 # http://editorconfig.org root = true [*] indent_style = space end_of_line = lf charset = utf-8 indent_size = 2 trim_trailing_whitespace = true insert_final_newline = true [*.md] trim_trailing_whitespace = false insert_final_newline = false [test/**] trim_trailing_whitespace = false insert_final_newline = false [templates/**] trim_trailing_whitespace = false insert_final_newline = false base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.eslintrc.json 0000664 0000000 0000000 00000007147 12733117470 0022175 0 ustar 00root root 0000000 0000000 { "ecmaFeatures": { "modules": true, "experimentalObjectRestSpread": true }, "env": { "browser": false, "es6": true, "node": true, "mocha": true }, "globals": { "document": false, "navigator": false, "window": false }, "rules": { "accessor-pairs": 2, "arrow-spacing": [2, { "before": true, "after": true }], "block-spacing": [2, "always"], "brace-style": [2, "1tbs", { "allowSingleLine": true }], "comma-dangle": [2, "never"], "comma-spacing": [2, { "before": false, "after": true }], "comma-style": [2, "last"], "constructor-super": 2, "curly": [2, "multi-line"], "dot-location": [2, "property"], "eol-last": 2, "eqeqeq": [2, "allow-null"], "generator-star-spacing": [2, { "before": true, "after": true }], "handle-callback-err": [2, "^(err|error)$" ], "indent": [2, 2, { "SwitchCase": 1 }], "keyword-spacing": [2, {"before": true, "after": true}], "key-spacing": [2, { "beforeColon": false, "afterColon": true }], "new-cap": [2, { "newIsCap": true, "capIsNew": false }], "new-parens": 2, "no-array-constructor": 2, "no-caller": 2, "no-class-assign": 2, "no-cond-assign": 2, "no-const-assign": 2, "no-control-regex": 2, "no-debugger": 2, "no-delete-var": 2, "no-dupe-args": 2, "no-dupe-class-members": 2, "no-dupe-keys": 2, "no-duplicate-case": 2, "no-empty-character-class": 2, "no-labels": 2, "no-eval": 2, "no-ex-assign": 2, "no-extend-native": 2, "no-extra-bind": 2, "no-extra-boolean-cast": 2, "no-extra-parens": [2, "functions"], "no-fallthrough": 2, "no-floating-decimal": 2, "no-func-assign": 2, "no-implied-eval": 2, "no-inner-declarations": [2, "functions"], "no-invalid-regexp": 2, "no-irregular-whitespace": 2, "no-iterator": 2, "no-label-var": 2, "no-labels": 2, "no-lone-blocks": 2, "no-mixed-spaces-and-tabs": 2, "no-multi-spaces": 2, "no-multi-str": 2, "no-multiple-empty-lines": [2, { "max": 1 }], "no-native-reassign": 2, "no-negated-in-lhs": 2, "no-new": 2, "no-new-func": 2, "no-new-object": 2, "no-new-require": 2, "no-new-wrappers": 2, "no-obj-calls": 2, "no-octal": 2, "no-octal-escape": 2, "no-proto": 0, "no-redeclare": 2, "no-regex-spaces": 2, "no-return-assign": 2, "no-self-compare": 2, "no-sequences": 2, "no-shadow-restricted-names": 2, "no-spaced-func": 2, "no-sparse-arrays": 2, "no-this-before-super": 2, "no-throw-literal": 2, "no-trailing-spaces": 0, "no-undef": 2, "no-undef-init": 2, "no-unexpected-multiline": 2, "no-unneeded-ternary": [2, { "defaultAssignment": false }], "no-unreachable": 2, "no-unused-vars": [2, { "vars": "all", "args": "none" }], "no-useless-call": 0, "no-with": 2, "one-var": [0, { "initialized": "never" }], "operator-linebreak": [0, "after", { "overrides": { "?": "before", ":": "before" } }], "padded-blocks": [0, "never"], "quotes": [2, "single", "avoid-escape"], "radix": 2, "semi": [2, "always"], "semi-spacing": [2, { "before": false, "after": true }], "space-before-blocks": [2, "always"], "space-before-function-paren": [2, "never"], "space-in-parens": [2, "never"], "space-infix-ops": 2, "space-unary-ops": [2, { "words": true, "nonwords": false }], "spaced-comment": [0, "always", { "markers": ["global", "globals", "eslint", "eslint-disable", "*package", "!", ","] }], "use-isnan": 2, "valid-typeof": 2, "wrap-iife": [2, "any"], "yoda": [2, "never"] } } base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.gitattributes 0000664 0000000 0000000 00000000200 12733117470 0022253 0 ustar 00root root 0000000 0000000 # Enforce Unix newlines * text eol=lf # binaries *.ai binary *.psd binary *.jpg binary *.gif binary *.png binary *.jpeg binary base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.gitignore 0000664 0000000 0000000 00000000221 12733117470 0021353 0 ustar 00root root 0000000 0000000 *.DS_Store *.sublime-* _gh_pages bower_components node_modules npm-debug.log actual test/actual temp tmp TODO.md vendor .idea benchmark coverage base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.travis.yml 0000664 0000000 0000000 00000000236 12733117470 0021502 0 ustar 00root root 0000000 0000000 sudo: false language: node_js node_js: - "stable" - "5" - "4" - "0.12" - "0.10" matrix: fast_finish: true allow_failures: - node_js: "0.10" base-d860297eb6b98f6f5b10b40ec43d8550eba07499/.verb.md 0000664 0000000 0000000 00000006611 12733117470 0020732 0 ustar 00root root 0000000 0000000 {{#block "logo"}}
{{/block}} {{#block "about"}} ## 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? 1. Will this method encourage practices or enforce conventions that are beneficial to implementors? 1. 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('{%= name %}'); 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('{%= name %}'); // 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' ``` {{/block}} ## API **Usage** ```js var Base = require('base'); var app = new Base(); app.set('foo', 'bar'); console.log(app.foo); //=> 'bar' ``` {%= apidocs("index.js") %} ## In the wild The following node.js applications were built with `Base`: - [assemble][] - [verb][] - [generate][] - [scaffold][] - [boilerplate][] ## Test coverage ``` {%= coverage('coverage/summary.txt') %} ``` ## History **v0.11.0 - major breaking changes!** - Static `.use` and `.run` methods are now non-enumerable **v0.9.0 - major 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 base-d860297eb6b98f6f5b10b40ec43d8550eba07499/LICENSE 0000664 0000000 0000000 00000002100 12733117470 0020366 0 ustar 00root root 0000000 0000000 The MIT License (MIT) Copyright (c) 2015-2016, Jon Schlinkert. 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. base-d860297eb6b98f6f5b10b40ec43d8550eba07499/README.md 0000664 0000000 0000000 00000040542 12733117470 0020654 0 ustar 00root root 0000000 0000000 # base [](https://www.npmjs.com/package/base) [](https://npmjs.org/package/base) [](https://travis-ci.org/node-base/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' ``` ## Install Install with [npm](https://www.npmjs.com/): ```sh $ npm install --save base ``` ## API **Usage** ```js var Base = require('base'); var app = new Base(); app.set('foo', 'bar'); console.log(app.foo); //=> 'bar' ``` ### [Base](index.js#L38) 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#L101) 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#L139) 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#L169) 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#L191) 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#L216) 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#L262) 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#L287) 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#L331) 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#L373) 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#L395) 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#L414) 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.95% ( 94/95 ) Branches : 92.31% ( 24/26 ) Functions : 100% ( 17/17 ) Lines : 98.94% ( 93/94 ) ``` ## History **v0.11.0 - major breaking changes!** * Static `.use` and `.run` methods are now non-enumerable **v0.9.0 - major 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 ## Related projects There are a number of different plugins available for extending base. Let us know if you create your own! * [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): Upgrade's plugin support in base applications to allow plugins to be called any time after… [more](https://github.com/node-base/base-plugins) | [homepage](https://github.com/node-base/base-plugins "Upgrade's plugin support in base applications to allow plugins to be called any time after init.") * [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