Navigates to the signin screen.

@param {Object} config The config spec.
@param {boolean} config.wait Whether to wait for the target UI.  Optional, defaults to true.
437690
function (config) {
			var _config = objectAssign({}, { wait: true }, config);
			this.navigate();
			if (_config.wait) this.waitForSigninScreen();
			return this;
		}
1170449
function Config(config) {
        config = config || {};
        // config default values
        this.config = {};

        corbel.utils.extend(this.config, config);
    }
415261
function(config) {

		this.property_name = config.property;
		this.from = config.from || [0,0,0];
		this.to = config.to || [0,0,0];
		this.delta = [this.to[0] - this.from[0], this.to[1] - this.from[1], this.to[2] - this.from[2]];

	}
174254
function(target, config){
			/* all arguments are optional */
			if (typeof target === 'object' && target instanceof $ === false && !config) {
				config = target;
				target = undefined;
			}

			var self = $.extend(this, config, {target: target}),
				css = !self.resetCss ? self.namespace : self.namespace+'-reset', /* by adding -reset to the classname, we reset all the default css */
				$background = $(self.background || [
					'<div class="'+css+'-loading '+css+'">',
						'<div class="'+css+'-content">',
							'<button class="'+css+'-close-icon '+ self.namespace + '-close" aria-label="Close">',
								self.closeIcon,
							'</button>',
							'<div class="'+self.namespace+'-inner">' + self.loading + '</div>',
						'</div>',
					'</div>'].join('')),
				closeButtonSelector = '.'+self.namespace+'-close' + (self.otherClose ? ',' + self.otherClose : '');

			self.$instance = $background.clone().addClass(self.variant); /* clone DOM for the background, wrapper and the close button */

			/* close when click on background/anywhere/null or closebox */
			self.$instance.on(self.closeTrigger+'.'+self.namespace, function(event) {
				if(event.isDefaultPrevented()) {
					return;
				}
				var $target = $(event.target);
				if( ('background' === self.closeOnClick  && $target.is('.'+self.namespace))
					|| 'anywhere' === self.closeOnClick
					|| $target.closest(closeButtonSelector).length ){
					self.close(event);
					event.preventDefault();
				}
			});

			return this;
		}
621115
function(config, widget) {

		this._widget = widget;
		this._property_name = config.property_name;
		this._scope = widget.getScopeByPathConfig(config.path_config);

		if (config.from_widget) {

			this._scope.setValue(this._widget.get(this._property_name));

		} else {

			this._widget.set(this._property_name, this._scope.getValue());
			this._scope_changed_listener = this._scope.on('changed', this.onScopeChanged, this);

		}

		if (!this._scope.isSetValue) Lava.t("Binding: bound scope does not implement setValue");
		this._widget_property_changed_listener = widget.onPropertyChanged(this._property_name, this.onWidgetPropertyChanged, this);

	}
1326055
public function init( $config = NULL )
    {
        $option                   = new Option();
        $option->shortCode        = 'h';
        $option->longCode         = 'help';
        $option->isOptional       = TRUE;
        $option->type             = Type::BOOLEAN;
        $option->shortDescription = 'Show the help menu';

        $this->options[ ] = $option;

        $option                   = new Option();
        $option->shortCode        = 'v';
        $option->longCode         = 'verbose';
        $option->isOptional       = TRUE;
        $option->type             = Type::BOOLEAN;
        $option->shortDescription = 'Show detailed log';

        $this->options[ ] = $option;
    }
363912
function(config){
  this.options = {
    hostname : config.url,
    port :      443,
    path :       '', //override
    method :     '', //override
    auth :    config.user + ':' + config.passwd,
    headers : config.headers
  };
}
493024
private function init($config = array())
    {
        $this->getCore()->open($this->getFilename(), $config);
        if ($this->currentSheet !== null) {
            $this->getCore()->setSheet($this->currentSheet);
        }
    }
708845
public function initialize(array $config)
    {
        parent::initialize($config);

        $this->Controller = $this->_registry->getController();

        if ($this->config('Auth')) {
            $this->Controller->loadComponent('Auth', $this->config('Auth'));
        }

        $this->Controller->loadComponent('Utils.Menu');
    }
742898
function init(config) {
    var deferred = Q.defer();

    connect(config.mongo.url, config.mongo.debug, config.mongo.mongos)
        .then(function () {

            IdxInfoModel = getModel({
                name: 'idx',
                fields: {
                    str: { type: String, index: { unique: true } },
                    name: String,
                    count: Number
                }
            });

            deferred.resolve(config);
        })
        .catch(function (err) {
            deferred.reject(err);
        });

    return deferred.promise;
}
523575
function (config) {
        if (typeof config !== 'object') {
            throw new Error('Invalid Route Config');
        }
        if (typeof config.route !== 'string') {
            var name_1 = config.name || '(no name)';
            throw new Error('Invalid Route Config for "' + name_1 + '": You must specify a "route:" pattern.');
        }
        if (!('redirect' in config || config.moduleId || config.navigationStrategy || config.viewPorts)) {
            throw new Error('Invalid Route Config for "' + config.route + '": You must specify a "moduleId:", "redirect:", "navigationStrategy:", or "viewPorts:".');
        }
    }
68501
function (config) {
			
			var nbChoices, position = -1;
			
			nbChoices = this.choicesList.length;
			
			// Handle position
			if (lang.isNumber(config.position) && config.position >= 0 && config.position < nbChoices) {
				
				position = parseInt(config.position, 10);
				
			} else if (!lang.isUndefined(config.value)) {
				
				// get position of choice with value === config.value
				position = inputEx.indexOf(config.value, this.choicesList, function (value, opt) {
					return opt.value === value;
				});
				
			} else if (lang.isString(config.label)) {
				
				// get position of choice with label === config.label
				position = inputEx.indexOf(config.label, this.choicesList, function (label, opt) {
					return opt.label === label;
				});
				
			}
			
			return position;
		}
275375
function (config) {
			if (config) {
				if (config.element) {
					this.expect.element(config.element).to.be.present;
				} else {
					throw new Error('adminUIApp:must specify an element!');
				}
			} else {
				throw new Error('adminUIApp:invalid config specification!');
			}
			return this;
		}
1260422
function configure(config) {
    tapLimit = config.tapLimit;
    testNumber = config.priorTestNumber;
    testFileRegex = new RegExp(config.testFileRegexStr);
    failedTests = config.failedTests;
    maxFailedTests = config.maxFailedTests;
    catchExceptions = config.catchExceptions;
    if (config.selectedTests !== '')
        selectTests(config.selectedTests);
    debugBreak = config.debugBreak;
    
    installTapWithPatches(config.tapPath);
    
    runUserCode(function() {
        require(config.filePath);
    }, false);
    
    // installing a tearDown handler induces tap autoend,
    // which sometimes causes tearDown before tests install,
    // so have to install handler *after* registering tests.
    // the handler installs because tap has to wait for all
    // tests by waiting at least until the next tick.
    
    tap.tearDown(function() {
        process.send({
            event: 'done',
            lastTestNumber: testNumber,
            failedTests: failedTests
        });
        // disconnect IPC so can exit when stdout, stderr,
        // child processes, and other resources complete.
        process.disconnect();
    });
    tap.end();
}
1300686
def _init_auth(self, config):
        
        self.auth_mode = self._get_param('auth', 'auth.mode', config)
        if self.auth_mode in ['and', 'or', 'none']:
            pass
        elif self.auth_mode == 'custom':
            # load custom auth module
            auth_module = self._get_param('auth', 'auth.module', config)
            auth = __import__(auth_module, globals(), locals(), ['Auth'], 0)
            self.auth = auth.Auth(config['auth'], cherrypy.log)
        else:
            raise WrongParamValue(
                'auth.mode',
                'auth',
                ['and', 'or', 'none', 'custom'],
                )

        self.roles_file = self._get_param('roles', 'roles.file', config)
        cherrypy.log.error(
            msg="loading roles file '%(file)s'" % {'file': self.roles_file},
            severity=logging.DEBUG
        )
        self.roles = Roles(self.roles_file)
516290
def wait_init(self):
        
        init_done = self.init_done.wait(timeout=self.init_wait_timeout)
        if not init_done:
            if hasattr(self, "peek"):
                app = self.config.get("application")
                if app:
                    bef_init_cmds = app.get("cli_ready_trigger")
                    if bef_init_cmds in self.peek():  # pylint: disable=no-member
                        init_done = True
        return init_done
1346502
function WaitScreen(options) {
        options = options || {};

        /**
         * ### WaitScreen.id
         *
         * The id of _waitingDiv_. Default: 'ng_waitScreen'
         *
         * @see WaitScreen.waitingDiv
         */
        this.id = options.id || 'ng_waitScreen';

        /**
         * ### WaitScreen.root
         *
         * Reference to the root element under which _waitingDiv is appended
         *
         * @see WaitScreen.waitingDiv
         */
        this.root = options.root || null;

        /**
         * ### WaitScreen.waitingDiv
         *
         * Reference to the HTML Element that actually locks the screen
         */
        this.waitingDiv = null;

        /**
         * ### WaitScreen.beforePauseText
         *
         * Flag if the screen should stay locked after a RESUMED event
         *
         * Contains the value of the innerHTML attribute of the waiting div.
         */
        this.beforePauseInnerHTML = null;

        /**
         * ### WaitScreen.enabled
         *
         * Flag is TRUE if the listeners are registered
         *
         * @see WaitScreen.enable
         */
        this.enabled = false;

        /**
         * ### WaitScreen.contentDiv
         *
         * Div containing the main content of the wait screen
         */
        this.contentDiv = null;

        /**
         * ### WaitScreen.countdownDiv
         *
         * Div containing the countdown span and other text
         *
         * @see WaitScreen.countdown
         * @see WaitScreen.countdownSpan
         */
        this.countdownDiv = null;

        /**
         * ### WaitScreen.countdownSpan
         *
         * Span containing a countdown timer for the max waiting
         *
         * @see WaitScreen.countdown
         * @see WaitScreen.countdownDiv
         */
        this.countdownSpan = null;

        /**
         * ### WaitScreen.countdown
         *
         * Countdown of max waiting time
         *
         * @see WaitScreen.countdown
         */
        this.countdown = null;

        /**
         * ### WaitScreen.text
         *
         * Default texts for default events
         */
        this.defaultTexts = {
            waiting: options.waitingText ||
                'Waiting for other players to be done...',
            stepping: options.steppingText ||
                'Initializing game step, will be ready soon...',
            paused: options.pausedText ||
                'Game is paused. Please wait.'
        };

        /**
         * ## WaitScreen.lockedInputs
         *
         * List of locked inputs by the _lock_ method
         *
         * @see WaitScreen.lock
         */
        this.lockedInputs = [];

        // Registers the event listeners.
        this.enable();
    }