pax_global_header00006660000000000000000000000064126336173130014517gustar00rootroot0000000000000052 comment=c4dc07ef1ed51c2b2a63f3585e5ef949ee577a49 node-delegates-1.0.0/000077500000000000000000000000001263361731300143755ustar00rootroot00000000000000node-delegates-1.0.0/.gitignore000066400000000000000000000000161263361731300163620ustar00rootroot00000000000000node_modules/ node-delegates-1.0.0/History.md000066400000000000000000000005201263361731300163550ustar00rootroot00000000000000 1.0.0 / 2015-12-14 ================== * Merge pull request #12 from kasicka/master * Add license text 0.1.0 / 2014-10-17 ================== * adds `.fluent()` to api 0.0.3 / 2014-01-13 ================== * fix receiver for .method() 0.0.2 / 2014-01-13 ================== * Object.defineProperty() sucks * Initial commit node-delegates-1.0.0/License000066400000000000000000000020671263361731300157070ustar00rootroot00000000000000Copyright (c) 2015 TJ Holowaychuk 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. node-delegates-1.0.0/Makefile000066400000000000000000000001441263361731300160340ustar00rootroot00000000000000 test: @./node_modules/.bin/mocha \ --require should \ --reporter spec \ --bail .PHONY: testnode-delegates-1.0.0/Readme.md000066400000000000000000000033501263361731300161150ustar00rootroot00000000000000 # delegates Node method and accessor delegation utilty. ## Installation ``` $ npm install delegates ``` ## Example ```js var delegate = require('delegates'); ... delegate(proto, 'request') .method('acceptsLanguages') .method('acceptsEncodings') .method('acceptsCharsets') .method('accepts') .method('is') .access('querystring') .access('idempotent') .access('socket') .access('length') .access('query') .access('search') .access('status') .access('method') .access('path') .access('body') .access('host') .access('url') .getter('subdomains') .getter('protocol') .getter('header') .getter('stale') .getter('fresh') .getter('secure') .getter('ips') .getter('ip') ``` # API ## Delegate(proto, prop) Creates a delegator instance used to configure using the `prop` on the given `proto` object. (which is usually a prototype) ## Delegate#method(name) Allows the given method `name` to be accessed on the host. ## Delegate#getter(name) Creates a "getter" for the property with the given `name` on the delegated object. ## Delegate#setter(name) Creates a "setter" for the property with the given `name` on the delegated object. ## Delegate#access(name) Creates an "accessor" (ie: both getter *and* setter) for the property with the given `name` on the delegated object. ## Delegate#fluent(name) A unique type of "accessor" that works for a "fluent" API. When called as a getter, the method returns the expected value. However, if the method is called with a value, it will return itself so it can be chained. For example: ```js delegate(proto, 'request') .fluent('query') // getter var q = request.query(); // setter (chainable) request .query({ a: 1 }) .query({ b: 2 }); ``` # License MIT node-delegates-1.0.0/index.js000066400000000000000000000040211263361731300160370ustar00rootroot00000000000000 /** * Expose `Delegator`. */ module.exports = Delegator; /** * Initialize a delegator. * * @param {Object} proto * @param {String} target * @api public */ function Delegator(proto, target) { if (!(this instanceof Delegator)) return new Delegator(proto, target); this.proto = proto; this.target = target; this.methods = []; this.getters = []; this.setters = []; this.fluents = []; } /** * Delegate method `name`. * * @param {String} name * @return {Delegator} self * @api public */ Delegator.prototype.method = function(name){ var proto = this.proto; var target = this.target; this.methods.push(name); proto[name] = function(){ return this[target][name].apply(this[target], arguments); }; return this; }; /** * Delegator accessor `name`. * * @param {String} name * @return {Delegator} self * @api public */ Delegator.prototype.access = function(name){ return this.getter(name).setter(name); }; /** * Delegator getter `name`. * * @param {String} name * @return {Delegator} self * @api public */ Delegator.prototype.getter = function(name){ var proto = this.proto; var target = this.target; this.getters.push(name); proto.__defineGetter__(name, function(){ return this[target][name]; }); return this; }; /** * Delegator setter `name`. * * @param {String} name * @return {Delegator} self * @api public */ Delegator.prototype.setter = function(name){ var proto = this.proto; var target = this.target; this.setters.push(name); proto.__defineSetter__(name, function(val){ return this[target][name] = val; }); return this; }; /** * Delegator fluent accessor * * @param {String} name * @return {Delegator} self * @api public */ Delegator.prototype.fluent = function (name) { var proto = this.proto; var target = this.target; this.fluents.push(name); proto[name] = function(val){ if ('undefined' != typeof val) { this[target][name] = val; return this; } else { return this[target][name]; } }; return this; }; node-delegates-1.0.0/package.json000066400000000000000000000004711263361731300166650ustar00rootroot00000000000000{ "name": "delegates", "version": "1.0.0", "repository": "visionmedia/node-delegates", "description": "delegate methods and accessors to another property", "keywords": ["delegate", "delegation"], "dependencies": {}, "devDependencies": { "mocha": "*", "should": "*" }, "license": "MIT" } node-delegates-1.0.0/test/000077500000000000000000000000001263361731300153545ustar00rootroot00000000000000node-delegates-1.0.0/test/index.js000066400000000000000000000033701263361731300170240ustar00rootroot00000000000000 var assert = require('assert'); var delegate = require('..'); describe('.method(name)', function(){ it('should delegate methods', function(){ var obj = {}; obj.request = { foo: function(bar){ assert(this == obj.request); return bar; } }; delegate(obj, 'request').method('foo'); obj.foo('something').should.equal('something'); }) }) describe('.getter(name)', function(){ it('should delegate getters', function(){ var obj = {}; obj.request = { get type() { return 'text/html'; } } delegate(obj, 'request').getter('type'); obj.type.should.equal('text/html'); }) }) describe('.setter(name)', function(){ it('should delegate setters', function(){ var obj = {}; obj.request = { get type() { return this._type.toUpperCase(); }, set type(val) { this._type = val; } } delegate(obj, 'request').setter('type'); obj.type = 'hey'; obj.request.type.should.equal('HEY'); }) }) describe('.access(name)', function(){ it('should delegate getters and setters', function(){ var obj = {}; obj.request = { get type() { return this._type.toUpperCase(); }, set type(val) { this._type = val; } } delegate(obj, 'request').access('type'); obj.type = 'hey'; obj.type.should.equal('HEY'); }) }) describe('.fluent(name)', function () { it('should delegate in a fluent fashion', function () { var obj = { settings: { env: 'development' } }; delegate(obj, 'settings').fluent('env'); obj.env().should.equal('development'); obj.env('production').should.equal(obj); obj.settings.env.should.equal('production'); }) })