[Pkg-freeipa-devel] freeipa: Changes to 'master'
Timo Aaltonen
tjaalton at moszumanska.debian.org
Wed Sep 14 10:17:01 UTC 2016
debian/README.source | 7
debian/changelog | 5
debian/missing-sources/dojo/Deferred.js | 320 ++++++
debian/missing-sources/dojo/_base/Deferred.js | 383 +++++++
debian/missing-sources/dojo/_base/config.js | 193 +++
debian/missing-sources/dojo/_base/connect.js | 374 +++++++
debian/missing-sources/dojo/_base/event.js | 59 +
debian/missing-sources/dojo/_base/kernel.js | 299 +++++
debian/missing-sources/dojo/_base/sniff.js | 93 +
debian/missing-sources/dojo/_base/window.js | 134 ++
debian/missing-sources/dojo/aspect.js | 223 ++++
debian/missing-sources/dojo/dom-attr.js | 220 ++++
debian/missing-sources/dojo/dom-geometry.js | 605 ++++++++++++
debian/missing-sources/dojo/errors/CancelError.js | 13
debian/missing-sources/dojo/errors/create.js | 41
debian/missing-sources/dojo/has.js | 173 +++
debian/missing-sources/dojo/mouse.js | 171 +++
debian/missing-sources/dojo/promise/Promise.js | 133 ++
debian/missing-sources/dojo/promise/instrumentation.js | 105 ++
debian/missing-sources/dojo/promise/tracer.js | 85 +
debian/missing-sources/dojo/ready.js | 153 +++
debian/missing-sources/dojo/router/RouterBase.js | 376 +++++++
debian/missing-sources/dojo/sniff.js | 80 +
debian/missing-sources/dojo/store/util/QueryResults.js | 63 +
debian/missing-sources/dojo/store/util/SimpleQueryEngine.js | 110 ++
debian/missing-sources/dojo/when.js | 55 +
debian/source/lintian-overrides | 10
27 files changed, 4477 insertions(+), 6 deletions(-)
New commits:
commit 30b1c852c647a416b7053c1c205c51e12215b295
Author: Timo Aaltonen <tjaalton at debian.org>
Date: Wed Sep 14 13:04:24 2016 +0300
releasing package freeipa version 4.3.2-1
diff --git a/debian/changelog b/debian/changelog
index a6f6be4..cf4b82f 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,4 +1,4 @@
-freeipa (4.3.2-1) UNRELEASED; urgency=medium
+freeipa (4.3.2-1) experimental; urgency=medium
* New upstream release.
* copyright, missing-sources, README.source: Exclude minified javascript
@@ -6,7 +6,7 @@ freeipa (4.3.2-1) UNRELEASED; urgency=medium
update copyright to match. (Closes: #787593)
* source/lintian-overrides: Document minified javascript issues.
- -- Timo Aaltonen <tjaalton at debian.org> Mon, 18 Apr 2016 17:40:32 +0300
+ -- Timo Aaltonen <tjaalton at debian.org> Wed, 14 Sep 2016 13:03:54 +0300
freeipa (4.3.1-2) experimental; urgency=medium
commit e1402d7d8103bc8bd379c00b8a15fa0c383bfe46
Author: Timo Aaltonen <tjaalton at debian.org>
Date: Thu Sep 1 11:28:34 2016 +0300
add stuff from webui.profile.js to missing-sources.
diff --git a/debian/README.source b/debian/README.source
index 92a9a2a..4bb9e0e 100644
--- a/debian/README.source
+++ b/debian/README.source
@@ -1,6 +1,7 @@
freeipa
Upstream does not ship unminified copies of various javascript files, so we must ship them
-in debian/missing-sources. Minified build.js and dojo.js are built with a certain set of
-modules, so those bits are under missing-sources/{build,dojo}. The list of modules are listed on
-install/ui/src/build.profile.js and install/ui/src/dojo.profile.js.
+in debian/missing-sources. Minified build.js, dojo.js and freeipa/{app,core}.js
+are built with a certain set of modules, so those bits are under missing-sources/{build,dojo}.
+The list of modules needed for the build are taken from install/ui/src/build.profile.js,
+install/ui/src/dojo.profile.js and install/ui/src/webui.profile.js.
diff --git a/debian/missing-sources/dojo/Deferred.js b/debian/missing-sources/dojo/Deferred.js
new file mode 100644
index 0000000..79d61f7
--- /dev/null
+++ b/debian/missing-sources/dojo/Deferred.js
@@ -0,0 +1,320 @@
+define([
+ "./has",
+ "./_base/lang",
+ "./errors/CancelError",
+ "./promise/Promise",
+ "./has!config-deferredInstrumentation?./promise/instrumentation"
+], function(has, lang, CancelError, Promise, instrumentation){
+ "use strict";
+
+ // module:
+ // dojo/Deferred
+
+ var PROGRESS = 0,
+ RESOLVED = 1,
+ REJECTED = 2;
+ var FULFILLED_ERROR_MESSAGE = "This deferred has already been fulfilled.";
+
+ var freezeObject = Object.freeze || function(){};
+
+ var signalWaiting = function(waiting, type, result, rejection, deferred){
+ if(has("config-deferredInstrumentation")){
+ if(type === REJECTED && Deferred.instrumentRejected && waiting.length === 0){
+ Deferred.instrumentRejected(result, false, rejection, deferred);
+ }
+ }
+
+ for(var i = 0; i < waiting.length; i++){
+ signalListener(waiting[i], type, result, rejection);
+ }
+ };
+
+ var signalListener = function(listener, type, result, rejection){
+ var func = listener[type];
+ var deferred = listener.deferred;
+ if(func){
+ try{
+ var newResult = func(result);
+ if(type === PROGRESS){
+ if(typeof newResult !== "undefined"){
+ signalDeferred(deferred, type, newResult);
+ }
+ }else{
+ if(newResult && typeof newResult.then === "function"){
+ listener.cancel = newResult.cancel;
+ newResult.then(
+ // Only make resolvers if they're actually going to be used
+ makeDeferredSignaler(deferred, RESOLVED),
+ makeDeferredSignaler(deferred, REJECTED),
+ makeDeferredSignaler(deferred, PROGRESS));
+ return;
+ }
+ signalDeferred(deferred, RESOLVED, newResult);
+ }
+ }catch(error){
+ signalDeferred(deferred, REJECTED, error);
+ }
+ }else{
+ signalDeferred(deferred, type, result);
+ }
+
+ if(has("config-deferredInstrumentation")){
+ if(type === REJECTED && Deferred.instrumentRejected){
+ Deferred.instrumentRejected(result, !!func, rejection, deferred.promise);
+ }
+ }
+ };
+
+ var makeDeferredSignaler = function(deferred, type){
+ return function(value){
+ signalDeferred(deferred, type, value);
+ };
+ };
+
+ var signalDeferred = function(deferred, type, result){
+ if(!deferred.isCanceled()){
+ switch(type){
+ case PROGRESS:
+ deferred.progress(result);
+ break;
+ case RESOLVED:
+ deferred.resolve(result);
+ break;
+ case REJECTED:
+ deferred.reject(result);
+ break;
+ }
+ }
+ };
+
+ var Deferred = function(canceler){
+ // summary:
+ // Creates a new deferred. This API is preferred over
+ // `dojo/_base/Deferred`.
+ // description:
+ // Creates a new deferred, as an abstraction over (primarily)
+ // asynchronous operations. The deferred is the private interface
+ // that should not be returned to calling code. That's what the
+ // `promise` is for. See `dojo/promise/Promise`.
+ // canceler: Function?
+ // Will be invoked if the deferred is canceled. The canceler
+ // receives the reason the deferred was canceled as its argument.
+ // The deferred is rejected with its return value, or a new
+ // `dojo/errors/CancelError` instance.
+
+ // promise: dojo/promise/Promise
+ // The public promise object that clients can add callbacks to.
+ var promise = this.promise = new Promise();
+
+ var deferred = this;
+ var fulfilled, result, rejection;
+ var canceled = false;
+ var waiting = [];
+
+ if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+ Error.captureStackTrace(deferred, Deferred);
+ Error.captureStackTrace(promise, Deferred);
+ }
+
+ this.isResolved = promise.isResolved = function(){
+ // summary:
+ // Checks whether the deferred has been resolved.
+ // returns: Boolean
+
+ return fulfilled === RESOLVED;
+ };
+
+ this.isRejected = promise.isRejected = function(){
+ // summary:
+ // Checks whether the deferred has been rejected.
+ // returns: Boolean
+
+ return fulfilled === REJECTED;
+ };
+
+ this.isFulfilled = promise.isFulfilled = function(){
+ // summary:
+ // Checks whether the deferred has been resolved or rejected.
+ // returns: Boolean
+
+ return !!fulfilled;
+ };
+
+ this.isCanceled = promise.isCanceled = function(){
+ // summary:
+ // Checks whether the deferred has been canceled.
+ // returns: Boolean
+
+ return canceled;
+ };
+
+ this.progress = function(update, strict){
+ // summary:
+ // Emit a progress update on the deferred.
+ // description:
+ // Emit a progress update on the deferred. Progress updates
+ // can be used to communicate updates about the asynchronous
+ // operation before it has finished.
+ // update: any
+ // The progress update. Passed to progbacks.
+ // strict: Boolean?
+ // If strict, will throw an error if the deferred has already
+ // been fulfilled and consequently no progress can be emitted.
+ // returns: dojo/promise/Promise
+ // Returns the original promise for the deferred.
+
+ if(!fulfilled){
+ signalWaiting(waiting, PROGRESS, update, null, deferred);
+ return promise;
+ }else if(strict === true){
+ throw new Error(FULFILLED_ERROR_MESSAGE);
+ }else{
+ return promise;
+ }
+ };
+
+ this.resolve = function(value, strict){
+ // summary:
+ // Resolve the deferred.
+ // description:
+ // Resolve the deferred, putting it in a success state.
+ // value: any
+ // The result of the deferred. Passed to callbacks.
+ // strict: Boolean?
+ // If strict, will throw an error if the deferred has already
+ // been fulfilled and consequently cannot be resolved.
+ // returns: dojo/promise/Promise
+ // Returns the original promise for the deferred.
+
+ if(!fulfilled){
+ // Set fulfilled, store value. After signaling waiting listeners unset
+ // waiting.
+ signalWaiting(waiting, fulfilled = RESOLVED, result = value, null, deferred);
+ waiting = null;
+ return promise;
+ }else if(strict === true){
+ throw new Error(FULFILLED_ERROR_MESSAGE);
+ }else{
+ return promise;
+ }
+ };
+
+ var reject = this.reject = function(error, strict){
+ // summary:
+ // Reject the deferred.
+ // description:
+ // Reject the deferred, putting it in an error state.
+ // error: any
+ // The error result of the deferred. Passed to errbacks.
+ // strict: Boolean?
+ // If strict, will throw an error if the deferred has already
+ // been fulfilled and consequently cannot be rejected.
+ // returns: dojo/promise/Promise
+ // Returns the original promise for the deferred.
+
+ if(!fulfilled){
+ if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+ Error.captureStackTrace(rejection = {}, reject);
+ }
+ signalWaiting(waiting, fulfilled = REJECTED, result = error, rejection, deferred);
+ waiting = null;
+ return promise;
+ }else if(strict === true){
+ throw new Error(FULFILLED_ERROR_MESSAGE);
+ }else{
+ return promise;
+ }
+ };
+
+ this.then = promise.then = function(callback, errback, progback){
+ // summary:
+ // Add new callbacks to the deferred.
+ // description:
+ // Add new callbacks to the deferred. Callbacks can be added
+ // before or after the deferred is fulfilled.
+ // callback: Function?
+ // Callback to be invoked when the promise is resolved.
+ // Receives the resolution value.
+ // errback: Function?
+ // Callback to be invoked when the promise is rejected.
+ // Receives the rejection error.
+ // progback: Function?
+ // Callback to be invoked when the promise emits a progress
+ // update. Receives the progress update.
+ // returns: dojo/promise/Promise
+ // Returns a new promise for the result of the callback(s).
+ // This can be used for chaining many asynchronous operations.
+
+ var listener = [progback, callback, errback];
+ // Ensure we cancel the promise we're waiting for, or if callback/errback
+ // have returned a promise, cancel that one.
+ listener.cancel = promise.cancel;
+ listener.deferred = new Deferred(function(reason){
+ // Check whether cancel is really available, returned promises are not
+ // required to expose `cancel`
+ return listener.cancel && listener.cancel(reason);
+ });
+ if(fulfilled && !waiting){
+ signalListener(listener, fulfilled, result, rejection);
+ }else{
+ waiting.push(listener);
+ }
+ return listener.deferred.promise;
+ };
+
+ this.cancel = promise.cancel = function(reason, strict){
+ // summary:
+ // Inform the deferred it may cancel its asynchronous operation.
+ // description:
+ // Inform the deferred it may cancel its asynchronous operation.
+ // The deferred's (optional) canceler is invoked and the
+ // deferred will be left in a rejected state. Can affect other
+ // promises that originate with the same deferred.
+ // reason: any
+ // A message that may be sent to the deferred's canceler,
+ // explaining why it's being canceled.
+ // strict: Boolean?
+ // If strict, will throw an error if the deferred has already
+ // been fulfilled and consequently cannot be canceled.
+ // returns: any
+ // Returns the rejection reason if the deferred was canceled
+ // normally.
+
+ if(!fulfilled){
+ // Cancel can be called even after the deferred is fulfilled
+ if(canceler){
+ var returnedReason = canceler(reason);
+ reason = typeof returnedReason === "undefined" ? reason : returnedReason;
+ }
+ canceled = true;
+ if(!fulfilled){
+ // Allow canceler to provide its own reason, but fall back to a CancelError
+ if(typeof reason === "undefined"){
+ reason = new CancelError();
+ }
+ reject(reason);
+ return reason;
+ }else if(fulfilled === REJECTED && result === reason){
+ return reason;
+ }
+ }else if(strict === true){
+ throw new Error(FULFILLED_ERROR_MESSAGE);
+ }
+ };
+
+ freezeObject(promise);
+ };
+
+ Deferred.prototype.toString = function(){
+ // returns: String
+ // Returns `[object Deferred]`.
+
+ return "[object Deferred]";
+ };
+
+ if(instrumentation){
+ instrumentation(Deferred);
+ }
+
+ return Deferred;
+});
diff --git a/debian/missing-sources/dojo/_base/Deferred.js b/debian/missing-sources/dojo/_base/Deferred.js
new file mode 100644
index 0000000..ed857ee
--- /dev/null
+++ b/debian/missing-sources/dojo/_base/Deferred.js
@@ -0,0 +1,383 @@
+define([
+ "./kernel",
+ "../Deferred",
+ "../promise/Promise",
+ "../errors/CancelError",
+ "../has",
+ "./lang",
+ "../when"
+], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){
+ // module:
+ // dojo/_base/Deferred
+
+ var mutator = function(){};
+ var freeze = Object.freeze || function(){};
+ // A deferred provides an API for creating and resolving a promise.
+ var Deferred = dojo.Deferred = function(/*Function?*/ canceller){
+ // summary:
+ // Deprecated. This module defines the legacy dojo/_base/Deferred API.
+ // New code should use dojo/Deferred instead.
+ // description:
+ // The Deferred API is based on the concept of promises that provide a
+ // generic interface into the eventual completion of an asynchronous action.
+ // The motivation for promises fundamentally is about creating a
+ // separation of concerns that allows one to achieve the same type of
+ // call patterns and logical data flow in asynchronous code as can be
+ // achieved in synchronous code. Promises allows one
+ // to be able to call a function purely with arguments needed for
+ // execution, without conflating the call with concerns of whether it is
+ // sync or async. One shouldn't need to alter a call's arguments if the
+ // implementation switches from sync to async (or vice versa). By having
+ // async functions return promises, the concerns of making the call are
+ // separated from the concerns of asynchronous interaction (which are
+ // handled by the promise).
+ //
+ // The Deferred is a type of promise that provides methods for fulfilling the
+ // promise with a successful result or an error. The most important method for
+ // working with Dojo's promises is the then() method, which follows the
+ // CommonJS proposed promise API. An example of using a Dojo promise:
+ //
+ // | var resultingPromise = someAsyncOperation.then(function(result){
+ // | ... handle result ...
+ // | },
+ // | function(error){
+ // | ... handle error ...
+ // | });
+ //
+ // The .then() call returns a new promise that represents the result of the
+ // execution of the callback. The callbacks will never affect the original promises value.
+ //
+ // The Deferred instances also provide the following functions for backwards compatibility:
+ //
+ // - addCallback(handler)
+ // - addErrback(handler)
+ // - callback(result)
+ // - errback(result)
+ //
+ // Callbacks are allowed to return promises themselves, so
+ // you can build complicated sequences of events with ease.
+ //
+ // The creator of the Deferred may specify a canceller. The canceller
+ // is a function that will be called if Deferred.cancel is called
+ // before the Deferred fires. You can use this to implement clean
+ // aborting of an XMLHttpRequest, etc. Note that cancel will fire the
+ // deferred with a CancelledError (unless your canceller returns
+ // another kind of error), so the errbacks should be prepared to
+ // handle that error for cancellable Deferreds.
+ // example:
+ // | var deferred = new Deferred();
+ // | setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+ // | return deferred;
+ // example:
+ // Deferred objects are often used when making code asynchronous. It
+ // may be easiest to write functions in a synchronous manner and then
+ // split code using a deferred to trigger a response to a long-lived
+ // operation. For example, instead of register a callback function to
+ // denote when a rendering operation completes, the function can
+ // simply return a deferred:
+ //
+ // | // callback style:
+ // | function renderLotsOfData(data, callback){
+ // | var success = false
+ // | try{
+ // | for(var x in data){
+ // | renderDataitem(data[x]);
+ // | }
+ // | success = true;
+ // | }catch(e){ }
+ // | if(callback){
+ // | callback(success);
+ // | }
+ // | }
+ //
+ // | // using callback style
+ // | renderLotsOfData(someDataObj, function(success){
+ // | // handles success or failure
+ // | if(!success){
+ // | promptUserToRecover();
+ // | }
+ // | });
+ // | // NOTE: no way to add another callback here!!
+ // example:
+ // Using a Deferred doesn't simplify the sending code any, but it
+ // provides a standard interface for callers and senders alike,
+ // providing both with a simple way to service multiple callbacks for
+ // an operation and freeing both sides from worrying about details
+ // such as "did this get called already?". With Deferreds, new
+ // callbacks can be added at any time.
+ //
+ // | // Deferred style:
+ // | function renderLotsOfData(data){
+ // | var d = new Deferred();
+ // | try{
+ // | for(var x in data){
+ // | renderDataitem(data[x]);
+ // | }
+ // | d.callback(true);
+ // | }catch(e){
+ // | d.errback(new Error("rendering failed"));
+ // | }
+ // | return d;
+ // | }
+ //
+ // | // using Deferred style
+ // | renderLotsOfData(someDataObj).then(null, function(){
+ // | promptUserToRecover();
+ // | });
+ // | // NOTE: addErrback and addCallback both return the Deferred
+ // | // again, so we could chain adding callbacks or save the
+ // | // deferred for later should we need to be notified again.
+ // example:
+ // In this example, renderLotsOfData is synchronous and so both
+ // versions are pretty artificial. Putting the data display on a
+ // timeout helps show why Deferreds rock:
+ //
+ // | // Deferred style and async func
+ // | function renderLotsOfData(data){
+ // | var d = new Deferred();
+ // | setTimeout(function(){
+ // | try{
+ // | for(var x in data){
+ // | renderDataitem(data[x]);
+ // | }
+ // | d.callback(true);
+ // | }catch(e){
+ // | d.errback(new Error("rendering failed"));
+ // | }
+ // | }, 100);
+ // | return d;
+ // | }
+ //
+ // | // using Deferred style
+ // | renderLotsOfData(someDataObj).then(null, function(){
+ // | promptUserToRecover();
+ // | });
+ //
+ // Note that the caller doesn't have to change his code at all to
+ // handle the asynchronous case.
+
+ var result, finished, canceled, fired, isError, head, nextListener;
+ var promise = (this.promise = new Promise());
+
+ function complete(value){
+ if(finished){
+ throw new Error("This deferred has already been resolved");
+ }
+ result = value;
+ finished = true;
+ notify();
+ }
+ function notify(){
+ var mutated;
+ while(!mutated && nextListener){
+ var listener = nextListener;
+ nextListener = nextListener.next;
+ if((mutated = (listener.progress == mutator))){ // assignment and check
+ finished = false;
+ }
+
+ var func = (isError ? listener.error : listener.resolved);
+ if(has("config-useDeferredInstrumentation")){
+ if(isError && NewDeferred.instrumentRejected){
+ NewDeferred.instrumentRejected(result, !!func);
+ }
+ }
+ if(func){
+ try{
+ var newResult = func(result);
+ if (newResult && typeof newResult.then === "function"){
+ newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
+ continue;
+ }
+ var unchanged = mutated && newResult === undefined;
+ if(mutated && !unchanged){
+ isError = newResult instanceof Error;
+ }
+ listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
+ }catch(e){
+ listener.deferred.reject(e);
+ }
+ }else{
+ if(isError){
+ listener.deferred.reject(result);
+ }else{
+ listener.deferred.resolve(result);
+ }
+ }
+ }
+ }
+
+ this.isResolved = promise.isResolved = function(){
+ // summary:
+ // Checks whether the deferred has been resolved.
+ // returns: Boolean
+
+ return fired == 0;
+ };
+
+ this.isRejected = promise.isRejected = function(){
+ // summary:
+ // Checks whether the deferred has been rejected.
+ // returns: Boolean
+
+ return fired == 1;
+ };
+
+ this.isFulfilled = promise.isFulfilled = function(){
+ // summary:
+ // Checks whether the deferred has been resolved or rejected.
+ // returns: Boolean
+
+ return fired >= 0;
+ };
+
+ this.isCanceled = promise.isCanceled = function(){
+ // summary:
+ // Checks whether the deferred has been canceled.
+ // returns: Boolean
+
+ return canceled;
+ };
+
+ // calling resolve will resolve the promise
+ this.resolve = this.callback = function(value){
+ // summary:
+ // Fulfills the Deferred instance successfully with the provide value
+ this.fired = fired = 0;
+ this.results = [value, null];
+ complete(value);
+ };
+
+
+ // calling error will indicate that the promise failed
+ this.reject = this.errback = function(error){
+ // summary:
+ // Fulfills the Deferred instance as an error with the provided error
+ isError = true;
+ this.fired = fired = 1;
+ if(has("config-useDeferredInstrumentation")){
+ if(NewDeferred.instrumentRejected){
+ NewDeferred.instrumentRejected(error, !!nextListener);
+ }
+ }
+ complete(error);
+ this.results = [null, error];
+ };
+ // call progress to provide updates on the progress on the completion of the promise
+ this.progress = function(update){
+ // summary:
+ // Send progress events to all listeners
+ var listener = nextListener;
+ while(listener){
+ var progress = listener.progress;
+ progress && progress(update);
+ listener = listener.next;
+ }
+ };
+ this.addCallbacks = function(callback, errback){
+ // summary:
+ // Adds callback and error callback for this deferred instance.
+ // callback: Function?
+ // The callback attached to this deferred object.
+ // errback: Function?
+ // The error callback attached to this deferred object.
+ // returns:
+ // Returns this deferred object.
+ this.then(callback, errback, mutator);
+ return this; // Deferred
+ };
+ // provide the implementation of the promise
+ promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+ // summary:
+ // Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
+ // completion of a promise. The fulfilledHandler is called when the promise
+ // is fulfilled. The errorHandler is called when a promise fails. The
+ // progressHandler is called for progress events. All arguments are optional
+ // and non-function values are ignored. The progressHandler is not only an
+ // optional argument, but progress events are purely optional. Promise
+ // providers are not required to ever create progress events.
+ //
+ // This function will return a new promise that is fulfilled when the given
+ // fulfilledHandler or errorHandler callback is finished. This allows promise
+ // operations to be chained together. The value returned from the callback
+ // handler is the fulfillment value for the returned promise. If the callback
+ // throws an error, the returned promise will be moved to failed state.
+ //
+ // returns:
+ // Returns a new promise that represents the result of the
+ // execution of the callback. The callbacks will never affect the original promises value.
+ // example:
+ // An example of using a CommonJS compliant promise:
+ // | asyncComputeTheAnswerToEverything().
+ // | then(addTwo).
+ // | then(printResult, onError);
+ // | >44
+ //
+ var returnDeferred = progressCallback == mutator ? this : new Deferred(promise.cancel);
+ var listener = {
+ resolved: resolvedCallback,
+ error: errorCallback,
+ progress: progressCallback,
+ deferred: returnDeferred
+ };
+ if(nextListener){
+ head = head.next = listener;
+ }
+ else{
+ nextListener = head = listener;
+ }
+ if(finished){
+ notify();
+ }
+ return returnDeferred.promise; // Promise
+ };
+ var deferred = this;
+ promise.cancel = this.cancel = function(){
+ // summary:
+ // Cancels the asynchronous operation
+ if(!finished){
+ var error = canceller && canceller(deferred);
+ if(!finished){
+ if (!(error instanceof Error)){
+ error = new CancelError(error);
+ }
+ error.log = false;
+ deferred.reject(error);
+ }
+ }
+ canceled = true;
+ };
+ freeze(promise);
+ };
+ lang.extend(Deferred, {
+ addCallback: function(/*Function*/ callback){
+ // summary:
+ // Adds successful callback for this deferred instance.
+ // returns:
+ // Returns this deferred object.
+ return this.addCallbacks(lang.hitch.apply(dojo, arguments)); // Deferred
+ },
+
+ addErrback: function(/*Function*/ errback){
+ // summary:
+ // Adds error callback for this deferred instance.
+ // returns:
+ // Returns this deferred object.
+ return this.addCallbacks(null, lang.hitch.apply(dojo, arguments)); // Deferred
+ },
+
+ addBoth: function(/*Function*/ callback){
+ // summary:
+ // Add handler as both successful callback and error callback for this deferred instance.
+ // returns:
+ // Returns this deferred object.
+ var enclosed = lang.hitch.apply(dojo, arguments);
+ return this.addCallbacks(enclosed, enclosed); // Deferred
+ },
+ fired: -1
+ });
+
+ Deferred.when = dojo.when = when;
+
+ return Deferred;
+});
diff --git a/debian/missing-sources/dojo/_base/config.js b/debian/missing-sources/dojo/_base/config.js
new file mode 100644
index 0000000..d94d9c8
--- /dev/null
+++ b/debian/missing-sources/dojo/_base/config.js
@@ -0,0 +1,193 @@
+define(["../has", "require"], function(has, require){
+ // module:
+ // dojo/_base/config
+
+/*=====
+return {
+ // summary:
+ // This module defines the user configuration during bootstrap.
+ // description:
+ // By defining user configuration as a module value, an entire configuration can be specified in a build,
+ // thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+ // Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+ // at an unique absolute module identifier as given by the package configuration. Implementing configuration
+ // as a module allows for specifying unique, per-instance configurations.
+ // example:
+ // Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
+ // dojo.js are already loaded).
+ // | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
+ // | require({
+ // | packages:[{
+ // | name:"myDojo",
+ // | location:".", //assume baseUrl points to dojo.js
+ // | }]
+ // | });
+ // |
+ // | // specify a configuration for the myDojo instance
+ // | define("myDojo/config", {
+ // | // normal configuration variables go here, e.g.,
+ // | locale:"fr-ca"
+ // | });
+ // |
+ // | // load and use the new instance of dojo
+ // | require(["myDojo"], function(dojo){
+ // | // dojo is the new instance of dojo
+ // | // use as required
+ // | });
+
+ // isDebug: Boolean
+ // Defaults to `false`. If set to `true`, ensures that Dojo provides
+ // extended debugging feedback via Firebug. If Firebug is not available
+ // on your platform, setting `isDebug` to `true` will force Dojo to
+ // pull in (and display) the version of Firebug Lite which is
+ // integrated into the Dojo distribution, thereby always providing a
+ // debugging/logging console when `isDebug` is enabled. Note that
+ // Firebug's `console.*` methods are ALWAYS defined by Dojo. If
+ // `isDebug` is false and you are on a platform without Firebug, these
+ // methods will be defined as no-ops.
+ isDebug: false,
+
+ // locale: String
+ // The locale to assume for loading localized resources in this page,
+ // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
+ // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
+ // See the documentation for `dojo.i18n` and `dojo.requireLocalization`
+ // for details on loading localized resources. If no locale is specified,
+ // Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
+ // or `navigator.language` properties.
+ locale: undefined,
+
+ // extraLocale: Array
+ // No default value. Specifies additional locales whose
+ // resources should also be loaded alongside the default locale when
+ // calls to `dojo.requireLocalization()` are processed.
+ extraLocale: undefined,
+
+ // baseUrl: String
+ // The directory in which `dojo.js` is located. Under normal
+ // conditions, Dojo auto-detects the correct location from which it
+ // was loaded. You may need to manually configure `baseUrl` in cases
+ // where you have renamed `dojo.js` or in which `<base>` tags confuse
+ // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
+ // either the value of `djConfig.baseUrl` if one is provided or the
+ // auto-detected root if not. Other modules are located relative to
+ // this path. The path should end in a slash.
+ baseUrl: undefined,
+
+ // modulePaths: [deprecated] Object
+ // A map of module names to paths relative to `dojo.baseUrl`. The
+ // key/value pairs correspond directly to the arguments which
+ // `dojo.registerModulePath` accepts. Specifying
+ // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+ // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+ // modules may be configured via `djConfig.modulePaths`.
+ modulePaths: {},
+
+ // addOnLoad: Function|Array
+ // Adds a callback via dojo/ready. Useful when Dojo is added after
+ // the page loads and djConfig.afterOnLoad is true. Supports the same
+ // arguments as dojo/ready. When using a function reference, use
+ // `djConfig.addOnLoad = function(){};`. For object with function name use
+ // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
+ // function reference use
+ // `djConfig.addOnLoad = [myObject, function(){}];`
+ addOnLoad: null,
+
+ // parseOnLoad: Boolean
+ // Run the parser after the page is loaded
+ parseOnLoad: false,
+
+ // require: String[]
+ // An array of module names to be loaded immediately after dojo.js has been included
+ // in a page.
+ require: [],
+
+ // defaultDuration: Number
+ // Default duration, in milliseconds, for wipe and fade animations within dijits.
+ // Assigned to dijit.defaultDuration.
+ defaultDuration: 200,
+
+ // dojoBlankHtmlUrl: String
+ // Used by some modules to configure an empty iframe. Used by dojo/io/iframe and
+ // dojo/back, and dijit/popup support in IE where an iframe is needed to make sure native
+ // controls do not bleed through the popups. Normally this configuration variable
+ // does not need to be set, except when using cross-domain/CDN Dojo builds.
+ // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
+ // to the path on your domain your copy of blank.html.
+ dojoBlankHtmlUrl: undefined,
+
+ // ioPublish: Boolean?
+ // Set this to true to enable publishing of topics for the different phases of
+ // IO operations. Publishing is done via dojo/topic.publish(). See dojo/main.__IoPublish for a list
+ // of topics that are published.
+ ioPublish: false,
+
+ // useCustomLogger: Anything?
+ // If set to a value that evaluates to true such as a string or array and
+ // isDebug is true and Firebug is not available or running, then it bypasses
+ // the creation of Firebug Lite allowing you to define your own console object.
+ useCustomLogger: undefined,
+
+ // transparentColor: Array
+ // Array containing the r, g, b components used as transparent color in dojo.Color;
+ // if undefined, [255,255,255] (white) will be used.
+ transparentColor: undefined,
+
+ // deps: Function|Array
+ // Defines dependencies to be used before the loader has been loaded.
+ // When provided, they cause the loader to execute require(deps, callback)
+ // once it has finished loading. Should be used with callback.
+ deps: undefined,
+
+ // callback: Function|Array
+ // Defines a callback to be used when dependencies are defined before
+ // the loader has been loaded. When provided, they cause the loader to
+ // execute require(deps, callback) once it has finished loading.
+ // Should be used with deps.
+ callback: undefined,
+
+ // deferredInstrumentation: Boolean
+ // Whether deferred instrumentation should be loaded or included
+ // in builds.
+ deferredInstrumentation: true,
+
+ // useDeferredInstrumentation: Boolean|String
+ // Whether the deferred instrumentation should be used.
+ //
+ // * `"report-rejections"`: report each rejection as it occurs.
+ // * `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
+ // in an attempt to detect unhandled rejections.
+ useDeferredInstrumentation: "report-unhandled-rejections"
+};
+=====*/
+
+ var result = {};
+ if(has("dojo-config-api")){
+ // must be the dojo loader; take a shallow copy of require.rawConfig
+ var src = require.rawConfig, p;
+ for(p in src){
+ result[p] = src[p];
+ }
+ }else{
+ var adviseHas = function(featureSet, prefix, booting){
+ for(p in featureSet){
+ p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+ }
+ };
+ result = has("dojo-loader") ?
+ // must be a built version of the dojo loader; all config stuffed in require.rawConfig
+ require.rawConfig :
+ // a foreign loader
+ this.dojoConfig || this.djConfig || {};
+ adviseHas(result, "config", 1);
+ adviseHas(result.has, "", 1);
+ }
+
+ if(!result.locale && typeof navigator != "undefined"){
+ // Default locale for browsers.
+ result.locale = (navigator.language || navigator.userLanguage).toLowerCase();
+ }
+
+ return result;
+});
+
diff --git a/debian/missing-sources/dojo/_base/connect.js b/debian/missing-sources/dojo/_base/connect.js
new file mode 100644
index 0000000..0f08bf2
--- /dev/null
+++ b/debian/missing-sources/dojo/_base/connect.js
@@ -0,0 +1,374 @@
+define(["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(dojo, on, hub, aspect, eventModule, mouse, has, lang){
+// module:
+// dojo/_base/connect
More information about the Pkg-freeipa-devel
mailing list