diff options
Diffstat (limited to 'deps/npm/node_modules/libcipm/node_modules/protoduck/index.js')
| -rw-r--r-- | deps/npm/node_modules/libcipm/node_modules/protoduck/index.js | 349 |
1 files changed, 0 insertions, 349 deletions
diff --git a/deps/npm/node_modules/libcipm/node_modules/protoduck/index.js b/deps/npm/node_modules/libcipm/node_modules/protoduck/index.js deleted file mode 100644 index 3596bb3299..0000000000 --- a/deps/npm/node_modules/libcipm/node_modules/protoduck/index.js +++ /dev/null @@ -1,349 +0,0 @@ -'use strict' - -const genfun = require('genfun') - -class Duck extends Function { - // Duck.impl(Foo, [String, Array], { frob (str, arr) { ... }}) - impl (target, types, impls) { - if (!impls && !isArray(types)) { - impls = types - types = [] - } - if (!impls && this.isDerivable) { - impls = this._defaultImpls - } - if (!impls) { - impls = {} - } - if (typeof target === 'function' && !target.isGenfun) { - target = target.prototype - } - checkImpls(this, target, impls) - checkArgTypes(this, types) - this._constraints.forEach(c => { - if (!c.verify(target, types)) { - throw new Error(`Implementations of ${ - this.name || 'this protocol' - } must first implement ${ - c.parent.name || 'its constraint protocols defined in opts.where.' - }`) - } - }) - this._methodNames.forEach(name => { - defineMethod(this, name, target, types, impls) - }) - } - - hasImpl (arg, args) { - args = args || [] - const fns = this._methodNames - var gf - if (typeof arg === 'function' && !arg.isGenfun) { - arg = arg.prototype - } - args = args.map(arg => { - if (typeof arg === 'function' && !arg.isGenfun) { - return arg.prototype - } else { - return arg - } - }) - for (var i = 0; i < fns.length; i++) { - gf = arg[fns[i]] - if (!gf || - (gf.hasMethod - ? !gf.hasMethod.apply(gf, args) - : typeof gf === 'function')) { - return false - } - } - return true - } - - // MyDuck.matches('a', ['this', 'c']) - matches (thisType, argTypes) { - if (!argTypes && isArray(thisType)) { - argTypes = thisType - thisType = 'this' - } - if (!thisType) { - thisType = 'this' - } - if (!argTypes) { - argTypes = [] - } - return new Constraint(this, thisType, argTypes) - } -} -Duck.prototype.isDuck = true -Duck.prototype.isProtocol = true - -const Protoduck = module.exports = define(['duck'], { - createGenfun: ['duck', _metaCreateGenfun], - addMethod: ['duck', _metaAddMethod] -}, {name: 'Protoduck'}) - -const noImplFound = module.exports.noImplFound = genfun.noApplicableMethod - -module.exports.define = define -function define (types, spec, opts) { - if (!isArray(types)) { - // protocol(spec, opts?) syntax for method-based protocols - opts = spec - spec = types - types = [] - } - const duck = function (thisType, argTypes) { - return duck.matches(thisType, argTypes) - } - Object.setPrototypeOf(duck, Duck.prototype) - duck.isDerivable = true - Object.defineProperty(duck, 'name', { - value: (opts && opts.name) || 'Protocol' - }) - if (opts && opts.where) { - let where = opts.where - if (!isArray(opts.where)) { where = [opts.where] } - duck._constraints = where.map(w => w.isProtocol // `where: [Foo]` - ? w.matches() - : w - ) - } else { - duck._constraints = [] - } - duck.isProtocol = true - duck._metaobject = opts && opts.metaobject - duck._types = types - duck._defaultImpls = {} - duck._gfTypes = {} - duck._methodNames = Object.keys(spec) - duck._methodNames.forEach(name => { - checkMethodSpec(duck, name, spec) - }) - duck._constraints.forEach(c => c.attach(duck)) - return duck -} - -function checkMethodSpec (duck, name, spec) { - let gfTypes = spec[name] - if (typeof gfTypes === 'function') { - duck._defaultImpls[name] = gfTypes - gfTypes = [gfTypes] - } if (typeof gfTypes[gfTypes.length - 1] === 'function') { - duck._defaultImpls[name] = gfTypes.pop() - } else { - duck.isDerivable = false - } - duck._gfTypes[name] = gfTypes.map(typeId => { - const idx = duck._types.indexOf(typeId) - if (idx === -1) { - throw new Error( - `type '${ - typeId - }' for function '${ - name - }' does not match any protocol types (${ - duck._types.join(', ') - }).` - ) - } else { - return idx - } - }) -} - -function defineMethod (duck, name, target, types, impls) { - const methodTypes = duck._gfTypes[name].map(function (typeIdx) { - return types[typeIdx] - }) - for (let i = methodTypes.length - 1; i >= 0; i--) { - if (methodTypes[i] === undefined) { - methodTypes.pop() - } else { - break - } - } - const useMetaobject = duck._metaobject && duck._metaobject !== Protoduck - // `target` does not necessarily inherit from `Object` - if (!Object.prototype.hasOwnProperty.call(target, name)) { - // Make a genfun if there's nothing there - const gf = useMetaobject - ? duck._metaobject.createGenfun(duck, target, name, null) - : _metaCreateGenfun(duck, target, name, null) - target[name] = gf - } else if (typeof target[name] === 'function' && !target[name].isGenfun) { - // Turn non-gf functions into genfuns - const gf = useMetaobject - ? duck._metaobject.createGenfun(duck, target, name, target[name]) - : _metaCreateGenfun(duck, target, name, target[name]) - target[name] = gf - } - - const fn = impls[name] || duck._defaultImpls[name] - if (fn) { // checkImpls made sure this is safe - useMetaobject - ? duck._metaobject.addMethod(duck, target, name, methodTypes, fn) - : _metaAddMethod(duck, target, name, methodTypes, fn) - } -} - -function checkImpls (duck, target, impls) { - duck._methodNames.forEach(function (name) { - if ( - !impls[name] && - !duck._defaultImpls[name] && - // Existing methods on the target are acceptable defaults. - typeof target[name] !== 'function' - ) { - throw new Error(`Missing implementation for ${ - formatMethod(duck, name, duck.name) - }. Make sure the method is present in your ${ - duck.name || 'protocol' - } definition. Required methods: ${ - duck._methodNames.filter(m => { - return !duck._defaultImpls[m] - }).map(m => formatMethod(duck, m)).join(', ') - }.`) - } - }) - Object.keys(impls).forEach(function (name) { - if (duck._methodNames.indexOf(name) === -1) { - throw new Error( - `${name}() was included in the impl, but is not part of ${ - duck.name || 'the protocol' - }. Allowed methods: ${ - duck._methodNames.map(m => formatMethod(duck, m)).join(', ') - }.` - ) - } - }) -} - -function formatMethod (duck, name, withDuckName) { - return `${ - withDuckName && duck.name ? `${duck.name}#` : '' - }${name}(${duck._gfTypes[name].map(n => duck._types[n]).join(', ')})` -} - -function checkArgTypes (duck, types) { - var requiredTypes = duck._types - if (types.length > requiredTypes.length) { - throw new Error( - `${ - duck.name || 'Protocol' - } expects to be defined across ${ - requiredTypes.length - } type${requiredTypes.length > 1 ? 's' : ''}, but ${ - types.length - } ${types.length > 1 ? 'were' : 'was'} specified.` - ) - } -} - -function typeName (obj) { - return (/\[object ([a-zA-Z0-9]+)\]/).exec(({}).toString.call(obj))[1] -} - -function installMethodErrorMessage (proto, gf, target, name) { - noImplFound.add([gf], function (gf, thisArg, args) { - let parent = Object.getPrototypeOf(thisArg) - while (parent && parent[name] === gf) { - parent = Object.getPrototypeOf(parent) - } - if (parent && parent[name] && typeof parent[name] === 'function') { - } - var msg = `No ${typeName(thisArg)} impl for ${ - proto.name ? `${proto.name}#` : '' - }${name}(${[].map.call(args, typeName).join(', ')}). You must implement ${ - proto.name - ? formatMethod(proto, name, true) - : `the protocol ${formatMethod(proto, name)} belongs to` - } in order to call ${typeName(thisArg)}#${name}(${ - [].map.call(args, typeName).join(', ') - }).` - const err = new Error(msg) - err.protocol = proto - err.function = gf - err.thisArg = thisArg - err.args = args - err.code = 'ENOIMPL' - throw err - }) -} - -function isArray (x) { - return Object.prototype.toString.call(x) === '[object Array]' -} - -// Metaobject Protocol -Protoduck.impl(Protoduck) // defaults configured by definition - -function _metaCreateGenfun (proto, target, name, deflt) { - var gf = genfun({ - default: deflt, - name: `${proto.name ? `${proto.name}#` : ''}${name}` - }) - installMethodErrorMessage(proto, gf, target, name) - gf.duck = proto - return gf -} - -function _metaAddMethod (duck, target, name, methodTypes, fn) { - return target[name].add(methodTypes, fn) -} - -// Constraints -class Constraint { - constructor (parent, thisType, argTypes) { - this.parent = parent - this.target = thisType - this.types = argTypes - } - - attach (obj) { - this.child = obj - if (this.target === 'this') { - this.thisIdx = 'this' - } else { - const idx = this.child._types.indexOf(this.target) - if (idx === -1) { - this.thisIdx = null - } else { - this.thisIdx = idx - } - } - this.indices = this.types.map(typeId => { - if (typeId === 'this') { - return 'this' - } else { - const idx = this.child._types.indexOf(typeId) - if (idx === -1) { - return null - } else { - return idx - } - } - }) - } - - verify (target, types) { - const thisType = ( - this.thisIdx === 'this' || this.thisIdx == null - ) - ? target - : types[this.thisIdx] - const parentTypes = this.indices.map(idx => { - if (idx === 'this') { - return target - } else if (idx === 'this') { - return types[this.thisIdx] - } else if (idx === null) { - return Object - } else { - return types[idx] || Object.prototype - } - }) - return this.parent.hasImpl(thisType, parentTypes) - } -} -Constraint.prototype.isConstraint = true |