repo
stringlengths 5
67
| path
stringlengths 4
116
| func_name
stringlengths 0
58
| original_string
stringlengths 52
373k
| language
stringclasses 1
value | code
stringlengths 52
373k
| code_tokens
list | docstring
stringlengths 4
11.8k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 86
226
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
guylabs/angular-spring-data-rest
|
src/angular-spring-data-rest-provider.js
|
fetchFunction
|
function fetchFunction(url, key, data, fetchLinkNames, recursive, fetchMultiple) {
if (config.fetchFunction == undefined) {
var promisesArray = [];
promisesArray.push($injector.get("$http").get(url)
.then(function (responseData) {
// wrap the response again with the adapter and return the promise
if (recursive) {
return processData(responseData.data, fetchLinkNames, true, fetchMultiple).then(function (processedData) {
data[key] = processedData;
});
} else {
return processData(responseData.data).then(function (processedData) {
data[key] = processedData;
});
}
}, function (error) {
if (error.status != 404) {
// just reject the error if its not a 404 as there are links which return a 404 which are not set
return $injector.get("$q").reject(error);
}
}));
// wait for all promises to be resolved and return a new promise
return $injector.get("$q").all(promisesArray);
} else {
return config.fetchFunction(url, key, data, fetchLinkNames, recursive, fetchMultiple);
}
}
|
javascript
|
function fetchFunction(url, key, data, fetchLinkNames, recursive, fetchMultiple) {
if (config.fetchFunction == undefined) {
var promisesArray = [];
promisesArray.push($injector.get("$http").get(url)
.then(function (responseData) {
// wrap the response again with the adapter and return the promise
if (recursive) {
return processData(responseData.data, fetchLinkNames, true, fetchMultiple).then(function (processedData) {
data[key] = processedData;
});
} else {
return processData(responseData.data).then(function (processedData) {
data[key] = processedData;
});
}
}, function (error) {
if (error.status != 404) {
// just reject the error if its not a 404 as there are links which return a 404 which are not set
return $injector.get("$q").reject(error);
}
}));
// wait for all promises to be resolved and return a new promise
return $injector.get("$q").all(promisesArray);
} else {
return config.fetchFunction(url, key, data, fetchLinkNames, recursive, fetchMultiple);
}
}
|
[
"function",
"fetchFunction",
"(",
"url",
",",
"key",
",",
"data",
",",
"fetchLinkNames",
",",
"recursive",
",",
"fetchMultiple",
")",
"{",
"if",
"(",
"config",
".",
"fetchFunction",
"==",
"undefined",
")",
"{",
"var",
"promisesArray",
"=",
"[",
"]",
";",
"promisesArray",
".",
"push",
"(",
"$injector",
".",
"get",
"(",
"\"$http\"",
")",
".",
"get",
"(",
"url",
")",
".",
"then",
"(",
"function",
"(",
"responseData",
")",
"{",
"if",
"(",
"recursive",
")",
"{",
"return",
"processData",
"(",
"responseData",
".",
"data",
",",
"fetchLinkNames",
",",
"true",
",",
"fetchMultiple",
")",
".",
"then",
"(",
"function",
"(",
"processedData",
")",
"{",
"data",
"[",
"key",
"]",
"=",
"processedData",
";",
"}",
")",
";",
"}",
"else",
"{",
"return",
"processData",
"(",
"responseData",
".",
"data",
")",
".",
"then",
"(",
"function",
"(",
"processedData",
")",
"{",
"data",
"[",
"key",
"]",
"=",
"processedData",
";",
"}",
")",
";",
"}",
"}",
",",
"function",
"(",
"error",
")",
"{",
"if",
"(",
"error",
".",
"status",
"!=",
"404",
")",
"{",
"return",
"$injector",
".",
"get",
"(",
"\"$q\"",
")",
".",
"reject",
"(",
"error",
")",
";",
"}",
"}",
")",
")",
";",
"return",
"$injector",
".",
"get",
"(",
"\"$q\"",
")",
".",
"all",
"(",
"promisesArray",
")",
";",
"}",
"else",
"{",
"return",
"config",
".",
"fetchFunction",
"(",
"url",
",",
"key",
",",
"data",
",",
"fetchLinkNames",
",",
"recursive",
",",
"fetchMultiple",
")",
";",
"}",
"}"
] |
Fetches the given URL and adds the response to the given data object as a property
with the name of the given key.
@param {string} url the url at which the resource is available
@param {string} key the key inside the data object where to store the returned response
@param {object} data the data object reference in which the response is stored
@param {[string]|string} fetchLinkNames the fetch link names to allow to process the fetched response
@param {boolean} recursive true if the fetched response should be processed recursively with the
@param {boolean} fetchMultiple true if multiple same link names should be resolved. ATTENTION: this could lead to
an infinite loop when you have circular dependencies between the links.
adapter, false otherwise
|
[
"Fetches",
"the",
"given",
"URL",
"and",
"adds",
"the",
"response",
"to",
"the",
"given",
"data",
"object",
"as",
"a",
"property",
"with",
"the",
"name",
"of",
"the",
"given",
"key",
"."
] |
70d15b5cf3cd37328037d3884c30a4715a12b616
|
https://github.com/guylabs/angular-spring-data-rest/blob/70d15b5cf3cd37328037d3884c30a4715a12b616/src/angular-spring-data-rest-provider.js#L95-L124
|
train
|
guylabs/angular-spring-data-rest
|
src/angular-spring-data-rest-provider.js
|
getProcessedUrl
|
function getProcessedUrl(data, resourceName) {
// get the raw URL out of the resource name and check if it is valid
var rawUrl = checkUrl(data[config.linksKey][resourceName][config.linksHrefKey], resourceName,
config.linksHrefKey);
// extract the template parameters of the raw URL
return extractUrl(rawUrl, data[config.linksKey][resourceName].templated);
}
|
javascript
|
function getProcessedUrl(data, resourceName) {
// get the raw URL out of the resource name and check if it is valid
var rawUrl = checkUrl(data[config.linksKey][resourceName][config.linksHrefKey], resourceName,
config.linksHrefKey);
// extract the template parameters of the raw URL
return extractUrl(rawUrl, data[config.linksKey][resourceName].templated);
}
|
[
"function",
"getProcessedUrl",
"(",
"data",
",",
"resourceName",
")",
"{",
"var",
"rawUrl",
"=",
"checkUrl",
"(",
"data",
"[",
"config",
".",
"linksKey",
"]",
"[",
"resourceName",
"]",
"[",
"config",
".",
"linksHrefKey",
"]",
",",
"resourceName",
",",
"config",
".",
"linksHrefKey",
")",
";",
"return",
"extractUrl",
"(",
"rawUrl",
",",
"data",
"[",
"config",
".",
"linksKey",
"]",
"[",
"resourceName",
"]",
".",
"templated",
")",
";",
"}"
] |
Gets the processed URL of the given resource name form the given data object.
@param {object} data the given data object
@param {string} resourceName the resource name from which the URL is retrieved
@returns {string} the processed url
|
[
"Gets",
"the",
"processed",
"URL",
"of",
"the",
"given",
"resource",
"name",
"form",
"the",
"given",
"data",
"object",
"."
] |
70d15b5cf3cd37328037d3884c30a4715a12b616
|
https://github.com/guylabs/angular-spring-data-rest/blob/70d15b5cf3cd37328037d3884c30a4715a12b616/src/angular-spring-data-rest-provider.js#L339-L346
|
train
|
guylabs/angular-spring-data-rest
|
src/angular-spring-data-rest-provider.js
|
extractUrlTemplates
|
function extractUrlTemplates(resourceName) {
if (hasUrlTemplate(resourceName)) {
var indexOfSlash = resourceName.indexOf("/");
return [resourceName.substr(0, indexOfSlash), resourceName.substr(indexOfSlash, resourceName.length)];
}
}
|
javascript
|
function extractUrlTemplates(resourceName) {
if (hasUrlTemplate(resourceName)) {
var indexOfSlash = resourceName.indexOf("/");
return [resourceName.substr(0, indexOfSlash), resourceName.substr(indexOfSlash, resourceName.length)];
}
}
|
[
"function",
"extractUrlTemplates",
"(",
"resourceName",
")",
"{",
"if",
"(",
"hasUrlTemplate",
"(",
"resourceName",
")",
")",
"{",
"var",
"indexOfSlash",
"=",
"resourceName",
".",
"indexOf",
"(",
"\"/\"",
")",
";",
"return",
"[",
"resourceName",
".",
"substr",
"(",
"0",
",",
"indexOfSlash",
")",
",",
"resourceName",
".",
"substr",
"(",
"indexOfSlash",
",",
"resourceName",
".",
"length",
")",
"]",
";",
"}",
"}"
] |
Extracts the URL template and returns the resource name and the URL templates as an array.
@param resourceName the resource name to parse
@returns {[]} the first element is the raw resource name and the second is the extracted URL templates
|
[
"Extracts",
"the",
"URL",
"template",
"and",
"returns",
"the",
"resource",
"name",
"and",
"the",
"URL",
"templates",
"as",
"an",
"array",
"."
] |
70d15b5cf3cd37328037d3884c30a4715a12b616
|
https://github.com/guylabs/angular-spring-data-rest/blob/70d15b5cf3cd37328037d3884c30a4715a12b616/src/angular-spring-data-rest-provider.js#L362-L367
|
train
|
enigma-io/react-input-placeholder
|
src/react-input-placeholder.js
|
function(e) {
this.hasFocus = true;
this.setSelectionIfNeeded(e.target);
if (this.props.onFocus) {
return this.props.onFocus(e);
}
}
|
javascript
|
function(e) {
this.hasFocus = true;
this.setSelectionIfNeeded(e.target);
if (this.props.onFocus) {
return this.props.onFocus(e);
}
}
|
[
"function",
"(",
"e",
")",
"{",
"this",
".",
"hasFocus",
"=",
"true",
";",
"this",
".",
"setSelectionIfNeeded",
"(",
"e",
".",
"target",
")",
";",
"if",
"(",
"this",
".",
"props",
".",
"onFocus",
")",
"{",
"return",
"this",
".",
"props",
".",
"onFocus",
"(",
"e",
")",
";",
"}",
"}"
] |
keep track of focus
|
[
"keep",
"track",
"of",
"focus"
] |
983dcf3659707d681b6c2f9133ad6c52d9101d18
|
https://github.com/enigma-io/react-input-placeholder/blob/983dcf3659707d681b6c2f9133ad6c52d9101d18/src/react-input-placeholder.js#L43-L50
|
train
|
|
joestelmach/laconic
|
laconic.js
|
function(tagName) {
return function() {
return laconic.apply(this,
[tagName].concat(Array.prototype.slice.call(arguments)));
};
}
|
javascript
|
function(tagName) {
return function() {
return laconic.apply(this,
[tagName].concat(Array.prototype.slice.call(arguments)));
};
}
|
[
"function",
"(",
"tagName",
")",
"{",
"return",
"function",
"(",
")",
"{",
"return",
"laconic",
".",
"apply",
"(",
"this",
",",
"[",
"tagName",
"]",
".",
"concat",
"(",
"Array",
".",
"prototype",
".",
"slice",
".",
"call",
"(",
"arguments",
")",
")",
")",
";",
"}",
";",
"}"
] |
add our tag methods to the laconic object
|
[
"add",
"our",
"tag",
"methods",
"to",
"the",
"laconic",
"object"
] |
faa5ff94dd36fd3f6ed2f41908cac84dc2a46eaf
|
https://github.com/joestelmach/laconic/blob/faa5ff94dd36fd3f6ed2f41908cac84dc2a46eaf/laconic.js#L173-L178
|
train
|
|
Kegsay/flow-jsdoc
|
index.js
|
extractJsdoc
|
function extractJsdoc(comment) {
var docAst = doctrine.parse(comment, { unwrap: true, sloppy: true });
if (!docAst.tags || docAst.tags.length === 0) {
return null;
}
// only interested in @param @property, and @return
var paramTags = docAst.tags.filter(function(tag) {
return tag.title === "param";
}).map(jsdocTagToFlowTag);
var returnTags = docAst.tags.filter(function(tag) {
return tag.title === "return" || tag.title === "returns";
}).map(jsdocTagToFlowTag);
var propTags = docAst.tags.filter(function(tag) {
return tag.title === "property" || tag.title === "prop";
}).map(jsdocTagToFlowTag);
return {
params: paramTags,
returns: returnTags,
props: propTags
};
}
|
javascript
|
function extractJsdoc(comment) {
var docAst = doctrine.parse(comment, { unwrap: true, sloppy: true });
if (!docAst.tags || docAst.tags.length === 0) {
return null;
}
// only interested in @param @property, and @return
var paramTags = docAst.tags.filter(function(tag) {
return tag.title === "param";
}).map(jsdocTagToFlowTag);
var returnTags = docAst.tags.filter(function(tag) {
return tag.title === "return" || tag.title === "returns";
}).map(jsdocTagToFlowTag);
var propTags = docAst.tags.filter(function(tag) {
return tag.title === "property" || tag.title === "prop";
}).map(jsdocTagToFlowTag);
return {
params: paramTags,
returns: returnTags,
props: propTags
};
}
|
[
"function",
"extractJsdoc",
"(",
"comment",
")",
"{",
"var",
"docAst",
"=",
"doctrine",
".",
"parse",
"(",
"comment",
",",
"{",
"unwrap",
":",
"true",
",",
"sloppy",
":",
"true",
"}",
")",
";",
"if",
"(",
"!",
"docAst",
".",
"tags",
"||",
"docAst",
".",
"tags",
".",
"length",
"===",
"0",
")",
"{",
"return",
"null",
";",
"}",
"var",
"paramTags",
"=",
"docAst",
".",
"tags",
".",
"filter",
"(",
"function",
"(",
"tag",
")",
"{",
"return",
"tag",
".",
"title",
"===",
"\"param\"",
";",
"}",
")",
".",
"map",
"(",
"jsdocTagToFlowTag",
")",
";",
"var",
"returnTags",
"=",
"docAst",
".",
"tags",
".",
"filter",
"(",
"function",
"(",
"tag",
")",
"{",
"return",
"tag",
".",
"title",
"===",
"\"return\"",
"||",
"tag",
".",
"title",
"===",
"\"returns\"",
";",
"}",
")",
".",
"map",
"(",
"jsdocTagToFlowTag",
")",
";",
"var",
"propTags",
"=",
"docAst",
".",
"tags",
".",
"filter",
"(",
"function",
"(",
"tag",
")",
"{",
"return",
"tag",
".",
"title",
"===",
"\"property\"",
"||",
"tag",
".",
"title",
"===",
"\"prop\"",
";",
"}",
")",
".",
"map",
"(",
"jsdocTagToFlowTag",
")",
";",
"return",
"{",
"params",
":",
"paramTags",
",",
"returns",
":",
"returnTags",
",",
"props",
":",
"propTags",
"}",
";",
"}"
] |
Extract formatted JSDoc from a comment.
@param {String} comment The comment which may have JSDoc in it.
@return {Object} With 'params' and 'return' arrays which have 'loc', 'name'
and 'type' elements.
|
[
"Extract",
"formatted",
"JSDoc",
"from",
"a",
"comment",
"."
] |
396815eb57d861481b2bb69ce124af2624bfbbbb
|
https://github.com/Kegsay/flow-jsdoc/blob/396815eb57d861481b2bb69ce124af2624bfbbbb/index.js#L23-L46
|
train
|
Kegsay/flow-jsdoc
|
index.js
|
getCommentedFunctionNode
|
function getCommentedFunctionNode(node) {
if (!node.leadingComments) {
// JSDoc comments are always before the function, so if there is
// nothing here, we ain't interested.
return null;
}
// console.log("=================");
// console.log("type: " + node.type);
// console.log(util.inspect(node));
/*
* We handle the following function representations:
*
* Type Path to Function Example
* ==========================================================================================
* FunctionDeclaration - function foo(bar) {}
* VariableDeclaration .declarations[0].init var foo = function(bar) {}
* ExpressionStatement .expression.right ObjClass.prototype.foo = function(bar) {}
* MethodDefinition .value class ObjClass { foo(bar) {} }
* Property .value var obj = { key: function(bar) {} }
* ReturnStatement .argument return function(foo, bar) {}
* ArrowFunctionExpression - (foo, bar) => {}
* ExportNamedDeclaration .declaration export function foo(bar) {}
*
*/
var nodeTypes = [
"FunctionDeclaration", "ExpressionStatement", "VariableDeclaration",
"MethodDefinition", "Property", "ReturnStatement", "ArrowFunctionExpression",
"ExportNamedDeclaration"
];
if (nodeTypes.indexOf(node.type) === -1) {
return null;
}
var funcNode = null;
switch (node.type) {
case "FunctionDeclaration":
case "ArrowFunctionExpression":
funcNode = node;
break;
case "VariableDeclaration":
funcNode = node.declarations[0].init;
break;
case "ExpressionStatement":
funcNode = node.expression.right;
break;
case "MethodDefinition":
funcNode = node.value;
break;
case "Property":
funcNode = node.value;
break;
case "ReturnStatement":
funcNode = node.argument;
break;
case "ExportNamedDeclaration":
var declaration = node.declaration;
if (declaration.type === 'VariableDeclaration') {
funcNode = declaration.declarations[0].init;
} else {
funcNode = declaration
}
break;
}
var funcNodeTypes = ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"];
if (!funcNode || funcNodeTypes.indexOf(funcNode.type) === -1) {
// We can't find a function here which can map to leadingComments.
return null;
}
var funcDocs = null;
for (var i=0; i<node.leadingComments.length; i++) {
// Block comments are either JSDoc or flow-jsdoc specific in-inline syntax
if (node.leadingComments[i].type === "Block") {
funcDocs = extractJsdoc(node.leadingComments[i].value);
if (funcDocs) { break; }
// may be inline form with /* */
funcDocs = extractInlineAnnotations(funcNode, node.leadingComments[i].value);
if (funcDocs) {
node.leadingComments[i].update("");
break;
}
}
else if (node.leadingComments[i].type === "Line") {
// Line comments can only be flow-jsdoc specific in-line syntax.
funcDocs = extractInlineAnnotations(funcNode, node.leadingComments[i].value);
if (funcDocs) {
node.leadingComments[i].update("");
break;
}
}
}
return {
node: funcNode,
jsdoc: funcDocs
};
}
|
javascript
|
function getCommentedFunctionNode(node) {
if (!node.leadingComments) {
// JSDoc comments are always before the function, so if there is
// nothing here, we ain't interested.
return null;
}
// console.log("=================");
// console.log("type: " + node.type);
// console.log(util.inspect(node));
/*
* We handle the following function representations:
*
* Type Path to Function Example
* ==========================================================================================
* FunctionDeclaration - function foo(bar) {}
* VariableDeclaration .declarations[0].init var foo = function(bar) {}
* ExpressionStatement .expression.right ObjClass.prototype.foo = function(bar) {}
* MethodDefinition .value class ObjClass { foo(bar) {} }
* Property .value var obj = { key: function(bar) {} }
* ReturnStatement .argument return function(foo, bar) {}
* ArrowFunctionExpression - (foo, bar) => {}
* ExportNamedDeclaration .declaration export function foo(bar) {}
*
*/
var nodeTypes = [
"FunctionDeclaration", "ExpressionStatement", "VariableDeclaration",
"MethodDefinition", "Property", "ReturnStatement", "ArrowFunctionExpression",
"ExportNamedDeclaration"
];
if (nodeTypes.indexOf(node.type) === -1) {
return null;
}
var funcNode = null;
switch (node.type) {
case "FunctionDeclaration":
case "ArrowFunctionExpression":
funcNode = node;
break;
case "VariableDeclaration":
funcNode = node.declarations[0].init;
break;
case "ExpressionStatement":
funcNode = node.expression.right;
break;
case "MethodDefinition":
funcNode = node.value;
break;
case "Property":
funcNode = node.value;
break;
case "ReturnStatement":
funcNode = node.argument;
break;
case "ExportNamedDeclaration":
var declaration = node.declaration;
if (declaration.type === 'VariableDeclaration') {
funcNode = declaration.declarations[0].init;
} else {
funcNode = declaration
}
break;
}
var funcNodeTypes = ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"];
if (!funcNode || funcNodeTypes.indexOf(funcNode.type) === -1) {
// We can't find a function here which can map to leadingComments.
return null;
}
var funcDocs = null;
for (var i=0; i<node.leadingComments.length; i++) {
// Block comments are either JSDoc or flow-jsdoc specific in-inline syntax
if (node.leadingComments[i].type === "Block") {
funcDocs = extractJsdoc(node.leadingComments[i].value);
if (funcDocs) { break; }
// may be inline form with /* */
funcDocs = extractInlineAnnotations(funcNode, node.leadingComments[i].value);
if (funcDocs) {
node.leadingComments[i].update("");
break;
}
}
else if (node.leadingComments[i].type === "Line") {
// Line comments can only be flow-jsdoc specific in-line syntax.
funcDocs = extractInlineAnnotations(funcNode, node.leadingComments[i].value);
if (funcDocs) {
node.leadingComments[i].update("");
break;
}
}
}
return {
node: funcNode,
jsdoc: funcDocs
};
}
|
[
"function",
"getCommentedFunctionNode",
"(",
"node",
")",
"{",
"if",
"(",
"!",
"node",
".",
"leadingComments",
")",
"{",
"return",
"null",
";",
"}",
"var",
"nodeTypes",
"=",
"[",
"\"FunctionDeclaration\"",
",",
"\"ExpressionStatement\"",
",",
"\"VariableDeclaration\"",
",",
"\"MethodDefinition\"",
",",
"\"Property\"",
",",
"\"ReturnStatement\"",
",",
"\"ArrowFunctionExpression\"",
",",
"\"ExportNamedDeclaration\"",
"]",
";",
"if",
"(",
"nodeTypes",
".",
"indexOf",
"(",
"node",
".",
"type",
")",
"===",
"-",
"1",
")",
"{",
"return",
"null",
";",
"}",
"var",
"funcNode",
"=",
"null",
";",
"switch",
"(",
"node",
".",
"type",
")",
"{",
"case",
"\"FunctionDeclaration\"",
":",
"case",
"\"ArrowFunctionExpression\"",
":",
"funcNode",
"=",
"node",
";",
"break",
";",
"case",
"\"VariableDeclaration\"",
":",
"funcNode",
"=",
"node",
".",
"declarations",
"[",
"0",
"]",
".",
"init",
";",
"break",
";",
"case",
"\"ExpressionStatement\"",
":",
"funcNode",
"=",
"node",
".",
"expression",
".",
"right",
";",
"break",
";",
"case",
"\"MethodDefinition\"",
":",
"funcNode",
"=",
"node",
".",
"value",
";",
"break",
";",
"case",
"\"Property\"",
":",
"funcNode",
"=",
"node",
".",
"value",
";",
"break",
";",
"case",
"\"ReturnStatement\"",
":",
"funcNode",
"=",
"node",
".",
"argument",
";",
"break",
";",
"case",
"\"ExportNamedDeclaration\"",
":",
"var",
"declaration",
"=",
"node",
".",
"declaration",
";",
"if",
"(",
"declaration",
".",
"type",
"===",
"'VariableDeclaration'",
")",
"{",
"funcNode",
"=",
"declaration",
".",
"declarations",
"[",
"0",
"]",
".",
"init",
";",
"}",
"else",
"{",
"funcNode",
"=",
"declaration",
"}",
"break",
";",
"}",
"var",
"funcNodeTypes",
"=",
"[",
"\"FunctionDeclaration\"",
",",
"\"FunctionExpression\"",
",",
"\"ArrowFunctionExpression\"",
"]",
";",
"if",
"(",
"!",
"funcNode",
"||",
"funcNodeTypes",
".",
"indexOf",
"(",
"funcNode",
".",
"type",
")",
"===",
"-",
"1",
")",
"{",
"return",
"null",
";",
"}",
"var",
"funcDocs",
"=",
"null",
";",
"for",
"(",
"var",
"i",
"=",
"0",
";",
"i",
"<",
"node",
".",
"leadingComments",
".",
"length",
";",
"i",
"++",
")",
"{",
"if",
"(",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"type",
"===",
"\"Block\"",
")",
"{",
"funcDocs",
"=",
"extractJsdoc",
"(",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"value",
")",
";",
"if",
"(",
"funcDocs",
")",
"{",
"break",
";",
"}",
"funcDocs",
"=",
"extractInlineAnnotations",
"(",
"funcNode",
",",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"value",
")",
";",
"if",
"(",
"funcDocs",
")",
"{",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"update",
"(",
"\"\"",
")",
";",
"break",
";",
"}",
"}",
"else",
"if",
"(",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"type",
"===",
"\"Line\"",
")",
"{",
"funcDocs",
"=",
"extractInlineAnnotations",
"(",
"funcNode",
",",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"value",
")",
";",
"if",
"(",
"funcDocs",
")",
"{",
"node",
".",
"leadingComments",
"[",
"i",
"]",
".",
"update",
"(",
"\"\"",
")",
";",
"break",
";",
"}",
"}",
"}",
"return",
"{",
"node",
":",
"funcNode",
",",
"jsdoc",
":",
"funcDocs",
"}",
";",
"}"
] |
Retrieve a function node along with parsed JSDoc comments for it.
@param {Node} node The node to inspect.
@return {?Object} An object with "jsdoc" and "node" keys, or null.
|
[
"Retrieve",
"a",
"function",
"node",
"along",
"with",
"parsed",
"JSDoc",
"comments",
"for",
"it",
"."
] |
396815eb57d861481b2bb69ce124af2624bfbbbb
|
https://github.com/Kegsay/flow-jsdoc/blob/396815eb57d861481b2bb69ce124af2624bfbbbb/index.js#L155-L249
|
train
|
Kegsay/flow-jsdoc
|
index.js
|
decorateClasses
|
function decorateClasses(node) {
// check for class nodes
var clsNode = getCommentedClassNode(node);
if (!clsNode || !clsNode.jsdoc || clsNode.jsdoc.props.length === 0) {
return;
}
var clsSrc = clsNode.node.source();
if (clsSrc[0] !== "{") {
// something isn't right, bail.
return;
}
// work out line endings (find first \n and see if it has \r before it)
var nl = "\n";
var newlineIndex = clsSrc.indexOf("\n");
if (clsSrc[newlineIndex-1] === "\r") {
nl = "\r\n";
}
// use the same indent as the next non-blank line
var indent = "";
var lines = clsSrc.split(nl);
for (var i = 1; i < lines.length; i++) { //i=1 to skip the starting {
if (lines[i].length > 0) {
var whitespaceMatch = /^[ \t]+/.exec(lines[i]); // match spaces or tabs
if (whitespaceMatch) {
indent = whitespaceMatch[0];
break;
}
}
}
// work out what to inject into the class definition
var fieldTypeDecls = clsNode.jsdoc.props.map(function(p) {
return indent + p.name + ": " + p.type + ";";
}).join(nl);
clsNode.node.update("{" + nl + fieldTypeDecls + clsSrc.substr(1));
}
|
javascript
|
function decorateClasses(node) {
// check for class nodes
var clsNode = getCommentedClassNode(node);
if (!clsNode || !clsNode.jsdoc || clsNode.jsdoc.props.length === 0) {
return;
}
var clsSrc = clsNode.node.source();
if (clsSrc[0] !== "{") {
// something isn't right, bail.
return;
}
// work out line endings (find first \n and see if it has \r before it)
var nl = "\n";
var newlineIndex = clsSrc.indexOf("\n");
if (clsSrc[newlineIndex-1] === "\r") {
nl = "\r\n";
}
// use the same indent as the next non-blank line
var indent = "";
var lines = clsSrc.split(nl);
for (var i = 1; i < lines.length; i++) { //i=1 to skip the starting {
if (lines[i].length > 0) {
var whitespaceMatch = /^[ \t]+/.exec(lines[i]); // match spaces or tabs
if (whitespaceMatch) {
indent = whitespaceMatch[0];
break;
}
}
}
// work out what to inject into the class definition
var fieldTypeDecls = clsNode.jsdoc.props.map(function(p) {
return indent + p.name + ": " + p.type + ";";
}).join(nl);
clsNode.node.update("{" + nl + fieldTypeDecls + clsSrc.substr(1));
}
|
[
"function",
"decorateClasses",
"(",
"node",
")",
"{",
"var",
"clsNode",
"=",
"getCommentedClassNode",
"(",
"node",
")",
";",
"if",
"(",
"!",
"clsNode",
"||",
"!",
"clsNode",
".",
"jsdoc",
"||",
"clsNode",
".",
"jsdoc",
".",
"props",
".",
"length",
"===",
"0",
")",
"{",
"return",
";",
"}",
"var",
"clsSrc",
"=",
"clsNode",
".",
"node",
".",
"source",
"(",
")",
";",
"if",
"(",
"clsSrc",
"[",
"0",
"]",
"!==",
"\"{\"",
")",
"{",
"return",
";",
"}",
"var",
"nl",
"=",
"\"\\n\"",
";",
"\\n",
"var",
"newlineIndex",
"=",
"clsSrc",
".",
"indexOf",
"(",
"\"\\n\"",
")",
";",
"\\n",
"if",
"(",
"clsSrc",
"[",
"newlineIndex",
"-",
"1",
"]",
"===",
"\"\\r\"",
")",
"\\r",
"{",
"nl",
"=",
"\"\\r\\n\"",
";",
"}",
"\\r",
"\\n",
"}"
] |
Modify ES6 classes by adding 'field declarations' to them if the constructor has JSDoc.
|
[
"Modify",
"ES6",
"classes",
"by",
"adding",
"field",
"declarations",
"to",
"them",
"if",
"the",
"constructor",
"has",
"JSDoc",
"."
] |
396815eb57d861481b2bb69ce124af2624bfbbbb
|
https://github.com/Kegsay/flow-jsdoc/blob/396815eb57d861481b2bb69ce124af2624bfbbbb/index.js#L360-L399
|
train
|
neiker/analytics-react-native
|
src/helpers/validate.js
|
validate
|
function validate(message, type) {
assert(
typeOf(message) === 'object',
'You must pass a message object.',
);
rules.forEach((rule) => {
if (message[rule.name]) {
const types = [].concat(rule.types);
assert(
types.some(t => typeOf(message[rule.name]) === t),
`"${rule.name}" must be ${types.join(' or ')}.`,
);
}
});
if (asserts[type]) {
asserts[type](message);
} else {
throw new TypeError('Invalid event type');
}
}
|
javascript
|
function validate(message, type) {
assert(
typeOf(message) === 'object',
'You must pass a message object.',
);
rules.forEach((rule) => {
if (message[rule.name]) {
const types = [].concat(rule.types);
assert(
types.some(t => typeOf(message[rule.name]) === t),
`"${rule.name}" must be ${types.join(' or ')}.`,
);
}
});
if (asserts[type]) {
asserts[type](message);
} else {
throw new TypeError('Invalid event type');
}
}
|
[
"function",
"validate",
"(",
"message",
",",
"type",
")",
"{",
"assert",
"(",
"typeOf",
"(",
"message",
")",
"===",
"'object'",
",",
"'You must pass a message object.'",
",",
")",
";",
"rules",
".",
"forEach",
"(",
"(",
"rule",
")",
"=>",
"{",
"if",
"(",
"message",
"[",
"rule",
".",
"name",
"]",
")",
"{",
"const",
"types",
"=",
"[",
"]",
".",
"concat",
"(",
"rule",
".",
"types",
")",
";",
"assert",
"(",
"types",
".",
"some",
"(",
"t",
"=>",
"typeOf",
"(",
"message",
"[",
"rule",
".",
"name",
"]",
")",
"===",
"t",
")",
",",
"`",
"${",
"rule",
".",
"name",
"}",
"${",
"types",
".",
"join",
"(",
"' or '",
")",
"}",
"`",
",",
")",
";",
"}",
"}",
")",
";",
"if",
"(",
"asserts",
"[",
"type",
"]",
")",
"{",
"asserts",
"[",
"type",
"]",
"(",
"message",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"TypeError",
"(",
"'Invalid event type'",
")",
";",
"}",
"}"
] |
Validate an options `obj`.
@param {Object} obj
|
[
"Validate",
"an",
"options",
"obj",
"."
] |
2c8d21467ead81eb726e5bc185ec9c72355ab121
|
https://github.com/neiker/analytics-react-native/blob/2c8d21467ead81eb726e5bc185ec9c72355ab121/src/helpers/validate.js#L108-L130
|
train
|
gonzalocasas/node-proxy-middleware
|
index.js
|
merge
|
function merge(src1, src2) {
var merged = {};
extend(merged, src1);
extend(merged, src2);
return merged;
}
|
javascript
|
function merge(src1, src2) {
var merged = {};
extend(merged, src1);
extend(merged, src2);
return merged;
}
|
[
"function",
"merge",
"(",
"src1",
",",
"src2",
")",
"{",
"var",
"merged",
"=",
"{",
"}",
";",
"extend",
"(",
"merged",
",",
"src1",
")",
";",
"extend",
"(",
"merged",
",",
"src2",
")",
";",
"return",
"merged",
";",
"}"
] |
merges data without changing state in either argument
|
[
"merges",
"data",
"without",
"changing",
"state",
"in",
"either",
"argument"
] |
d3f462e23d4dda4483fac601649bec33735548f1
|
https://github.com/gonzalocasas/node-proxy-middleware/blob/d3f462e23d4dda4483fac601649bec33735548f1/index.js#L136-L141
|
train
|
MikeRalphson/bbcparse
|
iblApi/ibl.js
|
getChannelsSchedule
|
function getChannelsSchedule(channel,date){
var p = '/ibl/v1/channels/{channel}/schedule/{date}';
p = p.replace('{channel}',channel);
p = p.replace('{date}',date);
return p;
}
|
javascript
|
function getChannelsSchedule(channel,date){
var p = '/ibl/v1/channels/{channel}/schedule/{date}';
p = p.replace('{channel}',channel);
p = p.replace('{date}',date);
return p;
}
|
[
"function",
"getChannelsSchedule",
"(",
"channel",
",",
"date",
")",
"{",
"var",
"p",
"=",
"'/ibl/v1/channels/{channel}/schedule/{date}'",
";",
"p",
"=",
"p",
".",
"replace",
"(",
"'{channel}'",
",",
"channel",
")",
";",
"p",
"=",
"p",
".",
"replace",
"(",
"'{date}'",
",",
"date",
")",
";",
"return",
"p",
";",
"}"
] |
Get schedule by channel
@param {string} channel The channel identifier to limit results to.
@param {string} date The date to return the schedule for, yyyy-mm-dd format
@return {string} The path to request
|
[
"Get",
"schedule",
"by",
"channel"
] |
785e0c2807c2d189c9c8779f7ac3f9b6f603bb57
|
https://github.com/MikeRalphson/bbcparse/blob/785e0c2807c2d189c9c8779f7ac3f9b6f603bb57/iblApi/ibl.js#L134-L139
|
train
|
canjs/can-connect
|
helpers/validate.js
|
BehaviorInterfaceError
|
function BehaviorInterfaceError(baseBehavior, extendingBehavior, missingProps) {
var extendingName = extendingBehavior.behaviorName || 'anonymous behavior',
baseName = baseBehavior.__behaviorName || 'anonymous behavior',
message = 'can-connect: Extending behavior "' + extendingName + '" found base behavior "' + baseName
+ '" was missing required properties: ' + JSON.stringify(missingProps.related),
instance = new Error(message);
if (Object.setPrototypeOf){
Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
}
return instance;
}
|
javascript
|
function BehaviorInterfaceError(baseBehavior, extendingBehavior, missingProps) {
var extendingName = extendingBehavior.behaviorName || 'anonymous behavior',
baseName = baseBehavior.__behaviorName || 'anonymous behavior',
message = 'can-connect: Extending behavior "' + extendingName + '" found base behavior "' + baseName
+ '" was missing required properties: ' + JSON.stringify(missingProps.related),
instance = new Error(message);
if (Object.setPrototypeOf){
Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
}
return instance;
}
|
[
"function",
"BehaviorInterfaceError",
"(",
"baseBehavior",
",",
"extendingBehavior",
",",
"missingProps",
")",
"{",
"var",
"extendingName",
"=",
"extendingBehavior",
".",
"behaviorName",
"||",
"'anonymous behavior'",
",",
"baseName",
"=",
"baseBehavior",
".",
"__behaviorName",
"||",
"'anonymous behavior'",
",",
"message",
"=",
"'can-connect: Extending behavior \"'",
"+",
"extendingName",
"+",
"'\" found base behavior \"'",
"+",
"baseName",
"+",
"'\" was missing required properties: '",
"+",
"JSON",
".",
"stringify",
"(",
"missingProps",
".",
"related",
")",
",",
"instance",
"=",
"new",
"Error",
"(",
"message",
")",
";",
"if",
"(",
"Object",
".",
"setPrototypeOf",
")",
"{",
"Object",
".",
"setPrototypeOf",
"(",
"instance",
",",
"Object",
".",
"getPrototypeOf",
"(",
"this",
")",
")",
";",
"}",
"return",
"instance",
";",
"}"
] |
change to 'BehaviourInterfaceError extends Error' once we drop support for pre-ES2015
|
[
"change",
"to",
"BehaviourInterfaceError",
"extends",
"Error",
"once",
"we",
"drop",
"support",
"for",
"pre",
"-",
"ES2015"
] |
513064178e1b229349cc219949aa69380c871a52
|
https://github.com/canjs/can-connect/blob/513064178e1b229349cc219949aa69380c871a52/helpers/validate.js#L35-L46
|
train
|
silklabs/silk
|
docs/examples/hid/hid.js
|
enableHID
|
async function enableHID() {
const usbConfig = getstrprop('sys.usb.state');
if (!usbConfig.startsWith('hid,')) {
log.warn('HID function does not seem to be enabled.');
const usbConfigWithHid = `hid,${usbConfig}`;
log.info(`changing USB config to ${usbConfigWithHid}`);
// WARNING! If this device is not Kenzo or this otherwise fails, it's likely
// that adb access will be lost until the next reboot
setprop('sys.usb.config', usbConfigWithHid);
// Wait for USB to be reconfigured.
await sleep(1000);
const newUsbConfig = getstrprop('sys.usb.state');
if (newUsbConfig !== usbConfigWithHid) {
throw new Error(`USB config expected to be ${usbConfigWithHid}, but it was ${newUsbConfig}`);
}
}
// Ensure the two HID devices are present
Promise.all(
['/dev/hidg0', '/dev/hidg1'].map(
file => fs.access(file, fs.constants.R_OK | fs.constants.W_OK)
)
);
}
|
javascript
|
async function enableHID() {
const usbConfig = getstrprop('sys.usb.state');
if (!usbConfig.startsWith('hid,')) {
log.warn('HID function does not seem to be enabled.');
const usbConfigWithHid = `hid,${usbConfig}`;
log.info(`changing USB config to ${usbConfigWithHid}`);
// WARNING! If this device is not Kenzo or this otherwise fails, it's likely
// that adb access will be lost until the next reboot
setprop('sys.usb.config', usbConfigWithHid);
// Wait for USB to be reconfigured.
await sleep(1000);
const newUsbConfig = getstrprop('sys.usb.state');
if (newUsbConfig !== usbConfigWithHid) {
throw new Error(`USB config expected to be ${usbConfigWithHid}, but it was ${newUsbConfig}`);
}
}
// Ensure the two HID devices are present
Promise.all(
['/dev/hidg0', '/dev/hidg1'].map(
file => fs.access(file, fs.constants.R_OK | fs.constants.W_OK)
)
);
}
|
[
"async",
"function",
"enableHID",
"(",
")",
"{",
"const",
"usbConfig",
"=",
"getstrprop",
"(",
"'sys.usb.state'",
")",
";",
"if",
"(",
"!",
"usbConfig",
".",
"startsWith",
"(",
"'hid,'",
")",
")",
"{",
"log",
".",
"warn",
"(",
"'HID function does not seem to be enabled.'",
")",
";",
"const",
"usbConfigWithHid",
"=",
"`",
"${",
"usbConfig",
"}",
"`",
";",
"log",
".",
"info",
"(",
"`",
"${",
"usbConfigWithHid",
"}",
"`",
")",
";",
"setprop",
"(",
"'sys.usb.config'",
",",
"usbConfigWithHid",
")",
";",
"await",
"sleep",
"(",
"1000",
")",
";",
"const",
"newUsbConfig",
"=",
"getstrprop",
"(",
"'sys.usb.state'",
")",
";",
"if",
"(",
"newUsbConfig",
"!==",
"usbConfigWithHid",
")",
"{",
"throw",
"new",
"Error",
"(",
"`",
"${",
"usbConfigWithHid",
"}",
"${",
"newUsbConfig",
"}",
"`",
")",
";",
"}",
"}",
"Promise",
".",
"all",
"(",
"[",
"'/dev/hidg0'",
",",
"'/dev/hidg1'",
"]",
".",
"map",
"(",
"file",
"=>",
"fs",
".",
"access",
"(",
"file",
",",
"fs",
".",
"constants",
".",
"R_OK",
"|",
"fs",
".",
"constants",
".",
"W_OK",
")",
")",
")",
";",
"}"
] |
Ensures the HID function in the USB Android gadget driver is active
|
[
"Ensures",
"the",
"HID",
"function",
"in",
"the",
"USB",
"Android",
"gadget",
"driver",
"is",
"active"
] |
08c273949086350aeddd8e23e92f0f79243f446f
|
https://github.com/silklabs/silk/blob/08c273949086350aeddd8e23e92f0f79243f446f/docs/examples/hid/hid.js#L14-L40
|
train
|
silklabs/silk
|
sdk/src/cli.js
|
ensureSetup
|
function ensureSetup(argv) {
const root = findPackageRoot();
const emulatorBin = path.join(root, 'node_modules/silk-sdk-emulator/vendor/bin');
// Additional paths to search for outside of PATH.
const additionalPaths = [];
if (fs.existsSync(emulatorBin)) {
additionalPaths.push(emulatorBin);
}
argv.arguments = argv.arguments || [];
argv.arguments = [
[['--device', '-d'], {
help: 'Specific device to operate under.',
}],
...argv.arguments,
];
const main = argv.main;
argv.main = function (args) {
const {device} = args;
const api = new SDKApi({
device: device,
additionalPaths: additionalPaths,
});
return main(api, args);
};
return argv;
}
|
javascript
|
function ensureSetup(argv) {
const root = findPackageRoot();
const emulatorBin = path.join(root, 'node_modules/silk-sdk-emulator/vendor/bin');
// Additional paths to search for outside of PATH.
const additionalPaths = [];
if (fs.existsSync(emulatorBin)) {
additionalPaths.push(emulatorBin);
}
argv.arguments = argv.arguments || [];
argv.arguments = [
[['--device', '-d'], {
help: 'Specific device to operate under.',
}],
...argv.arguments,
];
const main = argv.main;
argv.main = function (args) {
const {device} = args;
const api = new SDKApi({
device: device,
additionalPaths: additionalPaths,
});
return main(api, args);
};
return argv;
}
|
[
"function",
"ensureSetup",
"(",
"argv",
")",
"{",
"const",
"root",
"=",
"findPackageRoot",
"(",
")",
";",
"const",
"emulatorBin",
"=",
"path",
".",
"join",
"(",
"root",
",",
"'node_modules/silk-sdk-emulator/vendor/bin'",
")",
";",
"const",
"additionalPaths",
"=",
"[",
"]",
";",
"if",
"(",
"fs",
".",
"existsSync",
"(",
"emulatorBin",
")",
")",
"{",
"additionalPaths",
".",
"push",
"(",
"emulatorBin",
")",
";",
"}",
"argv",
".",
"arguments",
"=",
"argv",
".",
"arguments",
"||",
"[",
"]",
";",
"argv",
".",
"arguments",
"=",
"[",
"[",
"[",
"'--device'",
",",
"'-d'",
"]",
",",
"{",
"help",
":",
"'Specific device to operate under.'",
",",
"}",
"]",
",",
"...",
"argv",
".",
"arguments",
",",
"]",
";",
"const",
"main",
"=",
"argv",
".",
"main",
";",
"argv",
".",
"main",
"=",
"function",
"(",
"args",
")",
"{",
"const",
"{",
"device",
"}",
"=",
"args",
";",
"const",
"api",
"=",
"new",
"SDKApi",
"(",
"{",
"device",
":",
"device",
",",
"additionalPaths",
":",
"additionalPaths",
",",
"}",
")",
";",
"return",
"main",
"(",
"api",
",",
"args",
")",
";",
"}",
";",
"return",
"argv",
";",
"}"
] |
This function is run from every cli call to ensure the enviornment is
correctly setup.
|
[
"This",
"function",
"is",
"run",
"from",
"every",
"cli",
"call",
"to",
"ensure",
"the",
"enviornment",
"is",
"correctly",
"setup",
"."
] |
08c273949086350aeddd8e23e92f0f79243f446f
|
https://github.com/silklabs/silk/blob/08c273949086350aeddd8e23e92f0f79243f446f/sdk/src/cli.js#L84-L115
|
train
|
mdasberg/grunt-karma-sonar
|
install.js
|
fetchCdnVersion
|
function fetchCdnVersion(cdnUrl) {
var fullUrl = cdnUrl + path.sep + SONAR_RUNNER_DIST;
console.log('Fetching sonar-runner from CDN url [' + fullUrl + '].');
try {
var response = request('GET', fullUrl);
if(response.statusCode === 200) {
var destination = path.join('.tmp', SONAR_RUNNER_DIST);
fs.mkdirsSync('.tmp', '0775');
fs.writeFileSync(destination, response.getBody(), {replace: true});
return destination;
} else if(response.statusCode === 404) {
console.error('Could not find '+ SONAR_RUNNER_DIST + ' on the specified CDN url[' + fullUrl +'].');
} else {
console.error('Something went wrong while fetching '+ SONAR_RUNNER_DIST + ' on the specified CDN url[' + fullUrl +'], statusCode [' + response.statusCode + '] was received.');
}
} catch (e) {
console.error('Could not connect to CDN url[' + cdnUrl +'], received message [' + e + ']');
}
}
|
javascript
|
function fetchCdnVersion(cdnUrl) {
var fullUrl = cdnUrl + path.sep + SONAR_RUNNER_DIST;
console.log('Fetching sonar-runner from CDN url [' + fullUrl + '].');
try {
var response = request('GET', fullUrl);
if(response.statusCode === 200) {
var destination = path.join('.tmp', SONAR_RUNNER_DIST);
fs.mkdirsSync('.tmp', '0775');
fs.writeFileSync(destination, response.getBody(), {replace: true});
return destination;
} else if(response.statusCode === 404) {
console.error('Could not find '+ SONAR_RUNNER_DIST + ' on the specified CDN url[' + fullUrl +'].');
} else {
console.error('Something went wrong while fetching '+ SONAR_RUNNER_DIST + ' on the specified CDN url[' + fullUrl +'], statusCode [' + response.statusCode + '] was received.');
}
} catch (e) {
console.error('Could not connect to CDN url[' + cdnUrl +'], received message [' + e + ']');
}
}
|
[
"function",
"fetchCdnVersion",
"(",
"cdnUrl",
")",
"{",
"var",
"fullUrl",
"=",
"cdnUrl",
"+",
"path",
".",
"sep",
"+",
"SONAR_RUNNER_DIST",
";",
"console",
".",
"log",
"(",
"'Fetching sonar-runner from CDN url ['",
"+",
"fullUrl",
"+",
"'].'",
")",
";",
"try",
"{",
"var",
"response",
"=",
"request",
"(",
"'GET'",
",",
"fullUrl",
")",
";",
"if",
"(",
"response",
".",
"statusCode",
"===",
"200",
")",
"{",
"var",
"destination",
"=",
"path",
".",
"join",
"(",
"'.tmp'",
",",
"SONAR_RUNNER_DIST",
")",
";",
"fs",
".",
"mkdirsSync",
"(",
"'.tmp'",
",",
"'0775'",
")",
";",
"fs",
".",
"writeFileSync",
"(",
"destination",
",",
"response",
".",
"getBody",
"(",
")",
",",
"{",
"replace",
":",
"true",
"}",
")",
";",
"return",
"destination",
";",
"}",
"else",
"if",
"(",
"response",
".",
"statusCode",
"===",
"404",
")",
"{",
"console",
".",
"error",
"(",
"'Could not find '",
"+",
"SONAR_RUNNER_DIST",
"+",
"' on the specified CDN url['",
"+",
"fullUrl",
"+",
"'].'",
")",
";",
"}",
"else",
"{",
"console",
".",
"error",
"(",
"'Something went wrong while fetching '",
"+",
"SONAR_RUNNER_DIST",
"+",
"' on the specified CDN url['",
"+",
"fullUrl",
"+",
"'], statusCode ['",
"+",
"response",
".",
"statusCode",
"+",
"'] was received.'",
")",
";",
"}",
"}",
"catch",
"(",
"e",
")",
"{",
"console",
".",
"error",
"(",
"'Could not connect to CDN url['",
"+",
"cdnUrl",
"+",
"'], received message ['",
"+",
"e",
"+",
"']'",
")",
";",
"}",
"}"
] |
Fetch the cdn release of sonar-runner from nexus.
@param cdnDir The cdn url.
@return destination The location where the cdn sonar-runner is copied to.
|
[
"Fetch",
"the",
"cdn",
"release",
"of",
"sonar",
"-",
"runner",
"from",
"nexus",
"."
] |
6b632d3cfdda05eee37165ea87531f1171a10117
|
https://github.com/mdasberg/grunt-karma-sonar/blob/6b632d3cfdda05eee37165ea87531f1171a10117/install.js#L119-L137
|
train
|
mdasberg/grunt-karma-sonar
|
tasks/sonar.js
|
copyFiles
|
function copyFiles(g, defaultOutputDir, targetDir) {
var files = glob.sync(g.src.toString(), {cwd: g.cwd, root: '/'});
files.forEach(function (file) {
var destinationDirectory = defaultOutputDir + path.sep + targetDir;
var fileDirectory = path.dirname(file);
if (fileDirectory !== '.') {
destinationDirectory = destinationDirectory + path.sep + fileDirectory;
}
fs.mkdirpSync(destinationDirectory);
var source = path.resolve(g.cwd, file);
var extension = path.extname(file);
var destination;
if (targetDir === 'test') {
var base = path.basename(file, extension);
if (extension === '.js') {
destination = destinationDirectory + path.sep + path.basename(base.replace(/\./g, '_') + extension);
} else if (extension === '.feature') {
destination = destinationDirectory + path.sep + path.basename(base.concat(extension).replace(/\./g, '_') + '.js');
}
} else {
destination = destinationDirectory + path.sep + path.basename(file);
}
fs.copySync(source, destination, {replace: true});
});
}
|
javascript
|
function copyFiles(g, defaultOutputDir, targetDir) {
var files = glob.sync(g.src.toString(), {cwd: g.cwd, root: '/'});
files.forEach(function (file) {
var destinationDirectory = defaultOutputDir + path.sep + targetDir;
var fileDirectory = path.dirname(file);
if (fileDirectory !== '.') {
destinationDirectory = destinationDirectory + path.sep + fileDirectory;
}
fs.mkdirpSync(destinationDirectory);
var source = path.resolve(g.cwd, file);
var extension = path.extname(file);
var destination;
if (targetDir === 'test') {
var base = path.basename(file, extension);
if (extension === '.js') {
destination = destinationDirectory + path.sep + path.basename(base.replace(/\./g, '_') + extension);
} else if (extension === '.feature') {
destination = destinationDirectory + path.sep + path.basename(base.concat(extension).replace(/\./g, '_') + '.js');
}
} else {
destination = destinationDirectory + path.sep + path.basename(file);
}
fs.copySync(source, destination, {replace: true});
});
}
|
[
"function",
"copyFiles",
"(",
"g",
",",
"defaultOutputDir",
",",
"targetDir",
")",
"{",
"var",
"files",
"=",
"glob",
".",
"sync",
"(",
"g",
".",
"src",
".",
"toString",
"(",
")",
",",
"{",
"cwd",
":",
"g",
".",
"cwd",
",",
"root",
":",
"'/'",
"}",
")",
";",
"files",
".",
"forEach",
"(",
"function",
"(",
"file",
")",
"{",
"var",
"destinationDirectory",
"=",
"defaultOutputDir",
"+",
"path",
".",
"sep",
"+",
"targetDir",
";",
"var",
"fileDirectory",
"=",
"path",
".",
"dirname",
"(",
"file",
")",
";",
"if",
"(",
"fileDirectory",
"!==",
"'.'",
")",
"{",
"destinationDirectory",
"=",
"destinationDirectory",
"+",
"path",
".",
"sep",
"+",
"fileDirectory",
";",
"}",
"fs",
".",
"mkdirpSync",
"(",
"destinationDirectory",
")",
";",
"var",
"source",
"=",
"path",
".",
"resolve",
"(",
"g",
".",
"cwd",
",",
"file",
")",
";",
"var",
"extension",
"=",
"path",
".",
"extname",
"(",
"file",
")",
";",
"var",
"destination",
";",
"if",
"(",
"targetDir",
"===",
"'test'",
")",
"{",
"var",
"base",
"=",
"path",
".",
"basename",
"(",
"file",
",",
"extension",
")",
";",
"if",
"(",
"extension",
"===",
"'.js'",
")",
"{",
"destination",
"=",
"destinationDirectory",
"+",
"path",
".",
"sep",
"+",
"path",
".",
"basename",
"(",
"base",
".",
"replace",
"(",
"/",
"\\.",
"/",
"g",
",",
"'_'",
")",
"+",
"extension",
")",
";",
"}",
"else",
"if",
"(",
"extension",
"===",
"'.feature'",
")",
"{",
"destination",
"=",
"destinationDirectory",
"+",
"path",
".",
"sep",
"+",
"path",
".",
"basename",
"(",
"base",
".",
"concat",
"(",
"extension",
")",
".",
"replace",
"(",
"/",
"\\.",
"/",
"g",
",",
"'_'",
")",
"+",
"'.js'",
")",
";",
"}",
"}",
"else",
"{",
"destination",
"=",
"destinationDirectory",
"+",
"path",
".",
"sep",
"+",
"path",
".",
"basename",
"(",
"file",
")",
";",
"}",
"fs",
".",
"copySync",
"(",
"source",
",",
"destination",
",",
"{",
"replace",
":",
"true",
"}",
")",
";",
"}",
")",
";",
"}"
] |
Copy files to the temp directory.
@param g The glob.
|
[
"Copy",
"files",
"to",
"the",
"temp",
"directory",
"."
] |
6b632d3cfdda05eee37165ea87531f1171a10117
|
https://github.com/mdasberg/grunt-karma-sonar/blob/6b632d3cfdda05eee37165ea87531f1171a10117/tasks/sonar.js#L27-L52
|
train
|
mdasberg/grunt-karma-sonar
|
tasks/sonar.js
|
mergeJson
|
function mergeJson(original, override) {
return _.merge(original, override, function (a, b, key, aParent, bParent) {
if (_.isUndefined(b)) {
aParent[key] = undefined;
return;
}
});
}
|
javascript
|
function mergeJson(original, override) {
return _.merge(original, override, function (a, b, key, aParent, bParent) {
if (_.isUndefined(b)) {
aParent[key] = undefined;
return;
}
});
}
|
[
"function",
"mergeJson",
"(",
"original",
",",
"override",
")",
"{",
"return",
"_",
".",
"merge",
"(",
"original",
",",
"override",
",",
"function",
"(",
"a",
",",
"b",
",",
"key",
",",
"aParent",
",",
"bParent",
")",
"{",
"if",
"(",
"_",
".",
"isUndefined",
"(",
"b",
")",
")",
"{",
"aParent",
"[",
"key",
"]",
"=",
"undefined",
";",
"return",
";",
"}",
"}",
")",
";",
"}"
] |
Deep merge json objects.
@param original The original object.
@param override The override object.
@return merged The merged object.
|
[
"Deep",
"merge",
"json",
"objects",
"."
] |
6b632d3cfdda05eee37165ea87531f1171a10117
|
https://github.com/mdasberg/grunt-karma-sonar/blob/6b632d3cfdda05eee37165ea87531f1171a10117/tasks/sonar.js#L60-L67
|
train
|
mdasberg/grunt-karma-sonar
|
tasks/sonar.js
|
buildArgs
|
function buildArgs(sonarOptions, data) {
// Default arguments
var args = [
'-Dsonar.sources=src',
'-Dsonar.tests=test',
'-Dsonar.javascript.jstestdriver.reportsPath=results',
'-Dsonar.genericcoverage.unitTestReportPaths=' + 'results' + path.sep + 'TESTS-junit.xml',
'-Dsonar.javascript.jstestdriver.itReportsPath=results',
'-Dsonar.javascript.lcov.reportPaths=' + 'results' + path.sep + 'coverage_report.lcov' + ',' + 'results' + path.sep + 'it_coverage_report.lcov',
'-Dsonar.javascript.lcov.reportPath=' + 'results' + path.sep + 'coverage_report.lcov',
'-Dsonar.javascript.lcov.itReportPath=' + 'results' + path.sep + 'it_coverage_report.lcov'
];
// Add the parameter (-D) only when the 'key' exists in the 'object'
function addParameter(prop, object, key) {
var value = _.result(object, key);
if (value !== undefined && value !== null && sonarOptions.excludedProperties.indexOf(prop) === -1) {
args.push('-D' + prop + '=' + value);
}
}
addParameter('sonar.host.url', sonarOptions.instance, 'hostUrl');
addParameter('sonar.jdbc.url', sonarOptions.instance, 'jdbcUrl');
addParameter('sonar.jdbc.username', sonarOptions.instance, 'jdbcUsername');
addParameter('sonar.jdbc.password', sonarOptions.instance, 'jdbcPassword');
addParameter('sonar.login', sonarOptions.instance, 'login');
addParameter('sonar.password', sonarOptions.instance, 'password');
addParameter('sonar.sourceEncoding', sonarOptions, 'sourceEncoding');
addParameter('sonar.language', sonarOptions, 'language');
addParameter('sonar.dynamicAnalysis', sonarOptions, 'dynamicAnalysis');
addParameter('sonar.projectBaseDir', sonarOptions, 'defaultOutputDir');
addParameter('sonar.scm.disabled', sonarOptions, 'scmDisabled');
addParameter('sonar.projectKey', data.project, 'key');
addParameter('sonar.projectName', data.project, 'name');
addParameter('sonar.projectVersion', data.project, 'version');
addParameter('sonar.exclusions', data, 'exclusions');
return args;
}
|
javascript
|
function buildArgs(sonarOptions, data) {
// Default arguments
var args = [
'-Dsonar.sources=src',
'-Dsonar.tests=test',
'-Dsonar.javascript.jstestdriver.reportsPath=results',
'-Dsonar.genericcoverage.unitTestReportPaths=' + 'results' + path.sep + 'TESTS-junit.xml',
'-Dsonar.javascript.jstestdriver.itReportsPath=results',
'-Dsonar.javascript.lcov.reportPaths=' + 'results' + path.sep + 'coverage_report.lcov' + ',' + 'results' + path.sep + 'it_coverage_report.lcov',
'-Dsonar.javascript.lcov.reportPath=' + 'results' + path.sep + 'coverage_report.lcov',
'-Dsonar.javascript.lcov.itReportPath=' + 'results' + path.sep + 'it_coverage_report.lcov'
];
// Add the parameter (-D) only when the 'key' exists in the 'object'
function addParameter(prop, object, key) {
var value = _.result(object, key);
if (value !== undefined && value !== null && sonarOptions.excludedProperties.indexOf(prop) === -1) {
args.push('-D' + prop + '=' + value);
}
}
addParameter('sonar.host.url', sonarOptions.instance, 'hostUrl');
addParameter('sonar.jdbc.url', sonarOptions.instance, 'jdbcUrl');
addParameter('sonar.jdbc.username', sonarOptions.instance, 'jdbcUsername');
addParameter('sonar.jdbc.password', sonarOptions.instance, 'jdbcPassword');
addParameter('sonar.login', sonarOptions.instance, 'login');
addParameter('sonar.password', sonarOptions.instance, 'password');
addParameter('sonar.sourceEncoding', sonarOptions, 'sourceEncoding');
addParameter('sonar.language', sonarOptions, 'language');
addParameter('sonar.dynamicAnalysis', sonarOptions, 'dynamicAnalysis');
addParameter('sonar.projectBaseDir', sonarOptions, 'defaultOutputDir');
addParameter('sonar.scm.disabled', sonarOptions, 'scmDisabled');
addParameter('sonar.projectKey', data.project, 'key');
addParameter('sonar.projectName', data.project, 'name');
addParameter('sonar.projectVersion', data.project, 'version');
addParameter('sonar.exclusions', data, 'exclusions');
return args;
}
|
[
"function",
"buildArgs",
"(",
"sonarOptions",
",",
"data",
")",
"{",
"var",
"args",
"=",
"[",
"'-Dsonar.sources=src'",
",",
"'-Dsonar.tests=test'",
",",
"'-Dsonar.javascript.jstestdriver.reportsPath=results'",
",",
"'-Dsonar.genericcoverage.unitTestReportPaths='",
"+",
"'results'",
"+",
"path",
".",
"sep",
"+",
"'TESTS-junit.xml'",
",",
"'-Dsonar.javascript.jstestdriver.itReportsPath=results'",
",",
"'-Dsonar.javascript.lcov.reportPaths='",
"+",
"'results'",
"+",
"path",
".",
"sep",
"+",
"'coverage_report.lcov'",
"+",
"','",
"+",
"'results'",
"+",
"path",
".",
"sep",
"+",
"'it_coverage_report.lcov'",
",",
"'-Dsonar.javascript.lcov.reportPath='",
"+",
"'results'",
"+",
"path",
".",
"sep",
"+",
"'coverage_report.lcov'",
",",
"'-Dsonar.javascript.lcov.itReportPath='",
"+",
"'results'",
"+",
"path",
".",
"sep",
"+",
"'it_coverage_report.lcov'",
"]",
";",
"function",
"addParameter",
"(",
"prop",
",",
"object",
",",
"key",
")",
"{",
"var",
"value",
"=",
"_",
".",
"result",
"(",
"object",
",",
"key",
")",
";",
"if",
"(",
"value",
"!==",
"undefined",
"&&",
"value",
"!==",
"null",
"&&",
"sonarOptions",
".",
"excludedProperties",
".",
"indexOf",
"(",
"prop",
")",
"===",
"-",
"1",
")",
"{",
"args",
".",
"push",
"(",
"'-D'",
"+",
"prop",
"+",
"'='",
"+",
"value",
")",
";",
"}",
"}",
"addParameter",
"(",
"'sonar.host.url'",
",",
"sonarOptions",
".",
"instance",
",",
"'hostUrl'",
")",
";",
"addParameter",
"(",
"'sonar.jdbc.url'",
",",
"sonarOptions",
".",
"instance",
",",
"'jdbcUrl'",
")",
";",
"addParameter",
"(",
"'sonar.jdbc.username'",
",",
"sonarOptions",
".",
"instance",
",",
"'jdbcUsername'",
")",
";",
"addParameter",
"(",
"'sonar.jdbc.password'",
",",
"sonarOptions",
".",
"instance",
",",
"'jdbcPassword'",
")",
";",
"addParameter",
"(",
"'sonar.login'",
",",
"sonarOptions",
".",
"instance",
",",
"'login'",
")",
";",
"addParameter",
"(",
"'sonar.password'",
",",
"sonarOptions",
".",
"instance",
",",
"'password'",
")",
";",
"addParameter",
"(",
"'sonar.sourceEncoding'",
",",
"sonarOptions",
",",
"'sourceEncoding'",
")",
";",
"addParameter",
"(",
"'sonar.language'",
",",
"sonarOptions",
",",
"'language'",
")",
";",
"addParameter",
"(",
"'sonar.dynamicAnalysis'",
",",
"sonarOptions",
",",
"'dynamicAnalysis'",
")",
";",
"addParameter",
"(",
"'sonar.projectBaseDir'",
",",
"sonarOptions",
",",
"'defaultOutputDir'",
")",
";",
"addParameter",
"(",
"'sonar.scm.disabled'",
",",
"sonarOptions",
",",
"'scmDisabled'",
")",
";",
"addParameter",
"(",
"'sonar.projectKey'",
",",
"data",
".",
"project",
",",
"'key'",
")",
";",
"addParameter",
"(",
"'sonar.projectName'",
",",
"data",
".",
"project",
",",
"'name'",
")",
";",
"addParameter",
"(",
"'sonar.projectVersion'",
",",
"data",
".",
"project",
",",
"'version'",
")",
";",
"addParameter",
"(",
"'sonar.exclusions'",
",",
"data",
",",
"'exclusions'",
")",
";",
"return",
"args",
";",
"}"
] |
Builds the arguments that need to be sent to sonar-runner.
@param sonarOptions The sonar options such as username, password etc.
@param data The data such as project name and project version.
@returns The array of command line options for sonar-runner.
|
[
"Builds",
"the",
"arguments",
"that",
"need",
"to",
"be",
"sent",
"to",
"sonar",
"-",
"runner",
"."
] |
6b632d3cfdda05eee37165ea87531f1171a10117
|
https://github.com/mdasberg/grunt-karma-sonar/blob/6b632d3cfdda05eee37165ea87531f1171a10117/tasks/sonar.js#L76-L116
|
train
|
jonschlinkert/template
|
lib/mixins/list.js
|
createPage
|
function createPage() {
var page = new View(view.clone(), lazy.extend({}, view.options, opts));
page.data.pagination = new Parent(lazy.extend({}, self.options, {Item: Item}));
return page;
}
|
javascript
|
function createPage() {
var page = new View(view.clone(), lazy.extend({}, view.options, opts));
page.data.pagination = new Parent(lazy.extend({}, self.options, {Item: Item}));
return page;
}
|
[
"function",
"createPage",
"(",
")",
"{",
"var",
"page",
"=",
"new",
"View",
"(",
"view",
".",
"clone",
"(",
")",
",",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"view",
".",
"options",
",",
"opts",
")",
")",
";",
"page",
".",
"data",
".",
"pagination",
"=",
"new",
"Parent",
"(",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"self",
".",
"options",
",",
"{",
"Item",
":",
"Item",
"}",
")",
")",
";",
"return",
"page",
";",
"}"
] |
helper function to create a new page to put into the returned list.
|
[
"helper",
"function",
"to",
"create",
"a",
"new",
"page",
"to",
"put",
"into",
"the",
"returned",
"list",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/list.js#L57-L61
|
train
|
jonschlinkert/template
|
lib/mixins/list.js
|
function (prop, fn) {
if (typeof prop === 'function') {
fn = prop;
prop = undefined;
}
if (typeof prop === 'undefined') {
return this.sortByKeys(fn);
}
return this.sortByItems(prop, fn);
}
|
javascript
|
function (prop, fn) {
if (typeof prop === 'function') {
fn = prop;
prop = undefined;
}
if (typeof prop === 'undefined') {
return this.sortByKeys(fn);
}
return this.sortByItems(prop, fn);
}
|
[
"function",
"(",
"prop",
",",
"fn",
")",
"{",
"if",
"(",
"typeof",
"prop",
"===",
"'function'",
")",
"{",
"fn",
"=",
"prop",
";",
"prop",
"=",
"undefined",
";",
"}",
"if",
"(",
"typeof",
"prop",
"===",
"'undefined'",
")",
"{",
"return",
"this",
".",
"sortByKeys",
"(",
"fn",
")",
";",
"}",
"return",
"this",
".",
"sortByItems",
"(",
"prop",
",",
"fn",
")",
";",
"}"
] |
Sort list items.
@param {String} `prop` Property to sort by, undefined to sort by keys.
@param {Function} `fn` Optional getter function to get items by.
@return {Object} Returns current instance to enable chaining
@api public
|
[
"Sort",
"list",
"items",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/list.js#L108-L118
|
train
|
|
jonschlinkert/template
|
lib/mixins/list.js
|
function (fn) {
var items = this.items;
var sorted = lazy.sortObject(this.keyMap, {prop: undefined, get: fn});
var keys = Object.keys(sorted);
var len = keys.length, i = -1;
var arr = new Array(len);
while (++i < len) {
var key = keys[i];
arr[i] = items[sorted[key]];
sorted[key] = i;
}
this.items = arr;
this.keyMap = sorted;
return this;
}
|
javascript
|
function (fn) {
var items = this.items;
var sorted = lazy.sortObject(this.keyMap, {prop: undefined, get: fn});
var keys = Object.keys(sorted);
var len = keys.length, i = -1;
var arr = new Array(len);
while (++i < len) {
var key = keys[i];
arr[i] = items[sorted[key]];
sorted[key] = i;
}
this.items = arr;
this.keyMap = sorted;
return this;
}
|
[
"function",
"(",
"fn",
")",
"{",
"var",
"items",
"=",
"this",
".",
"items",
";",
"var",
"sorted",
"=",
"lazy",
".",
"sortObject",
"(",
"this",
".",
"keyMap",
",",
"{",
"prop",
":",
"undefined",
",",
"get",
":",
"fn",
"}",
")",
";",
"var",
"keys",
"=",
"Object",
".",
"keys",
"(",
"sorted",
")",
";",
"var",
"len",
"=",
"keys",
".",
"length",
",",
"i",
"=",
"-",
"1",
";",
"var",
"arr",
"=",
"new",
"Array",
"(",
"len",
")",
";",
"while",
"(",
"++",
"i",
"<",
"len",
")",
"{",
"var",
"key",
"=",
"keys",
"[",
"i",
"]",
";",
"arr",
"[",
"i",
"]",
"=",
"items",
"[",
"sorted",
"[",
"key",
"]",
"]",
";",
"sorted",
"[",
"key",
"]",
"=",
"i",
";",
"}",
"this",
".",
"items",
"=",
"arr",
";",
"this",
".",
"keyMap",
"=",
"sorted",
";",
"return",
"this",
";",
"}"
] |
Sort list items by their keys.
@param {Function} `fn` Optional getter function to get items by.
@return {Object} Returns current instance to enable chaining
@api public
|
[
"Sort",
"list",
"items",
"by",
"their",
"keys",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/list.js#L128-L144
|
train
|
|
jonschlinkert/template
|
lib/mixins/list.js
|
function (prop) {
var keys = Object.keys(this.keyMap);
var items = this.items.map(function (item, i) {
item.key = keys[i];
return item;
});
var sorted = lazy.arraySort(items, prop);
this.items = sorted;
this.keyMap = this.items.reduce(function (acc, item, i) {
acc[item.key] = i;
return acc;
}, {});
return this;
}
|
javascript
|
function (prop) {
var keys = Object.keys(this.keyMap);
var items = this.items.map(function (item, i) {
item.key = keys[i];
return item;
});
var sorted = lazy.arraySort(items, prop);
this.items = sorted;
this.keyMap = this.items.reduce(function (acc, item, i) {
acc[item.key] = i;
return acc;
}, {});
return this;
}
|
[
"function",
"(",
"prop",
")",
"{",
"var",
"keys",
"=",
"Object",
".",
"keys",
"(",
"this",
".",
"keyMap",
")",
";",
"var",
"items",
"=",
"this",
".",
"items",
".",
"map",
"(",
"function",
"(",
"item",
",",
"i",
")",
"{",
"item",
".",
"key",
"=",
"keys",
"[",
"i",
"]",
";",
"return",
"item",
";",
"}",
")",
";",
"var",
"sorted",
"=",
"lazy",
".",
"arraySort",
"(",
"items",
",",
"prop",
")",
";",
"this",
".",
"items",
"=",
"sorted",
";",
"this",
".",
"keyMap",
"=",
"this",
".",
"items",
".",
"reduce",
"(",
"function",
"(",
"acc",
",",
"item",
",",
"i",
")",
"{",
"acc",
"[",
"item",
".",
"key",
"]",
"=",
"i",
";",
"return",
"acc",
";",
"}",
",",
"{",
"}",
")",
";",
"return",
"this",
";",
"}"
] |
Sort list items by a property on each item.
@param {String} `prop` Property to sort by.
@param {Function} `fn` Optional getter function to get items by.
@return {Object} Returns current instance to enable chaining
@api public
|
[
"Sort",
"list",
"items",
"by",
"a",
"property",
"on",
"each",
"item",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/list.js#L155-L168
|
train
|
|
jonschlinkert/template
|
lib/file.js
|
File
|
function File(file, options) {
Item.call(this, file, options);
this.initFile(file);
return file;
}
|
javascript
|
function File(file, options) {
Item.call(this, file, options);
this.initFile(file);
return file;
}
|
[
"function",
"File",
"(",
"file",
",",
"options",
")",
"{",
"Item",
".",
"call",
"(",
"this",
",",
"file",
",",
"options",
")",
";",
"this",
".",
"initFile",
"(",
"file",
")",
";",
"return",
"file",
";",
"}"
] |
Create an instance of `File`.
|
[
"Create",
"an",
"instance",
"of",
"File",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/file.js#L26-L30
|
train
|
jonschlinkert/template
|
lib/file.js
|
function (file) {
this.src = file.src || {};
if (this.path) {
this.src.path = this.path;
}
if (Buffer.isBuffer(this.contents)) {
this.content = this.contents.toString();
}
if (this.content) {
this.options.orig = this.content;
}
// ensure that `file` has `path` and `content` properties
this.validate(file);
this.options.orig = file.content;
this.options.plural = this.collection.options.plural;
this.options.handled = this.options.handled = [];
this.src = file.src || {};
this.src.path = this.src.path || this.path;
// add non-emumerable properties
this.defineOption('route', this.options.route);
this.define('_callbacks', this._callbacks);
file.__proto__ = this;
file.path = this.path;
// handle `onLoad` middleware routes
this.app.handle('onLoad', file);
}
|
javascript
|
function (file) {
this.src = file.src || {};
if (this.path) {
this.src.path = this.path;
}
if (Buffer.isBuffer(this.contents)) {
this.content = this.contents.toString();
}
if (this.content) {
this.options.orig = this.content;
}
// ensure that `file` has `path` and `content` properties
this.validate(file);
this.options.orig = file.content;
this.options.plural = this.collection.options.plural;
this.options.handled = this.options.handled = [];
this.src = file.src || {};
this.src.path = this.src.path || this.path;
// add non-emumerable properties
this.defineOption('route', this.options.route);
this.define('_callbacks', this._callbacks);
file.__proto__ = this;
file.path = this.path;
// handle `onLoad` middleware routes
this.app.handle('onLoad', file);
}
|
[
"function",
"(",
"file",
")",
"{",
"this",
".",
"src",
"=",
"file",
".",
"src",
"||",
"{",
"}",
";",
"if",
"(",
"this",
".",
"path",
")",
"{",
"this",
".",
"src",
".",
"path",
"=",
"this",
".",
"path",
";",
"}",
"if",
"(",
"Buffer",
".",
"isBuffer",
"(",
"this",
".",
"contents",
")",
")",
"{",
"this",
".",
"content",
"=",
"this",
".",
"contents",
".",
"toString",
"(",
")",
";",
"}",
"if",
"(",
"this",
".",
"content",
")",
"{",
"this",
".",
"options",
".",
"orig",
"=",
"this",
".",
"content",
";",
"}",
"this",
".",
"validate",
"(",
"file",
")",
";",
"this",
".",
"options",
".",
"orig",
"=",
"file",
".",
"content",
";",
"this",
".",
"options",
".",
"plural",
"=",
"this",
".",
"collection",
".",
"options",
".",
"plural",
";",
"this",
".",
"options",
".",
"handled",
"=",
"this",
".",
"options",
".",
"handled",
"=",
"[",
"]",
";",
"this",
".",
"src",
"=",
"file",
".",
"src",
"||",
"{",
"}",
";",
"this",
".",
"src",
".",
"path",
"=",
"this",
".",
"src",
".",
"path",
"||",
"this",
".",
"path",
";",
"this",
".",
"defineOption",
"(",
"'route'",
",",
"this",
".",
"options",
".",
"route",
")",
";",
"this",
".",
"define",
"(",
"'_callbacks'",
",",
"this",
".",
"_callbacks",
")",
";",
"file",
".",
"__proto__",
"=",
"this",
";",
"file",
".",
"path",
"=",
"this",
".",
"path",
";",
"this",
".",
"app",
".",
"handle",
"(",
"'onLoad'",
",",
"file",
")",
";",
"}"
] |
Initialize file with base properties.
|
[
"Initialize",
"file",
"with",
"base",
"properties",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/file.js#L49-L79
|
train
|
|
jonschlinkert/template
|
lib/file.js
|
function(key) {
var fn = this.pickOption('renameKey');
if (!fn) {
fn = this.collection.renameKey || this.app.renameKey;
}
if (typeof fn !== 'function') return key;
return fn(key);
}
|
javascript
|
function(key) {
var fn = this.pickOption('renameKey');
if (!fn) {
fn = this.collection.renameKey || this.app.renameKey;
}
if (typeof fn !== 'function') return key;
return fn(key);
}
|
[
"function",
"(",
"key",
")",
"{",
"var",
"fn",
"=",
"this",
".",
"pickOption",
"(",
"'renameKey'",
")",
";",
"if",
"(",
"!",
"fn",
")",
"{",
"fn",
"=",
"this",
".",
"collection",
".",
"renameKey",
"||",
"this",
".",
"app",
".",
"renameKey",
";",
"}",
"if",
"(",
"typeof",
"fn",
"!==",
"'function'",
")",
"return",
"key",
";",
"return",
"fn",
"(",
"key",
")",
";",
"}"
] |
Get the basename of a file path.
|
[
"Get",
"the",
"basename",
"of",
"a",
"file",
"path",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/file.js#L100-L107
|
train
|
|
jonschlinkert/template
|
lib/view.js
|
View
|
function View(view, options) {
this.history = [];
Item.call(this, view, options);
this.init(view);
return view;
}
|
javascript
|
function View(view, options) {
this.history = [];
Item.call(this, view, options);
this.init(view);
return view;
}
|
[
"function",
"View",
"(",
"view",
",",
"options",
")",
"{",
"this",
".",
"history",
"=",
"[",
"]",
";",
"Item",
".",
"call",
"(",
"this",
",",
"view",
",",
"options",
")",
";",
"this",
".",
"init",
"(",
"view",
")",
";",
"return",
"view",
";",
"}"
] |
Create an instance of `View`.
|
[
"Create",
"an",
"instance",
"of",
"View",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/view.js#L34-L39
|
train
|
jonschlinkert/template
|
lib/view.js
|
function (view) {
view.base = view.base || view.cwd || process.cwd();
this.src = this.src || {};
// ensure that `view` has `path` and `content` properties
this.validate(view);
this.options.orig = view.content;
this.options.plural = this.collection.options.plural;
this.options.viewType = this.options.viewType = [];
this.options.handled = this.options.handled = [];
this.contexts = view.contexts = {};
this.locals = view.locals || {};
this.data = view.data || {};
mixins(this);
// add non-emumerable properties
this.defineOption('route', this.options.route);
this.define('_callbacks', this._callbacks);
if (view.stat) {
utils.defineProp(view, 'history', view.history);
utils.defineProp(view, '_contents', view._contents);
utils.defineProp(view, 'stat', view.stat);
}
view.__proto__ = this;
utils.defineProp(view, '_callbacks', view._callbacks);
// handle `onLoad` middleware routes
this.app.handleView('onLoad', view, view.locals);
this.ctx('locals', view.locals);
this.ctx('data', view.data);
}
|
javascript
|
function (view) {
view.base = view.base || view.cwd || process.cwd();
this.src = this.src || {};
// ensure that `view` has `path` and `content` properties
this.validate(view);
this.options.orig = view.content;
this.options.plural = this.collection.options.plural;
this.options.viewType = this.options.viewType = [];
this.options.handled = this.options.handled = [];
this.contexts = view.contexts = {};
this.locals = view.locals || {};
this.data = view.data || {};
mixins(this);
// add non-emumerable properties
this.defineOption('route', this.options.route);
this.define('_callbacks', this._callbacks);
if (view.stat) {
utils.defineProp(view, 'history', view.history);
utils.defineProp(view, '_contents', view._contents);
utils.defineProp(view, 'stat', view.stat);
}
view.__proto__ = this;
utils.defineProp(view, '_callbacks', view._callbacks);
// handle `onLoad` middleware routes
this.app.handleView('onLoad', view, view.locals);
this.ctx('locals', view.locals);
this.ctx('data', view.data);
}
|
[
"function",
"(",
"view",
")",
"{",
"view",
".",
"base",
"=",
"view",
".",
"base",
"||",
"view",
".",
"cwd",
"||",
"process",
".",
"cwd",
"(",
")",
";",
"this",
".",
"src",
"=",
"this",
".",
"src",
"||",
"{",
"}",
";",
"this",
".",
"validate",
"(",
"view",
")",
";",
"this",
".",
"options",
".",
"orig",
"=",
"view",
".",
"content",
";",
"this",
".",
"options",
".",
"plural",
"=",
"this",
".",
"collection",
".",
"options",
".",
"plural",
";",
"this",
".",
"options",
".",
"viewType",
"=",
"this",
".",
"options",
".",
"viewType",
"=",
"[",
"]",
";",
"this",
".",
"options",
".",
"handled",
"=",
"this",
".",
"options",
".",
"handled",
"=",
"[",
"]",
";",
"this",
".",
"contexts",
"=",
"view",
".",
"contexts",
"=",
"{",
"}",
";",
"this",
".",
"locals",
"=",
"view",
".",
"locals",
"||",
"{",
"}",
";",
"this",
".",
"data",
"=",
"view",
".",
"data",
"||",
"{",
"}",
";",
"mixins",
"(",
"this",
")",
";",
"this",
".",
"defineOption",
"(",
"'route'",
",",
"this",
".",
"options",
".",
"route",
")",
";",
"this",
".",
"define",
"(",
"'_callbacks'",
",",
"this",
".",
"_callbacks",
")",
";",
"if",
"(",
"view",
".",
"stat",
")",
"{",
"utils",
".",
"defineProp",
"(",
"view",
",",
"'history'",
",",
"view",
".",
"history",
")",
";",
"utils",
".",
"defineProp",
"(",
"view",
",",
"'_contents'",
",",
"view",
".",
"_contents",
")",
";",
"utils",
".",
"defineProp",
"(",
"view",
",",
"'stat'",
",",
"view",
".",
"stat",
")",
";",
"}",
"view",
".",
"__proto__",
"=",
"this",
";",
"utils",
".",
"defineProp",
"(",
"view",
",",
"'_callbacks'",
",",
"view",
".",
"_callbacks",
")",
";",
"this",
".",
"app",
".",
"handleView",
"(",
"'onLoad'",
",",
"view",
",",
"view",
".",
"locals",
")",
";",
"this",
".",
"ctx",
"(",
"'locals'",
",",
"view",
".",
"locals",
")",
";",
"this",
".",
"ctx",
"(",
"'data'",
",",
"view",
".",
"data",
")",
";",
"}"
] |
Initialize view with base properties.
|
[
"Initialize",
"view",
"with",
"base",
"properties",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/view.js#L58-L91
|
train
|
|
jonschlinkert/template
|
lib/view.js
|
function(locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
this.app.render(this, locals, cb);
return this;
}
|
javascript
|
function(locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
this.app.render(this, locals, cb);
return this;
}
|
[
"function",
"(",
"locals",
",",
"cb",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'function'",
")",
"{",
"cb",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"this",
".",
"app",
".",
"render",
"(",
"this",
",",
"locals",
",",
"cb",
")",
";",
"return",
"this",
";",
"}"
] |
Asynchronously render a view.
```js
pages.get('home.md')
.render({title: 'Home'}, function(err, res) {
//=> do stuff with `res`
});
```
@param {Object} `locals` Optionally pass locals to the engine.
@return {Object} `View` instance, for chaining.
@api public
|
[
"Asynchronously",
"render",
"a",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/view.js#L143-L150
|
train
|
|
jonschlinkert/template
|
lib/view.js
|
function(locals, fn) {
if (typeof locals === 'function') {
fn = locals;
locals = {};
}
var res = this.locals;
var data = this.app.cache.data;
this.ctx('global', data);
// extend context with same-named data-property from `app.cache.data`
if (!this.hint('extended')) {
this.hint('extended', true);
var name = this.collection.renameKey(this.path);
this.ctx('matched', data[name]);
}
this.ctx('data', this.data);
this.ctx('options', this.options);
// build up the array of context keys to calculate
var keys = ['global', 'compile', 'render', 'options', 'matched'];
if (this.pickOption('prefer locals') === true) {
keys = keys.concat(['data', 'locals']);
} else {
keys = keys.concat(['locals', 'data']);
}
keys = keys.concat(['helper', 'custom']);
function calculate(obj, contexts, props) {
var len = props.length, i = -1;
while (++i < len) {
var key = props[i];
lazy.extend(obj, contexts[key] || {});
}
}
fn = fn || this.pickOption('context');
if (typeof fn === 'function') {
fn.call(this, res, this.contexts, keys, calculate);
} else {
calculate(res, this.contexts, keys);
}
locals = locals || {};
lazy.extend(res, this.app.mergePartials(locals));
lazy.extend(res, locals);
return res;
}
|
javascript
|
function(locals, fn) {
if (typeof locals === 'function') {
fn = locals;
locals = {};
}
var res = this.locals;
var data = this.app.cache.data;
this.ctx('global', data);
// extend context with same-named data-property from `app.cache.data`
if (!this.hint('extended')) {
this.hint('extended', true);
var name = this.collection.renameKey(this.path);
this.ctx('matched', data[name]);
}
this.ctx('data', this.data);
this.ctx('options', this.options);
// build up the array of context keys to calculate
var keys = ['global', 'compile', 'render', 'options', 'matched'];
if (this.pickOption('prefer locals') === true) {
keys = keys.concat(['data', 'locals']);
} else {
keys = keys.concat(['locals', 'data']);
}
keys = keys.concat(['helper', 'custom']);
function calculate(obj, contexts, props) {
var len = props.length, i = -1;
while (++i < len) {
var key = props[i];
lazy.extend(obj, contexts[key] || {});
}
}
fn = fn || this.pickOption('context');
if (typeof fn === 'function') {
fn.call(this, res, this.contexts, keys, calculate);
} else {
calculate(res, this.contexts, keys);
}
locals = locals || {};
lazy.extend(res, this.app.mergePartials(locals));
lazy.extend(res, locals);
return res;
}
|
[
"function",
"(",
"locals",
",",
"fn",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'function'",
")",
"{",
"fn",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"var",
"res",
"=",
"this",
".",
"locals",
";",
"var",
"data",
"=",
"this",
".",
"app",
".",
"cache",
".",
"data",
";",
"this",
".",
"ctx",
"(",
"'global'",
",",
"data",
")",
";",
"if",
"(",
"!",
"this",
".",
"hint",
"(",
"'extended'",
")",
")",
"{",
"this",
".",
"hint",
"(",
"'extended'",
",",
"true",
")",
";",
"var",
"name",
"=",
"this",
".",
"collection",
".",
"renameKey",
"(",
"this",
".",
"path",
")",
";",
"this",
".",
"ctx",
"(",
"'matched'",
",",
"data",
"[",
"name",
"]",
")",
";",
"}",
"this",
".",
"ctx",
"(",
"'data'",
",",
"this",
".",
"data",
")",
";",
"this",
".",
"ctx",
"(",
"'options'",
",",
"this",
".",
"options",
")",
";",
"var",
"keys",
"=",
"[",
"'global'",
",",
"'compile'",
",",
"'render'",
",",
"'options'",
",",
"'matched'",
"]",
";",
"if",
"(",
"this",
".",
"pickOption",
"(",
"'prefer locals'",
")",
"===",
"true",
")",
"{",
"keys",
"=",
"keys",
".",
"concat",
"(",
"[",
"'data'",
",",
"'locals'",
"]",
")",
";",
"}",
"else",
"{",
"keys",
"=",
"keys",
".",
"concat",
"(",
"[",
"'locals'",
",",
"'data'",
"]",
")",
";",
"}",
"keys",
"=",
"keys",
".",
"concat",
"(",
"[",
"'helper'",
",",
"'custom'",
"]",
")",
";",
"function",
"calculate",
"(",
"obj",
",",
"contexts",
",",
"props",
")",
"{",
"var",
"len",
"=",
"props",
".",
"length",
",",
"i",
"=",
"-",
"1",
";",
"while",
"(",
"++",
"i",
"<",
"len",
")",
"{",
"var",
"key",
"=",
"props",
"[",
"i",
"]",
";",
"lazy",
".",
"extend",
"(",
"obj",
",",
"contexts",
"[",
"key",
"]",
"||",
"{",
"}",
")",
";",
"}",
"}",
"fn",
"=",
"fn",
"||",
"this",
".",
"pickOption",
"(",
"'context'",
")",
";",
"if",
"(",
"typeof",
"fn",
"===",
"'function'",
")",
"{",
"fn",
".",
"call",
"(",
"this",
",",
"res",
",",
"this",
".",
"contexts",
",",
"keys",
",",
"calculate",
")",
";",
"}",
"else",
"{",
"calculate",
"(",
"res",
",",
"this",
".",
"contexts",
",",
"keys",
")",
";",
"}",
"locals",
"=",
"locals",
"||",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"res",
",",
"this",
".",
"app",
".",
"mergePartials",
"(",
"locals",
")",
")",
";",
"lazy",
".",
"extend",
"(",
"res",
",",
"locals",
")",
";",
"return",
"res",
";",
"}"
] |
Build the context for a view.
@param {Function} `fn`
@api public
|
[
"Build",
"the",
"context",
"for",
"a",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/view.js#L181-L229
|
train
|
|
jonschlinkert/template
|
lib/collection.js
|
Collection
|
function Collection(options) {
Base.call(this, options);
this.define('lists', {});
this.define('_items', {});
this.define('Item', this.options.Item || require('./item'));
this.define('List', this.options.List || require('./list'));
mixins(this);
/**
* Get an object representing the current items on the instance.
*
* ```js
* var items = this.items;
* ```
*
* @return {Object} Object of items
*/
Object.defineProperty(this, 'items', {
enumerable: false,
configurable: true,
get: function () {
return this._items;
},
set: function (items) {
lazy.forIn(items, function (item, key) {
delete this._items[key];
delete this[key];
this.set(key, item);
}, this);
}
});
}
|
javascript
|
function Collection(options) {
Base.call(this, options);
this.define('lists', {});
this.define('_items', {});
this.define('Item', this.options.Item || require('./item'));
this.define('List', this.options.List || require('./list'));
mixins(this);
/**
* Get an object representing the current items on the instance.
*
* ```js
* var items = this.items;
* ```
*
* @return {Object} Object of items
*/
Object.defineProperty(this, 'items', {
enumerable: false,
configurable: true,
get: function () {
return this._items;
},
set: function (items) {
lazy.forIn(items, function (item, key) {
delete this._items[key];
delete this[key];
this.set(key, item);
}, this);
}
});
}
|
[
"function",
"Collection",
"(",
"options",
")",
"{",
"Base",
".",
"call",
"(",
"this",
",",
"options",
")",
";",
"this",
".",
"define",
"(",
"'lists'",
",",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'_items'",
",",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'Item'",
",",
"this",
".",
"options",
".",
"Item",
"||",
"require",
"(",
"'./item'",
")",
")",
";",
"this",
".",
"define",
"(",
"'List'",
",",
"this",
".",
"options",
".",
"List",
"||",
"require",
"(",
"'./list'",
")",
")",
";",
"mixins",
"(",
"this",
")",
";",
"Object",
".",
"defineProperty",
"(",
"this",
",",
"'items'",
",",
"{",
"enumerable",
":",
"false",
",",
"configurable",
":",
"true",
",",
"get",
":",
"function",
"(",
")",
"{",
"return",
"this",
".",
"_items",
";",
"}",
",",
"set",
":",
"function",
"(",
"items",
")",
"{",
"lazy",
".",
"forIn",
"(",
"items",
",",
"function",
"(",
"item",
",",
"key",
")",
"{",
"delete",
"this",
".",
"_items",
"[",
"key",
"]",
";",
"delete",
"this",
"[",
"key",
"]",
";",
"this",
".",
"set",
"(",
"key",
",",
"item",
")",
";",
"}",
",",
"this",
")",
";",
"}",
"}",
")",
";",
"}"
] |
Create an instance of `Collection` with the specified `options`.
The `Collection` constructor inherits from Base.
```js
var collection = new Collection();
```
@param {Object} `options`
@return {undefined}
@api public
|
[
"Create",
"an",
"instance",
"of",
"Collection",
"with",
"the",
"specified",
"options",
".",
"The",
"Collection",
"constructor",
"inherits",
"from",
"Base",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/collection.js#L36-L68
|
train
|
jonschlinkert/template
|
lib/collection.js
|
function (prop, val) {
this.setItem(prop, val);
if (prop === 'app' || prop === 'collection') {
this.define(prop, val);
} else {
lazy.set(this, prop, val);
}
return this;
}
|
javascript
|
function (prop, val) {
this.setItem(prop, val);
if (prop === 'app' || prop === 'collection') {
this.define(prop, val);
} else {
lazy.set(this, prop, val);
}
return this;
}
|
[
"function",
"(",
"prop",
",",
"val",
")",
"{",
"this",
".",
"setItem",
"(",
"prop",
",",
"val",
")",
";",
"if",
"(",
"prop",
"===",
"'app'",
"||",
"prop",
"===",
"'collection'",
")",
"{",
"this",
".",
"define",
"(",
"prop",
",",
"val",
")",
";",
"}",
"else",
"{",
"lazy",
".",
"set",
"(",
"this",
",",
"prop",
",",
"val",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
Set a value.
|
[
"Set",
"a",
"value",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/collection.js#L87-L95
|
train
|
|
jonschlinkert/template
|
lib/collection.js
|
function (prop, val) {
if (prop === 'app' || prop === 'collection') {
utils.defineProp(this._items, prop, val);
} else {
this._items[prop] = val;
}
return this;
}
|
javascript
|
function (prop, val) {
if (prop === 'app' || prop === 'collection') {
utils.defineProp(this._items, prop, val);
} else {
this._items[prop] = val;
}
return this;
}
|
[
"function",
"(",
"prop",
",",
"val",
")",
"{",
"if",
"(",
"prop",
"===",
"'app'",
"||",
"prop",
"===",
"'collection'",
")",
"{",
"utils",
".",
"defineProp",
"(",
"this",
".",
"_items",
",",
"prop",
",",
"val",
")",
";",
"}",
"else",
"{",
"this",
".",
"_items",
"[",
"prop",
"]",
"=",
"val",
";",
"}",
"return",
"this",
";",
"}"
] |
Set an item
|
[
"Set",
"an",
"item"
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/collection.js#L101-L108
|
train
|
|
jonschlinkert/template
|
lib/collection.js
|
function (name, items) {
var List = this.get('List');
var list = this.lists[name];
if (typeof list === 'undefined') {
var opts = lazy.clone(this.options);
opts.items = items || this.items;
opts.collection = this;
this.lists[name] = list = new List(opts);
}
return list;
}
|
javascript
|
function (name, items) {
var List = this.get('List');
var list = this.lists[name];
if (typeof list === 'undefined') {
var opts = lazy.clone(this.options);
opts.items = items || this.items;
opts.collection = this;
this.lists[name] = list = new List(opts);
}
return list;
}
|
[
"function",
"(",
"name",
",",
"items",
")",
"{",
"var",
"List",
"=",
"this",
".",
"get",
"(",
"'List'",
")",
";",
"var",
"list",
"=",
"this",
".",
"lists",
"[",
"name",
"]",
";",
"if",
"(",
"typeof",
"list",
"===",
"'undefined'",
")",
"{",
"var",
"opts",
"=",
"lazy",
".",
"clone",
"(",
"this",
".",
"options",
")",
";",
"opts",
".",
"items",
"=",
"items",
"||",
"this",
".",
"items",
";",
"opts",
".",
"collection",
"=",
"this",
";",
"this",
".",
"lists",
"[",
"name",
"]",
"=",
"list",
"=",
"new",
"List",
"(",
"opts",
")",
";",
"}",
"return",
"list",
";",
"}"
] |
Get or create a new list.
|
[
"Get",
"or",
"create",
"a",
"new",
"list",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/collection.js#L122-L132
|
train
|
|
jonschlinkert/template
|
lib/collection.js
|
function (prop, fn) {
if (typeof prop === 'function') {
fn = prop;
prop = undefined;
}
var items = this.items;
this.items = lazy.sortObj(items, {
prop: prop,
get: fn
});
return this;
}
|
javascript
|
function (prop, fn) {
if (typeof prop === 'function') {
fn = prop;
prop = undefined;
}
var items = this.items;
this.items = lazy.sortObj(items, {
prop: prop,
get: fn
});
return this;
}
|
[
"function",
"(",
"prop",
",",
"fn",
")",
"{",
"if",
"(",
"typeof",
"prop",
"===",
"'function'",
")",
"{",
"fn",
"=",
"prop",
";",
"prop",
"=",
"undefined",
";",
"}",
"var",
"items",
"=",
"this",
".",
"items",
";",
"this",
".",
"items",
"=",
"lazy",
".",
"sortObj",
"(",
"items",
",",
"{",
"prop",
":",
"prop",
",",
"get",
":",
"fn",
"}",
")",
";",
"return",
"this",
";",
"}"
] |
Return collection items sorted by the given property.
|
[
"Return",
"collection",
"items",
"sorted",
"by",
"the",
"given",
"property",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/collection.js#L186-L198
|
train
|
|
jonschlinkert/template
|
lib/item.js
|
Item
|
function Item(item, options) {
Base.call(this, options);
this.define('collection', this.options.collection);
if (typeof item === 'object') {
this.visit('set', item);
}
}
|
javascript
|
function Item(item, options) {
Base.call(this, options);
this.define('collection', this.options.collection);
if (typeof item === 'object') {
this.visit('set', item);
}
}
|
[
"function",
"Item",
"(",
"item",
",",
"options",
")",
"{",
"Base",
".",
"call",
"(",
"this",
",",
"options",
")",
";",
"this",
".",
"define",
"(",
"'collection'",
",",
"this",
".",
"options",
".",
"collection",
")",
";",
"if",
"(",
"typeof",
"item",
"===",
"'object'",
")",
"{",
"this",
".",
"visit",
"(",
"'set'",
",",
"item",
")",
";",
"}",
"}"
] |
Create an instance of `Item` with the specified `options`.
The `Item` constructor inherits from Base.
```js
var item = new Item();
```
@param {Object} `options`
@return {undefined}
@api public
|
[
"Create",
"an",
"instance",
"of",
"Item",
"with",
"the",
"specified",
"options",
".",
"The",
"Item",
"constructor",
"inherits",
"from",
"Base",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/item.js#L22-L29
|
train
|
jonschlinkert/template
|
lib/item.js
|
function(prop) {
var opt = this.option(prop);
if (typeof opt === 'undefined') {
opt = this.collection && this.collection.option(prop);
}
if (typeof opt === 'undefined') {
return this.app && this.app.option(prop);
}
return opt;
}
|
javascript
|
function(prop) {
var opt = this.option(prop);
if (typeof opt === 'undefined') {
opt = this.collection && this.collection.option(prop);
}
if (typeof opt === 'undefined') {
return this.app && this.app.option(prop);
}
return opt;
}
|
[
"function",
"(",
"prop",
")",
"{",
"var",
"opt",
"=",
"this",
".",
"option",
"(",
"prop",
")",
";",
"if",
"(",
"typeof",
"opt",
"===",
"'undefined'",
")",
"{",
"opt",
"=",
"this",
".",
"collection",
"&&",
"this",
".",
"collection",
".",
"option",
"(",
"prop",
")",
";",
"}",
"if",
"(",
"typeof",
"opt",
"===",
"'undefined'",
")",
"{",
"return",
"this",
".",
"app",
"&&",
"this",
".",
"app",
".",
"option",
"(",
"prop",
")",
";",
"}",
"return",
"opt",
";",
"}"
] |
Get an option from the item, collection or app instance,
in that order.
|
[
"Get",
"an",
"option",
"from",
"the",
"item",
"collection",
"or",
"app",
"instance",
"in",
"that",
"order",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/item.js#L67-L76
|
train
|
|
jonschlinkert/template
|
lib/mixins/view.js
|
function (data) {
var parse = function() {
var parsed = lazy.extend({}, lazy.parseFilepath(this.path), data);
if (typeof parsed.ext === 'undefined') {
parsed.ext = parsed.extname;
}
return parsed;
}.bind(this);
return this.fragmentCache('path', parse);
}
|
javascript
|
function (data) {
var parse = function() {
var parsed = lazy.extend({}, lazy.parseFilepath(this.path), data);
if (typeof parsed.ext === 'undefined') {
parsed.ext = parsed.extname;
}
return parsed;
}.bind(this);
return this.fragmentCache('path', parse);
}
|
[
"function",
"(",
"data",
")",
"{",
"var",
"parse",
"=",
"function",
"(",
")",
"{",
"var",
"parsed",
"=",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"lazy",
".",
"parseFilepath",
"(",
"this",
".",
"path",
")",
",",
"data",
")",
";",
"if",
"(",
"typeof",
"parsed",
".",
"ext",
"===",
"'undefined'",
")",
"{",
"parsed",
".",
"ext",
"=",
"parsed",
".",
"extname",
";",
"}",
"return",
"parsed",
";",
"}",
".",
"bind",
"(",
"this",
")",
";",
"return",
"this",
".",
"fragmentCache",
"(",
"'path'",
",",
"parse",
")",
";",
"}"
] |
Parse `view.path` into an object.
|
[
"Parse",
"view",
".",
"path",
"into",
"an",
"object",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/view.js#L33-L42
|
train
|
|
jonschlinkert/template
|
lib/mixins/view.js
|
function(filepath, fn) {
fn = fn || lazy.dashify;
if (typeof filepath === 'undefined') {
var ctx = this.context();
filepath = ctx.slug || this.path;
}
return fn(filepath);
}
|
javascript
|
function(filepath, fn) {
fn = fn || lazy.dashify;
if (typeof filepath === 'undefined') {
var ctx = this.context();
filepath = ctx.slug || this.path;
}
return fn(filepath);
}
|
[
"function",
"(",
"filepath",
",",
"fn",
")",
"{",
"fn",
"=",
"fn",
"||",
"lazy",
".",
"dashify",
";",
"if",
"(",
"typeof",
"filepath",
"===",
"'undefined'",
")",
"{",
"var",
"ctx",
"=",
"this",
".",
"context",
"(",
")",
";",
"filepath",
"=",
"ctx",
".",
"slug",
"||",
"this",
".",
"path",
";",
"}",
"return",
"fn",
"(",
"filepath",
")",
";",
"}"
] |
Returns a slugified filepath. If `filepath` is not passed,
`view.data.slug` or `view.path` will be slugified.
|
[
"Returns",
"a",
"slugified",
"filepath",
".",
"If",
"filepath",
"is",
"not",
"passed",
"view",
".",
"data",
".",
"slug",
"or",
"view",
".",
"path",
"will",
"be",
"slugified",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/view.js#L49-L56
|
train
|
|
jonschlinkert/template
|
lib/mixins/view.js
|
function(str) {
if (typeof str !== 'string') {
str = this.content;
}
if (typeof str !== 'string') return '';
str = str.replace(/(<([^>]+)>)/g, '');
return str.trim();
}
|
javascript
|
function(str) {
if (typeof str !== 'string') {
str = this.content;
}
if (typeof str !== 'string') return '';
str = str.replace(/(<([^>]+)>)/g, '');
return str.trim();
}
|
[
"function",
"(",
"str",
")",
"{",
"if",
"(",
"typeof",
"str",
"!==",
"'string'",
")",
"{",
"str",
"=",
"this",
".",
"content",
";",
"}",
"if",
"(",
"typeof",
"str",
"!==",
"'string'",
")",
"return",
"''",
";",
"str",
"=",
"str",
".",
"replace",
"(",
"/",
"(<([^>]+)>)",
"/",
"g",
",",
"''",
")",
";",
"return",
"str",
".",
"trim",
"(",
")",
";",
"}"
] |
Strip HTML from the given `str` or `view.content`
@param {String} str HTML string
@return {String}
|
[
"Strip",
"HTML",
"from",
"the",
"given",
"str",
"or",
"view",
".",
"content"
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/view.js#L65-L72
|
train
|
|
jonschlinkert/template
|
lib/mixins/view.js
|
function (options) {
options = options || {};
lazy.extend(options, this.options.excerpt || {});
var re = /<!--+\s*more\s*--+>/;
var str = this.content;
var view = this;
var link = options.link || '<a id="more"></a>';
this.content = str.replace(re, function (match, i) {
view.data.excerpt = str.slice(0, i).trim();
view.data.more = str.slice(i + match.length).trim() + link;
return '';
});
return this;
}
|
javascript
|
function (options) {
options = options || {};
lazy.extend(options, this.options.excerpt || {});
var re = /<!--+\s*more\s*--+>/;
var str = this.content;
var view = this;
var link = options.link || '<a id="more"></a>';
this.content = str.replace(re, function (match, i) {
view.data.excerpt = str.slice(0, i).trim();
view.data.more = str.slice(i + match.length).trim() + link;
return '';
});
return this;
}
|
[
"function",
"(",
"options",
")",
"{",
"options",
"=",
"options",
"||",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"options",
",",
"this",
".",
"options",
".",
"excerpt",
"||",
"{",
"}",
")",
";",
"var",
"re",
"=",
"/",
"<!--+\\s*more\\s*--+>",
"/",
";",
"var",
"str",
"=",
"this",
".",
"content",
";",
"var",
"view",
"=",
"this",
";",
"var",
"link",
"=",
"options",
".",
"link",
"||",
"'<a id=\"more\"></a>'",
";",
"this",
".",
"content",
"=",
"str",
".",
"replace",
"(",
"re",
",",
"function",
"(",
"match",
",",
"i",
")",
"{",
"view",
".",
"data",
".",
"excerpt",
"=",
"str",
".",
"slice",
"(",
"0",
",",
"i",
")",
".",
"trim",
"(",
")",
";",
"view",
".",
"data",
".",
"more",
"=",
"str",
".",
"slice",
"(",
"i",
"+",
"match",
".",
"length",
")",
".",
"trim",
"(",
")",
"+",
"link",
";",
"return",
"''",
";",
"}",
")",
";",
"return",
"this",
";",
"}"
] |
Generate an excerpt for a view.
```js
app.posts.get('foo.md')
.excerpt()
.render(function (err, res) {
//=>
});
```
@param {Object} `options` Excerpt options.
@option {Object} `template` Template to use for the excerpt tag.
@return {Object}
|
[
"Generate",
"an",
"excerpt",
"for",
"a",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/view.js#L90-L106
|
train
|
|
jonschlinkert/template
|
lib/mixins/view.js
|
function (structure, locals) {
if (typeof structure !== 'string') {
locals = structure;
structure = null;
}
var self = this;
var data = {};
lazy.extend(data, this);
lazy.extend(data, this.parsePath());
lazy.extend(data, this.context(locals));
this.data.dest = this.data.dest || {};
var opts = lazy.get(data, 'permalinks') || {};
lazy.extend(opts, this.options.permalinks || {});
if (typeof structure !== 'string') {
structure = opts.structure || ':path';
}
return structure.replace(/:(\w+)(?:\((.*)\))?/g, function (m, param, prop) {
var res = data[param] || param;
if (typeof res === 'function' && prop) {
return res.call(data, prop);
}
self.data.dest = res;
return res;
});
}
|
javascript
|
function (structure, locals) {
if (typeof structure !== 'string') {
locals = structure;
structure = null;
}
var self = this;
var data = {};
lazy.extend(data, this);
lazy.extend(data, this.parsePath());
lazy.extend(data, this.context(locals));
this.data.dest = this.data.dest || {};
var opts = lazy.get(data, 'permalinks') || {};
lazy.extend(opts, this.options.permalinks || {});
if (typeof structure !== 'string') {
structure = opts.structure || ':path';
}
return structure.replace(/:(\w+)(?:\((.*)\))?/g, function (m, param, prop) {
var res = data[param] || param;
if (typeof res === 'function' && prop) {
return res.call(data, prop);
}
self.data.dest = res;
return res;
});
}
|
[
"function",
"(",
"structure",
",",
"locals",
")",
"{",
"if",
"(",
"typeof",
"structure",
"!==",
"'string'",
")",
"{",
"locals",
"=",
"structure",
";",
"structure",
"=",
"null",
";",
"}",
"var",
"self",
"=",
"this",
";",
"var",
"data",
"=",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"data",
",",
"this",
")",
";",
"lazy",
".",
"extend",
"(",
"data",
",",
"this",
".",
"parsePath",
"(",
")",
")",
";",
"lazy",
".",
"extend",
"(",
"data",
",",
"this",
".",
"context",
"(",
"locals",
")",
")",
";",
"this",
".",
"data",
".",
"dest",
"=",
"this",
".",
"data",
".",
"dest",
"||",
"{",
"}",
";",
"var",
"opts",
"=",
"lazy",
".",
"get",
"(",
"data",
",",
"'permalinks'",
")",
"||",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"opts",
",",
"this",
".",
"options",
".",
"permalinks",
"||",
"{",
"}",
")",
";",
"if",
"(",
"typeof",
"structure",
"!==",
"'string'",
")",
"{",
"structure",
"=",
"opts",
".",
"structure",
"||",
"':path'",
";",
"}",
"return",
"structure",
".",
"replace",
"(",
"/",
":(\\w+)(?:\\((.*)\\))?",
"/",
"g",
",",
"function",
"(",
"m",
",",
"param",
",",
"prop",
")",
"{",
"var",
"res",
"=",
"data",
"[",
"param",
"]",
"||",
"param",
";",
"if",
"(",
"typeof",
"res",
"===",
"'function'",
"&&",
"prop",
")",
"{",
"return",
"res",
".",
"call",
"(",
"data",
",",
"prop",
")",
";",
"}",
"self",
".",
"data",
".",
"dest",
"=",
"res",
";",
"return",
"res",
";",
"}",
")",
";",
"}"
] |
Generate a permalink for a view.
```js
app.posts.get('foo.md')
.render(function (err, res) {
dest(res.permalink(), res);
//=>
});
```
@param {Object} `locals` pass any additional locals for context.
@return {String} Returns a permalink string.
@api public
|
[
"Generate",
"a",
"permalink",
"for",
"a",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/mixins/view.js#L133-L163
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
Views
|
function Views(options) {
Collection.call(this, options);
this.options.collection = this.options.collection || this;
this.define('View', this.options.View || require('./view'));
this.define('Item', this.View);
}
|
javascript
|
function Views(options) {
Collection.call(this, options);
this.options.collection = this.options.collection || this;
this.define('View', this.options.View || require('./view'));
this.define('Item', this.View);
}
|
[
"function",
"Views",
"(",
"options",
")",
"{",
"Collection",
".",
"call",
"(",
"this",
",",
"options",
")",
";",
"this",
".",
"options",
".",
"collection",
"=",
"this",
".",
"options",
".",
"collection",
"||",
"this",
";",
"this",
".",
"define",
"(",
"'View'",
",",
"this",
".",
"options",
".",
"View",
"||",
"require",
"(",
"'./view'",
")",
")",
";",
"this",
".",
"define",
"(",
"'Item'",
",",
"this",
".",
"View",
")",
";",
"}"
] |
Create an instance of `Views`.
@api public
|
[
"Create",
"an",
"instance",
"of",
"Views",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L32-L37
|
train
|
jonschlinkert/template
|
lib/views.js
|
function (key, val) {
if (lazy.typeOf(val) !== 'object') {
lazy.set(this, key, val);
return this;
}
this.addView(key, val);
return this;
}
|
javascript
|
function (key, val) {
if (lazy.typeOf(val) !== 'object') {
lazy.set(this, key, val);
return this;
}
this.addView(key, val);
return this;
}
|
[
"function",
"(",
"key",
",",
"val",
")",
"{",
"if",
"(",
"lazy",
".",
"typeOf",
"(",
"val",
")",
"!==",
"'object'",
")",
"{",
"lazy",
".",
"set",
"(",
"this",
",",
"key",
",",
"val",
")",
";",
"return",
"this",
";",
"}",
"this",
".",
"addView",
"(",
"key",
",",
"val",
")",
";",
"return",
"this",
";",
"}"
] |
Set a value on the collection instance.
@param {String} `key`
@param {Object} `val` The view object
@param {Object} Returns the instance of `Views` for chaining.
@api public
|
[
"Set",
"a",
"value",
"on",
"the",
"collection",
"instance",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L61-L68
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function (key, val) {
var opts = lazy.clone(this.options);
var View = this.get('View');
val.path = val.path || key;
key = val.key = this.renameKey(key);
this.setItem(key, (this[key] = new View(val, opts)));
return this;
}
|
javascript
|
function (key, val) {
var opts = lazy.clone(this.options);
var View = this.get('View');
val.path = val.path || key;
key = val.key = this.renameKey(key);
this.setItem(key, (this[key] = new View(val, opts)));
return this;
}
|
[
"function",
"(",
"key",
",",
"val",
")",
"{",
"var",
"opts",
"=",
"lazy",
".",
"clone",
"(",
"this",
".",
"options",
")",
";",
"var",
"View",
"=",
"this",
".",
"get",
"(",
"'View'",
")",
";",
"val",
".",
"path",
"=",
"val",
".",
"path",
"||",
"key",
";",
"key",
"=",
"val",
".",
"key",
"=",
"this",
".",
"renameKey",
"(",
"key",
")",
";",
"this",
".",
"setItem",
"(",
"key",
",",
"(",
"this",
"[",
"key",
"]",
"=",
"new",
"View",
"(",
"val",
",",
"opts",
")",
")",
")",
";",
"return",
"this",
";",
"}"
] |
Add a view to the current collection.
@param {String} `key`
@param {Object} `val` The view object
@param {Object} Returns the instance of `Views` for chaining.
@api public
|
[
"Add",
"a",
"view",
"to",
"the",
"current",
"collection",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L79-L86
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function(prop) {
var res = this[prop];
if (typeof res === 'undefined') {
var name = this.renameKey(prop);
if (name && name !== prop) {
res = this[name];
}
}
if (typeof res === 'undefined') {
res = lazy.get(this, prop);
}
if (typeof res === 'undefined') {
res = this.find(prop);
}
return res;
}
|
javascript
|
function(prop) {
var res = this[prop];
if (typeof res === 'undefined') {
var name = this.renameKey(prop);
if (name && name !== prop) {
res = this[name];
}
}
if (typeof res === 'undefined') {
res = lazy.get(this, prop);
}
if (typeof res === 'undefined') {
res = this.find(prop);
}
return res;
}
|
[
"function",
"(",
"prop",
")",
"{",
"var",
"res",
"=",
"this",
"[",
"prop",
"]",
";",
"if",
"(",
"typeof",
"res",
"===",
"'undefined'",
")",
"{",
"var",
"name",
"=",
"this",
".",
"renameKey",
"(",
"prop",
")",
";",
"if",
"(",
"name",
"&&",
"name",
"!==",
"prop",
")",
"{",
"res",
"=",
"this",
"[",
"name",
"]",
";",
"}",
"}",
"if",
"(",
"typeof",
"res",
"===",
"'undefined'",
")",
"{",
"res",
"=",
"lazy",
".",
"get",
"(",
"this",
",",
"prop",
")",
";",
"}",
"if",
"(",
"typeof",
"res",
"===",
"'undefined'",
")",
"{",
"res",
"=",
"this",
".",
"find",
"(",
"prop",
")",
";",
"}",
"return",
"res",
";",
"}"
] |
Get a view.
|
[
"Get",
"a",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L105-L120
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function (pattern, options) {
var self = this;
function find() {
var isMatch = lazy.mm.matcher(pattern, options);
for (var key in self) {
var val = self[key];
if (typeof val === 'object' && isMatch(key)) {
return val;
}
}
}
var res = this.fragmentCache(pattern, find);
res.__proto__ = this;
return res;
}
|
javascript
|
function (pattern, options) {
var self = this;
function find() {
var isMatch = lazy.mm.matcher(pattern, options);
for (var key in self) {
var val = self[key];
if (typeof val === 'object' && isMatch(key)) {
return val;
}
}
}
var res = this.fragmentCache(pattern, find);
res.__proto__ = this;
return res;
}
|
[
"function",
"(",
"pattern",
",",
"options",
")",
"{",
"var",
"self",
"=",
"this",
";",
"function",
"find",
"(",
")",
"{",
"var",
"isMatch",
"=",
"lazy",
".",
"mm",
".",
"matcher",
"(",
"pattern",
",",
"options",
")",
";",
"for",
"(",
"var",
"key",
"in",
"self",
")",
"{",
"var",
"val",
"=",
"self",
"[",
"key",
"]",
";",
"if",
"(",
"typeof",
"val",
"===",
"'object'",
"&&",
"isMatch",
"(",
"key",
")",
")",
"{",
"return",
"val",
";",
"}",
"}",
"}",
"var",
"res",
"=",
"this",
".",
"fragmentCache",
"(",
"pattern",
",",
"find",
")",
";",
"res",
".",
"__proto__",
"=",
"this",
";",
"return",
"res",
";",
"}"
] |
Find a view by `key` or glob pattern.
@param {String} `pattern` Key or glob pattern.
@param {Object} `options` Options for [micromatch]
@return {Object} Matching view.
|
[
"Find",
"a",
"view",
"by",
"key",
"or",
"glob",
"pattern",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L130-L144
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function (view/*, locals, fn*/) {
var args = [].slice.call(arguments, 1);
var app = this.app;
if (typeof view === 'string') view = this[view];
app.render.apply(app, [view].concat(args));
return this;
}
|
javascript
|
function (view/*, locals, fn*/) {
var args = [].slice.call(arguments, 1);
var app = this.app;
if (typeof view === 'string') view = this[view];
app.render.apply(app, [view].concat(args));
return this;
}
|
[
"function",
"(",
"view",
")",
"{",
"var",
"args",
"=",
"[",
"]",
".",
"slice",
".",
"call",
"(",
"arguments",
",",
"1",
")",
";",
"var",
"app",
"=",
"this",
".",
"app",
";",
"if",
"(",
"typeof",
"view",
"===",
"'string'",
")",
"view",
"=",
"this",
"[",
"view",
"]",
";",
"app",
".",
"render",
".",
"apply",
"(",
"app",
",",
"[",
"view",
"]",
".",
"concat",
"(",
"args",
")",
")",
";",
"return",
"this",
";",
"}"
] |
Render a view in the collection.
@param {String|Object} `view` View key or object.
@param {Object} `locals`
@param {Function} `fn`
@return {Object}
|
[
"Render",
"a",
"view",
"in",
"the",
"collection",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L172-L179
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function (prop, pattern, options) {
options = options || {};
var views = this.items;
var res = Object.create(this);
var matcher = pattern ? lazy.mm.isMatch(pattern, options) : null;
for (var key in views) {
if (views.hasOwnProperty(key)) {
var file = views[key];
if (prop === 'key') {
if (matcher) {
if (matcher(path.relative(process.cwd(), key))) {
res[key] = file;
}
} else {
res[key] = file;
}
} else {
var val = lazy.get(file, prop);
if (prop === 'path' || prop === 'cwd') {
val = path.relative(process.cwd(), val);
}
if (lazy.has(val)) {
if (matcher) {
if (matcher(val)) {
res[key] = file;
}
} else {
res[key] = file;
}
}
}
}
}
return res;
}
|
javascript
|
function (prop, pattern, options) {
options = options || {};
var views = this.items;
var res = Object.create(this);
var matcher = pattern ? lazy.mm.isMatch(pattern, options) : null;
for (var key in views) {
if (views.hasOwnProperty(key)) {
var file = views[key];
if (prop === 'key') {
if (matcher) {
if (matcher(path.relative(process.cwd(), key))) {
res[key] = file;
}
} else {
res[key] = file;
}
} else {
var val = lazy.get(file, prop);
if (prop === 'path' || prop === 'cwd') {
val = path.relative(process.cwd(), val);
}
if (lazy.has(val)) {
if (matcher) {
if (matcher(val)) {
res[key] = file;
}
} else {
res[key] = file;
}
}
}
}
}
return res;
}
|
[
"function",
"(",
"prop",
",",
"pattern",
",",
"options",
")",
"{",
"options",
"=",
"options",
"||",
"{",
"}",
";",
"var",
"views",
"=",
"this",
".",
"items",
";",
"var",
"res",
"=",
"Object",
".",
"create",
"(",
"this",
")",
";",
"var",
"matcher",
"=",
"pattern",
"?",
"lazy",
".",
"mm",
".",
"isMatch",
"(",
"pattern",
",",
"options",
")",
":",
"null",
";",
"for",
"(",
"var",
"key",
"in",
"views",
")",
"{",
"if",
"(",
"views",
".",
"hasOwnProperty",
"(",
"key",
")",
")",
"{",
"var",
"file",
"=",
"views",
"[",
"key",
"]",
";",
"if",
"(",
"prop",
"===",
"'key'",
")",
"{",
"if",
"(",
"matcher",
")",
"{",
"if",
"(",
"matcher",
"(",
"path",
".",
"relative",
"(",
"process",
".",
"cwd",
"(",
")",
",",
"key",
")",
")",
")",
"{",
"res",
"[",
"key",
"]",
"=",
"file",
";",
"}",
"}",
"else",
"{",
"res",
"[",
"key",
"]",
"=",
"file",
";",
"}",
"}",
"else",
"{",
"var",
"val",
"=",
"lazy",
".",
"get",
"(",
"file",
",",
"prop",
")",
";",
"if",
"(",
"prop",
"===",
"'path'",
"||",
"prop",
"===",
"'cwd'",
")",
"{",
"val",
"=",
"path",
".",
"relative",
"(",
"process",
".",
"cwd",
"(",
")",
",",
"val",
")",
";",
"}",
"if",
"(",
"lazy",
".",
"has",
"(",
"val",
")",
")",
"{",
"if",
"(",
"matcher",
")",
"{",
"if",
"(",
"matcher",
"(",
"val",
")",
")",
"{",
"res",
"[",
"key",
"]",
"=",
"file",
";",
"}",
"}",
"else",
"{",
"res",
"[",
"key",
"]",
"=",
"file",
";",
"}",
"}",
"}",
"}",
"}",
"return",
"res",
";",
"}"
] |
Filter views by the given `prop`, using the specified `pattern` and `options.
@param {String} `prop` The property to sort by.
@param {String|Object|Array|Function} `pattern` Function, glob patterns, object, array, or string pattern to use for pre-filtering views.
@param {Object} `options`
@option {Object} `limit` [options]
@option {Object} `limit` [options]
@return {Object}
|
[
"Filter",
"views",
"by",
"the",
"given",
"prop",
"using",
"the",
"specified",
"pattern",
"and",
"options",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L192-L228
|
train
|
|
jonschlinkert/template
|
lib/views.js
|
function() {
this.options.viewType = utils.arrayify(this.options.viewType || []);
if (this.options.viewType.length === 0) {
this.options.viewType.push('renderable');
}
return this.options.viewType;
}
|
javascript
|
function() {
this.options.viewType = utils.arrayify(this.options.viewType || []);
if (this.options.viewType.length === 0) {
this.options.viewType.push('renderable');
}
return this.options.viewType;
}
|
[
"function",
"(",
")",
"{",
"this",
".",
"options",
".",
"viewType",
"=",
"utils",
".",
"arrayify",
"(",
"this",
".",
"options",
".",
"viewType",
"||",
"[",
"]",
")",
";",
"if",
"(",
"this",
".",
"options",
".",
"viewType",
".",
"length",
"===",
"0",
")",
"{",
"this",
".",
"options",
".",
"viewType",
".",
"push",
"(",
"'renderable'",
")",
";",
"}",
"return",
"this",
".",
"options",
".",
"viewType",
";",
"}"
] |
Set view types for the collection.
@param {String} `plural` e.g. `pages`
@param {Object} `options`
@api private
|
[
"Set",
"view",
"types",
"for",
"the",
"collection",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/views.js#L238-L244
|
train
|
|
jonschlinkert/template
|
lib/base.js
|
Base
|
function Base(options) {
this.define('options', options || {});
this.define('hints', this.hints || {});
this.define('data', this.data || {});
this.define('app', this.app || this.options.app || {});
this.define('_cache', {});
this.define('_callbacks', this._callbacks);
if (typeof this.options.mixins === 'object') {
this.visit('mixin', this.options.mixins);
}
}
|
javascript
|
function Base(options) {
this.define('options', options || {});
this.define('hints', this.hints || {});
this.define('data', this.data || {});
this.define('app', this.app || this.options.app || {});
this.define('_cache', {});
this.define('_callbacks', this._callbacks);
if (typeof this.options.mixins === 'object') {
this.visit('mixin', this.options.mixins);
}
}
|
[
"function",
"Base",
"(",
"options",
")",
"{",
"this",
".",
"define",
"(",
"'options'",
",",
"options",
"||",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'hints'",
",",
"this",
".",
"hints",
"||",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'data'",
",",
"this",
".",
"data",
"||",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'app'",
",",
"this",
".",
"app",
"||",
"this",
".",
"options",
".",
"app",
"||",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'_cache'",
",",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'_callbacks'",
",",
"this",
".",
"_callbacks",
")",
";",
"if",
"(",
"typeof",
"this",
".",
"options",
".",
"mixins",
"===",
"'object'",
")",
"{",
"this",
".",
"visit",
"(",
"'mixin'",
",",
"this",
".",
"options",
".",
"mixins",
")",
";",
"}",
"}"
] |
Create an instance of `Base` with specified `options.
The `Base` class extends `Collection`, `List` and `Item`
with common methods, properties and behavior.
```js
function MyClass(options) {
Base.call(this, options);
}
Base.extend(MyClass);
```
@param {Object} `options`
@return {undefined}
@api public
|
[
"Create",
"an",
"instance",
"of",
"Base",
"with",
"specified",
"options",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/base.js#L44-L55
|
train
|
jonschlinkert/template
|
lib/base.js
|
function (key, val) {
if (this._cache[key]) {
return this._cache[key];
}
if (typeof val === 'function') {
val = val.call(this);
}
return (this._cache[key] = val);
}
|
javascript
|
function (key, val) {
if (this._cache[key]) {
return this._cache[key];
}
if (typeof val === 'function') {
val = val.call(this);
}
return (this._cache[key] = val);
}
|
[
"function",
"(",
"key",
",",
"val",
")",
"{",
"if",
"(",
"this",
".",
"_cache",
"[",
"key",
"]",
")",
"{",
"return",
"this",
".",
"_cache",
"[",
"key",
"]",
";",
"}",
"if",
"(",
"typeof",
"val",
"===",
"'function'",
")",
"{",
"val",
"=",
"val",
".",
"call",
"(",
"this",
")",
";",
"}",
"return",
"(",
"this",
".",
"_cache",
"[",
"key",
"]",
"=",
"val",
")",
";",
"}"
] |
Get a value if it exists, otherwise call the given function
and cache the result and return it on subsequent calls.
@param {String} `key`
@param {any} `val`
@return {any}
@api public
|
[
"Get",
"a",
"value",
"if",
"it",
"exists",
"otherwise",
"call",
"the",
"given",
"function",
"and",
"cache",
"the",
"result",
"and",
"return",
"it",
"on",
"subsequent",
"calls",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/base.js#L74-L82
|
train
|
|
jonschlinkert/template
|
lib/base.js
|
function (keys) {
var Parent = this.constructor;
var opts = lazy.clone(this.options);
var res = new Parent(opts);
lazy.omit(this, keys, function (val, key) {
res[key] = lazy.clone(val);
});
return res;
}
|
javascript
|
function (keys) {
var Parent = this.constructor;
var opts = lazy.clone(this.options);
var res = new Parent(opts);
lazy.omit(this, keys, function (val, key) {
res[key] = lazy.clone(val);
});
return res;
}
|
[
"function",
"(",
"keys",
")",
"{",
"var",
"Parent",
"=",
"this",
".",
"constructor",
";",
"var",
"opts",
"=",
"lazy",
".",
"clone",
"(",
"this",
".",
"options",
")",
";",
"var",
"res",
"=",
"new",
"Parent",
"(",
"opts",
")",
";",
"lazy",
".",
"omit",
"(",
"this",
",",
"keys",
",",
"function",
"(",
"val",
",",
"key",
")",
"{",
"res",
"[",
"key",
"]",
"=",
"lazy",
".",
"clone",
"(",
"val",
")",
";",
"}",
")",
";",
"return",
"res",
";",
"}"
] |
Return a clone of the instance.
```js
var foo = app.clone();
```
@param {Array} keys Optionally pass an array of keys to omit.
@return {Object}
@api public
|
[
"Return",
"a",
"clone",
"of",
"the",
"instance",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/base.js#L95-L104
|
train
|
|
jonschlinkert/template
|
lib/base.js
|
function(prop) {
var opt = this.option(prop);
if (typeof opt === 'undefined') {
return this.app && this.app.option ? this.app.option(prop) : null;
}
return opt;
}
|
javascript
|
function(prop) {
var opt = this.option(prop);
if (typeof opt === 'undefined') {
return this.app && this.app.option ? this.app.option(prop) : null;
}
return opt;
}
|
[
"function",
"(",
"prop",
")",
"{",
"var",
"opt",
"=",
"this",
".",
"option",
"(",
"prop",
")",
";",
"if",
"(",
"typeof",
"opt",
"===",
"'undefined'",
")",
"{",
"return",
"this",
".",
"app",
"&&",
"this",
".",
"app",
".",
"option",
"?",
"this",
".",
"app",
".",
"option",
"(",
"prop",
")",
":",
"null",
";",
"}",
"return",
"opt",
";",
"}"
] |
Get an option from either the view, collection, or app instance,
in that order.
@param {String} prop Property name. Dot notation may be used.
@return {any}
@api public
|
[
"Get",
"an",
"option",
"from",
"either",
"the",
"view",
"collection",
"or",
"app",
"instance",
"in",
"that",
"order",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/base.js#L259-L265
|
train
|
|
jonschlinkert/template
|
lib/base.js
|
function (key, fn) {
if (typeof key === 'function') {
fn = key;
key = null;
}
if (typeof fn !== 'function') {
fn = this.pickOption('renameKey');
}
if (typeof fn !== 'function') {
fn = utils.identity;
}
this.options.renameKey = fn;
if (arguments.length === 2) {
return fn(key);
}
if (typeof key === 'string') {
return fn(key);
}
return fn;
}
|
javascript
|
function (key, fn) {
if (typeof key === 'function') {
fn = key;
key = null;
}
if (typeof fn !== 'function') {
fn = this.pickOption('renameKey');
}
if (typeof fn !== 'function') {
fn = utils.identity;
}
this.options.renameKey = fn;
if (arguments.length === 2) {
return fn(key);
}
if (typeof key === 'string') {
return fn(key);
}
return fn;
}
|
[
"function",
"(",
"key",
",",
"fn",
")",
"{",
"if",
"(",
"typeof",
"key",
"===",
"'function'",
")",
"{",
"fn",
"=",
"key",
";",
"key",
"=",
"null",
";",
"}",
"if",
"(",
"typeof",
"fn",
"!==",
"'function'",
")",
"{",
"fn",
"=",
"this",
".",
"pickOption",
"(",
"'renameKey'",
")",
";",
"}",
"if",
"(",
"typeof",
"fn",
"!==",
"'function'",
")",
"{",
"fn",
"=",
"utils",
".",
"identity",
";",
"}",
"this",
".",
"options",
".",
"renameKey",
"=",
"fn",
";",
"if",
"(",
"arguments",
".",
"length",
"===",
"2",
")",
"{",
"return",
"fn",
"(",
"key",
")",
";",
"}",
"if",
"(",
"typeof",
"key",
"===",
"'string'",
")",
"{",
"return",
"fn",
"(",
"key",
")",
";",
"}",
"return",
"fn",
";",
"}"
] |
Resolves the renaming function to use on `view` keys.
|
[
"Resolves",
"the",
"renaming",
"function",
"to",
"use",
"on",
"view",
"keys",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/base.js#L271-L291
|
train
|
|
johno/ember-linkify
|
addon/utils/url-regex.js
|
shortenUrl
|
function shortenUrl ( url , length ) {
if( !isBlank( url ) && url.length > length) {
url = url.substr( 0 , length ) + "...";
}
return url;
}
|
javascript
|
function shortenUrl ( url , length ) {
if( !isBlank( url ) && url.length > length) {
url = url.substr( 0 , length ) + "...";
}
return url;
}
|
[
"function",
"shortenUrl",
"(",
"url",
",",
"length",
")",
"{",
"if",
"(",
"!",
"isBlank",
"(",
"url",
")",
"&&",
"url",
".",
"length",
">",
"length",
")",
"{",
"url",
"=",
"url",
".",
"substr",
"(",
"0",
",",
"length",
")",
"+",
"\"...\"",
";",
"}",
"return",
"url",
";",
"}"
] |
Shortens the URL and adds three dots to the end
|
[
"Shortens",
"the",
"URL",
"and",
"adds",
"three",
"dots",
"to",
"the",
"end"
] |
dd3b59f6602218aab3244d00ffcbd9f42e4fdb7c
|
https://github.com/johno/ember-linkify/blob/dd3b59f6602218aab3244d00ffcbd9f42e4fdb7c/addon/utils/url-regex.js#L9-L16
|
train
|
jonschlinkert/template
|
lib/helpers/methods.js
|
function(helpers, options) {
if (typeof helpers === 'object') {
this.visit('helper', helpers);
return this;
}
if (lazy.isGlob(helpers)) {
this.loader('helpers-glob', ['base-glob'], function (files) {
return files.map(function (fp) {
return require(path.resolve(fp));
});
});
var res = this.compose('helpers-glob')(helpers, options);
this.visit('helper', res);
return this;
}
if (typeof helpers === 'string') {
console.log('loading helpers from a string is not implemented yet.');
}
return this;
}
|
javascript
|
function(helpers, options) {
if (typeof helpers === 'object') {
this.visit('helper', helpers);
return this;
}
if (lazy.isGlob(helpers)) {
this.loader('helpers-glob', ['base-glob'], function (files) {
return files.map(function (fp) {
return require(path.resolve(fp));
});
});
var res = this.compose('helpers-glob')(helpers, options);
this.visit('helper', res);
return this;
}
if (typeof helpers === 'string') {
console.log('loading helpers from a string is not implemented yet.');
}
return this;
}
|
[
"function",
"(",
"helpers",
",",
"options",
")",
"{",
"if",
"(",
"typeof",
"helpers",
"===",
"'object'",
")",
"{",
"this",
".",
"visit",
"(",
"'helper'",
",",
"helpers",
")",
";",
"return",
"this",
";",
"}",
"if",
"(",
"lazy",
".",
"isGlob",
"(",
"helpers",
")",
")",
"{",
"this",
".",
"loader",
"(",
"'helpers-glob'",
",",
"[",
"'base-glob'",
"]",
",",
"function",
"(",
"files",
")",
"{",
"return",
"files",
".",
"map",
"(",
"function",
"(",
"fp",
")",
"{",
"return",
"require",
"(",
"path",
".",
"resolve",
"(",
"fp",
")",
")",
";",
"}",
")",
";",
"}",
")",
";",
"var",
"res",
"=",
"this",
".",
"compose",
"(",
"'helpers-glob'",
")",
"(",
"helpers",
",",
"options",
")",
";",
"this",
".",
"visit",
"(",
"'helper'",
",",
"res",
")",
";",
"return",
"this",
";",
"}",
"if",
"(",
"typeof",
"helpers",
"===",
"'string'",
")",
"{",
"console",
".",
"log",
"(",
"'loading helpers from a string is not implemented yet.'",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
Register multiple template helpers.
@param {Object|Array} `helpers` Object, array of objects, or glob patterns.
@api public
|
[
"Register",
"multiple",
"template",
"helpers",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/helpers/methods.js#L77-L99
|
train
|
|
jonschlinkert/template
|
lib/list.js
|
List
|
function List(options) {
Base.call(this, options || {});
this.items = [];
this.define('keyMap', {});
this.define('Item', this.options.Item || require('./item'));
this.visit('item', this.options.items || {});
delete this.options.items;
mixins(this);
}
|
javascript
|
function List(options) {
Base.call(this, options || {});
this.items = [];
this.define('keyMap', {});
this.define('Item', this.options.Item || require('./item'));
this.visit('item', this.options.items || {});
delete this.options.items;
mixins(this);
}
|
[
"function",
"List",
"(",
"options",
")",
"{",
"Base",
".",
"call",
"(",
"this",
",",
"options",
"||",
"{",
"}",
")",
";",
"this",
".",
"items",
"=",
"[",
"]",
";",
"this",
".",
"define",
"(",
"'keyMap'",
",",
"{",
"}",
")",
";",
"this",
".",
"define",
"(",
"'Item'",
",",
"this",
".",
"options",
".",
"Item",
"||",
"require",
"(",
"'./item'",
")",
")",
";",
"this",
".",
"visit",
"(",
"'item'",
",",
"this",
".",
"options",
".",
"items",
"||",
"{",
"}",
")",
";",
"delete",
"this",
".",
"options",
".",
"items",
";",
"mixins",
"(",
"this",
")",
";",
"}"
] |
Create an instance of `List` with the given options. Lists are
arrayified collections, with items that can be sorted, filtered,
grouped, and paginated. The `List` constructor inherits from Base.
```js
var list = new List();
```
@param {Object} `options` `List` options (passed to `Base`)
@return {undefined}
@api public
|
[
"Create",
"an",
"instance",
"of",
"List",
"with",
"the",
"given",
"options",
".",
"Lists",
"are",
"arrayified",
"collections",
"with",
"items",
"that",
"can",
"be",
"sorted",
"filtered",
"grouped",
"and",
"paginated",
".",
"The",
"List",
"constructor",
"inherits",
"from",
"Base",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/list.js#L36-L44
|
train
|
jonschlinkert/template
|
lib/list.js
|
function(key, value) {
if (typeof key !== 'string') {
throw new TypeError('item key must be a string.');
}
if (typeof value === 'undefined') {
return this.getItem(key);
}
this.addItem(key, value);
return value;
}
|
javascript
|
function(key, value) {
if (typeof key !== 'string') {
throw new TypeError('item key must be a string.');
}
if (typeof value === 'undefined') {
return this.getItem(key);
}
this.addItem(key, value);
return value;
}
|
[
"function",
"(",
"key",
",",
"value",
")",
"{",
"if",
"(",
"typeof",
"key",
"!==",
"'string'",
")",
"{",
"throw",
"new",
"TypeError",
"(",
"'item key must be a string.'",
")",
";",
"}",
"if",
"(",
"typeof",
"value",
"===",
"'undefined'",
")",
"{",
"return",
"this",
".",
"getItem",
"(",
"key",
")",
";",
"}",
"this",
".",
"addItem",
"(",
"key",
",",
"value",
")",
";",
"return",
"value",
";",
"}"
] |
Get or Add an item to the list. Creates a new instance of `Item` when
adding.
```js
var list = new List();
list.item('foo', {name: 'foo'});
console.log(list.items);
//=> [{name: 'foo'}]
```
@param {String} `name` Name of the item to get or add.
@param {Object} `obj` Optional item to add or update.
@return {Object} `item`
@api public
|
[
"Get",
"or",
"Add",
"an",
"item",
"to",
"the",
"list",
".",
"Creates",
"a",
"new",
"instance",
"of",
"Item",
"when",
"adding",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/list.js#L76-L85
|
train
|
|
jonschlinkert/template
|
lib/list.js
|
function (key, value) {
var Item = this.get('Item');
if (!(value instanceof Item)) {
value = new Item(value);
}
value.key = value.key || key;
var i = this.indexOf(key);
if (i !== -1) {
this.items[i] = value;
} else {
this.items.push(value);
this.keyMap[key] = this.items.length - 1;
}
this.emit('item', key, value);
return this;
}
|
javascript
|
function (key, value) {
var Item = this.get('Item');
if (!(value instanceof Item)) {
value = new Item(value);
}
value.key = value.key || key;
var i = this.indexOf(key);
if (i !== -1) {
this.items[i] = value;
} else {
this.items.push(value);
this.keyMap[key] = this.items.length - 1;
}
this.emit('item', key, value);
return this;
}
|
[
"function",
"(",
"key",
",",
"value",
")",
"{",
"var",
"Item",
"=",
"this",
".",
"get",
"(",
"'Item'",
")",
";",
"if",
"(",
"!",
"(",
"value",
"instanceof",
"Item",
")",
")",
"{",
"value",
"=",
"new",
"Item",
"(",
"value",
")",
";",
"}",
"value",
".",
"key",
"=",
"value",
".",
"key",
"||",
"key",
";",
"var",
"i",
"=",
"this",
".",
"indexOf",
"(",
"key",
")",
";",
"if",
"(",
"i",
"!==",
"-",
"1",
")",
"{",
"this",
".",
"items",
"[",
"i",
"]",
"=",
"value",
";",
"}",
"else",
"{",
"this",
".",
"items",
".",
"push",
"(",
"value",
")",
";",
"this",
".",
"keyMap",
"[",
"key",
"]",
"=",
"this",
".",
"items",
".",
"length",
"-",
"1",
";",
"}",
"this",
".",
"emit",
"(",
"'item'",
",",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
Add a new item or update an existing item.
```js
list.addItem('foo', {contents: '...'});
```
@param {String} `key`
@param {Object} `value`
@api public
|
[
"Add",
"a",
"new",
"item",
"or",
"update",
"an",
"existing",
"item",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/list.js#L99-L118
|
train
|
|
jonschlinkert/template
|
lib/list.js
|
function (locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
lazy.each(this.items, function (item, next) {
this.app.render(item, locals, next);
}.bind(this), cb);
}
|
javascript
|
function (locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
lazy.each(this.items, function (item, next) {
this.app.render(item, locals, next);
}.bind(this), cb);
}
|
[
"function",
"(",
"locals",
",",
"cb",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'function'",
")",
"{",
"cb",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"lazy",
".",
"each",
"(",
"this",
".",
"items",
",",
"function",
"(",
"item",
",",
"next",
")",
"{",
"this",
".",
"app",
".",
"render",
"(",
"item",
",",
"locals",
",",
"next",
")",
";",
"}",
".",
"bind",
"(",
"this",
")",
",",
"cb",
")",
";",
"}"
] |
Render all items in the list and return an array in the callback.
@param {Object} `locals`
@param {Function} `fn`
@return {Object}
@api public
|
[
"Render",
"all",
"items",
"in",
"the",
"list",
"and",
"return",
"an",
"array",
"in",
"the",
"callback",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/list.js#L191-L200
|
train
|
|
jonschlinkert/template
|
lib/engines.js
|
function(exts, fn, options) {
if (arguments.length === 1 && typeof exts === 'string') {
return this.getEngine(exts);
}
exts = utils.arrayify(exts);
var len = exts.length;
while (len--) {
var ext = exts[len];
if (ext && ext[0] !== '.') ext = '.' + ext;
this._.engines.setEngine(ext, fn, options);
}
return this;
}
|
javascript
|
function(exts, fn, options) {
if (arguments.length === 1 && typeof exts === 'string') {
return this.getEngine(exts);
}
exts = utils.arrayify(exts);
var len = exts.length;
while (len--) {
var ext = exts[len];
if (ext && ext[0] !== '.') ext = '.' + ext;
this._.engines.setEngine(ext, fn, options);
}
return this;
}
|
[
"function",
"(",
"exts",
",",
"fn",
",",
"options",
")",
"{",
"if",
"(",
"arguments",
".",
"length",
"===",
"1",
"&&",
"typeof",
"exts",
"===",
"'string'",
")",
"{",
"return",
"this",
".",
"getEngine",
"(",
"exts",
")",
";",
"}",
"exts",
"=",
"utils",
".",
"arrayify",
"(",
"exts",
")",
";",
"var",
"len",
"=",
"exts",
".",
"length",
";",
"while",
"(",
"len",
"--",
")",
"{",
"var",
"ext",
"=",
"exts",
"[",
"len",
"]",
";",
"if",
"(",
"ext",
"&&",
"ext",
"[",
"0",
"]",
"!==",
"'.'",
")",
"ext",
"=",
"'.'",
"+",
"ext",
";",
"this",
".",
"_",
".",
"engines",
".",
"setEngine",
"(",
"ext",
",",
"fn",
",",
"options",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
Register the given view engine callback `fn` as `ext`.
@param {String|Array} `exts` File extension or array of extensions.
@param {Function|Object} `fn` or `options`
@param {Object} `options`
@api public
|
[
"Register",
"the",
"given",
"view",
"engine",
"callback",
"fn",
"as",
"ext",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/engines.js#L32-L44
|
train
|
|
jonschlinkert/template
|
lib/engines.js
|
function(ext) {
ext = ext || this.option('view engine');
if (ext && ext[0] !== '.') {
ext = '.' + ext;
}
return this._.engines.getEngine(ext);
}
|
javascript
|
function(ext) {
ext = ext || this.option('view engine');
if (ext && ext[0] !== '.') {
ext = '.' + ext;
}
return this._.engines.getEngine(ext);
}
|
[
"function",
"(",
"ext",
")",
"{",
"ext",
"=",
"ext",
"||",
"this",
".",
"option",
"(",
"'view engine'",
")",
";",
"if",
"(",
"ext",
"&&",
"ext",
"[",
"0",
"]",
"!==",
"'.'",
")",
"{",
"ext",
"=",
"'.'",
"+",
"ext",
";",
"}",
"return",
"this",
".",
"_",
".",
"engines",
".",
"getEngine",
"(",
"ext",
")",
";",
"}"
] |
Get the engine settings registered for the given `ext`.
@param {String} `ext` The engine to get.
@api public
|
[
"Get",
"the",
"engine",
"settings",
"registered",
"for",
"the",
"given",
"ext",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/engines.js#L53-L59
|
train
|
|
jonschlinkert/template
|
index.js
|
function(key, val) {
if (arguments.length === 1) {
if (typeof key === 'string') {
if (key.indexOf('.') === -1) {
return this.cache.data[key];
}
if (lazy.isGlob(key)) {
this.compose('data')(key, val);
return this;
}
return lazy.get(this.cache.data, key);
}
}
if (typeof key === 'object') {
var args = [].slice.call(arguments);
key = [].concat.apply([], args);
this.visit('data', key);
return this;
}
lazy.set(this.cache.data, key, val);
this.emit('data', key, val);
return this;
}
|
javascript
|
function(key, val) {
if (arguments.length === 1) {
if (typeof key === 'string') {
if (key.indexOf('.') === -1) {
return this.cache.data[key];
}
if (lazy.isGlob(key)) {
this.compose('data')(key, val);
return this;
}
return lazy.get(this.cache.data, key);
}
}
if (typeof key === 'object') {
var args = [].slice.call(arguments);
key = [].concat.apply([], args);
this.visit('data', key);
return this;
}
lazy.set(this.cache.data, key, val);
this.emit('data', key, val);
return this;
}
|
[
"function",
"(",
"key",
",",
"val",
")",
"{",
"if",
"(",
"arguments",
".",
"length",
"===",
"1",
")",
"{",
"if",
"(",
"typeof",
"key",
"===",
"'string'",
")",
"{",
"if",
"(",
"key",
".",
"indexOf",
"(",
"'.'",
")",
"===",
"-",
"1",
")",
"{",
"return",
"this",
".",
"cache",
".",
"data",
"[",
"key",
"]",
";",
"}",
"if",
"(",
"lazy",
".",
"isGlob",
"(",
"key",
")",
")",
"{",
"this",
".",
"compose",
"(",
"'data'",
")",
"(",
"key",
",",
"val",
")",
";",
"return",
"this",
";",
"}",
"return",
"lazy",
".",
"get",
"(",
"this",
".",
"cache",
".",
"data",
",",
"key",
")",
";",
"}",
"}",
"if",
"(",
"typeof",
"key",
"===",
"'object'",
")",
"{",
"var",
"args",
"=",
"[",
"]",
".",
"slice",
".",
"call",
"(",
"arguments",
")",
";",
"key",
"=",
"[",
"]",
".",
"concat",
".",
"apply",
"(",
"[",
"]",
",",
"args",
")",
";",
"this",
".",
"visit",
"(",
"'data'",
",",
"key",
")",
";",
"return",
"this",
";",
"}",
"lazy",
".",
"set",
"(",
"this",
".",
"cache",
".",
"data",
",",
"key",
",",
"val",
")",
";",
"this",
".",
"emit",
"(",
"'data'",
",",
"key",
",",
"val",
")",
";",
"return",
"this",
";",
"}"
] |
Load data onto `app.cache.data`
```js
console.log(app.cache.data);
//=> {};
app.data('a', 'b');
app.data({c: 'd'});
console.log(app.cache.data);
//=> {a: 'b', c: 'd'}
```
@name .data
@param {String|Object} `key` Key of the value to set, or object to extend.
@param {any} `val`
@return {Object} Returns the instance of `Template` for chaining
@api public
|
[
"Load",
"data",
"onto",
"app",
".",
"cache",
".",
"data"
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L159-L183
|
train
|
|
jonschlinkert/template
|
index.js
|
function (methods) {
this.lazyLoaders();
var loaders = this.loaders;
var self = this;
utils.arrayify(methods).forEach(function (method) {
self.define(method, function() {
return loaders[method].apply(loaders, arguments);
});
});
}
|
javascript
|
function (methods) {
this.lazyLoaders();
var loaders = this.loaders;
var self = this;
utils.arrayify(methods).forEach(function (method) {
self.define(method, function() {
return loaders[method].apply(loaders, arguments);
});
});
}
|
[
"function",
"(",
"methods",
")",
"{",
"this",
".",
"lazyLoaders",
"(",
")",
";",
"var",
"loaders",
"=",
"this",
".",
"loaders",
";",
"var",
"self",
"=",
"this",
";",
"utils",
".",
"arrayify",
"(",
"methods",
")",
".",
"forEach",
"(",
"function",
"(",
"method",
")",
"{",
"self",
".",
"define",
"(",
"method",
",",
"function",
"(",
")",
"{",
"return",
"loaders",
"[",
"method",
"]",
".",
"apply",
"(",
"loaders",
",",
"arguments",
")",
";",
"}",
")",
";",
"}",
")",
";",
"}"
] |
Delegate loader methods
|
[
"Delegate",
"loader",
"methods"
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L200-L210
|
train
|
|
jonschlinkert/template
|
index.js
|
function (name, opts, loaders) {
var args = utils.slice(arguments, 1);
opts = lazy.clone(args.shift());
loaders = args;
var single = lazy.inflect.singularize(name);
var plural = lazy.inflect.pluralize(name);
this.inflections[single] = plural;
if (typeof opts.renameKey === 'undefined' && this.options.renameKey) {
opts.renameKey = this.options.renameKey;
}
opts.plural = plural;
opts.inflection = single;
opts.loaders = loaders;
opts.app = this;
opts = lazy.extend({}, opts, this.options);
if (!opts.loaderType) {
opts.loaderType = 'sync';
}
var Views = this.get('Views');
var views = new Views(opts);
this.viewType(plural, views.viewType());
// add custom View constructor for collection items
var ViewClass = viewFactory(single, opts);
var classKey = single[0].toUpperCase() + single.slice(1);
this.define(classKey, ViewClass);
// init the collection object on `views`
this.views[plural] = views;
this.loader(plural, opts, loaders);
// wrap loaders to expose the collection and opts
utils.defineProp(opts, 'wrap', views.wrap.bind(views, opts));
opts.defaultLoader = opts.defaultLoader || 'default';
// create the actual loader function
var fn = this.compose(plural, opts);
views.forward(fn, ['forOwn']);
// forward collection methods onto loader
utils.setProto(fn, views);
// add loader methods to the instance: `app.pages()`
this.mixin(single, fn);
this.mixin(plural, fn);
// decorate named loader methods back to the collection
// to allow chaining like `.pages().pages()` etc
utils.defineProp(views, plural, fn);
utils.defineProp(views, single, fn);
// add collection and view (item) helpers
helpers.collection(this, views, opts);
helpers.view(this, views, opts);
return this;
}
|
javascript
|
function (name, opts, loaders) {
var args = utils.slice(arguments, 1);
opts = lazy.clone(args.shift());
loaders = args;
var single = lazy.inflect.singularize(name);
var plural = lazy.inflect.pluralize(name);
this.inflections[single] = plural;
if (typeof opts.renameKey === 'undefined' && this.options.renameKey) {
opts.renameKey = this.options.renameKey;
}
opts.plural = plural;
opts.inflection = single;
opts.loaders = loaders;
opts.app = this;
opts = lazy.extend({}, opts, this.options);
if (!opts.loaderType) {
opts.loaderType = 'sync';
}
var Views = this.get('Views');
var views = new Views(opts);
this.viewType(plural, views.viewType());
// add custom View constructor for collection items
var ViewClass = viewFactory(single, opts);
var classKey = single[0].toUpperCase() + single.slice(1);
this.define(classKey, ViewClass);
// init the collection object on `views`
this.views[plural] = views;
this.loader(plural, opts, loaders);
// wrap loaders to expose the collection and opts
utils.defineProp(opts, 'wrap', views.wrap.bind(views, opts));
opts.defaultLoader = opts.defaultLoader || 'default';
// create the actual loader function
var fn = this.compose(plural, opts);
views.forward(fn, ['forOwn']);
// forward collection methods onto loader
utils.setProto(fn, views);
// add loader methods to the instance: `app.pages()`
this.mixin(single, fn);
this.mixin(plural, fn);
// decorate named loader methods back to the collection
// to allow chaining like `.pages().pages()` etc
utils.defineProp(views, plural, fn);
utils.defineProp(views, single, fn);
// add collection and view (item) helpers
helpers.collection(this, views, opts);
helpers.view(this, views, opts);
return this;
}
|
[
"function",
"(",
"name",
",",
"opts",
",",
"loaders",
")",
"{",
"var",
"args",
"=",
"utils",
".",
"slice",
"(",
"arguments",
",",
"1",
")",
";",
"opts",
"=",
"lazy",
".",
"clone",
"(",
"args",
".",
"shift",
"(",
")",
")",
";",
"loaders",
"=",
"args",
";",
"var",
"single",
"=",
"lazy",
".",
"inflect",
".",
"singularize",
"(",
"name",
")",
";",
"var",
"plural",
"=",
"lazy",
".",
"inflect",
".",
"pluralize",
"(",
"name",
")",
";",
"this",
".",
"inflections",
"[",
"single",
"]",
"=",
"plural",
";",
"if",
"(",
"typeof",
"opts",
".",
"renameKey",
"===",
"'undefined'",
"&&",
"this",
".",
"options",
".",
"renameKey",
")",
"{",
"opts",
".",
"renameKey",
"=",
"this",
".",
"options",
".",
"renameKey",
";",
"}",
"opts",
".",
"plural",
"=",
"plural",
";",
"opts",
".",
"inflection",
"=",
"single",
";",
"opts",
".",
"loaders",
"=",
"loaders",
";",
"opts",
".",
"app",
"=",
"this",
";",
"opts",
"=",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"opts",
",",
"this",
".",
"options",
")",
";",
"if",
"(",
"!",
"opts",
".",
"loaderType",
")",
"{",
"opts",
".",
"loaderType",
"=",
"'sync'",
";",
"}",
"var",
"Views",
"=",
"this",
".",
"get",
"(",
"'Views'",
")",
";",
"var",
"views",
"=",
"new",
"Views",
"(",
"opts",
")",
";",
"this",
".",
"viewType",
"(",
"plural",
",",
"views",
".",
"viewType",
"(",
")",
")",
";",
"var",
"ViewClass",
"=",
"viewFactory",
"(",
"single",
",",
"opts",
")",
";",
"var",
"classKey",
"=",
"single",
"[",
"0",
"]",
".",
"toUpperCase",
"(",
")",
"+",
"single",
".",
"slice",
"(",
"1",
")",
";",
"this",
".",
"define",
"(",
"classKey",
",",
"ViewClass",
")",
";",
"this",
".",
"views",
"[",
"plural",
"]",
"=",
"views",
";",
"this",
".",
"loader",
"(",
"plural",
",",
"opts",
",",
"loaders",
")",
";",
"utils",
".",
"defineProp",
"(",
"opts",
",",
"'wrap'",
",",
"views",
".",
"wrap",
".",
"bind",
"(",
"views",
",",
"opts",
")",
")",
";",
"opts",
".",
"defaultLoader",
"=",
"opts",
".",
"defaultLoader",
"||",
"'default'",
";",
"var",
"fn",
"=",
"this",
".",
"compose",
"(",
"plural",
",",
"opts",
")",
";",
"views",
".",
"forward",
"(",
"fn",
",",
"[",
"'forOwn'",
"]",
")",
";",
"utils",
".",
"setProto",
"(",
"fn",
",",
"views",
")",
";",
"this",
".",
"mixin",
"(",
"single",
",",
"fn",
")",
";",
"this",
".",
"mixin",
"(",
"plural",
",",
"fn",
")",
";",
"utils",
".",
"defineProp",
"(",
"views",
",",
"plural",
",",
"fn",
")",
";",
"utils",
".",
"defineProp",
"(",
"views",
",",
"single",
",",
"fn",
")",
";",
"helpers",
".",
"collection",
"(",
"this",
",",
"views",
",",
"opts",
")",
";",
"helpers",
".",
"view",
"(",
"this",
",",
"views",
",",
"opts",
")",
";",
"return",
"this",
";",
"}"
] |
Create a new `Views` collection.
```js
app.create('foo');
app.foo('*.hbs');
var view = app.foo.get('baz.hbs');
```
@name .create
@param {String} `name` The name of the collection. Plural or singular form.
@param {Object} `opts` Collection options
@param {String|Array|Function} `loaders` Loaders to use for adding views to the created collection.
@return {Object} Returns the `Assemble` instance for chaining.
@api public
|
[
"Create",
"a",
"new",
"Views",
"collection",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L229-L289
|
train
|
|
jonschlinkert/template
|
index.js
|
function (method, view, locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
this.lazyRouter();
view.options = view.options || {};
view.options.handled = view.options.handled || [];
if (typeof cb !== 'function') {
cb = this.handleError(method, view);
}
view.options.method = method;
view.options.handled.push(method);
if (view.emit) {
view.emit('handle', method);
}
this.router.handle(view, function (err) {
if (err) return cb(err);
cb(null, view);
});
}
|
javascript
|
function (method, view, locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
this.lazyRouter();
view.options = view.options || {};
view.options.handled = view.options.handled || [];
if (typeof cb !== 'function') {
cb = this.handleError(method, view);
}
view.options.method = method;
view.options.handled.push(method);
if (view.emit) {
view.emit('handle', method);
}
this.router.handle(view, function (err) {
if (err) return cb(err);
cb(null, view);
});
}
|
[
"function",
"(",
"method",
",",
"view",
",",
"locals",
",",
"cb",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'function'",
")",
"{",
"cb",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"this",
".",
"lazyRouter",
"(",
")",
";",
"view",
".",
"options",
"=",
"view",
".",
"options",
"||",
"{",
"}",
";",
"view",
".",
"options",
".",
"handled",
"=",
"view",
".",
"options",
".",
"handled",
"||",
"[",
"]",
";",
"if",
"(",
"typeof",
"cb",
"!==",
"'function'",
")",
"{",
"cb",
"=",
"this",
".",
"handleError",
"(",
"method",
",",
"view",
")",
";",
"}",
"view",
".",
"options",
".",
"method",
"=",
"method",
";",
"view",
".",
"options",
".",
"handled",
".",
"push",
"(",
"method",
")",
";",
"if",
"(",
"view",
".",
"emit",
")",
"{",
"view",
".",
"emit",
"(",
"'handle'",
",",
"method",
")",
";",
"}",
"this",
".",
"router",
".",
"handle",
"(",
"view",
",",
"function",
"(",
"err",
")",
"{",
"if",
"(",
"err",
")",
"return",
"cb",
"(",
"err",
")",
";",
"cb",
"(",
"null",
",",
"view",
")",
";",
"}",
")",
";",
"}"
] |
Handle middleware for the given `view` and locals.
```js
app.handle('customHandle', view);
```
@name .handle
@param {String} `method` Router VERB
@param {Object} `view` View object
@param {Object} `locals`
@param {Function} `cb`
@return {Object}
@api public
|
[
"Handle",
"middleware",
"for",
"the",
"given",
"view",
"and",
"locals",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L345-L369
|
train
|
|
jonschlinkert/template
|
index.js
|
function (method, view, locals/*, cb*/) {
if (view.options.handled.indexOf(method) === -1) {
this.handle.apply(this, arguments);
}
this.emit(method, view, locals);
}
|
javascript
|
function (method, view, locals/*, cb*/) {
if (view.options.handled.indexOf(method) === -1) {
this.handle.apply(this, arguments);
}
this.emit(method, view, locals);
}
|
[
"function",
"(",
"method",
",",
"view",
",",
"locals",
")",
"{",
"if",
"(",
"view",
".",
"options",
".",
"handled",
".",
"indexOf",
"(",
"method",
")",
"===",
"-",
"1",
")",
"{",
"this",
".",
"handle",
".",
"apply",
"(",
"this",
",",
"arguments",
")",
";",
"}",
"this",
".",
"emit",
"(",
"method",
",",
"view",
",",
"locals",
")",
";",
"}"
] |
Run the given handler only if the view has not
already been handled by the method
@name .handleView
@param {Object} `collection` Collection name
@param {Object} `locals`
@return {Array} Returns an array of view objects with rendered content.
|
[
"Run",
"the",
"given",
"handler",
"only",
"if",
"the",
"view",
"has",
"not",
"already",
"been",
"handled",
"by",
"the",
"method"
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L381-L386
|
train
|
|
jonschlinkert/template
|
index.js
|
function(method, view) {
return function (err) {
if (err) {
err.reason = 'Template#handle' + method + ': ' + view.path;
return err;
}
};
}
|
javascript
|
function(method, view) {
return function (err) {
if (err) {
err.reason = 'Template#handle' + method + ': ' + view.path;
return err;
}
};
}
|
[
"function",
"(",
"method",
",",
"view",
")",
"{",
"return",
"function",
"(",
"err",
")",
"{",
"if",
"(",
"err",
")",
"{",
"err",
".",
"reason",
"=",
"'Template#handle'",
"+",
"method",
"+",
"': '",
"+",
"view",
".",
"path",
";",
"return",
"err",
";",
"}",
"}",
";",
"}"
] |
Handle middleware errors.
|
[
"Handle",
"middleware",
"errors",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L392-L399
|
train
|
|
jonschlinkert/template
|
index.js
|
function(path/*, callback*/) {
this.lazyRouter();
var route = this.router.route(path);
route.all.apply(route, [].slice.call(arguments, 1));
return this;
}
|
javascript
|
function(path/*, callback*/) {
this.lazyRouter();
var route = this.router.route(path);
route.all.apply(route, [].slice.call(arguments, 1));
return this;
}
|
[
"function",
"(",
"path",
")",
"{",
"this",
".",
"lazyRouter",
"(",
")",
";",
"var",
"route",
"=",
"this",
".",
"router",
".",
"route",
"(",
"path",
")",
";",
"route",
".",
"all",
".",
"apply",
"(",
"route",
",",
"[",
"]",
".",
"slice",
".",
"call",
"(",
"arguments",
",",
"1",
")",
")",
";",
"return",
"this",
";",
"}"
] |
Special-cased "all" method, applying the given route `path`,
middleware, and callback.
@name .all
@param {String} `path`
@param {Function} `callback`
@return {Object} `this` for chaining
|
[
"Special",
"-",
"cased",
"all",
"method",
"applying",
"the",
"given",
"route",
"path",
"middleware",
"and",
"callback",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L411-L416
|
train
|
|
jonschlinkert/template
|
index.js
|
function(view) {
if (view.options.layoutApplied) {
return view;
}
// handle pre-layout middleware
this.handle('preLayout', view);
var opts = {};
lazy.extend(opts, this.options);
lazy.extend(opts, view.options);
lazy.extend(opts, view.context());
// get the layout stack
var stack = {};
var alias = this.viewTypes.layout;
var len = alias.length, i = 0;
while (len--) {
var views = this.views[alias[i++]];
for (var key in views) {
var val = views[key];
if (views.hasOwnProperty(key) && typeof val !== 'function' && val.path) {
stack[key] = val;
}
}
}
// get the name of the first layout
var name = view.layout;
var str = view.content;
var self = this;
if (!name) return view;
// Handle each layout before it's applied to a view
function handleLayout(layoutObj) {
view.currentLayout = layoutObj.layout;
self.handle('onLayout', view);
delete view.currentLayout;
}
// actually apply the layout
var res = lazy.layouts(str, name, stack, opts, handleLayout);
view.option('layoutStack', res.history);
view.option('layoutApplied', true);
view.content = res.result;
// handle post-layout middleware
this.handle('postLayout', view);
return view;
}
|
javascript
|
function(view) {
if (view.options.layoutApplied) {
return view;
}
// handle pre-layout middleware
this.handle('preLayout', view);
var opts = {};
lazy.extend(opts, this.options);
lazy.extend(opts, view.options);
lazy.extend(opts, view.context());
// get the layout stack
var stack = {};
var alias = this.viewTypes.layout;
var len = alias.length, i = 0;
while (len--) {
var views = this.views[alias[i++]];
for (var key in views) {
var val = views[key];
if (views.hasOwnProperty(key) && typeof val !== 'function' && val.path) {
stack[key] = val;
}
}
}
// get the name of the first layout
var name = view.layout;
var str = view.content;
var self = this;
if (!name) return view;
// Handle each layout before it's applied to a view
function handleLayout(layoutObj) {
view.currentLayout = layoutObj.layout;
self.handle('onLayout', view);
delete view.currentLayout;
}
// actually apply the layout
var res = lazy.layouts(str, name, stack, opts, handleLayout);
view.option('layoutStack', res.history);
view.option('layoutApplied', true);
view.content = res.result;
// handle post-layout middleware
this.handle('postLayout', view);
return view;
}
|
[
"function",
"(",
"view",
")",
"{",
"if",
"(",
"view",
".",
"options",
".",
"layoutApplied",
")",
"{",
"return",
"view",
";",
"}",
"this",
".",
"handle",
"(",
"'preLayout'",
",",
"view",
")",
";",
"var",
"opts",
"=",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"opts",
",",
"this",
".",
"options",
")",
";",
"lazy",
".",
"extend",
"(",
"opts",
",",
"view",
".",
"options",
")",
";",
"lazy",
".",
"extend",
"(",
"opts",
",",
"view",
".",
"context",
"(",
")",
")",
";",
"var",
"stack",
"=",
"{",
"}",
";",
"var",
"alias",
"=",
"this",
".",
"viewTypes",
".",
"layout",
";",
"var",
"len",
"=",
"alias",
".",
"length",
",",
"i",
"=",
"0",
";",
"while",
"(",
"len",
"--",
")",
"{",
"var",
"views",
"=",
"this",
".",
"views",
"[",
"alias",
"[",
"i",
"++",
"]",
"]",
";",
"for",
"(",
"var",
"key",
"in",
"views",
")",
"{",
"var",
"val",
"=",
"views",
"[",
"key",
"]",
";",
"if",
"(",
"views",
".",
"hasOwnProperty",
"(",
"key",
")",
"&&",
"typeof",
"val",
"!==",
"'function'",
"&&",
"val",
".",
"path",
")",
"{",
"stack",
"[",
"key",
"]",
"=",
"val",
";",
"}",
"}",
"}",
"var",
"name",
"=",
"view",
".",
"layout",
";",
"var",
"str",
"=",
"view",
".",
"content",
";",
"var",
"self",
"=",
"this",
";",
"if",
"(",
"!",
"name",
")",
"return",
"view",
";",
"function",
"handleLayout",
"(",
"layoutObj",
")",
"{",
"view",
".",
"currentLayout",
"=",
"layoutObj",
".",
"layout",
";",
"self",
".",
"handle",
"(",
"'onLayout'",
",",
"view",
")",
";",
"delete",
"view",
".",
"currentLayout",
";",
"}",
"var",
"res",
"=",
"lazy",
".",
"layouts",
"(",
"str",
",",
"name",
",",
"stack",
",",
"opts",
",",
"handleLayout",
")",
";",
"view",
".",
"option",
"(",
"'layoutStack'",
",",
"res",
".",
"history",
")",
";",
"view",
".",
"option",
"(",
"'layoutApplied'",
",",
"true",
")",
";",
"view",
".",
"content",
"=",
"res",
".",
"result",
";",
"this",
".",
"handle",
"(",
"'postLayout'",
",",
"view",
")",
";",
"return",
"view",
";",
"}"
] |
Apply a layout to the given `view`.
@name .applyLayout
@param {Object} `view`
@return {Object} Returns a `view` object.
|
[
"Apply",
"a",
"layout",
"to",
"the",
"given",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L441-L493
|
train
|
|
jonschlinkert/template
|
index.js
|
function(view, locals, isAsync) {
if (typeof locals === 'boolean') {
isAsync = locals;
locals = {};
}
// get the engine to use
locals = locals || {};
var engine = this.engine(locals.engine ? locals.engine : view.engine);
if (typeof engine === 'undefined') {
throw this.error('compile', 'engine', view);
}
if (!engine.hasOwnProperty('compile')) {
throw this.error('compile', 'method', engine);
}
view.ctx('compile', locals);
// build the context to pass to the engine
var ctx = view.context(locals);
// apply layout
view = this.applyLayout(view, ctx);
// handle `preCompile` middleware
this.handleView('preCompile', view, locals);
// Bind context to helpers before passing to the engine.
this.bindHelpers(view, locals, ctx, (locals.async = isAsync));
var settings = lazy.extend({}, ctx, locals);
// compile the string
view.fn = engine.compile(view.content, settings);
// handle `postCompile` middleware
this.handleView('postCompile', view, locals);
return view;
}
|
javascript
|
function(view, locals, isAsync) {
if (typeof locals === 'boolean') {
isAsync = locals;
locals = {};
}
// get the engine to use
locals = locals || {};
var engine = this.engine(locals.engine ? locals.engine : view.engine);
if (typeof engine === 'undefined') {
throw this.error('compile', 'engine', view);
}
if (!engine.hasOwnProperty('compile')) {
throw this.error('compile', 'method', engine);
}
view.ctx('compile', locals);
// build the context to pass to the engine
var ctx = view.context(locals);
// apply layout
view = this.applyLayout(view, ctx);
// handle `preCompile` middleware
this.handleView('preCompile', view, locals);
// Bind context to helpers before passing to the engine.
this.bindHelpers(view, locals, ctx, (locals.async = isAsync));
var settings = lazy.extend({}, ctx, locals);
// compile the string
view.fn = engine.compile(view.content, settings);
// handle `postCompile` middleware
this.handleView('postCompile', view, locals);
return view;
}
|
[
"function",
"(",
"view",
",",
"locals",
",",
"isAsync",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'boolean'",
")",
"{",
"isAsync",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"locals",
"=",
"locals",
"||",
"{",
"}",
";",
"var",
"engine",
"=",
"this",
".",
"engine",
"(",
"locals",
".",
"engine",
"?",
"locals",
".",
"engine",
":",
"view",
".",
"engine",
")",
";",
"if",
"(",
"typeof",
"engine",
"===",
"'undefined'",
")",
"{",
"throw",
"this",
".",
"error",
"(",
"'compile'",
",",
"'engine'",
",",
"view",
")",
";",
"}",
"if",
"(",
"!",
"engine",
".",
"hasOwnProperty",
"(",
"'compile'",
")",
")",
"{",
"throw",
"this",
".",
"error",
"(",
"'compile'",
",",
"'method'",
",",
"engine",
")",
";",
"}",
"view",
".",
"ctx",
"(",
"'compile'",
",",
"locals",
")",
";",
"var",
"ctx",
"=",
"view",
".",
"context",
"(",
"locals",
")",
";",
"view",
"=",
"this",
".",
"applyLayout",
"(",
"view",
",",
"ctx",
")",
";",
"this",
".",
"handleView",
"(",
"'preCompile'",
",",
"view",
",",
"locals",
")",
";",
"this",
".",
"bindHelpers",
"(",
"view",
",",
"locals",
",",
"ctx",
",",
"(",
"locals",
".",
"async",
"=",
"isAsync",
")",
")",
";",
"var",
"settings",
"=",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"ctx",
",",
"locals",
")",
";",
"view",
".",
"fn",
"=",
"engine",
".",
"compile",
"(",
"view",
".",
"content",
",",
"settings",
")",
";",
"this",
".",
"handleView",
"(",
"'postCompile'",
",",
"view",
",",
"locals",
")",
";",
"return",
"view",
";",
"}"
] |
Compile `content` with the given `locals`.
```js
var blogPost = app.post('2015-09-01-foo-bar');
var view = app.compile(blogPost);
// view.fn => [function]
```
@name .compile
@param {Object|String} `view` View object.
@param {Object} `locals`
@param {Boolean} `isAsync` Load async helpers
@return {Object} View object with `fn` property with the compiled function.
@api public
|
[
"Compile",
"content",
"with",
"the",
"given",
"locals",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L512-L546
|
train
|
|
jonschlinkert/template
|
index.js
|
function (view, locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
// if `view` is a function, it's probably from chaining
// a collection method
if (typeof view === 'function') {
return view.call(this);
}
// if `view` is a string, see if it's a cache view
if (typeof view === 'string') {
view = this.lookup(view);
}
locals = locals || {};
// add `locals` to `view.contexts`
view.ctx('render', locals);
var data = this.cache.data;
for (var key in locals) {
if (locals.hasOwnProperty(key) && !data.hasOwnProperty(key)) {
data[key] = locals[key];
}
}
// handle `preRender` middleware
this.handleView('preRender', view, locals);
// build the context for the view
var ctx = this.context(locals);
// get the engine
var engine = this.engine(locals.engine ? locals.engine : view.engine);
if (typeof cb !== 'function') {
throw this.error('render', 'callback');
}
if (typeof engine === 'undefined') {
throw this.error('render', 'engine', path.extname(view.path));
}
if (!engine.hasOwnProperty('render')) {
throw this.error('render', 'method', JSON.stringify(view));
}
// if it's not already compiled, do that first
if (typeof view.fn !== 'function') {
try {
var isAsync = typeof cb === 'function';
view = this.compile(view, locals, isAsync);
return this.render(view, locals, cb);
} catch (err) {
this.emit('error', err);
return cb.call(this, err);
}
}
var context = this.context(view, ctx, locals);
// render the view
return engine.render(view.fn, context, function (err, res) {
if (err) {
this.emit('error', err);
return cb.call(this, err);
}
// handle `postRender` middleware
view.content = res;
this.handle('postRender', view, locals, cb);
}.bind(this));
}
|
javascript
|
function (view, locals, cb) {
if (typeof locals === 'function') {
cb = locals;
locals = {};
}
// if `view` is a function, it's probably from chaining
// a collection method
if (typeof view === 'function') {
return view.call(this);
}
// if `view` is a string, see if it's a cache view
if (typeof view === 'string') {
view = this.lookup(view);
}
locals = locals || {};
// add `locals` to `view.contexts`
view.ctx('render', locals);
var data = this.cache.data;
for (var key in locals) {
if (locals.hasOwnProperty(key) && !data.hasOwnProperty(key)) {
data[key] = locals[key];
}
}
// handle `preRender` middleware
this.handleView('preRender', view, locals);
// build the context for the view
var ctx = this.context(locals);
// get the engine
var engine = this.engine(locals.engine ? locals.engine : view.engine);
if (typeof cb !== 'function') {
throw this.error('render', 'callback');
}
if (typeof engine === 'undefined') {
throw this.error('render', 'engine', path.extname(view.path));
}
if (!engine.hasOwnProperty('render')) {
throw this.error('render', 'method', JSON.stringify(view));
}
// if it's not already compiled, do that first
if (typeof view.fn !== 'function') {
try {
var isAsync = typeof cb === 'function';
view = this.compile(view, locals, isAsync);
return this.render(view, locals, cb);
} catch (err) {
this.emit('error', err);
return cb.call(this, err);
}
}
var context = this.context(view, ctx, locals);
// render the view
return engine.render(view.fn, context, function (err, res) {
if (err) {
this.emit('error', err);
return cb.call(this, err);
}
// handle `postRender` middleware
view.content = res;
this.handle('postRender', view, locals, cb);
}.bind(this));
}
|
[
"function",
"(",
"view",
",",
"locals",
",",
"cb",
")",
"{",
"if",
"(",
"typeof",
"locals",
"===",
"'function'",
")",
"{",
"cb",
"=",
"locals",
";",
"locals",
"=",
"{",
"}",
";",
"}",
"if",
"(",
"typeof",
"view",
"===",
"'function'",
")",
"{",
"return",
"view",
".",
"call",
"(",
"this",
")",
";",
"}",
"if",
"(",
"typeof",
"view",
"===",
"'string'",
")",
"{",
"view",
"=",
"this",
".",
"lookup",
"(",
"view",
")",
";",
"}",
"locals",
"=",
"locals",
"||",
"{",
"}",
";",
"view",
".",
"ctx",
"(",
"'render'",
",",
"locals",
")",
";",
"var",
"data",
"=",
"this",
".",
"cache",
".",
"data",
";",
"for",
"(",
"var",
"key",
"in",
"locals",
")",
"{",
"if",
"(",
"locals",
".",
"hasOwnProperty",
"(",
"key",
")",
"&&",
"!",
"data",
".",
"hasOwnProperty",
"(",
"key",
")",
")",
"{",
"data",
"[",
"key",
"]",
"=",
"locals",
"[",
"key",
"]",
";",
"}",
"}",
"this",
".",
"handleView",
"(",
"'preRender'",
",",
"view",
",",
"locals",
")",
";",
"var",
"ctx",
"=",
"this",
".",
"context",
"(",
"locals",
")",
";",
"var",
"engine",
"=",
"this",
".",
"engine",
"(",
"locals",
".",
"engine",
"?",
"locals",
".",
"engine",
":",
"view",
".",
"engine",
")",
";",
"if",
"(",
"typeof",
"cb",
"!==",
"'function'",
")",
"{",
"throw",
"this",
".",
"error",
"(",
"'render'",
",",
"'callback'",
")",
";",
"}",
"if",
"(",
"typeof",
"engine",
"===",
"'undefined'",
")",
"{",
"throw",
"this",
".",
"error",
"(",
"'render'",
",",
"'engine'",
",",
"path",
".",
"extname",
"(",
"view",
".",
"path",
")",
")",
";",
"}",
"if",
"(",
"!",
"engine",
".",
"hasOwnProperty",
"(",
"'render'",
")",
")",
"{",
"throw",
"this",
".",
"error",
"(",
"'render'",
",",
"'method'",
",",
"JSON",
".",
"stringify",
"(",
"view",
")",
")",
";",
"}",
"if",
"(",
"typeof",
"view",
".",
"fn",
"!==",
"'function'",
")",
"{",
"try",
"{",
"var",
"isAsync",
"=",
"typeof",
"cb",
"===",
"'function'",
";",
"view",
"=",
"this",
".",
"compile",
"(",
"view",
",",
"locals",
",",
"isAsync",
")",
";",
"return",
"this",
".",
"render",
"(",
"view",
",",
"locals",
",",
"cb",
")",
";",
"}",
"catch",
"(",
"err",
")",
"{",
"this",
".",
"emit",
"(",
"'error'",
",",
"err",
")",
";",
"return",
"cb",
".",
"call",
"(",
"this",
",",
"err",
")",
";",
"}",
"}",
"var",
"context",
"=",
"this",
".",
"context",
"(",
"view",
",",
"ctx",
",",
"locals",
")",
";",
"return",
"engine",
".",
"render",
"(",
"view",
".",
"fn",
",",
"context",
",",
"function",
"(",
"err",
",",
"res",
")",
"{",
"if",
"(",
"err",
")",
"{",
"this",
".",
"emit",
"(",
"'error'",
",",
"err",
")",
";",
"return",
"cb",
".",
"call",
"(",
"this",
",",
"err",
")",
";",
"}",
"view",
".",
"content",
"=",
"res",
";",
"this",
".",
"handle",
"(",
"'postRender'",
",",
"view",
",",
"locals",
",",
"cb",
")",
";",
"}",
".",
"bind",
"(",
"this",
")",
")",
";",
"}"
] |
Render `content` with the given `locals` and `callback`.
```js
var blogPost = app.post('2015-09-01-foo-bar');
app.render(blogPost, function(err, view) {
// `view` is an object with a rendered `content` property
});
```
@name .render
@param {Object|String} `file` String or normalized template object.
@param {Object} `locals` Locals to pass to registered view engines.
@param {Function} `callback`
@api public
|
[
"Render",
"content",
"with",
"the",
"given",
"locals",
"and",
"callback",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L565-L636
|
train
|
|
jonschlinkert/template
|
index.js
|
function (locals, viewTypes) {
var names = viewTypes || this.viewTypes.partial;
var opts = lazy.extend({}, this.options, locals);
return names.reduce(function (acc, name) {
var collection = this.views[name];
lazy.forOwn(collection, function (view, key) {
// handle `onMerge` middleware
this.handleView('onMerge', view, locals);
if (view.options.nomerge) return;
if (opts.mergePartials !== false) {
name = 'partials';
}
acc[name] = acc[name] || {};
acc[name][key] = view.content;
}, this);
return acc;
}.bind(this), {});
}
|
javascript
|
function (locals, viewTypes) {
var names = viewTypes || this.viewTypes.partial;
var opts = lazy.extend({}, this.options, locals);
return names.reduce(function (acc, name) {
var collection = this.views[name];
lazy.forOwn(collection, function (view, key) {
// handle `onMerge` middleware
this.handleView('onMerge', view, locals);
if (view.options.nomerge) return;
if (opts.mergePartials !== false) {
name = 'partials';
}
acc[name] = acc[name] || {};
acc[name][key] = view.content;
}, this);
return acc;
}.bind(this), {});
}
|
[
"function",
"(",
"locals",
",",
"viewTypes",
")",
"{",
"var",
"names",
"=",
"viewTypes",
"||",
"this",
".",
"viewTypes",
".",
"partial",
";",
"var",
"opts",
"=",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"this",
".",
"options",
",",
"locals",
")",
";",
"return",
"names",
".",
"reduce",
"(",
"function",
"(",
"acc",
",",
"name",
")",
"{",
"var",
"collection",
"=",
"this",
".",
"views",
"[",
"name",
"]",
";",
"lazy",
".",
"forOwn",
"(",
"collection",
",",
"function",
"(",
"view",
",",
"key",
")",
"{",
"this",
".",
"handleView",
"(",
"'onMerge'",
",",
"view",
",",
"locals",
")",
";",
"if",
"(",
"view",
".",
"options",
".",
"nomerge",
")",
"return",
";",
"if",
"(",
"opts",
".",
"mergePartials",
"!==",
"false",
")",
"{",
"name",
"=",
"'partials'",
";",
"}",
"acc",
"[",
"name",
"]",
"=",
"acc",
"[",
"name",
"]",
"||",
"{",
"}",
";",
"acc",
"[",
"name",
"]",
"[",
"key",
"]",
"=",
"view",
".",
"content",
";",
"}",
",",
"this",
")",
";",
"return",
"acc",
";",
"}",
".",
"bind",
"(",
"this",
")",
",",
"{",
"}",
")",
";",
"}"
] |
Merge "partials" view types. This is necessary for template
engines that only support one class of partials.
@name .mergePartials
@param {Object} `locals`
@param {Array} `viewTypes` Optionally pass an array of viewTypes to include.
@return {Object} Merged partials
|
[
"Merge",
"partials",
"view",
"types",
".",
"This",
"is",
"necessary",
"for",
"template",
"engines",
"that",
"only",
"support",
"one",
"class",
"of",
"partials",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L648-L668
|
train
|
|
jonschlinkert/template
|
index.js
|
function (view, ctx, locals) {
var obj = {};
lazy.mixin(obj, ctx);
lazy.mixin(obj, this.cache.data);
lazy.mixin(obj, view.data);
lazy.mixin(obj, view.locals);
lazy.mixin(obj, locals);
return obj;
}
|
javascript
|
function (view, ctx, locals) {
var obj = {};
lazy.mixin(obj, ctx);
lazy.mixin(obj, this.cache.data);
lazy.mixin(obj, view.data);
lazy.mixin(obj, view.locals);
lazy.mixin(obj, locals);
return obj;
}
|
[
"function",
"(",
"view",
",",
"ctx",
",",
"locals",
")",
"{",
"var",
"obj",
"=",
"{",
"}",
";",
"lazy",
".",
"mixin",
"(",
"obj",
",",
"ctx",
")",
";",
"lazy",
".",
"mixin",
"(",
"obj",
",",
"this",
".",
"cache",
".",
"data",
")",
";",
"lazy",
".",
"mixin",
"(",
"obj",
",",
"view",
".",
"data",
")",
";",
"lazy",
".",
"mixin",
"(",
"obj",
",",
"view",
".",
"locals",
")",
";",
"lazy",
".",
"mixin",
"(",
"obj",
",",
"locals",
")",
";",
"return",
"obj",
";",
"}"
] |
Build the context for the given `view` and `locals`.
This can be overridden by passing a function to the
`mergeContext` option.
@name .context
@param {Object} `view` Template object
@param {Object} `locals`
@return {Object} The object to be passed to engines/views as context.
|
[
"Build",
"the",
"context",
"for",
"the",
"given",
"view",
"and",
"locals",
".",
"This",
"can",
"be",
"overridden",
"by",
"passing",
"a",
"function",
"to",
"the",
"mergeContext",
"option",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L681-L689
|
train
|
|
jonschlinkert/template
|
index.js
|
function (view, locals, context, isAsync) {
var helpers = {};
lazy.extend(helpers, this.options.helpers);
lazy.extend(helpers, this._.helpers.sync);
if (isAsync) lazy.extend(helpers, this._.helpers.async);
lazy.extend(helpers, locals.helpers);
// build the context to expose as `this` in helpers
var thisArg = {};
thisArg.options = lazy.extend({}, this.options, locals);
thisArg.context = context || {};
thisArg.context.view = view;
thisArg.app = this;
// bind template helpers to the instance
locals.helpers = utils.bindAll(helpers, thisArg);
}
|
javascript
|
function (view, locals, context, isAsync) {
var helpers = {};
lazy.extend(helpers, this.options.helpers);
lazy.extend(helpers, this._.helpers.sync);
if (isAsync) lazy.extend(helpers, this._.helpers.async);
lazy.extend(helpers, locals.helpers);
// build the context to expose as `this` in helpers
var thisArg = {};
thisArg.options = lazy.extend({}, this.options, locals);
thisArg.context = context || {};
thisArg.context.view = view;
thisArg.app = this;
// bind template helpers to the instance
locals.helpers = utils.bindAll(helpers, thisArg);
}
|
[
"function",
"(",
"view",
",",
"locals",
",",
"context",
",",
"isAsync",
")",
"{",
"var",
"helpers",
"=",
"{",
"}",
";",
"lazy",
".",
"extend",
"(",
"helpers",
",",
"this",
".",
"options",
".",
"helpers",
")",
";",
"lazy",
".",
"extend",
"(",
"helpers",
",",
"this",
".",
"_",
".",
"helpers",
".",
"sync",
")",
";",
"if",
"(",
"isAsync",
")",
"lazy",
".",
"extend",
"(",
"helpers",
",",
"this",
".",
"_",
".",
"helpers",
".",
"async",
")",
";",
"lazy",
".",
"extend",
"(",
"helpers",
",",
"locals",
".",
"helpers",
")",
";",
"var",
"thisArg",
"=",
"{",
"}",
";",
"thisArg",
".",
"options",
"=",
"lazy",
".",
"extend",
"(",
"{",
"}",
",",
"this",
".",
"options",
",",
"locals",
")",
";",
"thisArg",
".",
"context",
"=",
"context",
"||",
"{",
"}",
";",
"thisArg",
".",
"context",
".",
"view",
"=",
"view",
";",
"thisArg",
".",
"app",
"=",
"this",
";",
"locals",
".",
"helpers",
"=",
"utils",
".",
"bindAll",
"(",
"helpers",
",",
"thisArg",
")",
";",
"}"
] |
Build the context for the given `view` and `locals`.
|
[
"Build",
"the",
"context",
"for",
"the",
"given",
"view",
"and",
"locals",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L695-L712
|
train
|
|
jonschlinkert/template
|
index.js
|
function (methods) {
this.lazyRouter();
this.router.method(methods);
utils.arrayify(methods).forEach(function (method) {
this.define(method, function(path) {
var route = this.router.route(path);
var args = [].slice.call(arguments, 1);
route[method].apply(route, args);
return this;
}.bind(this));
}.bind(this));
}
|
javascript
|
function (methods) {
this.lazyRouter();
this.router.method(methods);
utils.arrayify(methods).forEach(function (method) {
this.define(method, function(path) {
var route = this.router.route(path);
var args = [].slice.call(arguments, 1);
route[method].apply(route, args);
return this;
}.bind(this));
}.bind(this));
}
|
[
"function",
"(",
"methods",
")",
"{",
"this",
".",
"lazyRouter",
"(",
")",
";",
"this",
".",
"router",
".",
"method",
"(",
"methods",
")",
";",
"utils",
".",
"arrayify",
"(",
"methods",
")",
".",
"forEach",
"(",
"function",
"(",
"method",
")",
"{",
"this",
".",
"define",
"(",
"method",
",",
"function",
"(",
"path",
")",
"{",
"var",
"route",
"=",
"this",
".",
"router",
".",
"route",
"(",
"path",
")",
";",
"var",
"args",
"=",
"[",
"]",
".",
"slice",
".",
"call",
"(",
"arguments",
",",
"1",
")",
";",
"route",
"[",
"method",
"]",
".",
"apply",
"(",
"route",
",",
"args",
")",
";",
"return",
"this",
";",
"}",
".",
"bind",
"(",
"this",
")",
")",
";",
"}",
".",
"bind",
"(",
"this",
")",
")",
";",
"}"
] |
Add default Router handlers to Template.
|
[
"Add",
"default",
"Router",
"handlers",
"to",
"Template",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/index.js#L728-L739
|
train
|
|
jonschlinkert/template
|
lib/lookup.js
|
function(collection, pattern, options) {
var views = this.getViews(collection);
if (views.hasOwnProperty(pattern)) {
return views[pattern];
}
return utils.matchKey(views, pattern, options);
}
|
javascript
|
function(collection, pattern, options) {
var views = this.getViews(collection);
if (views.hasOwnProperty(pattern)) {
return views[pattern];
}
return utils.matchKey(views, pattern, options);
}
|
[
"function",
"(",
"collection",
",",
"pattern",
",",
"options",
")",
"{",
"var",
"views",
"=",
"this",
".",
"getViews",
"(",
"collection",
")",
";",
"if",
"(",
"views",
".",
"hasOwnProperty",
"(",
"pattern",
")",
")",
"{",
"return",
"views",
"[",
"pattern",
"]",
";",
"}",
"return",
"utils",
".",
"matchKey",
"(",
"views",
",",
"pattern",
",",
"options",
")",
";",
"}"
] |
Returns the first template from the given collection with a key
that matches the given glob pattern.
```js
var pages = app.matchView('pages', 'home.*');
//=> {'home.hbs': { ... }, ...}
var posts = app.matchView('posts', '2010-*');
//=> {'2015-10-10.md': { ... }, ...}
```
@param {String} `collection` Collection name.
@param {String} `pattern` glob pattern
@param {Object} `options` options to pass to [micromatch]
@return {Object}
@api public
|
[
"Returns",
"the",
"first",
"template",
"from",
"the",
"given",
"collection",
"with",
"a",
"key",
"that",
"matches",
"the",
"given",
"glob",
"pattern",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/lookup.js#L34-L40
|
train
|
|
jonschlinkert/template
|
lib/lookup.js
|
function(collection, pattern, options) {
var views = this.getViews(collection);
return utils.matchKeys(views, pattern, options);
}
|
javascript
|
function(collection, pattern, options) {
var views = this.getViews(collection);
return utils.matchKeys(views, pattern, options);
}
|
[
"function",
"(",
"collection",
",",
"pattern",
",",
"options",
")",
"{",
"var",
"views",
"=",
"this",
".",
"getViews",
"(",
"collection",
")",
";",
"return",
"utils",
".",
"matchKeys",
"(",
"views",
",",
"pattern",
",",
"options",
")",
";",
"}"
] |
Returns any templates from the specified collection with keys
that match the given glob pattern.
```js
var pages = app.matchViews('pages', 'home.*');
//=> {'home.hbs': { ... }, ...}
var posts = app.matchViews('posts', '2010-*');
//=> {'2015-10-10.md': { ... }, ...}
```
@param {String} `collection` Collection name.
@param {String} `pattern` glob pattern
@param {Object} `options` options to pass to [micromatch]
@return {Object}
@api public
|
[
"Returns",
"any",
"templates",
"from",
"the",
"specified",
"collection",
"with",
"keys",
"that",
"match",
"the",
"given",
"glob",
"pattern",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/lookup.js#L61-L64
|
train
|
|
jonschlinkert/template
|
lib/lookup.js
|
function(collection, key, fn) {
var views = this.getViews(collection);
// if a custom renameKey function is passed, try using it
if (typeof fn === 'function') {
key = fn(key);
}
if (views.hasOwnProperty(key)) {
return views[key];
}
// try again with the default renameKey function
fn = this.option('renameKey');
var name;
if (typeof fn === 'function') {
name = fn(key);
}
if (name && name !== key && views.hasOwnProperty(name)) {
return views[name];
}
return null;
}
|
javascript
|
function(collection, key, fn) {
var views = this.getViews(collection);
// if a custom renameKey function is passed, try using it
if (typeof fn === 'function') {
key = fn(key);
}
if (views.hasOwnProperty(key)) {
return views[key];
}
// try again with the default renameKey function
fn = this.option('renameKey');
var name;
if (typeof fn === 'function') {
name = fn(key);
}
if (name && name !== key && views.hasOwnProperty(name)) {
return views[name];
}
return null;
}
|
[
"function",
"(",
"collection",
",",
"key",
",",
"fn",
")",
"{",
"var",
"views",
"=",
"this",
".",
"getViews",
"(",
"collection",
")",
";",
"if",
"(",
"typeof",
"fn",
"===",
"'function'",
")",
"{",
"key",
"=",
"fn",
"(",
"key",
")",
";",
"}",
"if",
"(",
"views",
".",
"hasOwnProperty",
"(",
"key",
")",
")",
"{",
"return",
"views",
"[",
"key",
"]",
";",
"}",
"fn",
"=",
"this",
".",
"option",
"(",
"'renameKey'",
")",
";",
"var",
"name",
";",
"if",
"(",
"typeof",
"fn",
"===",
"'function'",
")",
"{",
"name",
"=",
"fn",
"(",
"key",
")",
";",
"}",
"if",
"(",
"name",
"&&",
"name",
"!==",
"key",
"&&",
"views",
".",
"hasOwnProperty",
"(",
"name",
")",
")",
"{",
"return",
"views",
"[",
"name",
"]",
";",
"}",
"return",
"null",
";",
"}"
] |
Get a specific template from the specified collection.
```js
app.getView('pages', 'a.hbs', function(fp) {
return path.basename(fp);
});
```
@param {String} `collectionName` Collection name, like `pages`
@param {String} `key` Template name
@param {Function} `fn` Optionally pass a `renameKey` function
@return {Object}
@api public
|
[
"Get",
"a",
"specific",
"template",
"from",
"the",
"specified",
"collection",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/lookup.js#L82-L101
|
train
|
|
jonschlinkert/template
|
lib/lookup.js
|
function(plural) {
if (lazy.isObject(plural)) return plural;
if (!this.views.hasOwnProperty(plural)) {
plural = this.inflections[plural];
}
if (!this.views.hasOwnProperty(plural)) {
throw new Error('getViews cannot find collection' + plural);
}
return this.views[plural];
}
|
javascript
|
function(plural) {
if (lazy.isObject(plural)) return plural;
if (!this.views.hasOwnProperty(plural)) {
plural = this.inflections[plural];
}
if (!this.views.hasOwnProperty(plural)) {
throw new Error('getViews cannot find collection' + plural);
}
return this.views[plural];
}
|
[
"function",
"(",
"plural",
")",
"{",
"if",
"(",
"lazy",
".",
"isObject",
"(",
"plural",
")",
")",
"return",
"plural",
";",
"if",
"(",
"!",
"this",
".",
"views",
".",
"hasOwnProperty",
"(",
"plural",
")",
")",
"{",
"plural",
"=",
"this",
".",
"inflections",
"[",
"plural",
"]",
";",
"}",
"if",
"(",
"!",
"this",
".",
"views",
".",
"hasOwnProperty",
"(",
"plural",
")",
")",
"{",
"throw",
"new",
"Error",
"(",
"'getViews cannot find collection'",
"+",
"plural",
")",
";",
"}",
"return",
"this",
".",
"views",
"[",
"plural",
"]",
";",
"}"
] |
Get a view `collection` by its singular or plural name.
```js
var pages = app.getViews('pages');
//=> { pages: {'home.hbs': { ... }}
var posts = app.getViews('posts');
//=> { posts: {'2015-10-10.md': { ... }}
```
@param {String} `plural` The plural collection name, e.g. `pages`
@return {Object}
@api public
|
[
"Get",
"a",
"view",
"collection",
"by",
"its",
"singular",
"or",
"plural",
"name",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/lookup.js#L119-L128
|
train
|
|
jonschlinkert/template
|
lib/lookup.js
|
function (view, collection) {
if (typeof view === 'string') {
if (typeof collection === 'string') {
return this[collection].get(view);
}
var collections = this.viewTypes.renderable;
var len = collections.length, i = 0;
while (len--) {
var plural = collections[i++];
var views = this.views[plural];
var res;
if (res = views[view]) {
return res;
}
}
}
return null;
}
|
javascript
|
function (view, collection) {
if (typeof view === 'string') {
if (typeof collection === 'string') {
return this[collection].get(view);
}
var collections = this.viewTypes.renderable;
var len = collections.length, i = 0;
while (len--) {
var plural = collections[i++];
var views = this.views[plural];
var res;
if (res = views[view]) {
return res;
}
}
}
return null;
}
|
[
"function",
"(",
"view",
",",
"collection",
")",
"{",
"if",
"(",
"typeof",
"view",
"===",
"'string'",
")",
"{",
"if",
"(",
"typeof",
"collection",
"===",
"'string'",
")",
"{",
"return",
"this",
"[",
"collection",
"]",
".",
"get",
"(",
"view",
")",
";",
"}",
"var",
"collections",
"=",
"this",
".",
"viewTypes",
".",
"renderable",
";",
"var",
"len",
"=",
"collections",
".",
"length",
",",
"i",
"=",
"0",
";",
"while",
"(",
"len",
"--",
")",
"{",
"var",
"plural",
"=",
"collections",
"[",
"i",
"++",
"]",
";",
"var",
"views",
"=",
"this",
".",
"views",
"[",
"plural",
"]",
";",
"var",
"res",
";",
"if",
"(",
"res",
"=",
"views",
"[",
"view",
"]",
")",
"{",
"return",
"res",
";",
"}",
"}",
"}",
"return",
"null",
";",
"}"
] |
Find a stashed view.
|
[
"Find",
"a",
"stashed",
"view",
"."
] |
51397ab65330a8be9490ba4a5c96ad85548bddc6
|
https://github.com/jonschlinkert/template/blob/51397ab65330a8be9490ba4a5c96ad85548bddc6/lib/lookup.js#L134-L153
|
train
|
|
layerhq/layer-websdk
|
src/client-registry.js
|
register
|
function register(client) {
const appId = client.appId;
if (registry[appId] && !registry[appId].isDestroyed) {
registry[appId].destroy();
}
registry[appId] = client;
defer(() => listeners.forEach(listener => listener(client)));
}
|
javascript
|
function register(client) {
const appId = client.appId;
if (registry[appId] && !registry[appId].isDestroyed) {
registry[appId].destroy();
}
registry[appId] = client;
defer(() => listeners.forEach(listener => listener(client)));
}
|
[
"function",
"register",
"(",
"client",
")",
"{",
"const",
"appId",
"=",
"client",
".",
"appId",
";",
"if",
"(",
"registry",
"[",
"appId",
"]",
"&&",
"!",
"registry",
"[",
"appId",
"]",
".",
"isDestroyed",
")",
"{",
"registry",
"[",
"appId",
"]",
".",
"destroy",
"(",
")",
";",
"}",
"registry",
"[",
"appId",
"]",
"=",
"client",
";",
"defer",
"(",
"(",
")",
"=>",
"listeners",
".",
"forEach",
"(",
"listener",
"=>",
"listener",
"(",
"client",
")",
")",
")",
";",
"}"
] |
Register a new Client; will destroy any previous client with the same appId.
@method register
@param {layer.Client} client
|
[
"Register",
"a",
"new",
"Client",
";",
"will",
"destroy",
"any",
"previous",
"client",
"with",
"the",
"same",
"appId",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/src/client-registry.js#L20-L28
|
train
|
layerhq/layer-websdk
|
src/client-registry.js
|
removeListener
|
function removeListener(listener) {
if (listener) {
const index = listeners.indexOf(listener);
if (index >= 0) listeners.splice(index, 1);
} else {
listeners.splice(0, listeners.length);
}
}
|
javascript
|
function removeListener(listener) {
if (listener) {
const index = listeners.indexOf(listener);
if (index >= 0) listeners.splice(index, 1);
} else {
listeners.splice(0, listeners.length);
}
}
|
[
"function",
"removeListener",
"(",
"listener",
")",
"{",
"if",
"(",
"listener",
")",
"{",
"const",
"index",
"=",
"listeners",
".",
"indexOf",
"(",
"listener",
")",
";",
"if",
"(",
"index",
">=",
"0",
")",
"listeners",
".",
"splice",
"(",
"index",
",",
"1",
")",
";",
"}",
"else",
"{",
"listeners",
".",
"splice",
"(",
"0",
",",
"listeners",
".",
"length",
")",
";",
"}",
"}"
] |
Remove a registered listener or all listeners.
If called with no arguments or null arguments, removes all listeners.
@method removeListener
@param {Function}
|
[
"Remove",
"a",
"registered",
"listener",
"or",
"all",
"listeners",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/src/client-registry.js#L73-L80
|
train
|
stjohnjohnson/jenkins-mocha
|
lib/jenkins.js
|
getBin
|
function getBin(filename) {
try {
return escape(whichLocal.sync(filename));
} catch (unused) {
return escape(whichCwd.sync(filename));
}
}
|
javascript
|
function getBin(filename) {
try {
return escape(whichLocal.sync(filename));
} catch (unused) {
return escape(whichCwd.sync(filename));
}
}
|
[
"function",
"getBin",
"(",
"filename",
")",
"{",
"try",
"{",
"return",
"escape",
"(",
"whichLocal",
".",
"sync",
"(",
"filename",
")",
")",
";",
"}",
"catch",
"(",
"unused",
")",
"{",
"return",
"escape",
"(",
"whichCwd",
".",
"sync",
"(",
"filename",
")",
")",
";",
"}",
"}"
] |
Get the file location of this node_module binary
@method getBin
@param {string} filename Bin you are looking for
@return {string} Full path to the file
|
[
"Get",
"the",
"file",
"location",
"of",
"this",
"node_module",
"binary"
] |
35beb42b2dec31c7aeb13650847a9c6fcf902b94
|
https://github.com/stjohnjohnson/jenkins-mocha/blob/35beb42b2dec31c7aeb13650847a9c6fcf902b94/lib/jenkins.js#L19-L25
|
train
|
layerhq/layer-websdk
|
grunt-template-jasmine-istanbul_src-main-js-template.js
|
function (sources, tmp) {
var instrumenter = new istanbul.Instrumenter();
var instrumentedSources = [];
sources.forEach(function (source) {
var instrumentedSource = instrumenter.instrumentSync(
grunt.file.read(source), source);
var tmpSource = source;
// don't try to write "C:" as part of a folder name on Windows
if (process.platform == 'win32') {
tmpSource = tmpSource.replace(/^([a-z]):/i, '$1');
}
tmpSource = path.join(tmp, tmpSource);
grunt.file.write(tmpSource, instrumentedSource);
instrumentedSources.push(tmpSource);
});
return instrumentedSources;
}
|
javascript
|
function (sources, tmp) {
var instrumenter = new istanbul.Instrumenter();
var instrumentedSources = [];
sources.forEach(function (source) {
var instrumentedSource = instrumenter.instrumentSync(
grunt.file.read(source), source);
var tmpSource = source;
// don't try to write "C:" as part of a folder name on Windows
if (process.platform == 'win32') {
tmpSource = tmpSource.replace(/^([a-z]):/i, '$1');
}
tmpSource = path.join(tmp, tmpSource);
grunt.file.write(tmpSource, instrumentedSource);
instrumentedSources.push(tmpSource);
});
return instrumentedSources;
}
|
[
"function",
"(",
"sources",
",",
"tmp",
")",
"{",
"var",
"instrumenter",
"=",
"new",
"istanbul",
".",
"Instrumenter",
"(",
")",
";",
"var",
"instrumentedSources",
"=",
"[",
"]",
";",
"sources",
".",
"forEach",
"(",
"function",
"(",
"source",
")",
"{",
"var",
"instrumentedSource",
"=",
"instrumenter",
".",
"instrumentSync",
"(",
"grunt",
".",
"file",
".",
"read",
"(",
"source",
")",
",",
"source",
")",
";",
"var",
"tmpSource",
"=",
"source",
";",
"if",
"(",
"process",
".",
"platform",
"==",
"'win32'",
")",
"{",
"tmpSource",
"=",
"tmpSource",
".",
"replace",
"(",
"/",
"^([a-z]):",
"/",
"i",
",",
"'$1'",
")",
";",
"}",
"tmpSource",
"=",
"path",
".",
"join",
"(",
"tmp",
",",
"tmpSource",
")",
";",
"grunt",
".",
"file",
".",
"write",
"(",
"tmpSource",
",",
"instrumentedSource",
")",
";",
"instrumentedSources",
".",
"push",
"(",
"tmpSource",
")",
";",
"}",
")",
";",
"return",
"instrumentedSources",
";",
"}"
] |
Instruments the specified sources and moves the instrumented sources to the
temporary location, recreating the original directory structure.
@private
@method instrument
@param {Array} sources The paths of the original sources
@param {String} tmp The path to the temporary directory
@return {Array} The paths to the instrumented sources
|
[
"Instruments",
"the",
"specified",
"sources",
"and",
"moves",
"the",
"instrumented",
"sources",
"to",
"the",
"temporary",
"location",
"recreating",
"the",
"original",
"directory",
"structure",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/grunt-template-jasmine-istanbul_src-main-js-template.js#L43-L59
|
train
|
|
layerhq/layer-websdk
|
grunt-template-jasmine-istanbul_src-main-js-template.js
|
function (type, options, collector) {
istanbul.Report.create(type, options).writeReport(collector, true);
}
|
javascript
|
function (type, options, collector) {
istanbul.Report.create(type, options).writeReport(collector, true);
}
|
[
"function",
"(",
"type",
",",
"options",
",",
"collector",
")",
"{",
"istanbul",
".",
"Report",
".",
"create",
"(",
"type",
",",
"options",
")",
".",
"writeReport",
"(",
"collector",
",",
"true",
")",
";",
"}"
] |
Writes the report of the specified type, using the specified options and
reporting the coverage collected by the specified collector.
@private
@method writeReport
@param {String} type The report type
@param {Object} options The report options
@param {Collector} collector The collector containing the coverage
|
[
"Writes",
"the",
"report",
"of",
"the",
"specified",
"type",
"using",
"the",
"specified",
"options",
"and",
"reporting",
"the",
"coverage",
"collected",
"by",
"the",
"specified",
"collector",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/grunt-template-jasmine-istanbul_src-main-js-template.js#L85-L87
|
train
|
|
layerhq/layer-websdk
|
grunt-template-jasmine-istanbul_src-main-js-template.js
|
function (collector, options) {
if (typeof options == 'string' || options instanceof String) {
// default to html report at options directory
writeReport('html', {
dir: options
}, collector);
} else if (options instanceof Array) {
// multiple reports
for (var i = 0; i < options.length; i = i + 1) {
var report = options[i];
writeReport(report.type, report.options, collector);
}
} else {
// single report
writeReport(options.type, options.options, collector);
}
}
|
javascript
|
function (collector, options) {
if (typeof options == 'string' || options instanceof String) {
// default to html report at options directory
writeReport('html', {
dir: options
}, collector);
} else if (options instanceof Array) {
// multiple reports
for (var i = 0; i < options.length; i = i + 1) {
var report = options[i];
writeReport(report.type, report.options, collector);
}
} else {
// single report
writeReport(options.type, options.options, collector);
}
}
|
[
"function",
"(",
"collector",
",",
"options",
")",
"{",
"if",
"(",
"typeof",
"options",
"==",
"'string'",
"||",
"options",
"instanceof",
"String",
")",
"{",
"writeReport",
"(",
"'html'",
",",
"{",
"dir",
":",
"options",
"}",
",",
"collector",
")",
";",
"}",
"else",
"if",
"(",
"options",
"instanceof",
"Array",
")",
"{",
"for",
"(",
"var",
"i",
"=",
"0",
";",
"i",
"<",
"options",
".",
"length",
";",
"i",
"=",
"i",
"+",
"1",
")",
"{",
"var",
"report",
"=",
"options",
"[",
"i",
"]",
";",
"writeReport",
"(",
"report",
".",
"type",
",",
"report",
".",
"options",
",",
"collector",
")",
";",
"}",
"}",
"else",
"{",
"writeReport",
"(",
"options",
".",
"type",
",",
"options",
".",
"options",
",",
"collector",
")",
";",
"}",
"}"
] |
Writes the istanbul reports created from the specified options.
@private
@method writeReports
@param {Collector} collector The collector containing the coverage
@param {Object} options The options describing the reports
|
[
"Writes",
"the",
"istanbul",
"reports",
"created",
"from",
"the",
"specified",
"options",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/grunt-template-jasmine-istanbul_src-main-js-template.js#L98-L114
|
train
|
|
layerhq/layer-websdk
|
grunt-template-jasmine-istanbul_src-main-js-template.js
|
function (collector, options) {
var summaries = [];
var thresholds = options.thresholds;
var files = collector.files();
files.forEach(function(file) {
summaries.push(istanbul.utils.summarizeFileCoverage(
collector.fileCoverageFor(file)));
});
var finalSummary = istanbul.utils.mergeSummaryObjects.apply(null,
summaries);
grunt.util._.each(thresholds, function (threshold, metric) {
var actual = finalSummary[metric];
if(!actual) {
grunt.warn('unrecognized metric: ' + metric);
}
if(actual.pct < threshold) {
grunt.warn('expected ' + metric + ' coverage to be at least '
+ threshold + '% but was ' + actual.pct + '%');
}
});
}
|
javascript
|
function (collector, options) {
var summaries = [];
var thresholds = options.thresholds;
var files = collector.files();
files.forEach(function(file) {
summaries.push(istanbul.utils.summarizeFileCoverage(
collector.fileCoverageFor(file)));
});
var finalSummary = istanbul.utils.mergeSummaryObjects.apply(null,
summaries);
grunt.util._.each(thresholds, function (threshold, metric) {
var actual = finalSummary[metric];
if(!actual) {
grunt.warn('unrecognized metric: ' + metric);
}
if(actual.pct < threshold) {
grunt.warn('expected ' + metric + ' coverage to be at least '
+ threshold + '% but was ' + actual.pct + '%');
}
});
}
|
[
"function",
"(",
"collector",
",",
"options",
")",
"{",
"var",
"summaries",
"=",
"[",
"]",
";",
"var",
"thresholds",
"=",
"options",
".",
"thresholds",
";",
"var",
"files",
"=",
"collector",
".",
"files",
"(",
")",
";",
"files",
".",
"forEach",
"(",
"function",
"(",
"file",
")",
"{",
"summaries",
".",
"push",
"(",
"istanbul",
".",
"utils",
".",
"summarizeFileCoverage",
"(",
"collector",
".",
"fileCoverageFor",
"(",
"file",
")",
")",
")",
";",
"}",
")",
";",
"var",
"finalSummary",
"=",
"istanbul",
".",
"utils",
".",
"mergeSummaryObjects",
".",
"apply",
"(",
"null",
",",
"summaries",
")",
";",
"grunt",
".",
"util",
".",
"_",
".",
"each",
"(",
"thresholds",
",",
"function",
"(",
"threshold",
",",
"metric",
")",
"{",
"var",
"actual",
"=",
"finalSummary",
"[",
"metric",
"]",
";",
"if",
"(",
"!",
"actual",
")",
"{",
"grunt",
".",
"warn",
"(",
"'unrecognized metric: '",
"+",
"metric",
")",
";",
"}",
"if",
"(",
"actual",
".",
"pct",
"<",
"threshold",
")",
"{",
"grunt",
".",
"warn",
"(",
"'expected '",
"+",
"metric",
"+",
"' coverage to be at least '",
"+",
"threshold",
"+",
"'% but was '",
"+",
"actual",
".",
"pct",
"+",
"'%'",
")",
";",
"}",
"}",
")",
";",
"}"
] |
Checks whether the specified threshold options have been met. Issues a
warning if not.
@param {Collector} collector The collector containing the coverage
@param {Object} options The options describing the thresholds
|
[
"Checks",
"whether",
"the",
"specified",
"threshold",
"options",
"have",
"been",
"met",
".",
"Issues",
"a",
"warning",
"if",
"not",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/grunt-template-jasmine-istanbul_src-main-js-template.js#L123-L146
|
train
|
|
layerhq/layer-websdk
|
grunt-template-jasmine-istanbul_src-main-js-template.js
|
function (grunt, task, context) {
var template = context.options.template;
if (!template) {
template = DEFAULT_TEMPLATE;
}
// clone context
var mixedInContext = JSON.parse(JSON.stringify(context));
// transit templateOptions
mixedInContext.options = context.options.templateOptions || {};
if (template.process) {
return template.process(grunt, task, mixedInContext);
} else {
return grunt.util._.template(grunt.file.read(template), mixedInContext);
}
}
|
javascript
|
function (grunt, task, context) {
var template = context.options.template;
if (!template) {
template = DEFAULT_TEMPLATE;
}
// clone context
var mixedInContext = JSON.parse(JSON.stringify(context));
// transit templateOptions
mixedInContext.options = context.options.templateOptions || {};
if (template.process) {
return template.process(grunt, task, mixedInContext);
} else {
return grunt.util._.template(grunt.file.read(template), mixedInContext);
}
}
|
[
"function",
"(",
"grunt",
",",
"task",
",",
"context",
")",
"{",
"var",
"template",
"=",
"context",
".",
"options",
".",
"template",
";",
"if",
"(",
"!",
"template",
")",
"{",
"template",
"=",
"DEFAULT_TEMPLATE",
";",
"}",
"var",
"mixedInContext",
"=",
"JSON",
".",
"parse",
"(",
"JSON",
".",
"stringify",
"(",
"context",
")",
")",
";",
"mixedInContext",
".",
"options",
"=",
"context",
".",
"options",
".",
"templateOptions",
"||",
"{",
"}",
";",
"if",
"(",
"template",
".",
"process",
")",
"{",
"return",
"template",
".",
"process",
"(",
"grunt",
",",
"task",
",",
"mixedInContext",
")",
";",
"}",
"else",
"{",
"return",
"grunt",
".",
"util",
".",
"_",
".",
"template",
"(",
"grunt",
".",
"file",
".",
"read",
"(",
"template",
")",
",",
"mixedInContext",
")",
";",
"}",
"}"
] |
Processes the mixed-in template. Defaults to jasmine's default template and
sets up the context using the mixed-in template's options.
@private
@method processMixedInTemplate
@param {Object} grunt The grunt object
@param {Object} task Provides utility methods to register listeners and
handle temporary files
@param {Object} context Contains all options
@return {String} The template HTML source of the mixed in template
|
[
"Processes",
"the",
"mixed",
"-",
"in",
"template",
".",
"Defaults",
"to",
"jasmine",
"s",
"default",
"template",
"and",
"sets",
"up",
"the",
"context",
"using",
"the",
"mixed",
"-",
"in",
"template",
"s",
"options",
"."
] |
aead2b88b6b01d188d846a1298bc04fb2f42ad1a
|
https://github.com/layerhq/layer-websdk/blob/aead2b88b6b01d188d846a1298bc04fb2f42ad1a/grunt-template-jasmine-istanbul_src-main-js-template.js#L162-L176
|
train
|
|
knpwrs/gulp-spawn-mocha
|
lib/index.js
|
parseArgs
|
function parseArgs(obj) {
var args = [];
_.each(obj, function (val, key) {
if (_.isArray(val)) {
_.each(val, function (val) {
addArg(args, key, val);
});
} else {
addArg(args, key, val);
}
});
return args;
}
|
javascript
|
function parseArgs(obj) {
var args = [];
_.each(obj, function (val, key) {
if (_.isArray(val)) {
_.each(val, function (val) {
addArg(args, key, val);
});
} else {
addArg(args, key, val);
}
});
return args;
}
|
[
"function",
"parseArgs",
"(",
"obj",
")",
"{",
"var",
"args",
"=",
"[",
"]",
";",
"_",
".",
"each",
"(",
"obj",
",",
"function",
"(",
"val",
",",
"key",
")",
"{",
"if",
"(",
"_",
".",
"isArray",
"(",
"val",
")",
")",
"{",
"_",
".",
"each",
"(",
"val",
",",
"function",
"(",
"val",
")",
"{",
"addArg",
"(",
"args",
",",
"key",
",",
"val",
")",
";",
"}",
")",
";",
"}",
"else",
"{",
"addArg",
"(",
"args",
",",
"key",
",",
"val",
")",
";",
"}",
"}",
")",
";",
"return",
"args",
";",
"}"
] |
Parses the arugments from a configuration object for passing to a mocha
executable.
@param {Object} obj The object to parse from.
@return {Array} An array of parsed arguments.
|
[
"Parses",
"the",
"arugments",
"from",
"a",
"configuration",
"object",
"for",
"passing",
"to",
"a",
"mocha",
"executable",
"."
] |
8b5e7fdd41bcb65b6e12164e53111fe4376fd9d4
|
https://github.com/knpwrs/gulp-spawn-mocha/blob/8b5e7fdd41bcb65b6e12164e53111fe4376fd9d4/lib/index.js#L90-L102
|
train
|
knpwrs/gulp-spawn-mocha
|
lib/index.js
|
addArg
|
function addArg(args, name, val) {
if (!val && val !== 0) {
return;
}
var arg = name.length > 1 ? '--' + _.kebabCase(name) : '-' + name;
// --max-old-space-size argument requires an `=`
if (arg === '--max-old-space-size') {
args.push(arg + '=' + val);
return;
} else {
args.push(arg);
}
if (_.isString(val) || _.isNumber(val)) {
args.push(val);
}
}
|
javascript
|
function addArg(args, name, val) {
if (!val && val !== 0) {
return;
}
var arg = name.length > 1 ? '--' + _.kebabCase(name) : '-' + name;
// --max-old-space-size argument requires an `=`
if (arg === '--max-old-space-size') {
args.push(arg + '=' + val);
return;
} else {
args.push(arg);
}
if (_.isString(val) || _.isNumber(val)) {
args.push(val);
}
}
|
[
"function",
"addArg",
"(",
"args",
",",
"name",
",",
"val",
")",
"{",
"if",
"(",
"!",
"val",
"&&",
"val",
"!==",
"0",
")",
"{",
"return",
";",
"}",
"var",
"arg",
"=",
"name",
".",
"length",
">",
"1",
"?",
"'--'",
"+",
"_",
".",
"kebabCase",
"(",
"name",
")",
":",
"'-'",
"+",
"name",
";",
"if",
"(",
"arg",
"===",
"'--max-old-space-size'",
")",
"{",
"args",
".",
"push",
"(",
"arg",
"+",
"'='",
"+",
"val",
")",
";",
"return",
";",
"}",
"else",
"{",
"args",
".",
"push",
"(",
"arg",
")",
";",
"}",
"if",
"(",
"_",
".",
"isString",
"(",
"val",
")",
"||",
"_",
".",
"isNumber",
"(",
"val",
")",
")",
"{",
"args",
".",
"push",
"(",
"val",
")",
";",
"}",
"}"
] |
Adds a given argument with name and value to arugment array.
@param {Array} args String array of arguments.
@param {String} name Name of the argument.
@param {String} val Value of the argument. Returns without doing anything
if falsy and not zero.
|
[
"Adds",
"a",
"given",
"argument",
"with",
"name",
"and",
"value",
"to",
"arugment",
"array",
"."
] |
8b5e7fdd41bcb65b6e12164e53111fe4376fd9d4
|
https://github.com/knpwrs/gulp-spawn-mocha/blob/8b5e7fdd41bcb65b6e12164e53111fe4376fd9d4/lib/index.js#L111-L126
|
train
|
expressjs/express-expose
|
lib/express-expose.js
|
expose
|
function expose(obj, namespace, name) {
var app = this.app || this;
var req = this.req;
app._exposed = app._exposed || {};
// support second arg as name
// when a string or function is given
if ('string' === typeof obj || 'function' === typeof obj) {
name = namespace || _name;
} else {
name = name || _name;
namespace = namespace || _namespace;
}
// buffer string
if ('string' === typeof obj) {
this.js = this.js || {};
var buf = this.js[name] = this.js[name] || [];
buf.push(obj);
// buffer function
} else if ('function' === typeof obj && obj.name) {
this.expose(obj.toString(), name);
// buffer self-calling function
} else if ('function' === typeof obj) {
this.expose(';(' + obj + ')();', name);
// buffer object
} else {
this.expose(renderNamespace(namespace), name);
this.expose(renderObject(obj, namespace), name);
this.expose('\n');
}
// locals
function locals(req, res) {
var appjs = app.exposed(name);
var resjs = res.exposed(name);
var js = '';
if (appjs || resjs) {
js += '// app: \n' + appjs;
js += '// res: \n' + resjs;
}
res.locals[name] = js;
}
// app level locals
if (!req && !app._exposed[name]) {
app._exposed[name] = true;
app.use(function(req, res, next){
locals(req, res);
next();
});
// request level locals
} else if (req) {
locals(req, this);
}
return this;
}
|
javascript
|
function expose(obj, namespace, name) {
var app = this.app || this;
var req = this.req;
app._exposed = app._exposed || {};
// support second arg as name
// when a string or function is given
if ('string' === typeof obj || 'function' === typeof obj) {
name = namespace || _name;
} else {
name = name || _name;
namespace = namespace || _namespace;
}
// buffer string
if ('string' === typeof obj) {
this.js = this.js || {};
var buf = this.js[name] = this.js[name] || [];
buf.push(obj);
// buffer function
} else if ('function' === typeof obj && obj.name) {
this.expose(obj.toString(), name);
// buffer self-calling function
} else if ('function' === typeof obj) {
this.expose(';(' + obj + ')();', name);
// buffer object
} else {
this.expose(renderNamespace(namespace), name);
this.expose(renderObject(obj, namespace), name);
this.expose('\n');
}
// locals
function locals(req, res) {
var appjs = app.exposed(name);
var resjs = res.exposed(name);
var js = '';
if (appjs || resjs) {
js += '// app: \n' + appjs;
js += '// res: \n' + resjs;
}
res.locals[name] = js;
}
// app level locals
if (!req && !app._exposed[name]) {
app._exposed[name] = true;
app.use(function(req, res, next){
locals(req, res);
next();
});
// request level locals
} else if (req) {
locals(req, this);
}
return this;
}
|
[
"function",
"expose",
"(",
"obj",
",",
"namespace",
",",
"name",
")",
"{",
"var",
"app",
"=",
"this",
".",
"app",
"||",
"this",
";",
"var",
"req",
"=",
"this",
".",
"req",
";",
"app",
".",
"_exposed",
"=",
"app",
".",
"_exposed",
"||",
"{",
"}",
";",
"if",
"(",
"'string'",
"===",
"typeof",
"obj",
"||",
"'function'",
"===",
"typeof",
"obj",
")",
"{",
"name",
"=",
"namespace",
"||",
"_name",
";",
"}",
"else",
"{",
"name",
"=",
"name",
"||",
"_name",
";",
"namespace",
"=",
"namespace",
"||",
"_namespace",
";",
"}",
"if",
"(",
"'string'",
"===",
"typeof",
"obj",
")",
"{",
"this",
".",
"js",
"=",
"this",
".",
"js",
"||",
"{",
"}",
";",
"var",
"buf",
"=",
"this",
".",
"js",
"[",
"name",
"]",
"=",
"this",
".",
"js",
"[",
"name",
"]",
"||",
"[",
"]",
";",
"buf",
".",
"push",
"(",
"obj",
")",
";",
"}",
"else",
"if",
"(",
"'function'",
"===",
"typeof",
"obj",
"&&",
"obj",
".",
"name",
")",
"{",
"this",
".",
"expose",
"(",
"obj",
".",
"toString",
"(",
")",
",",
"name",
")",
";",
"}",
"else",
"if",
"(",
"'function'",
"===",
"typeof",
"obj",
")",
"{",
"this",
".",
"expose",
"(",
"';('",
"+",
"obj",
"+",
"')();'",
",",
"name",
")",
";",
"}",
"else",
"{",
"this",
".",
"expose",
"(",
"renderNamespace",
"(",
"namespace",
")",
",",
"name",
")",
";",
"this",
".",
"expose",
"(",
"renderObject",
"(",
"obj",
",",
"namespace",
")",
",",
"name",
")",
";",
"this",
".",
"expose",
"(",
"'\\n'",
")",
";",
"}",
"\\n",
"function",
"locals",
"(",
"req",
",",
"res",
")",
"{",
"var",
"appjs",
"=",
"app",
".",
"exposed",
"(",
"name",
")",
";",
"var",
"resjs",
"=",
"res",
".",
"exposed",
"(",
"name",
")",
";",
"var",
"js",
"=",
"''",
";",
"if",
"(",
"appjs",
"||",
"resjs",
")",
"{",
"js",
"+=",
"'// app: \\n'",
"+",
"\\n",
";",
"appjs",
"}",
"js",
"+=",
"'// res: \\n'",
"+",
"\\n",
";",
"}",
"resjs",
"}"
] |
Expose the given `obj` to the client-side, with
an optional `namespace` defaulting to "express".
@param {Object|String|Function} obj
@param {String} namespace
@param {String} name
@return {HTTPServer} for chaining
@api public
|
[
"Expose",
"the",
"given",
"obj",
"to",
"the",
"client",
"-",
"side",
"with",
"an",
"optional",
"namespace",
"defaulting",
"to",
"express",
"."
] |
a270d335464d7ecdd2cb894dd44a16231757aec9
|
https://github.com/expressjs/express-expose/blob/a270d335464d7ecdd2cb894dd44a16231757aec9/lib/express-expose.js#L37-L101
|
train
|
expressjs/express-expose
|
lib/express-expose.js
|
exposed
|
function exposed(name) {
name = name || _name;
this.js = this.js || {};
return this.js[name]
? this.js[name].join('\n')
: '';
}
|
javascript
|
function exposed(name) {
name = name || _name;
this.js = this.js || {};
return this.js[name]
? this.js[name].join('\n')
: '';
}
|
[
"function",
"exposed",
"(",
"name",
")",
"{",
"name",
"=",
"name",
"||",
"_name",
";",
"this",
".",
"js",
"=",
"this",
".",
"js",
"||",
"{",
"}",
";",
"return",
"this",
".",
"js",
"[",
"name",
"]",
"?",
"this",
".",
"js",
"[",
"name",
"]",
".",
"join",
"(",
"'\\n'",
")",
":",
"\\n",
";",
"}"
] |
Render the exposed javascript.
@return {String}
@api private
|
[
"Render",
"the",
"exposed",
"javascript",
"."
] |
a270d335464d7ecdd2cb894dd44a16231757aec9
|
https://github.com/expressjs/express-expose/blob/a270d335464d7ecdd2cb894dd44a16231757aec9/lib/express-expose.js#L110-L116
|
train
|
expressjs/express-expose
|
lib/express-expose.js
|
renderNamespace
|
function renderNamespace(str) {
var parts = [];
var split = str.split('.');
var len = split.length;
return str.split('.').map(function(part, i) {
parts.push(part);
part = parts.join('.');
return (i ? '' : 'window.') + part + ' = window.' + part + ' || {};';
}).join('\n');
}
|
javascript
|
function renderNamespace(str) {
var parts = [];
var split = str.split('.');
var len = split.length;
return str.split('.').map(function(part, i) {
parts.push(part);
part = parts.join('.');
return (i ? '' : 'window.') + part + ' = window.' + part + ' || {};';
}).join('\n');
}
|
[
"function",
"renderNamespace",
"(",
"str",
")",
"{",
"var",
"parts",
"=",
"[",
"]",
";",
"var",
"split",
"=",
"str",
".",
"split",
"(",
"'.'",
")",
";",
"var",
"len",
"=",
"split",
".",
"length",
";",
"return",
"str",
".",
"split",
"(",
"'.'",
")",
".",
"map",
"(",
"function",
"(",
"part",
",",
"i",
")",
"{",
"parts",
".",
"push",
"(",
"part",
")",
";",
"part",
"=",
"parts",
".",
"join",
"(",
"'.'",
")",
";",
"return",
"(",
"i",
"?",
"''",
":",
"'window.'",
")",
"+",
"part",
"+",
"' = window.'",
"+",
"part",
"+",
"' || {};'",
";",
"}",
")",
".",
"join",
"(",
"'\\n'",
")",
";",
"}"
] |
Render a namespace from the given `str`.
Examples:
renderNamespace('foo.bar.baz');
var foo = foo || {};
foo.bar = foo.bar || {};
foo.bar.baz = foo.bar.baz || {};
@param {String} str
@return {String}
@api private
|
[
"Render",
"a",
"namespace",
"from",
"the",
"given",
"str",
"."
] |
a270d335464d7ecdd2cb894dd44a16231757aec9
|
https://github.com/expressjs/express-expose/blob/a270d335464d7ecdd2cb894dd44a16231757aec9/lib/express-expose.js#L134-L145
|
train
|
expressjs/express-expose
|
lib/express-expose.js
|
renderObject
|
function renderObject(obj, namespace) {
return Object.keys(obj).map(function(key){
var val = obj[key];
return namespace + '["' + key + '"] = ' + string(val) + ';';
}).join('\n');
}
|
javascript
|
function renderObject(obj, namespace) {
return Object.keys(obj).map(function(key){
var val = obj[key];
return namespace + '["' + key + '"] = ' + string(val) + ';';
}).join('\n');
}
|
[
"function",
"renderObject",
"(",
"obj",
",",
"namespace",
")",
"{",
"return",
"Object",
".",
"keys",
"(",
"obj",
")",
".",
"map",
"(",
"function",
"(",
"key",
")",
"{",
"var",
"val",
"=",
"obj",
"[",
"key",
"]",
";",
"return",
"namespace",
"+",
"'[\"'",
"+",
"key",
"+",
"'\"] = '",
"+",
"string",
"(",
"val",
")",
"+",
"';'",
";",
"}",
")",
".",
"join",
"(",
"'\\n'",
")",
";",
"}"
] |
Render `obj` with the given `namespace`.
@param {Object} obj
@param {String} namespace
@return {String}
@api private
|
[
"Render",
"obj",
"with",
"the",
"given",
"namespace",
"."
] |
a270d335464d7ecdd2cb894dd44a16231757aec9
|
https://github.com/expressjs/express-expose/blob/a270d335464d7ecdd2cb894dd44a16231757aec9/lib/express-expose.js#L156-L161
|
train
|
expressjs/express-expose
|
lib/express-expose.js
|
string
|
function string(obj) {
if ('function' === typeof obj) {
return obj.toString();
} else if (obj instanceof Date) {
return 'new Date("' + obj + '")';
} else if (Array.isArray(obj)) {
return '[' + obj.map(string).join(', ') + ']';
} else if ('[object Object]' === Object.prototype.toString.call(obj)) {
return '{' + Object.keys(obj).map(function(key){
return '"' + key + '":' + string(obj[key]);
}).join(', ') + '}';
} else {
return JSON.stringify(obj);
}
}
|
javascript
|
function string(obj) {
if ('function' === typeof obj) {
return obj.toString();
} else if (obj instanceof Date) {
return 'new Date("' + obj + '")';
} else if (Array.isArray(obj)) {
return '[' + obj.map(string).join(', ') + ']';
} else if ('[object Object]' === Object.prototype.toString.call(obj)) {
return '{' + Object.keys(obj).map(function(key){
return '"' + key + '":' + string(obj[key]);
}).join(', ') + '}';
} else {
return JSON.stringify(obj);
}
}
|
[
"function",
"string",
"(",
"obj",
")",
"{",
"if",
"(",
"'function'",
"===",
"typeof",
"obj",
")",
"{",
"return",
"obj",
".",
"toString",
"(",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"Date",
")",
"{",
"return",
"'new Date(\"'",
"+",
"obj",
"+",
"'\")'",
";",
"}",
"else",
"if",
"(",
"Array",
".",
"isArray",
"(",
"obj",
")",
")",
"{",
"return",
"'['",
"+",
"obj",
".",
"map",
"(",
"string",
")",
".",
"join",
"(",
"', '",
")",
"+",
"']'",
";",
"}",
"else",
"if",
"(",
"'[object Object]'",
"===",
"Object",
".",
"prototype",
".",
"toString",
".",
"call",
"(",
"obj",
")",
")",
"{",
"return",
"'{'",
"+",
"Object",
".",
"keys",
"(",
"obj",
")",
".",
"map",
"(",
"function",
"(",
"key",
")",
"{",
"return",
"'\"'",
"+",
"key",
"+",
"'\":'",
"+",
"string",
"(",
"obj",
"[",
"key",
"]",
")",
";",
"}",
")",
".",
"join",
"(",
"', '",
")",
"+",
"'}'",
";",
"}",
"else",
"{",
"return",
"JSON",
".",
"stringify",
"(",
"obj",
")",
";",
"}",
"}"
] |
Return a string representation of `obj`.
@param {Mixed} obj
@return {String}
@api private
|
[
"Return",
"a",
"string",
"representation",
"of",
"obj",
"."
] |
a270d335464d7ecdd2cb894dd44a16231757aec9
|
https://github.com/expressjs/express-expose/blob/a270d335464d7ecdd2cb894dd44a16231757aec9/lib/express-expose.js#L171-L185
|
train
|
bitpay/bloom-filter
|
lib/murmurhash3.js
|
MurmurHash3
|
function MurmurHash3(seed, data) {
/* jshint maxstatements: 32, maxcomplexity: 10 */
var c1 = 0xcc9e2d51;
var c2 = 0x1b873593;
var r1 = 15;
var r2 = 13;
var m = 5;
var n = 0x6b64e654;
var hash = seed;
function mul32(a, b) {
return (a & 0xffff) * b + (((a >>> 16) * b & 0xffff) << 16) & 0xffffffff;
}
function sum32(a, b) {
return (a & 0xffff) + (b >>> 16) + (((a >>> 16) + b & 0xffff) << 16) & 0xffffffff;
}
function rotl32(a, b) {
return (a << b) | (a >>> (32 - b));
}
var k1;
for (var i = 0; i + 4 <= data.length; i += 4) {
k1 = data[i] |
(data[i + 1] << 8) |
(data[i + 2] << 16) |
(data[i + 3] << 24);
k1 = mul32(k1, c1);
k1 = rotl32(k1, r1);
k1 = mul32(k1, c2);
hash ^= k1;
hash = rotl32(hash, r2);
hash = mul32(hash, m);
hash = sum32(hash, n);
}
k1 = 0;
switch(data.length & 3) {
case 3:
k1 ^= data[i + 2] << 16;
/* falls through */
case 2:
k1 ^= data[i + 1] << 8;
/* falls through */
case 1:
k1 ^= data[i];
k1 = mul32(k1, c1);
k1 = rotl32(k1, r1);
k1 = mul32(k1, c2);
hash ^= k1;
}
hash ^= data.length;
hash ^= hash >>> 16;
hash = mul32(hash, 0x85ebca6b);
hash ^= hash >>> 13;
hash = mul32(hash, 0xc2b2ae35);
hash ^= hash >>> 16;
return hash >>> 0;
}
|
javascript
|
function MurmurHash3(seed, data) {
/* jshint maxstatements: 32, maxcomplexity: 10 */
var c1 = 0xcc9e2d51;
var c2 = 0x1b873593;
var r1 = 15;
var r2 = 13;
var m = 5;
var n = 0x6b64e654;
var hash = seed;
function mul32(a, b) {
return (a & 0xffff) * b + (((a >>> 16) * b & 0xffff) << 16) & 0xffffffff;
}
function sum32(a, b) {
return (a & 0xffff) + (b >>> 16) + (((a >>> 16) + b & 0xffff) << 16) & 0xffffffff;
}
function rotl32(a, b) {
return (a << b) | (a >>> (32 - b));
}
var k1;
for (var i = 0; i + 4 <= data.length; i += 4) {
k1 = data[i] |
(data[i + 1] << 8) |
(data[i + 2] << 16) |
(data[i + 3] << 24);
k1 = mul32(k1, c1);
k1 = rotl32(k1, r1);
k1 = mul32(k1, c2);
hash ^= k1;
hash = rotl32(hash, r2);
hash = mul32(hash, m);
hash = sum32(hash, n);
}
k1 = 0;
switch(data.length & 3) {
case 3:
k1 ^= data[i + 2] << 16;
/* falls through */
case 2:
k1 ^= data[i + 1] << 8;
/* falls through */
case 1:
k1 ^= data[i];
k1 = mul32(k1, c1);
k1 = rotl32(k1, r1);
k1 = mul32(k1, c2);
hash ^= k1;
}
hash ^= data.length;
hash ^= hash >>> 16;
hash = mul32(hash, 0x85ebca6b);
hash ^= hash >>> 13;
hash = mul32(hash, 0xc2b2ae35);
hash ^= hash >>> 16;
return hash >>> 0;
}
|
[
"function",
"MurmurHash3",
"(",
"seed",
",",
"data",
")",
"{",
"var",
"c1",
"=",
"0xcc9e2d51",
";",
"var",
"c2",
"=",
"0x1b873593",
";",
"var",
"r1",
"=",
"15",
";",
"var",
"r2",
"=",
"13",
";",
"var",
"m",
"=",
"5",
";",
"var",
"n",
"=",
"0x6b64e654",
";",
"var",
"hash",
"=",
"seed",
";",
"function",
"mul32",
"(",
"a",
",",
"b",
")",
"{",
"return",
"(",
"a",
"&",
"0xffff",
")",
"*",
"b",
"+",
"(",
"(",
"(",
"a",
">>>",
"16",
")",
"*",
"b",
"&",
"0xffff",
")",
"<<",
"16",
")",
"&",
"0xffffffff",
";",
"}",
"function",
"sum32",
"(",
"a",
",",
"b",
")",
"{",
"return",
"(",
"a",
"&",
"0xffff",
")",
"+",
"(",
"b",
">>>",
"16",
")",
"+",
"(",
"(",
"(",
"a",
">>>",
"16",
")",
"+",
"b",
"&",
"0xffff",
")",
"<<",
"16",
")",
"&",
"0xffffffff",
";",
"}",
"function",
"rotl32",
"(",
"a",
",",
"b",
")",
"{",
"return",
"(",
"a",
"<<",
"b",
")",
"|",
"(",
"a",
">>>",
"(",
"32",
"-",
"b",
")",
")",
";",
"}",
"var",
"k1",
";",
"for",
"(",
"var",
"i",
"=",
"0",
";",
"i",
"+",
"4",
"<=",
"data",
".",
"length",
";",
"i",
"+=",
"4",
")",
"{",
"k1",
"=",
"data",
"[",
"i",
"]",
"|",
"(",
"data",
"[",
"i",
"+",
"1",
"]",
"<<",
"8",
")",
"|",
"(",
"data",
"[",
"i",
"+",
"2",
"]",
"<<",
"16",
")",
"|",
"(",
"data",
"[",
"i",
"+",
"3",
"]",
"<<",
"24",
")",
";",
"k1",
"=",
"mul32",
"(",
"k1",
",",
"c1",
")",
";",
"k1",
"=",
"rotl32",
"(",
"k1",
",",
"r1",
")",
";",
"k1",
"=",
"mul32",
"(",
"k1",
",",
"c2",
")",
";",
"hash",
"^=",
"k1",
";",
"hash",
"=",
"rotl32",
"(",
"hash",
",",
"r2",
")",
";",
"hash",
"=",
"mul32",
"(",
"hash",
",",
"m",
")",
";",
"hash",
"=",
"sum32",
"(",
"hash",
",",
"n",
")",
";",
"}",
"k1",
"=",
"0",
";",
"switch",
"(",
"data",
".",
"length",
"&",
"3",
")",
"{",
"case",
"3",
":",
"k1",
"^=",
"data",
"[",
"i",
"+",
"2",
"]",
"<<",
"16",
";",
"case",
"2",
":",
"k1",
"^=",
"data",
"[",
"i",
"+",
"1",
"]",
"<<",
"8",
";",
"case",
"1",
":",
"k1",
"^=",
"data",
"[",
"i",
"]",
";",
"k1",
"=",
"mul32",
"(",
"k1",
",",
"c1",
")",
";",
"k1",
"=",
"rotl32",
"(",
"k1",
",",
"r1",
")",
";",
"k1",
"=",
"mul32",
"(",
"k1",
",",
"c2",
")",
";",
"hash",
"^=",
"k1",
";",
"}",
"hash",
"^=",
"data",
".",
"length",
";",
"hash",
"^=",
"hash",
">>>",
"16",
";",
"hash",
"=",
"mul32",
"(",
"hash",
",",
"0x85ebca6b",
")",
";",
"hash",
"^=",
"hash",
">>>",
"13",
";",
"hash",
"=",
"mul32",
"(",
"hash",
",",
"0xc2b2ae35",
")",
";",
"hash",
"^=",
"hash",
">>>",
"16",
";",
"return",
"hash",
">>>",
"0",
";",
"}"
] |
MurmurHash is a non-cryptographic hash function suitable for general hash-based lookup
@see https://en.wikipedia.org/wiki/MurmurHash
@see https://github.com/petertodd/python-bitcoinlib/blob/master/bitcoin/bloom.py
@see https://github.com/bitcoinj/bitcoinj/blob/master/core/src/main/java/org/bitcoinj/core/BloomFilter.java#L170
@see https://github.com/bitcoin/bitcoin/blob/master/src/hash.cpp
@see https://github.com/indutny/bcoin/blob/master/lib/bcoin/bloom.js
@see https://github.com/garycourt/murmurhash-js
@param {Buffer} data to be hashed
@param {Number} seed Positive integer only
@return {Number} a 32-bit positive integer hash
|
[
"MurmurHash",
"is",
"a",
"non",
"-",
"cryptographic",
"hash",
"function",
"suitable",
"for",
"general",
"hash",
"-",
"based",
"lookup"
] |
937f18b33a190a2a94bff166fc82bd9c8977bea0
|
https://github.com/bitpay/bloom-filter/blob/937f18b33a190a2a94bff166fc82bd9c8977bea0/lib/murmurhash3.js#L17-L84
|
train
|
fasttime/JScrewIt
|
lib/jscrewit.js
|
function ()
{
var mask = this.mask;
var included =
_Array_prototype_every.call
(
arguments,
function (arg)
{
var otherMask = validMaskFromArrayOrStringOrFeature(arg);
var result = maskIncludes(mask, otherMask);
return result;
}
);
return included;
}
|
javascript
|
function ()
{
var mask = this.mask;
var included =
_Array_prototype_every.call
(
arguments,
function (arg)
{
var otherMask = validMaskFromArrayOrStringOrFeature(arg);
var result = maskIncludes(mask, otherMask);
return result;
}
);
return included;
}
|
[
"function",
"(",
")",
"{",
"var",
"mask",
"=",
"this",
".",
"mask",
";",
"var",
"included",
"=",
"_Array_prototype_every",
".",
"call",
"(",
"arguments",
",",
"function",
"(",
"arg",
")",
"{",
"var",
"otherMask",
"=",
"validMaskFromArrayOrStringOrFeature",
"(",
"arg",
")",
";",
"var",
"result",
"=",
"maskIncludes",
"(",
"mask",
",",
"otherMask",
")",
";",
"return",
"result",
";",
"}",
")",
";",
"return",
"included",
";",
"}"
] |
Determines whether this feature object includes all of the specified features.
@function JScrewIt.Feature#includes
@param {...(FeatureElement|CompatibleFeatureArray)} [feature]
@returns {boolean}
`true` if this feature object includes all of the specified features; otherwise, `false`.
If no arguments are specified, the return value is `true`.
|
[
"Determines",
"whether",
"this",
"feature",
"object",
"includes",
"all",
"of",
"the",
"specified",
"features",
"."
] |
f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc
|
https://github.com/fasttime/JScrewIt/blob/f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc/lib/jscrewit.js#L1980-L1995
|
train
|
|
fasttime/JScrewIt
|
lib/jscrewit.js
|
function (environment, engineFeatureObjs)
{
var resultMask = maskNew();
var thisMask = this.mask;
var attributeCache = createEmpty();
ELEMENTARY.forEach
(
function (featureObj)
{
var otherMask = featureObj.mask;
var included = maskIncludes(thisMask, otherMask);
if (included)
{
var attributeValue = featureObj.attributes[environment];
if
(
attributeValue === undefined ||
engineFeatureObjs !== undefined &&
!isExcludingAttribute(attributeCache, attributeValue, engineFeatureObjs)
)
resultMask = maskUnion(resultMask, otherMask);
}
}
);
var result = featureFromMask(resultMask);
return result;
}
|
javascript
|
function (environment, engineFeatureObjs)
{
var resultMask = maskNew();
var thisMask = this.mask;
var attributeCache = createEmpty();
ELEMENTARY.forEach
(
function (featureObj)
{
var otherMask = featureObj.mask;
var included = maskIncludes(thisMask, otherMask);
if (included)
{
var attributeValue = featureObj.attributes[environment];
if
(
attributeValue === undefined ||
engineFeatureObjs !== undefined &&
!isExcludingAttribute(attributeCache, attributeValue, engineFeatureObjs)
)
resultMask = maskUnion(resultMask, otherMask);
}
}
);
var result = featureFromMask(resultMask);
return result;
}
|
[
"function",
"(",
"environment",
",",
"engineFeatureObjs",
")",
"{",
"var",
"resultMask",
"=",
"maskNew",
"(",
")",
";",
"var",
"thisMask",
"=",
"this",
".",
"mask",
";",
"var",
"attributeCache",
"=",
"createEmpty",
"(",
")",
";",
"ELEMENTARY",
".",
"forEach",
"(",
"function",
"(",
"featureObj",
")",
"{",
"var",
"otherMask",
"=",
"featureObj",
".",
"mask",
";",
"var",
"included",
"=",
"maskIncludes",
"(",
"thisMask",
",",
"otherMask",
")",
";",
"if",
"(",
"included",
")",
"{",
"var",
"attributeValue",
"=",
"featureObj",
".",
"attributes",
"[",
"environment",
"]",
";",
"if",
"(",
"attributeValue",
"===",
"undefined",
"||",
"engineFeatureObjs",
"!==",
"undefined",
"&&",
"!",
"isExcludingAttribute",
"(",
"attributeCache",
",",
"attributeValue",
",",
"engineFeatureObjs",
")",
")",
"resultMask",
"=",
"maskUnion",
"(",
"resultMask",
",",
"otherMask",
")",
";",
"}",
"}",
")",
";",
"var",
"result",
"=",
"featureFromMask",
"(",
"resultMask",
")",
";",
"return",
"result",
";",
"}"
] |
Creates a new feature object from this feature by removing elementary features that are
not available inside a particular environment.
This method is useful to selectively exclude features that are available inside a web
worker.
@function JScrewIt.Feature#restrict
@param {string} environment
The environment to which this feature should be restricted.
Two environments are currently supported.
<dl>
<dt><code>"forced-strict-mode"</code></dt>
<dd>
Removes features that are not available in environments that require strict mode
code.</dd>
<dt><code>"web-worker"</code></dt>
<dd>Removes features that are not available inside web workers.</dd>
</dl>
@param {JScrewIt.Feature[]} [engineFeatureObjs]
An array of predefined feature objects, each corresponding to a particular engine in
which the restriction should be enacted.
If this parameter is omitted, the restriction is enacted in all engines.
@returns {JScrewIt.Feature}
A feature object.
|
[
"Creates",
"a",
"new",
"feature",
"object",
"from",
"this",
"feature",
"by",
"removing",
"elementary",
"features",
"that",
"are",
"not",
"available",
"inside",
"a",
"particular",
"environment",
"."
] |
f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc
|
https://github.com/fasttime/JScrewIt/blob/f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc/lib/jscrewit.js#L2052-L2078
|
train
|
|
fasttime/JScrewIt
|
lib/jscrewit.js
|
function ()
{
var name = this.name;
if (name === undefined)
name = '{' + this.canonicalNames.join(', ') + '}';
var str = '[Feature ' + name + ']';
return str;
}
|
javascript
|
function ()
{
var name = this.name;
if (name === undefined)
name = '{' + this.canonicalNames.join(', ') + '}';
var str = '[Feature ' + name + ']';
return str;
}
|
[
"function",
"(",
")",
"{",
"var",
"name",
"=",
"this",
".",
"name",
";",
"if",
"(",
"name",
"===",
"undefined",
")",
"name",
"=",
"'{'",
"+",
"this",
".",
"canonicalNames",
".",
"join",
"(",
"', '",
")",
"+",
"'}'",
";",
"var",
"str",
"=",
"'[Feature '",
"+",
"name",
"+",
"']'",
";",
"return",
"str",
";",
"}"
] |
Returns a string representation of this feature object.
@function JScrewIt.Feature#toString
@returns {string}
A string representation of this feature object.
|
[
"Returns",
"a",
"string",
"representation",
"of",
"this",
"feature",
"object",
"."
] |
f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc
|
https://github.com/fasttime/JScrewIt/blob/f0a9e93ccbc957d72ed775a7ad528a6b1fe9ffcc/lib/jscrewit.js#L2090-L2097
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.