Code Duplication - Otaku-Projects/AngularJS-CRUD-PHP - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 85-92 lines in 3 locations

third-party/jQuery/jquery-1.12.1.js 1 location



jQuery.extend( {

	Deferred: function( func ) {
		var tuples = [

				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred( function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];

							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[ 1 ] ]( function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.progress( newDefer.notify )
										.done( newDefer.resolve )
										.fail( newDefer.reject );
								} else {
									newDefer[ tuple[ 0 ] + "With" ](
										this === promise ? newDefer.promise() : this,
										fn ? [ returned ] : arguments
									);
								}
							} );
						} );
						fns = null;
					} ).promise();
				},

				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

		// Keep pipe for back-compat
		promise.pipe = promise.then;

		// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

			// promise[ done | fail | progress ] = list.add
			promise[ tuple[ 1 ] ] = list.add;

			// Handle state
			if ( stateString ) {
				list.add( function() {

					// state = [ resolved | rejected ]
					state = stateString;

				// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

			// deferred[ resolve | reject | notify ]
			deferred[ tuple[ 0 ] ] = function() {
				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
		} );

		// Make the deferred a promise
		promise.promise( deferred );

		// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

		// All done!
		return deferred;
	},

	// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {

third-party/jQuery/jquery-2.2.1.js 1 location



jQuery.extend( {

	Deferred: function( func ) {
		var tuples = [

				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred( function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];

							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[ 1 ] ]( function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.progress( newDefer.notify )
										.done( newDefer.resolve )
										.fail( newDefer.reject );
								} else {
									newDefer[ tuple[ 0 ] + "With" ](
										this === promise ? newDefer.promise() : this,
										fn ? [ returned ] : arguments
									);
								}
							} );
						} );
						fns = null;
					} ).promise();
				},

				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

		// Keep pipe for back-compat
		promise.pipe = promise.then;

		// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

			// promise[ done | fail | progress ] = list.add
			promise[ tuple[ 1 ] ] = list.add;

			// Handle state
			if ( stateString ) {
				list.add( function() {

					// state = [ resolved | rejected ]
					state = stateString;

				// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

			// deferred[ resolve | reject | notify ]
			deferred[ tuple[ 0 ] ] = function() {
				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
		} );

		// Make the deferred a promise
		promise.promise( deferred );

		// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

		// All done!
		return deferred;
	},

	// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {

third-party/angularjs/angular-1.5.0/docs/components/jquery-2.1.1/jquery.js 1 location



jQuery.extend({

	Deferred: function( func ) {
		var tuples = [
				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks("memory") ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred(function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[1] ](function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.done( newDefer.resolve )
										.fail( newDefer.reject )
										.progress( newDefer.notify );
								} else {
									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
								}
							});
						});
						fns = null;
					}).promise();
				},
				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

		// Keep pipe for back-compat
		promise.pipe = promise.then;

		// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

			// promise[ done | fail | progress ] = list.add
			promise[ tuple[1] ] = list.add;

			// Handle state
			if ( stateString ) {
				list.add(function() {
					// state = [ resolved | rejected ]
					state = stateString;

				// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

			// deferred[ resolve | reject | notify ]
			deferred[ tuple[0] ] = function() {
				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[0] + "With" ] = list.fireWith;
		});

		// Make the deferred a promise
		promise.promise( deferred );

		// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

		// All done!
		return deferred;
	},

	// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {

		@@ 3386-3477 (lines=92) @@
3383
3384		jQuery.extend( {
3385
3386		Deferred: function( func ) {
3387		var tuples = [
3388
3389		// action, add listener, listener list, final state
3390		[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
3391		[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
3392		[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
3393		],
3394		state = "pending",
3395		promise = {
3396		state: function() {
3397		return state;
3398		},
3399		always: function() {
3400		deferred.done( arguments ).fail( arguments );
3401		return this;
3402		},
3403		then: function( /* fnDone, fnFail, fnProgress */ ) {
3404		var fns = arguments;
3405		return jQuery.Deferred( function( newDefer ) {
3406		jQuery.each( tuples, function( i, tuple ) {
3407		var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3408
3409		// deferred[ done \| fail \| progress ] for forwarding actions to newDefer
3410		deferred[ tuple[ 1 ] ]( function() {
3411		var returned = fn && fn.apply( this, arguments );
3412		if ( returned && jQuery.isFunction( returned.promise ) ) {
3413		returned.promise()
3414		.progress( newDefer.notify )
3415		.done( newDefer.resolve )
3416		.fail( newDefer.reject );
3417		} else {
3418		newDefer[ tuple[ 0 ] + "With" ](
3419		this === promise ? newDefer.promise() : this,
3420		fn ? [ returned ] : arguments
3421		);
3422		}
3423		} );
3424		} );
3425		fns = null;
3426		} ).promise();
3427		},
3428
3429		// Get a promise for this deferred
3430		// If obj is provided, the promise aspect is added to the object
3431		promise: function( obj ) {
3432		return obj != null ? jQuery.extend( obj, promise ) : promise;
3433		}
3434		},
3435		deferred = {};
3436
3437		// Keep pipe for back-compat
3438		promise.pipe = promise.then;
3439
3440		// Add list-specific methods
3441		jQuery.each( tuples, function( i, tuple ) {
3442		var list = tuple[ 2 ],
3443		stateString = tuple[ 3 ];
3444
3445		// promise[ done \| fail \| progress ] = list.add
3446		promise[ tuple[ 1 ] ] = list.add;
3447
3448		// Handle state
3449		if ( stateString ) {
3450		list.add( function() {
3451
3452		// state = [ resolved \| rejected ]
3453		state = stateString;
3454
3455		// [ reject_list \| resolve_list ].disable; progress_list.lock
3456		}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3457		}
3458
3459		// deferred[ resolve \| reject \| notify ]
3460		deferred[ tuple[ 0 ] ] = function() {
3461		deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
3462		return this;
3463		};
3464		deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3465		} );
3466
3467		// Make the deferred a promise
3468		promise.promise( deferred );
3469
3470		// Call given func if any
3471		if ( func ) {
3472		func.call( deferred, deferred );
3473		}
3474
3475		// All done!
3476		return deferred;
3477		},
3478
3479		// Deferred helper
3480		when: function( subordinate /* , ..., subordinateN */ ) {

		@@ 3336-3427 (lines=92) @@
3333
3334		jQuery.extend( {
3335
3336		Deferred: function( func ) {
3337		var tuples = [
3338
3339		// action, add listener, listener list, final state
3340		[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
3341		[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
3342		[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
3343		],
3344		state = "pending",
3345		promise = {
3346		state: function() {
3347		return state;
3348		},
3349		always: function() {
3350		deferred.done( arguments ).fail( arguments );
3351		return this;
3352		},
3353		then: function( /* fnDone, fnFail, fnProgress */ ) {
3354		var fns = arguments;
3355		return jQuery.Deferred( function( newDefer ) {
3356		jQuery.each( tuples, function( i, tuple ) {
3357		var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3358
3359		// deferred[ done \| fail \| progress ] for forwarding actions to newDefer
3360		deferred[ tuple[ 1 ] ]( function() {
3361		var returned = fn && fn.apply( this, arguments );
3362		if ( returned && jQuery.isFunction( returned.promise ) ) {
3363		returned.promise()
3364		.progress( newDefer.notify )
3365		.done( newDefer.resolve )
3366		.fail( newDefer.reject );
3367		} else {
3368		newDefer[ tuple[ 0 ] + "With" ](
3369		this === promise ? newDefer.promise() : this,
3370		fn ? [ returned ] : arguments
3371		);
3372		}
3373		} );
3374		} );
3375		fns = null;
3376		} ).promise();
3377		},
3378
3379		// Get a promise for this deferred
3380		// If obj is provided, the promise aspect is added to the object
3381		promise: function( obj ) {
3382		return obj != null ? jQuery.extend( obj, promise ) : promise;
3383		}
3384		},
3385		deferred = {};
3386
3387		// Keep pipe for back-compat
3388		promise.pipe = promise.then;
3389
3390		// Add list-specific methods
3391		jQuery.each( tuples, function( i, tuple ) {
3392		var list = tuple[ 2 ],
3393		stateString = tuple[ 3 ];
3394
3395		// promise[ done \| fail \| progress ] = list.add
3396		promise[ tuple[ 1 ] ] = list.add;
3397
3398		// Handle state
3399		if ( stateString ) {
3400		list.add( function() {
3401
3402		// state = [ resolved \| rejected ]
3403		state = stateString;
3404
3405		// [ reject_list \| resolve_list ].disable; progress_list.lock
3406		}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3407		}
3408
3409		// deferred[ resolve \| reject \| notify ]
3410		deferred[ tuple[ 0 ] ] = function() {
3411		deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
3412		return this;
3413		};
3414		deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3415		} );
3416
3417		// Make the deferred a promise
3418		promise.promise( deferred );
3419
3420		// Call given func if any
3421		if ( func ) {
3422		func.call( deferred, deferred );
3423		}
3424
3425		// All done!
3426		return deferred;
3427		},
3428
3429		// Deferred helper
3430		when: function( subordinate /* , ..., subordinateN */ ) {

		@@ 3207-3291 (lines=85) @@
3204
3205		jQuery.extend({
3206
3207		Deferred: function( func ) {
3208		var tuples = [
3209		// action, add listener, listener list, final state
3210		[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
3211		[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
3212		[ "notify", "progress", jQuery.Callbacks("memory") ]
3213		],
3214		state = "pending",
3215		promise = {
3216		state: function() {
3217		return state;
3218		},
3219		always: function() {
3220		deferred.done( arguments ).fail( arguments );
3221		return this;
3222		},
3223		then: function( /* fnDone, fnFail, fnProgress */ ) {
3224		var fns = arguments;
3225		return jQuery.Deferred(function( newDefer ) {
3226		jQuery.each( tuples, function( i, tuple ) {
3227		var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3228		// deferred[ done \| fail \| progress ] for forwarding actions to newDefer
3229		deferred[ tuple[1] ](function() {
3230		var returned = fn && fn.apply( this, arguments );
3231		if ( returned && jQuery.isFunction( returned.promise ) ) {
3232		returned.promise()
3233		.done( newDefer.resolve )
3234		.fail( newDefer.reject )
3235		.progress( newDefer.notify );
3236		} else {
3237		newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
3238		}
3239		});
3240		});
3241		fns = null;
3242		}).promise();
3243		},
3244		// Get a promise for this deferred
3245		// If obj is provided, the promise aspect is added to the object
3246		promise: function( obj ) {
3247		return obj != null ? jQuery.extend( obj, promise ) : promise;
3248		}
3249		},
3250		deferred = {};
3251
3252		// Keep pipe for back-compat
3253		promise.pipe = promise.then;
3254
3255		// Add list-specific methods
3256		jQuery.each( tuples, function( i, tuple ) {
3257		var list = tuple[ 2 ],
3258		stateString = tuple[ 3 ];
3259
3260		// promise[ done \| fail \| progress ] = list.add
3261		promise[ tuple[1] ] = list.add;
3262
3263		// Handle state
3264		if ( stateString ) {
3265		list.add(function() {
3266		// state = [ resolved \| rejected ]
3267		state = stateString;
3268
3269		// [ reject_list \| resolve_list ].disable; progress_list.lock
3270		}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3271		}
3272
3273		// deferred[ resolve \| reject \| notify ]
3274		deferred[ tuple[0] ] = function() {
3275		deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
3276		return this;
3277		};
3278		deferred[ tuple[0] + "With" ] = list.fireWith;
3279		});
3280
3281		// Make the deferred a promise
3282		promise.promise( deferred );
3283
3284		// Call given func if any
3285		if ( func ) {
3286		func.call( deferred, deferred );
3287		}
3288
3289		// All done!
3290		return deferred;
3291		},
3292
3293		// Deferred helper
3294		when: function( subordinate /* , ..., subordinateN */ ) {

Otaku-Projects / AngularJS-CRUD-PHP

GitHub Access Token became invalid

Code Duplication Length = 85-92 lines in 3 locations

third-party/jQuery/jquery-1.12.1.js 1 location

third-party/jQuery/jquery-2.2.1.js 1 location

third-party/angularjs/angular-1.5.0/docs/components/jquery-2.1.1/jquery.js 1 location