_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2000
|
train
|
function( entireComponent ) {
// Insert a new component holder in the root or box.
if ( entireComponent ) P.$root.html( createWrappedComponent() )
else P.$root.find( '.' + CLASSES.box ).html( P.component.nodes( STATE.open ) )
// Trigger the queued “render” events.
return P.trigger( 'render' )
}
|
javascript
|
{
"resource": ""
}
|
|
q2001
|
train
|
function() {
// If it’s already stopped, do nothing.
if ( !STATE.start ) return P
// Then close the picker.
P.close()
// Remove the hidden field.
if ( P._hidden ) {
P._hidden.parentNode.removeChild( P._hidden )
}
// Remove the root.
P.$root.remove()
// Remove the input class, remove the stored data, and unbind
// the events (after a tick for IE - see `P.close`).
$ELEMENT.removeClass( CLASSES.input ).removeData( NAME )
setTimeout( function() {
$ELEMENT.off( '.' + STATE.id )
}, 0)
// Restore the element state
ELEMENT.type = STATE.type
ELEMENT.readOnly = false
// Trigger the queued “stop” events.
P.trigger( 'stop' )
// Reset the picker states.
STATE.methods = {}
STATE.start = false
return P
}
|
javascript
|
{
"resource": ""
}
|
|
q2002
|
train
|
function( dontGiveFocus ) {
// If it’s already open, do nothing.
if ( STATE.open ) return P
// Add the “active” class.
$ELEMENT.addClass( CLASSES.active )
aria( ELEMENT, 'expanded', true )
// * A Firefox bug, when `html` has `overflow:hidden`, results in
// killing transitions :(. So add the “opened” state on the next tick.
// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=625289
setTimeout( function() {
// Add the “opened” class to the picker root.
P.$root.addClass( CLASSES.opened )
aria( P.$root[0], 'hidden', false )
}, 0 )
// If we have to give focus, bind the element and doc events.
if ( dontGiveFocus !== false ) {
// Set it as open.
STATE.open = true
// Prevent the page from scrolling.
if ( IS_DEFAULT_THEME ) {
$html.
css( 'overflow', 'hidden' ).
css( 'padding-right', '+=' + getScrollbarWidth() )
}
// Pass focus to the root element’s jQuery object.
// * Workaround for iOS8 to bring the picker’s root into view.
P.$root[0].focus()
// Bind the document events.
$document.on( 'click.' + STATE.id + ' focusin.' + STATE.id, function( event ) {
var target = event.target
// If the target of the event is not the element, close the picker picker.
// * Don’t worry about clicks or focusins on the root because those don’t bubble up.
// Also, for Firefox, a click on an `option` element bubbles up directly
// to the doc. So make sure the target wasn't the doc.
// * In Firefox stopPropagation() doesn’t prevent right-click events from bubbling,
// which causes the picker to unexpectedly close when right-clicking it. So make
// sure the event wasn’t a right-click.
if ( target != ELEMENT && target != document && event.which != 3 ) {
// If the target was the holder that covers the screen,
// keep the element focused to maintain tabindex.
P.close( target === P.$root.children()[0] )
}
}).on( 'keydown.' + STATE.id, function( event ) {
var
// Get the keycode.
keycode = event.keyCode,
// Translate that to a selection change.
keycodeToMove = P.component.key[ keycode ],
// Grab the target.
target = event.target
// On escape, close the picker and give focus.
if ( keycode == 27 ) {
P.close( true )
}
// Check if there is a key movement or “enter” keypress on the element.
else if ( target == P.$root[0] && ( keycodeToMove || keycode == 13 ) ) {
// Prevent the default action to stop page movement.
event.preventDefault()
// Trigger the key movement action.
if ( keycodeToMove ) {
PickerConstructor._.trigger( P.component.key.go, P, [ PickerConstructor._.trigger( keycodeToMove ) ] )
}
// On “enter”, if the highlighted item isn’t disabled, set the value and close.
else if ( !P.$root.find( '.' + CLASSES.highlighted ).hasClass( CLASSES.disabled ) ) {
P.set( 'select', P.component.item.highlight ).close()
}
}
// If the target is within the root and “enter” is pressed,
// prevent the default action and trigger a click on the target instead.
else if ( $.contains( P.$root[0], target ) && keycode == 13 ) {
event.preventDefault()
target.click()
}
})
}
// Trigger the queued “open” events.
return P.trigger( 'open' )
}
|
javascript
|
{
"resource": ""
}
|
|
q2003
|
train
|
function( thing, value, options ) {
var thingItem, thingValue,
thingIsObject = $.isPlainObject( thing ),
thingObject = thingIsObject ? thing : {}
// Make sure we have usable options.
options = thingIsObject && $.isPlainObject( value ) ? value : options || {}
if ( thing ) {
// If the thing isn’t an object, make it one.
if ( !thingIsObject ) {
thingObject[ thing ] = value
}
// Go through the things of items to set.
for ( thingItem in thingObject ) {
// Grab the value of the thing.
thingValue = thingObject[ thingItem ]
// First, if the item exists and there’s a value, set it.
if ( thingItem in P.component.item ) {
if ( thingValue === undefined ) thingValue = null
P.component.set( thingItem, thingValue, options )
}
// Then, check to update the element value and broadcast a change.
if ( thingItem == 'select' || thingItem == 'clear' ) {
$ELEMENT.
val( thingItem == 'clear' ? '' : P.get( thingItem, SETTINGS.format ) ).
trigger( 'change' )
}
}
// Render a new picker.
P.render()
}
// When the method isn’t muted, trigger queued “set” events and pass the `thingObject`.
return options.muted ? P : P.trigger( 'set', thingObject )
}
|
javascript
|
{
"resource": ""
}
|
|
q2004
|
train
|
function( thing, format ) {
// Make sure there’s something to get.
thing = thing || 'value'
// If a picker state exists, return that.
if ( STATE[ thing ] != null ) {
return STATE[ thing ]
}
// Return the submission value, if that.
if ( thing == 'valueSubmit' ) {
if ( P._hidden ) {
return P._hidden.value
}
thing = 'value'
}
// Return the value, if that.
if ( thing == 'value' ) {
return ELEMENT.value
}
// Check if a component item exists, return that.
if ( thing in P.component.item ) {
if ( typeof format == 'string' ) {
var thingValue = P.component.get( thing )
return thingValue ?
PickerConstructor._.trigger(
P.component.formats.toString,
P.component,
[ format, thingValue ]
) : ''
}
return P.component.get( thing )
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2005
|
train
|
function( thing, method, internal ) {
var thingName, thingMethod,
thingIsObject = $.isPlainObject( thing ),
thingObject = thingIsObject ? thing : {}
if ( thing ) {
// If the thing isn’t an object, make it one.
if ( !thingIsObject ) {
thingObject[ thing ] = method
}
// Go through the things to bind to.
for ( thingName in thingObject ) {
// Grab the method of the thing.
thingMethod = thingObject[ thingName ]
// If it was an internal binding, prefix it.
if ( internal ) {
thingName = '_' + thingName
}
// Make sure the thing methods collection exists.
STATE.methods[ thingName ] = STATE.methods[ thingName ] || []
// Add the method to the relative method collection.
STATE.methods[ thingName ].push( thingMethod )
}
}
return P
}
|
javascript
|
{
"resource": ""
}
|
|
q2006
|
train
|
function() {
var i, thingName,
names = arguments;
for ( i = 0, namesCount = names.length; i < namesCount; i += 1 ) {
thingName = names[i]
if ( thingName in STATE.methods ) {
delete STATE.methods[thingName]
}
}
return P
}
|
javascript
|
{
"resource": ""
}
|
|
q2007
|
train
|
function( name, data ) {
var _trigger = function( name ) {
var methodList = STATE.methods[ name ]
if ( methodList ) {
methodList.map( function( method ) {
PickerConstructor._.trigger( method, P, [ data ] )
})
}
}
_trigger( '_' + name )
_trigger( name )
return P
}
|
javascript
|
{
"resource": ""
}
|
|
q2008
|
createWrappedComponent
|
train
|
function createWrappedComponent() {
// Create a picker wrapper holder
return PickerConstructor._.node( 'div',
// Create a picker wrapper node
PickerConstructor._.node( 'div',
// Create a picker frame
PickerConstructor._.node( 'div',
// Create a picker box node
PickerConstructor._.node( 'div',
// Create the components nodes.
P.component.nodes( STATE.open ),
// The picker box class
CLASSES.box
),
// Picker wrap class
CLASSES.wrap
),
// Picker frame class
CLASSES.frame
),
// Picker holder class
CLASSES.holder
) //endreturn
}
|
javascript
|
{
"resource": ""
}
|
q2009
|
prepareElement
|
train
|
function prepareElement() {
$ELEMENT.
// Store the picker data by component name.
data(NAME, P).
// Add the “input” class name.
addClass(CLASSES.input).
// Remove the tabindex.
attr('tabindex', -1).
// If there’s a `data-value`, update the value of the element.
val( $ELEMENT.data('value') ?
P.get('select', SETTINGS.format) :
ELEMENT.value
)
// Only bind keydown events if the element isn’t editable.
if ( !SETTINGS.editable ) {
$ELEMENT.
// On focus/click, focus onto the root to open it up.
on( 'focus.' + STATE.id + ' click.' + STATE.id, function( event ) {
event.preventDefault()
P.$root[0].focus()
}).
// Handle keyboard event based on the picker being opened or not.
on( 'keydown.' + STATE.id, handleKeydownEvent )
}
// Update the aria attributes.
aria(ELEMENT, {
haspopup: true,
expanded: false,
readonly: false,
owns: ELEMENT.id + '_root'
})
}
|
javascript
|
{
"resource": ""
}
|
q2010
|
prepareElementRoot
|
train
|
function prepareElementRoot() {
P.$root.
on({
// For iOS8.
keydown: handleKeydownEvent,
// When something within the root is focused, stop from bubbling
// to the doc and remove the “focused” state from the root.
focusin: function( event ) {
P.$root.removeClass( CLASSES.focused )
event.stopPropagation()
},
// When something within the root holder is clicked, stop it
// from bubbling to the doc.
'mousedown click': function( event ) {
var target = event.target
// Make sure the target isn’t the root holder so it can bubble up.
if ( target != P.$root.children()[ 0 ] ) {
event.stopPropagation()
// * For mousedown events, cancel the default action in order to
// prevent cases where focus is shifted onto external elements
// when using things like jQuery mobile or MagnificPopup (ref: #249 & #120).
// Also, for Firefox, don’t prevent action on the `option` element.
if ( event.type == 'mousedown' && !$( target ).is( 'input, select, textarea, button, option' )) {
event.preventDefault()
// Re-focus onto the root so that users can click away
// from elements focused within the picker.
P.$root[0].focus()
}
}
}
}).
// Add/remove the “target” class on focus and blur.
on({
focus: function() {
$ELEMENT.addClass( CLASSES.target )
},
blur: function() {
$ELEMENT.removeClass( CLASSES.target )
}
}).
// Open the picker and adjust the root “focused” state
on( 'focus.toOpen', handleFocusToOpenEvent ).
// If there’s a click on an actionable element, carry out the actions.
on( 'click', '[data-pick], [data-nav], [data-clear], [data-close]', function() {
var $target = $( this ),
targetData = $target.data(),
targetDisabled = $target.hasClass( CLASSES.navDisabled ) || $target.hasClass( CLASSES.disabled ),
// * For IE, non-focusable elements can be active elements as well
// (http://stackoverflow.com/a/2684561).
activeElement = getActiveElement()
activeElement = activeElement && ( activeElement.type || activeElement.href )
// If it’s disabled or nothing inside is actively focused, re-focus the element.
if ( targetDisabled || activeElement && !$.contains( P.$root[0], activeElement ) ) {
P.$root[0].focus()
}
// If something is superficially changed, update the `highlight` based on the `nav`.
if ( !targetDisabled && targetData.nav ) {
P.set( 'highlight', P.component.item.highlight, { nav: targetData.nav } )
}
// If something is picked, set `select` then close with focus.
else if ( !targetDisabled && 'pick' in targetData ) {
P.set( 'select', targetData.pick )
}
// If a “clear” button is pressed, empty the values and close with focus.
else if ( targetData.clear ) {
P.clear().close( true )
}
else if ( targetData.close ) {
P.close( true )
}
}) //P.$root
aria( P.$root[0], 'hidden', true )
}
|
javascript
|
{
"resource": ""
}
|
q2011
|
train
|
function( event ) {
var target = event.target
// Make sure the target isn’t the root holder so it can bubble up.
if ( target != P.$root.children()[ 0 ] ) {
event.stopPropagation()
// * For mousedown events, cancel the default action in order to
// prevent cases where focus is shifted onto external elements
// when using things like jQuery mobile or MagnificPopup (ref: #249 & #120).
// Also, for Firefox, don’t prevent action on the `option` element.
if ( event.type == 'mousedown' && !$( target ).is( 'input, select, textarea, button, option' )) {
event.preventDefault()
// Re-focus onto the root so that users can click away
// from elements focused within the picker.
P.$root[0].focus()
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2012
|
prepareElementHidden
|
train
|
function prepareElementHidden() {
var name
if ( SETTINGS.hiddenName === true ) {
name = ELEMENT.name
ELEMENT.name = ''
}
else {
name = [
typeof SETTINGS.hiddenPrefix == 'string' ? SETTINGS.hiddenPrefix : '',
typeof SETTINGS.hiddenSuffix == 'string' ? SETTINGS.hiddenSuffix : '_submit'
]
name = name[0] + ELEMENT.name + name[1]
}
P._hidden = $(
'<input ' +
'type=hidden ' +
// Create the name using the original input’s with a prefix and suffix.
'name="' + name + '"' +
// If the element has a value, set the hidden value as well.
(
$ELEMENT.data('value') || ELEMENT.value ?
' value="' + P.get('select', SETTINGS.formatSubmit) + '"' :
''
) +
'>'
)[0]
$ELEMENT.
// If the value changes, update the hidden input with the correct format.
on('change.' + STATE.id, function() {
P._hidden.value = ELEMENT.value ?
P.get('select', SETTINGS.formatSubmit) :
''
})
// Insert the hidden input as specified in the settings.
if ( SETTINGS.container ) $( SETTINGS.container ).append( P._hidden )
else $ELEMENT.after( P._hidden )
}
|
javascript
|
{
"resource": ""
}
|
q2013
|
handleKeydownEvent
|
train
|
function handleKeydownEvent( event ) {
var keycode = event.keyCode,
// Check if one of the delete keys was pressed.
isKeycodeDelete = /^(8|46)$/.test(keycode)
// For some reason IE clears the input value on “escape”.
if ( keycode == 27 ) {
P.close()
return false
}
// Check if `space` or `delete` was pressed or the picker is closed with a key movement.
if ( keycode == 32 || isKeycodeDelete || !STATE.open && P.component.key[keycode] ) {
// Prevent it from moving the page and bubbling to doc.
event.preventDefault()
event.stopPropagation()
// If `delete` was pressed, clear the values and close the picker.
// Otherwise open the picker.
if ( isKeycodeDelete ) { P.clear().close() }
else { P.open() }
}
}
|
javascript
|
{
"resource": ""
}
|
q2014
|
handleFocusToOpenEvent
|
train
|
function handleFocusToOpenEvent( event ) {
// Stop the event from propagating to the doc.
event.stopPropagation()
// If it’s a focus event, add the “focused” class to the root.
if ( event.type == 'focus' ) {
P.$root.addClass( CLASSES.focused )
}
// And then finally open the picker.
P.open()
}
|
javascript
|
{
"resource": ""
}
|
q2015
|
isUsingDefaultTheme
|
train
|
function isUsingDefaultTheme( element ) {
var theme,
prop = 'position'
// For IE.
if ( element.currentStyle ) {
theme = element.currentStyle[prop]
}
// For normal browsers.
else if ( window.getComputedStyle ) {
theme = getComputedStyle( element )[prop]
}
return theme == 'fixed'
}
|
javascript
|
{
"resource": ""
}
|
q2016
|
train
|
function( wrapper, item, klass, attribute ) {
// If the item is false-y, just return an empty string
if ( !item ) return ''
// If the item is an array, do a join
item = $.isArray( item ) ? item.join( '' ) : item
// Check for the class
klass = klass ? ' class="' + klass + '"' : ''
// Check for any attributes
attribute = attribute ? ' ' + attribute : ''
// Return the wrapped item
return '<' + wrapper + klass + attribute + '>' + item + '</' + wrapper + '>'
}
|
javascript
|
{
"resource": ""
}
|
|
q2017
|
getWordLengthFromCollection
|
train
|
function getWordLengthFromCollection( string, collection, dateObject ) {
// Grab the first word from the string.
var word = string.match( /\w+/ )[ 0 ]
// If there's no month index, add it to the date object
if ( !dateObject.mm && !dateObject.m ) {
dateObject.m = collection.indexOf( word ) + 1
}
// Return the length of the word.
return word.length
}
|
javascript
|
{
"resource": ""
}
|
q2018
|
train
|
function ( formatString, itemObject ) {
var calendar = this
return calendar.formats.toArray( formatString ).map( function( label ) {
return _.trigger( calendar.formats[ label ], calendar, [ 0, itemObject ] ) || label.replace( /^!/, '' )
}).join( '' )
}
|
javascript
|
{
"resource": ""
}
|
|
q2019
|
_addRouteRecord
|
train
|
function _addRouteRecord(route, parent, exclude = false, ancestors = []) {
const { path, name, handler } = route;
const finalPath = _normalizePath(path, parent, ancestors);
// Push path into ancestors array
ancestors.push(path);
const record = {
name,
parent,
handler,
path: finalPath,
regex: PathToRegexp(finalPath),
// redirect, TODO: Look into redirect functionality further
before: route.before,
init: route.init,
update: route.update,
after: route.after,
unload: route.unload,
pop: route.pop,
meta: route.meta || {},
};
// Children should be mapped before parent in case of wildcard in parent
if (route.children && route.children.length) {
let i = 0;
const length = route.children.length;
for (; i < length; i++) {
_addRouteRecord(route.children[i], route, exclude, ancestors);
// After record is added, pop last ancestor off for the next set of paths
ancestors.pop();
}
}
// Exclude from main mapping/return created route record object
if (exclude) {
return record;
}
if (! pathMap[record.path]) {
pathList.push(record.path);
pathMap[record.path] = record;
}
if (name && ! nameMap[name]) {
nameMap[name] = record;
}
}
|
javascript
|
{
"resource": ""
}
|
q2020
|
_normalizePath
|
train
|
function _normalizePath(path, parent, ancestors) {
if (path === '/') {
return path;
}
path = path.replace(/\/$/, '');
// If path begins with / then assume it is independent route
if (path[0] === '/') {
return path;
}
// If no parent, and route doesn't start with /, then prepend /
if (! parent) {
return `/${path}`;
}
if (ancestors) {
return _cleanPath(`${ancestors.join('/')}/${path}`);
}
return _cleanPath(`${parent.path}/${path}`);
}
|
javascript
|
{
"resource": ""
}
|
q2021
|
build_doc_map
|
train
|
function build_doc_map(docs) {
var map = {};
_.each(docs, function(tag) {
if (map[tag["tagname"]])
map[tag["tagname"]].push(tag);
else
map[tag["tagname"]] = new Array(tag);
});
return map;
}
|
javascript
|
{
"resource": ""
}
|
q2022
|
isIso8601DateTimeString
|
train
|
function isIso8601DateTimeString(value) {
var regex = /^(([+-]\d{6}|\d{4})(-(0[1-9]|1[0-2])(-(0[1-9]|[12]\d|3[01]))?)?)(T((([01]\d|2[0-3])(:[0-5]\d)(:[0-5]\d(\.\d{1,3})?)?)|(24:00(:00(\.0{1,3})?)?))(Z|([+-])([01]\d|2[0-3]):([0-5]\d))?)?$/;
// Verify that it's in ISO 8601 format (via the regex) and that it represents a valid point in time (via Date.parse)
return regex.test(value) && !isNaN(Date.parse(value));
}
|
javascript
|
{
"resource": ""
}
|
q2023
|
isIso8601DateString
|
train
|
function isIso8601DateString(value) {
var regex = /^([+-]\d{6}|\d{4})(-(0[1-9]|1[0-2])(-(0[1-9]|[12]\d|3[01]))?)?$/;
// Verify that it's in ISO 8601 format (via the regex) and that it represents a valid day (via Date.parse)
return regex.test(value) && !isNaN(Date.parse(value));
}
|
javascript
|
{
"resource": ""
}
|
q2024
|
extractIso8601TimePieces
|
train
|
function extractIso8601TimePieces(value) {
var timePieces = /^(\d{2}):(\d{2})(?:\:(\d{2}))?(?:\.(\d{1,3}))?$/.exec(value);
if (timePieces === null) {
return null;
}
var hour = timePieces[1] ? parseInt(timePieces[1], 10) : 0;
var minute = timePieces[2] ? parseInt(timePieces[2], 10) : 0;
var second = timePieces[3] ? parseInt(timePieces[3], 10) : 0;
// The millisecond component has a variable length; normalize the length by padding it with zeros
var millisecond = timePieces[4] ? parseInt(utils.padRight(timePieces[4], 3, '0'), 10) : 0;
return [ hour, minute, second, millisecond ];
}
|
javascript
|
{
"resource": ""
}
|
q2025
|
compareTimes
|
train
|
function compareTimes(a, b) {
if (typeof a !== 'string' || typeof b !== 'string') {
return NaN;
}
var aTimePieces = extractIso8601TimePieces(a);
var bTimePieces = extractIso8601TimePieces(b);
if (aTimePieces === null || bTimePieces === null) {
return NaN;
}
for (var timePieceIndex = 0; timePieceIndex < aTimePieces.length; timePieceIndex++) {
if (aTimePieces[timePieceIndex] < bTimePieces[timePieceIndex]) {
return -1;
} else if (aTimePieces[timePieceIndex] > bTimePieces[timePieceIndex]) {
return 1;
}
}
// If we got here, the two parameters represent the same time of day
return 0;
}
|
javascript
|
{
"resource": ""
}
|
q2026
|
convertToTimestamp
|
train
|
function convertToTimestamp(value) {
if (value instanceof Date) {
return value.getTime();
} else if (typeof value === 'number') {
return Math.floor(value);
} else if (typeof value === 'string') {
return Date.parse(value);
} else {
return NaN;
}
}
|
javascript
|
{
"resource": ""
}
|
q2027
|
compareDates
|
train
|
function compareDates(a, b) {
var aTimestamp = convertToTimestamp(a);
var bTimestamp = convertToTimestamp(b);
if (isNaN(aTimestamp) || isNaN(bTimestamp)) {
return NaN;
} else {
return aTimestamp - bTimestamp;
}
}
|
javascript
|
{
"resource": ""
}
|
q2028
|
normalizeIso8601TimeZone
|
train
|
function normalizeIso8601TimeZone(value) {
if (value === 'Z') {
return 0;
}
var regex = /^([+-])(\d\d):?(\d\d)$/;
var matches = regex.exec(value);
if (matches === null) {
return NaN;
} else {
var multiplicationFactor = (matches[1] === '+') ? 1 : -1;
var hour = parseInt(matches[2], 10);
var minute = parseInt(matches[3], 10);
return multiplicationFactor * ((hour * 60) + minute);
}
}
|
javascript
|
{
"resource": ""
}
|
q2029
|
compareTimeZones
|
train
|
function compareTimeZones(a, b) {
if (typeof a !== 'string' || typeof b !== 'string') {
return NaN;
}
return normalizeIso8601TimeZone(a) - normalizeIso8601TimeZone(b);
}
|
javascript
|
{
"resource": ""
}
|
q2030
|
decode_param
|
train
|
function decode_param(val) {
if (typeof val !== 'string' || val.length === 0) {
return val;
}
try {
return decodeURIComponent(val);
} catch (err) {
if (err instanceof URIError) {
err.message = `Failed to decode param '${val}'`;
err.status = err.statusCode = 400;
}
throw err;
}
}
|
javascript
|
{
"resource": ""
}
|
q2031
|
train
|
function (mime) {
var info = {
type: UNKNOWN,
format: RAW,
guessed: true
},
match,
base;
// extract the mime base
base = (base = mime.split(SEP)) && base[0] || E;
// bail out on the mime types that are sure-shot ones with no ambiguity
match = base.match(AUDIO_VIDEO_IMAGE_TEXT);
if (match && match[1]) {
info.type = info.format = match[1];
// we do special kane matching to extract the format in case the match was text
// this ensures that we get same formats like we will do in kane match later down the line
if (info.type === TEXT) {
match = mime.match(JSON_XML_SCRIPT_SIBLINGS);
info.format = match && match[1] || PLAIN;
}
return info;
}
// we do a kane match on entire mime (not just base) to find texts
match = mime.match(JSON_XML_SCRIPT_SIBLINGS);
if (match && match[1]) {
info.type = TEXT;
info.format = match[1];
return info;
}
// now we match the subtype having names from the sure shot bases
match = mime.match(AUDIO_VIDEO_IMAGE_TEXT_SUBTYPE);
if (match && match[1]) {
info.type = info.format = match[1];
return info;
}
// now that most text and sure-shot types and sub-types are out of our way, we detect standard bases
// and rest are unknown
match = base.match(APPLICATION_MESSAGE_MULTIPART);
if (match && match[1]) {
info.type = match[1];
info.format = RAW;
return info;
}
// at this point nothing has matched nothing. it is worth keeping a note of it
info.orphan = true;
return info;
}
|
javascript
|
{
"resource": ""
}
|
|
q2032
|
train
|
function(o) {
var a = [];
_.each(o, function(value, key) {
a.push({file:key,method:value});
});
return a;
}
|
javascript
|
{
"resource": ""
}
|
|
q2033
|
expand
|
train
|
function expand(docset, customTags) {
docset["comment"] = DocParser.parse(docset["comment"], customTags);
docset["tagname"] = DocType.detect(docset["comment"], docset["code"]);
if (docset["tagname"] == "class")
return DocExpander.expand(docset);
else
return docset;
}
|
javascript
|
{
"resource": ""
}
|
q2034
|
merge
|
train
|
function merge(docset, customTags) {
doc_ast.linenr = docset["linenr"];
// useful for applying global NS items to the proper NS
docset["original_name"] = docset["code"].name;
docset["comment"] = doc_ast.detect(docset["tagname"], docset["comment"], customTags);
return Merger.merge(docset);
}
|
javascript
|
{
"resource": ""
}
|
q2035
|
createBasicTranslation
|
train
|
function createBasicTranslation(memberName, type, i, options) {
var node = {};
node["id"] = memberName;
node["type"] = type;
if (i["inheritdoc"] !== undefined) {
node["inheritdoc"] = i["inheritdoc"].src;
}
else if (i["doc"] !== undefined) {
node["description"] = i["doc"];
// short description lasts until the first empty line
node["short_description"] = node["description"].replace(/\n\n[\s\S]*$/, '\n');
}
else {
node["undocumented"] = true;
}
node["line"] = i["linenr"];
if (i["private"] !== undefined)
node["private"] = i["private"];
if (i["experimental"] !== undefined)
node["experimental"] = i["experimental"];
if (i["ignore"] !== undefined)
node["ignore"] = i["ignore"];
if (i["chainable"] !== undefined)
node["chainable"] = i["chainable"];
if (i["see"] !== undefined)
node["related_to"] = i["see"].name;
if (i["author"] !== undefined && i["author"].length > 0)
node["author"] = i["author"].doc;
if (i["version"] !== undefined)
node["version"] = i["version"].doc;
if (i["since"] !== undefined)
node["since"] = i["since"].doc;
if (i["author"] !== undefined)
node["author"] = i["author"];
if (i["related"] !== undefined)
node["related"] = i["related"].name;
if (options.customTags) {
_.each(options.customTags, function(tag) {
if (i[tag] !== undefined)
node[tag] = i[tag];
});
}
return node;
}
|
javascript
|
{
"resource": ""
}
|
q2036
|
Route
|
train
|
function Route(path) {
this.path = path;
this.stack = [];
this.handle = compose(this.stack);
debug('new %s', path);
// route handlers for various http methods
this.methods = {};
}
|
javascript
|
{
"resource": ""
}
|
q2037
|
train
|
function(data, name, $field, $el, field, callback) {
data[name] = self.getArea($el, name);
if (field.required && (apos.areaIsEmpty(data[name]))) {
return apos.afterYield(_.partial(callback, 'required'));
}
return apos.afterYield(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q2038
|
train
|
function(data, name, $field, $el, field, callback) {
data[name] = $field.val();
if (field.required && !data[name].length) {
return apos.afterYield(_.partial(callback, 'required'));
}
if (field.max && (data[name].length > field.max)) {
var $fieldset = self.findFieldset($el, name);
$fieldset.addClass('apos-error-max');
return apos.afterYield(_.partial(callback, 'max'));
}
return apos.afterYield(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q2039
|
_isValid
|
train
|
function _isValid(el, currentPath) {
// Link has no destination URL
if (! el.href) { return false; }
// Link opens a new browser window
if (el.target === '_blank') { return false; }
// Link is not absolute URL
if (! /https?:/.test(el.href)) { return false; }
// Link is a download
if (el.hasAttribute('download')) { return false; }
// Link is supposed to be ignored
if (el.hasAttribute('data-static')) { return false; }
// Link is external URL
if (el.host && el.host !== location.host) { return false; }
// Link is current page, but with a hash added
if (el.hash && el.pathname === currentPath) { return false; }
return true;
}
|
javascript
|
{
"resource": ""
}
|
q2040
|
_path
|
train
|
function _path(loc) {
loc = loc || location;
return loc.pathname + loc.search + loc.hash;
}
|
javascript
|
{
"resource": ""
}
|
q2041
|
train
|
function (message) {
if (options.force) {
grunt.log.error(message);
} else {
grunt.warn(message);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2042
|
simpleTypeFilter
|
train
|
function simpleTypeFilter(newDoc, oldDoc, candidateDocType) {
if (oldDoc) {
if (newDoc._deleted) {
return oldDoc.type === candidateDocType;
} else {
return newDoc.type === oldDoc.type && oldDoc.type === candidateDocType;
}
} else {
return newDoc.type === candidateDocType;
}
}
|
javascript
|
{
"resource": ""
}
|
q2043
|
train
|
function(methodName, alternatives) {
return function() {
var callback = Array.prototype.slice.call(arguments).pop();
if (!Array.isArray(alternatives)) {
alternatives = [alternatives];
}
var alternativeString;
if (alternatives.length === 1) {
alternativeString = alternatives[0];
} else {
var lastItem = alternatives.pop();
alternativeString = alternatives.join('", "') + '" or "' +
lastItem;
}
callback(MongoError.create({
message: 'Method "' + methodName + '" is deprecated, use "' +
alternativeString + '" instead',
driver: true
}));
};
}
|
javascript
|
{
"resource": ""
}
|
|
q2044
|
add_shared
|
train
|
function add_shared(hash, customTags, doc_map) {
hash = utils.merge(hash, {
"inheritable" : !!doc_map["inheritable"],
"inheritdoc" : extract(doc_map, "inheritdoc"),
"related" : extract(doc_map, "related"),
"see" : extract(doc_map, "see"),
"private" : extract(doc_map, "private") !== null ? true : false,
"experimental" : extract(doc_map, "experimental") !== null ? true : false,
"ignore" : extract(doc_map, "ignore") !== null ? true : false,
"author" : extract_plural(doc_map["author"] || []),
"version" : extract(doc_map, "version"),
"since" : extract(doc_map, "since"),
"todo" : extract(doc_map, "todo")
});
if (customTags !== undefined) {
var custom = {};
_.each(customTags, function(tag) {
var text = extract(doc_map, tag);
if (text !== null) {
custom[tag] = text.doc.length > 0 ? text.doc : true;
}
});
hash = utils.merge(hash, custom);
}
return hash;
}
|
javascript
|
{
"resource": ""
}
|
q2045
|
detect_list
|
train
|
function detect_list(type, doc_map) {
if (doc_map[type])
return _.flatten(_.map(doc_map[type], function(d) { d[type] }));
else
return null;
}
|
javascript
|
{
"resource": ""
}
|
q2046
|
detect_doc
|
train
|
function detect_doc(docs, customTags) {
var ignore_tags = _.union(["param", "return", "author", "version",
"cancelable", "bubbles", "since", "inherits", "todo", "deprecated"], customTags);
var doc_tags = _.filter(docs, function(tag) { return !_.include(ignore_tags, tag["tagname"]) && !subproperty(tag) });
return _.compact(_.map(doc_tags, function(tag) { return tag["doc"] })).join(" ");
}
|
javascript
|
{
"resource": ""
}
|
q2047
|
maybe_name
|
train
|
function maybe_name() {
skip_horiz_white();
if (look(ident_pattern_with_dot)) {
current_tag["name"] = match(ident_pattern_with_dot);
}
else if (look(ident_pattern)) {
current_tag["name"] = match(ident_pattern);
}
}
|
javascript
|
{
"resource": ""
}
|
q2048
|
default_value
|
train
|
function default_value() {
start_pos = input.pointer();
value = parse_balanced(/\[/, /\]/, /[^\[\]]*/);
if (look(/\]/)) {
return value;
}
else {
input.setPointer(start_pos);
return match(/[^\]]*/);
}
}
|
javascript
|
{
"resource": ""
}
|
q2049
|
parse_balanced
|
train
|
function parse_balanced(re_open, re_close, re_rest) {
result = match(re_rest);
while (look(re_open)) {
result += match(re_open);
result += parse_balanced(re_open, re_close, re_rest);
result += match(re_close);
result += match(re_rest);
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q2050
|
RedisPool
|
train
|
function RedisPool(opts) {
if (!(this instanceof RedisPool)) {
return new RedisPool(opts);
}
EventEmitter.call(this);
opts = opts || {};
var defaults = {
host: '127.0.0.1',
port: '6379',
max: 50,
idleTimeoutMillis: 10000,
reapIntervalMillis: 1000,
noReadyCheck: false,
returnToHead: false,
unwatchOnRelease: true,
name: 'default',
log: false,
slowPool: {
log: false,
elapsedThreshold: 25
},
emitter: {
statusInterval: 60000
},
commands: []
};
this.options = _.defaults(opts, defaults);
this.pools = {};
this.elapsedThreshold = this.options.slowPool.elapsedThreshold;
// add custom Redis commands
if (this.options.commands && this.options.commands.length) {
this.options.commands.forEach(function(newCommand) {
redis.add_command(newCommand);
});
}
var self = this;
setInterval(function() {
Object.keys(self.pools).forEach(function(poolKey) {
var pool = self.pools[poolKey];
self.emit('status', {
name: self.options.name,
db: poolKey,
count: pool.getPoolSize(),
unused: pool.availableObjectsCount(),
waiting: pool.waitingClientsCount()
});
});
}, this.options.emitter.statusInterval);
}
|
javascript
|
{
"resource": ""
}
|
q2051
|
makePool
|
train
|
function makePool(options, database) {
return Pool({
name: options.name + ':' + database,
create: function(callback) {
var callbackCalled = false;
var client = redis.createClient(options.port, options.host, {
no_ready_check: options.noReadyCheck
});
client.on('error', function (err) {
log(options, {db: database, action: 'error', err: err.message});
if (!callbackCalled) {
callbackCalled = true;
callback(err, client);
}
client.end(FLUSH_CONNECTION);
});
client.on('ready', function () {
client.select(database, function(err/*, res*/) {
if (!callbackCalled) {
callbackCalled = true;
callback(err, client);
}
});
});
},
destroy: function(client) {
client.quit();
client.end(FLUSH_CONNECTION);
},
validate: function(client) {
return client && client.connected;
},
max: options.max,
idleTimeoutMillis: options.idleTimeoutMillis,
reapIntervalMillis: options.reapIntervalMillis,
returnToHead: options.returnToHead,
log: options.log
});
}
|
javascript
|
{
"resource": ""
}
|
q2052
|
_storageFactory
|
train
|
function _storageFactory(type) {
let storage;
if (type === 'local') {
storage = window.localStorage;
} else if (type === 'session') {
storage = window.sessionStorage;
}
return {
getItem(key) {
return JSON.parse(storage.getItem(key));
},
setItem(key, value) {
value = JSON.stringify(value);
return storage.setItem(key, value);
},
removeItem(key) {
return storage.removeItem(key);
}
};
}
|
javascript
|
{
"resource": ""
}
|
q2053
|
train
|
function(numberOfDownloaded, finishCallback, allCompletedCallback) {
let downloadedItem = 0;
return zincGeometry => {
downloadedItem = downloadedItem + 1;
if (finishCallback != undefined && (typeof finishCallback == 'function'))
finishCallback(zincGeometry);
if (downloadedItem == numberOfDownloaded)
if (allCompletedCallback != undefined && (typeof allCompletedCallback == 'function'))
allCompletedCallback();
};
}
|
javascript
|
{
"resource": ""
}
|
|
q2054
|
extend
|
train
|
function extend (host, methods) {
for (var name in methods) {
if (!host[name]) {
host[name] = methods[name];
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2055
|
makeTypeConstraintsSchema
|
train
|
function makeTypeConstraintsSchema(typeName) {
const allTypeConstraints = typeSpecificConstraintSchemas();
const constraints = Object.assign({ }, universalConstraintSchemas(typeEqualitySchemas[typeName]), allTypeConstraints[typeName]);
return joi.object().keys(constraints)
// Prevent the use of more than one constraint from the "required value" category
.without('required', [ 'mustNotBeMissing', 'mustNotBeNull' ])
.without('mustNotBeMissing', [ 'required', 'mustNotBeNull' ])
.without('mustNotBeNull', [ 'required', 'mustNotBeMissing' ])
// Prevent the use of more than one constraint from the "equality" category
.without('mustEqual', [ 'mustEqualStrict', 'mustEqualIgnoreCase' ])
.without('mustEqualStrict', [ 'mustEqual', 'mustEqualIgnoreCase' ])
.without('mustEqualIgnoreCase', [ 'mustEqual', 'mustEqualStrict' ])
// Prevent the use of more than one constraint from the "minimum value" category
.without('minimumValue', [ 'minimumValueExclusive', 'mustEqual', 'mustEqualStrict', 'mustEqualIgnoreCase' ])
.without('minimumValueExclusive', [ 'minimumValue', 'mustEqual', 'mustEqualStrict', 'mustEqualIgnoreCase' ])
// Prevent the use of more than one constraint from the "maximum value" category
.without('maximumValue', [ 'maximumValueExclusive', 'mustEqualStrict', 'mustEqual', 'mustEqualIgnoreCase' ])
.without('maximumValueExclusive', [ 'maximumValue', 'mustEqualStrict', 'mustEqual', 'mustEqualIgnoreCase' ])
// Prevent the use of more than one constraint from the "immutability" category
.without('immutable', [ 'immutableStrict', 'immutableWhenSet', 'immutableWhenSetStrict' ])
.without('immutableStrict', [ 'immutable', 'immutableWhenSet', 'immutableWhenSetStrict' ])
.without('immutableWhenSet', [ 'immutable', 'immutableStrict', 'immutableWhenSetStrict' ])
.without('immutableWhenSetStrict', [ 'immutable', 'immutableStrict', 'immutableWhenSet' ])
// Prevent the use of more than one constraint from the "skip validation" category
.without('skipValidationWhenValueUnchanged', [ 'skipValidationWhenValueUnchangedStrict' ]);
}
|
javascript
|
{
"resource": ""
}
|
q2056
|
processOne
|
train
|
function processOne() {
var item = array.pop();
fn(item, function(result, err) {
if (array.length > 0)
processOne();
else
callback(result, err);
});
}
|
javascript
|
{
"resource": ""
}
|
q2057
|
_setClass
|
train
|
function _setClass(el, className) {
el instanceof SVGElement ?
el.setAttribute('class', className) :
el.className = className;
}
|
javascript
|
{
"resource": ""
}
|
q2058
|
_toCamel
|
train
|
function _toCamel(name) {
return name.toLowerCase()
.replace(/-(.)/g, (match, val) => val.toUpperCase());
}
|
javascript
|
{
"resource": ""
}
|
q2059
|
_getSelected
|
train
|
function _getSelected(select) {
const arr = [];
_slice.call(select.options).map((el) => {
if (el.selected) {
arr.push(el.value);
}
});
return arr;
}
|
javascript
|
{
"resource": ""
}
|
q2060
|
_getSibling
|
train
|
function _getSibling(target, dir, filter, options) {
let match;
$each(target, (el) => {
const index = $index(el) + dir;
$children($parent(el)).forEach((el, i) => {
if (i === index &&
(! filter || filter && $is(el, filter, options))) {
match = el;
}
});
});
return match;
}
|
javascript
|
{
"resource": ""
}
|
q2061
|
partialCallback
|
train
|
function partialCallback(text, urlIndex) {
result[urlIndex] = text;
numComplete++;
// When all files have downloaded
if (numComplete == numUrls) {
callback(result);
}
}
|
javascript
|
{
"resource": ""
}
|
q2062
|
write
|
train
|
function write(id, chunk) {
// They want to write to our real stream
var stream = streams[id];
if (!stream) return;
stream.write(chunk);
}
|
javascript
|
{
"resource": ""
}
|
q2063
|
expand_comment
|
train
|
function expand_comment(docset) {
groups = {
"class": [],
"cfg": [],
"Constructor": []
}
// By default everything goes to :class group
var group_name = "class";
_.each(docset["comment"], function (tag) {
tagname = tag["tagname"];
if (tagname == "cfg" || tagname == "Constructor") {
group_name = tagname;
if (tagname == "cfg")
groups["cfg"].push([]);
}
if (tagname == "alias")
groups["class"].push(tag); // For backwards compatibility allow @xtype after @constructor
else if (group_name == "cfg")
_.last(groups["cfg"]).push(tag);
else
groups[group_name].push(tag);
});
return groups_to_docsets(groups, docset);
}
|
javascript
|
{
"resource": ""
}
|
q2064
|
groups_to_docsets
|
train
|
function groups_to_docsets(groups, docset) {
var results = [{
"tagname": "class",
"type": docset["type"],
"comment": groups["class"],
"code": docset["code"],
"linenr": docset["linenr"]
}];
_.each(groups["cfg"], function(cfg) {
results.push({
"tagname": "cfg",
"type": docset["type"],
"comment": cfg,
"code": {},
"linenr": docset["linenr"]
});
});
if (groups["Constructor"].length > 0) {
// Remember that a constructor is already found and ignore if a
// constructor is detected from code.
var constructor_found = true
results.push({
"tagname": "method",
"type": docset["type"],
"comment": groups["Constructor"],
"code": {},
"linenr": docset["linenr"]
});
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
q2065
|
expand_code
|
train
|
function expand_code(docset) {
var results = [];
if (docset["code"] && docset["code"]["members"]) {
_.each(docset["code"]["members"], function(m) {
if (! (constructor_found && m["name"] == "Constructor") )
results.push(code_to_docset(m));
});
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
q2066
|
vertextes
|
train
|
function vertextes(parent, exist = [], item, _path) {
return [...parent.children].reduce( (acc, node, index) => {
if(node.tagName === "IMG") {
//const [ name, props = {} ] = JSON.parse(node.getAttribute("m2") || "[]");
node.setAttribute("m2", JSON.stringify([
`*${imgcounter++}`, { resources: [ {type: "img", url: node.getAttribute("src") } ]}
]));
item = [];
}
/*
if(node.tagName === "link" && node.getAttribute("rel") === "stylesheet") {
exist[1].resources.push( {type: "style", url: node.getAttribute("href") } );
node.remove();
return acc;
}*/
if(node.getAttribute("m2")) {
const m2data = transform(node, item, _path);
if(!m2data[1].template && exist[1].type !== "switcher") {
const placer = document.createElement("div");
placer.setAttribute("data-pid", m2data[1].pid );
node.parentNode.replaceChild(placer, node);
}
node.remove();
acc.push( m2data );
}
else {
vertextes(node, exist, item, _path);
}
return acc;
}, exist);
}
|
javascript
|
{
"resource": ""
}
|
q2067
|
declarationImpliesInitialisation
|
train
|
function declarationImpliesInitialisation(variable, scope) {
return variable.name === "arguments" && scope.type === ScopeType.FUNCTION ||
variable.declarations.some(decl =>
decl.type === DeclarationType.PARAMETER ||
decl.type === DeclarationType.FUNCTION_NAME ||
decl.type === DeclarationType.CATCH
);
}
|
javascript
|
{
"resource": ""
}
|
q2068
|
_arrEquals
|
train
|
function _arrEquals(a, b) {
return a.length == b.length &&
a.every((el, i) => _equals(el, b[i]));
}
|
javascript
|
{
"resource": ""
}
|
q2069
|
_copy
|
train
|
function _copy(val) {
const type = $type(val);
if (type == 'object') {
val = _extend({}, val, true);
} else if (type == 'array') {
val = val.slice(0);
}
return val;
}
|
javascript
|
{
"resource": ""
}
|
q2070
|
_equals
|
train
|
function _equals(a, b) {
if (a === b) {
return true;
}
const aType = $type(a);
if (aType != $type(b)) {
return false;
}
if (aType == 'array') {
return _arrEquals(a, b);
}
if (aType == 'object') {
return _objEquals(a, b);
}
if (aType == 'date') {
return +a == +b;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q2071
|
_objEquals
|
train
|
function _objEquals(a, b) {
const aKeys = Object.keys(a);
return _arrEquals(aKeys.sort(), Object.keys(b).sort()) &&
aKeys.every(i => _equals(a[i], b[i]));
}
|
javascript
|
{
"resource": ""
}
|
q2072
|
format_parsed
|
train
|
function format_parsed (parsed) {
var pkg = (parsed.s && '@' + parsed.s + '/')
+ parsed.n + '@' + parsed.v;
parsed.id = pkg + parsed.p;
parsed.k = pkg;
return parsed;
}
|
javascript
|
{
"resource": ""
}
|
q2073
|
mix
|
train
|
function mix (receiver, supplier) {
for (var key in supplier) {
receiver[key] = supplier[key];
}
return receiver;
}
|
javascript
|
{
"resource": ""
}
|
q2074
|
_whichTransitionEvent
|
train
|
function _whichTransitionEvent() {
const el = document.createElement('meta');
const animations = {
transition: 'transitionend',
OTransition: 'oTransitionEnd',
MozTransition: 'transitionend',
WebkitTransition: 'webkitTransitionEnd',
};
for (const t in animations) {
if (el.style[t] !== undefined) {
return animations[t];
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2075
|
_addRule
|
train
|
function _addRule(conf) {
// Attach unique identifier
conf.i = id++;
// Only setup watching when enabled
if (conf.watch !== false) {
events.push(conf);
// Only attach event once
if (! bound) {
const run = _run.bind(this, false, 0, null);
bound = 1;
events = [conf];
// Attach resize event
_win.addEventListener('resize', run);
}
}
// Evaluate rule immediately if not disabled
if (conf.init !== false) {
_run(true, [conf]);
}
}
|
javascript
|
{
"resource": ""
}
|
q2076
|
_eq
|
train
|
function _eq(evt, size, init) {
const sz = evt.size;
const mn = evt.min;
const mx = evt.max;
const ex = evt.each || init;
// Check match against rules
return (! sz && ! mn && ! mx) ||
(sz && sz === size) ||
(mn && size >= mn && (ex || current < mn) && (! mx || size <= mx)) ||
(mx && size <= mx && (ex || current > mx) && (! mn || size >= mn));
}
|
javascript
|
{
"resource": ""
}
|
q2077
|
_run
|
train
|
function _run(init, rules, namespace) {
const size = _size();
let evts = rules || events;
let i;
// If breakpoint has been hit or resize logic initialized
if (size && (init || size !== current)) {
if (namespace) {
evts = evts.filter(obj => obj.namespace === namespace);
}
i = evts.length;
while (i--) {
const evt = evts[i];
if (_eq(evt, size, init)) {
const f = init && ! current;
const data = {
dir: f ? 0 : (size > current ? 1 : -1),
init: f,
prev: current,
size,
};
$exec(evt.callback, {
args: evt.args ? [data].concat(evt.args) : [data],
scope: evt.scope,
});
// Disable future execution if once
if (evt.once) {
events = events.filter(obj => obj.i !== evt.i);
}
}
}
// Cache current value
current = size;
}
}
|
javascript
|
{
"resource": ""
}
|
q2078
|
router
|
train
|
function router(config = {}) {
$extend(settings, config);
// Update scrollBehavior property in case that was changed
history.scrollBehavior = settings.scrollBehavior;
history.transition = settings.transition;
return router;
}
|
javascript
|
{
"resource": ""
}
|
q2079
|
run_callbacks
|
train
|
function run_callbacks (object, key) {
var callbacks = object[key];
var callback;
// Mark the module is ready
// `delete module.c` is not safe
// #135
// Android 2.2 might treat `null` as [object Global] and equal it to true,
// So, never confuse `null` and `false`
object[key] = FALSE;
while(callback = callbacks.pop()){
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q2080
|
Parser
|
train
|
function Parser(options) {
options = options || {};
// env storage
this._env = Object.create(null);
// current env
this._currEnv = options.currEnv || process.env;
// enable/disable booleans
this._allowBool = has.call(options, 'booleans')
? options.booleans
: false;
// enable/disable numbers
this._allowNum = has.call(options, 'numbers')
? options.numbers
: false;
}
|
javascript
|
{
"resource": ""
}
|
q2081
|
scan
|
train
|
function scan(str, re) {
var match = null;
var ret = [];
while (match = re.exec(str)) {
ret.push(match);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q2082
|
train
|
function() {
// First deal only with doc-comments
doc_comments = _.filter(docs, function(d) {
return d["type"] == "doc_comment";
});
// Detect code in each docset. Sometimes a docset has already
// been detected as part of detecting some previous docset (like
// Class detecting all of its configs) - in such case, skip.
_.each(doc_comments, function(docset) {
code = docset["code"];
if ( !(code && code["tagname"]) )
docset["code"] = detect(code);
else
docset["code"] = "";
});
// Return all doc-comments + other comments for which related
// code was detected.
return _.filter(docs, function(d) {
return d["type"] == "doc_comment" || d["code"] && d["code"]["tagname"];
});
}
|
javascript
|
{
"resource": ""
}
|
|
q2083
|
detect_class_members_from_object
|
train
|
function detect_class_members_from_object(cls, ast) {
cls["members"] = []
return each_pair_in_object_expression(ast, function(key, value, pair) {
detect_method_or_property(cls, key, value, pair);
});
}
|
javascript
|
{
"resource": ""
}
|
q2084
|
detect_class_members_from_array
|
train
|
function detect_class_members_from_array(cls, ast) {
cls["members"] = [];
return _.each(ast["elements"], function(el) {
detect_method_or_property(cls, key_value(el), el, el);
});
}
|
javascript
|
{
"resource": ""
}
|
q2085
|
detect_method_or_property
|
train
|
function detect_method_or_property(cls, key, value, pair) {
if (isFn(value)) {
var m = make_method(key, value);
if (apply_autodetected(m, pair))
return cls["members"].push(m);
}
else {
var p = make_property(key, value);
if (apply_autodetected(p, pair))
return cls["members"].push(p);
}
}
|
javascript
|
{
"resource": ""
}
|
q2086
|
apply_autodetected
|
train
|
function apply_autodetected(m, ast, inheritable) {
docset = find_docset(ast);
var inheritable = inheritable || true;
if (!docset || docset["type"] != "doc_comment") {
if (inheritable)
m["inheritdoc"] = {};
else
m["private"] = true;
m["autodetected"] = true;
}
if (docset) {
docset["code"] = m;
return false;
}
else {
// Get line number from third place at range array.
// This third item exists in forked EsprimaJS at
// https://github.com/nene/esprima/tree/linenr-in-range
m["linenr"] = ast["range"][2];
return true;
}
}
|
javascript
|
{
"resource": ""
}
|
q2087
|
each_pair_in_object_expression
|
train
|
function each_pair_in_object_expression(ast, func) {
if (! (ast && ast["type"] == "ObjectExpression")) {
return;
}
return _.each(ast["properties"], function(p) {
isFn(key_value(p["key"]), p["value"], p);
});
}
|
javascript
|
{
"resource": ""
}
|
q2088
|
createFetchInstance
|
train
|
function createFetchInstance(defaultConfig) {
const context = fetchFactory(defaultConfig);
const instance = bind(context.request, context);
// Copy properties from context
extend(instance, context, context);
return instance;
}
|
javascript
|
{
"resource": ""
}
|
q2089
|
line_number
|
train
|
function line_number(index, source) {
// To speed things up, remember the index until which we counted,
// then next time just begin counting from there. This way we
// only count each line once.
var i = start_index;
var count = 0;
while (i < index) {
if (source[i] === "\n") {
count++;
}
i++;
}
start_linenr = count + start_linenr;
start_index = index;
return start_linenr;
}
|
javascript
|
{
"resource": ""
}
|
q2090
|
stuff_after
|
train
|
function stuff_after(comment, ast) {
var code = code_after(comment["range"], ast);
if (code && comment["next"])
return code["range"][0] < comment["next"]["range"][0] ? code : "";
else
return code;
}
|
javascript
|
{
"resource": ""
}
|
q2091
|
code_after
|
train
|
function code_after(range, parent) {
// Look through all child nodes of parent...
var children = child_nodes(parent);
for (var i = 0; i < children.length; i++) {
if (less(range, children[i]["range"])) {
// If node is after our range, then that's it. There could
// be comments in our way, but that's taken care of in
// #stuff_after method.
return children[i];
}
else if (within(range, children[i]["range"])) {
// Our range is within the node --> recurse
return code_after(range, children[i])
}
}
return;
}
|
javascript
|
{
"resource": ""
}
|
q2092
|
child_nodes
|
train
|
function child_nodes(node) {
var properties = NODE_TYPES[node["type"]];
if (properties === undefined) {
console.error("FATAL".red + ": Unknown node type: " + node["type"]);
console.trace();
process.exit(1);
}
var x = properties.map(function(p) {
return node[p];
});
return _.flatten(_.compact(x));
}
|
javascript
|
{
"resource": ""
}
|
q2093
|
train
|
function(req, data, name, snippet, field, callback) {
var manager = self._pages.getManager(field.withType);
if (!manager) {
return callback(new Error('join with type ' + field.withType + ' unrecognized'));
}
var titleOrId = self._apos.sanitizeString(data[name]);
var criteria = { $or: [ { sortTitle: self._apos.sortify(titleOrId) }, { _id: titleOrId } ] };
return manager.get(req, criteria, { fields: { _id: 1 } }, function(err, results) {
if (err) {
return callback(err);
}
results = results.pages || results.snippets;
if (!results.length) {
return callback(null);
}
snippet[field.idField] = results[0]._id;
return callback(null);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q2094
|
train
|
function(req, data, name, snippet, field, callback) {
var manager = self._pages.getManager(field.withType);
if (!manager) {
return callback(new Error('join with type ' + field.withType + ' unrecognized'));
}
var titlesOrIds = self._apos.sanitizeString(data[name]).split(/\s*,\s*/);
if ((!titlesOrIds) || (titlesOrIds[0] === undefined)) {
return setImmediate(callback);
}
var clauses = [];
_.each(titlesOrIds, function(titleOrId) {
clauses.push({ sortTitle: self._apos.sortify(titleOrId) });
clauses.push({ _id: titleOrId });
});
return manager.get(req, { $or: clauses }, { fields: { _id: 1 }, withJoins: false }, function(err, results) {
if (err) {
return callback(err);
}
results = results.pages || results.snippets;
if (field.limit !== undefined) {
results = results.slice(0, field.limit);
}
snippet[field.idsField] = _.pluck(results, '_id');
return callback(null);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q2095
|
error
|
train
|
function error() {
reject(new TypeError());
doc.removeEventListener(api.events.error, error, false);
}
|
javascript
|
{
"resource": ""
}
|
q2096
|
insertInto
|
train
|
function insertInto(annotations, index, text, afterExisting) {
for (let i = 0; i < annotations.length; ++i) {
if (annotations[i].index >= index) {
if (afterExisting) {
while (i < annotations.length && annotations[i].index === index) {
++i;
}
}
annotations.splice(i, 0, { index, text });
return;
}
}
annotations.push({ index, text });
}
|
javascript
|
{
"resource": ""
}
|
q2097
|
DiscordJS
|
train
|
function DiscordJS(embed) {
if (embed.file) {
console.log('Files in embeds will not be sent.');
embed.file = undefined;
}
return {
'embeds': [
embed,
],
};
}
|
javascript
|
{
"resource": ""
}
|
q2098
|
parse_files
|
train
|
function parse_files(files, options, callback) {
var nodes = {
// root section node
'': {
id: '',
type: 'section',
children: [],
description: '',
short_description: '',
href: '#',
root: true,
file: '',
line: 0
}
};
var reportObject = { };
async.forEachSeries(files, function (file, next_file) {
var fn = parsers[path.extname(file)];
if (!fn) {
next_file();
return;
}
console.info('Parsing file: ' + file);
fn(file, options, function (err, file_nodes, file_report) {
// TODO: fail on name clash here as well -- as we might get name clash
// from different parsers, or even different files
_.extend(nodes, file_nodes);
_.extend(reportObject, file_report);
next_file(err);
});
}, function (err) {
callback(err, nodes, reportObject);
});
}
|
javascript
|
{
"resource": ""
}
|
q2099
|
isPortTaken
|
train
|
function isPortTaken(port, fn) {
const net = require('net')
const tester = net.createServer()
.once('error', function (err) {
if (err.code != 'EADDRINUSE') return fn(err)
fn(null, true)
})
.once('listening', function() {
tester.once('close', function() { fn(null, false) })
.close()
})
.listen(port)
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.