ember_simple_auth-rails 0.5.3 → 0.6.0

data/vendor/assets/javascripts/ember-simple-auth.js

@@ -54,17 +54,7 @@ var define, requireModule;
   requireModule.registry = registry;
 })();
 
-define("ember-simple-auth", 
-  [],
-  function() {
-    "use strict";
-    /**
-      Ember.SimpleAuth's main module.
-
-      @module Ember.SimpleAuth
-    */
-  });
-define("ember-simple-auth/authenticators/base", 
+define("simple-auth/authenticators/base", 
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -81,36 +71,45 @@ define("ember-simple-auth/authenticators/base",
       provider like Facebook etc. and depends on the specific authenticator. Any
       data that the authenticator receives upon successful authentication and
       resolves with from the
-      [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)
+      [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)
       method is stored in the session and can then be used by the authorizer (see
-      [Ember.SimpleAuth.Authorizers.Base](#Ember-SimpleAuth-Authorizers-Base)).
+      [`Authorizers.Base`](#SimpleAuth-Authorizers-Base)).
 
       The authenticator also decides whether a set of data that was restored from
       the session store (see
-      [Ember.SimpleAuth.Stores.Base](#Ember-SimpleAuth-Stores-Base)) is sufficient
-      for the session to be authenticated or not.
+      [`Stores.Base`](#SimpleAuth-Stores-Base)) is sufficient for the session to be
+      authenticated or not.
 
       __Custom authenticators have to be registered with Ember's dependency
       injection container__ so that the session can retrieve an instance, e.g.:
 
       ```javascript
-      var CustomAuthenticator = Ember.SimpleAuth.Authenticators.Base.extend({
+      import Base from 'simple-auth/authenticators/base';
+
+      var CustomAuthenticator = Base.extend({
         ...
       });
+
       Ember.Application.initializer({
         name: 'authentication',
         initialize: function(container, application) {
           container.register('authenticator:custom', CustomAuthenticator);
-          Ember.SimpleAuth.setup(container, application);
         }
       });
-      App.AuthenticationController  = Ember.Controller.extend(Ember.SimpleAuth.AuthenticationControllerMixin, {
+      ```
+
+      ```javascript
+      // app/controllers/login.js
+      import AuthenticationControllerMixin from 'simple-auth/mixins/authentication-controller-mixin';
+
+      export default Ember.Controller.extend(AuthenticationControllerMixin, {
         authenticatorFactory: 'authenticator:custom'
       });
       ```
 
       @class Base
-      @namespace Authenticators
+      @namespace SimpleAuth.Authenticators
+      @module simple-auth/authenticators/base
       @extends Ember.Object
       @uses Ember.Evented
     */
@@ -121,7 +120,7 @@ define("ember-simple-auth/authenticators/base",
         it or an event from is triggered from an external authentication provider.
         The session automatically catches that event, passes the updated data back
         to the authenticator's
-        [Ember.SimpleAuth.Authenticators.Base#restore](#Ember-SimpleAuth-Authenticators-Base-restore)
+        [SimpleAuth.Authenticators.Base#restore](#SimpleAuth-Authenticators-Base-restore)
         method and handles the result of that invocation accordingly.
 
         @event sessionDataUpdated
@@ -151,7 +150,7 @@ define("ember-simple-auth/authenticators/base",
         argument will simply be forwarded through the promise. A rejecting promise
         indicates that authentication failed and the session will remain unchanged.
 
-        `Ember.SimpleAuth.Authenticators.Base`'s implementation always returns a
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
         rejecting promise.
 
         @method restore
@@ -168,14 +167,14 @@ define("ember-simple-auth/authenticators/base",
         implements (e.g. a set of credentials or a Facebook account id etc.). __The
         session will invoke this method when an action in the appliaction triggers
         authentication__ (see
-        [Ember.SimpleAuth.AuthenticationControllerMixin.actions#authenticate](#Ember-SimpleAuth-AuthenticationControllerMixin-authenticate)).
+        [SimpleAuth.AuthenticationControllerMixin.actions#authenticate](#SimpleAuth-AuthenticationControllerMixin-authenticate)).
 
         __This method returns a promise. A resolving promise will result in the
         session being authenticated.__ Any properties the promise resolves with
         will be saved in and accessible via the session. A rejecting promise
         indicates that authentication failed and the session will remain unchanged.
 
-        `Ember.SimpleAuth.Authenticators.Base`'s implementation always returns a
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
         rejecting promise and thus never authenticates the session.
 
         @method authenticate
@@ -197,7 +196,7 @@ define("ember-simple-auth/authenticators/base",
         session being invalidated.__ A rejecting promise will result in the session
         invalidation being intercepted and the session being left authenticated.
 
-        `Ember.SimpleAuth.Authenticators.Base`'s implementation always returns a
+        `SimpleAuth.Authenticators.Base`'s implementation always returns a
         resolving promise and thus never intercepts session invalidation.
 
         @method invalidate
@@ -208,7 +207,7 @@ define("ember-simple-auth/authenticators/base",
       }
     });
   });
-define("ember-simple-auth/authorizers/base", 
+define("simple-auth/authorizers/base", 
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -220,28 +219,29 @@ define("ember-simple-auth/authorizers/base",
       implementing custom authorizers and must not be used directly.__
 
       __The authorizer preprocesses all XHR requests__ (except ones to 3rd party
-      origins, see [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup)) and makes
-      sure they have the required data attached that allows the server to identify
-      the user making the request. This data might be a specific header, data in
-      the query part of the URL, cookies etc. __The authorizer has to fit the
-      authenticator__ (see
-      [Ember.SimpleAuth.Authenticators.Base](#Ember-SimpleAuth-Authenticators-Base))
-      as it relies on data that the authenticator retrieved during authentication
-      and that it makes available through the session.
+      origins, see
+      [Configuration.crossOriginWhitelist](#SimpleAuth-Configuration-crossOriginWhitelist))
+      and makes sure they have the required data attached that allows the server to
+      identify the user making the request. This data might be an HTTP header,
+      query string parameters in the URL, cookies etc. __The authorizer has to fit
+      the authenticator__ (see
+      [SimpleAuth.Authenticators.Base](#SimpleAuth-Authenticators-Base))
+      as it relies on data that the authenticator acquires during authentication.
 
       @class Base
-      @namespace Authorizers
+      @namespace SimpleAuth.Authorizers
+      @module simple-auth/authorizers/base
       @extends Ember.Object
     */
     __exports__["default"] = Ember.Object.extend({
       /**
         The session the authorizer gets the data it needs to authorize requests
-        from (see [Ember.SimpleAuth.Session](#Ember-SimpleAuth-Session)).
+        from.
 
         @property session
         @readOnly
-        @type Ember.SimpleAuth.Session
-        @default the session instance that is created during Ember.SimpleAuth' setup (see [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup))
+        @type SimpleAuth.Session
+        @default the session instance
       */
       session: null,
 
@@ -250,7 +250,7 @@ define("ember-simple-auth/authorizers/base",
         allows the server to identify the user making the request (e.g. a token in
         the `Authorization` header or some other secret in the query string etc.).
 
-        `Ember.SimpleAuth.Authorizers.Base`'s implementation does nothing.
+        `SimpleAuth.Authorizers.Base`'s implementation does nothing.
 
         @method authorize
         @param {jqXHR} jqXHR The XHR request to authorize (see http://api.jquery.com/jQuery.ajax/#jqXHR)
@@ -260,20 +260,32 @@ define("ember-simple-auth/authorizers/base",
       }
     });
   });
-define("ember-simple-auth/configuration", 
-  ["exports"],
-  function(__exports__) {
+define("simple-auth/configuration", 
+  ["./utils/get-global-config","exports"],
+  function(__dependency1__, __exports__) {
     "use strict";
+    var getGlobalConfig = __dependency1__["default"];
+
     /**
-      Ember.SimpleAuth's configuration object.
+      Ember Simple Auth's configuration object.
+
+      To change any of these values, define a global environment object for Ember
+      Simple Auth and define the values there:
+
+      ```javascript
+      window.ENV = window.ENV || {};
+      window.ENV['simple-auth'] = {
+        authenticationRoute: 'sign-in'
+      };
+      ```
 
       @class Configuration
-      @namespace $mainModule
+      @namespace SimpleAuth
+      @module simple-auth/configuration
     */
     __exports__["default"] = {
       /**
-        The route to transition to for authentication; should be set through
-        [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup).
+        The route to transition to for authentication.
 
         @property authenticationRoute
         @readOnly
@@ -284,8 +296,7 @@ define("ember-simple-auth/configuration",
       authenticationRoute: 'login',
 
       /**
-        The route to transition to after successful authentication; should be set
-        through [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup).
+        The route to transition to after successful authentication.
 
         @property routeAfterAuthentication
         @readOnly
@@ -297,8 +308,7 @@ define("ember-simple-auth/configuration",
 
       /**
         The name of the property that the session is injected with into routes and
-        controllers; should be set through
-        [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup).
+        controllers.
 
         @property sessionPropertyName
         @readOnly
@@ -309,44 +319,98 @@ define("ember-simple-auth/configuration",
       sessionPropertyName: 'session',
 
       /**
-        @property applicationRootUrl
+        The authorizer factory to use as it is registered with Ember's container,
+        see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register);
+        when the application does not interact with a server that requires
+        authorized requests, no auzthorizer is needed.
+
+        @property sessionPropertyName
+        @readOnly
         @static
-        @private
         @type String
+        @default null
       */
-      applicationRootUrl: null,
+      authorizerFactory: null,
 
       /**
-        @property extensionInitializers
+        The store factory to use as it is registered with Ember's container, see
+        [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register).
+
+        @property storeFactory
+        @readOnly
+        @static
+        @type String
+        @default simple-auth-session-store:local-storage
+      */
+      storeFactory: 'simple-auth-session-store:local-storage',
+
+      /**
+        Ember Simple Auth will never authorize requests going to a different origin
+        than the one the Ember.js application was loaded from; to explicitely
+        enable authorization for additional origins, whitelist those origins with
+        this setting. _Beware that origins consist of protocol, host and port (port
+        can be left out when it is 80 for HTTP or 443 for HTTPS)_
+
+        @property crossOriginWhitelist
+        @readOnly
         @static
-        @private
         @type Array
+        @default []
       */
-      extensionInitializers: []
+      crossOriginWhitelist: [],
+
+      /**
+        @property applicationRootUrl
+        @private
+      */
+      applicationRootUrl: null,
+
+      /**
+        @method load
+        @private
+      */
+      load: function(container) {
+        var globalConfig              = getGlobalConfig('simple-auth');
+        this.authenticationRoute      = globalConfig.authenticationRoute || this.authenticationRoute;
+        this.routeAfterAuthentication = globalConfig.routeAfterAuthentication || this.routeAfterAuthentication;
+        this.sessionPropertyName      = globalConfig.sessionPropertyName || this.sessionPropertyName;
+        this.authorizerFactory        = globalConfig.authorizerFactory || this.authorizerFactory;
+        this.storeFactory             = globalConfig.storeFactory || this.storeFactory;
+        this.applicationRootUrl       = container.lookup('router:main').get('rootURL') || '/';
+      }
     };
   });
-define("ember-simple-auth/initialize_extension", 
-  ["./configuration","exports"],
+define("simple-auth/ember", 
+  ["./initializer"],
+  function(__dependency1__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {},
+        Ember = global.Ember;
+
+    var initializer = __dependency1__["default"];
+
+    Ember.onLoad('Ember.Application', function(Application) {
+      Application.initializer(initializer);
+    });
+  });
+define("simple-auth/initializer", 
+  ["./setup","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
-    var Configuration = __dependency1__["default"];
+    var global = (typeof window !== 'undefined') ? window : {},
+        Ember = global.Ember;
 
-    /**
-      Registers an extension initializer to be invoked when
-      [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup) is invoked. __This is used
-      by extensions__ to the base Ember.SimpleAuth library that can e.g. register
-      factories with the Ember.js dependency injection container here etc.
+    var setup = __dependency1__["default"];
 
-      @method initializeExtension
-      @namespace $mainModule
-      @static
-      @param {Function} initializer The initializer to be invoked when [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup) is invoked; this will receive the same arguments as [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup).
-    */
-    __exports__["default"] = function(initializer) {
-      Configuration.extensionInitializers.push(initializer);
-    }
+    __exports__["default"] = {
+      name:       'simple-auth',
+      initialize: function(container, application) {
+        setup(container, application);
+      }
+    };
   });
-define("ember-simple-auth/mixins/application_route_mixin", 
+define("simple-auth/mixins/application-route-mixin", 
   ["./../configuration","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -356,7 +420,7 @@ define("ember-simple-auth/mixins/application_route_mixin",
     var Configuration = __dependency1__["default"];
 
     /**
-      The mixin for the application route. This defines actions to authenticate the
+      The mixin for the application route; defines actions to authenticate the
       session as well as to invalidate it. These actions can be used in all
       templates like this:
 
@@ -368,9 +432,7 @@ define("ember-simple-auth/mixins/application_route_mixin",
       {{/if}}
       ```
 
-      While this code works it is __preferrable to use the regular `link-to` helper
-      for the _'login'_ link__ as that will add the `'active'` class to the link.
-      For the _'logout'_ actions of course there is no route.
+      or in the case that the application uses a dedicated route for logging in:
 
       ```handlebars
       {{#if session.isAuthenticated}}
@@ -386,19 +448,39 @@ define("ember-simple-auth/mixins/application_route_mixin",
       custom behavior to these events.
 
       __When this mixin is used and the application's `ApplicationRoute` defines
-      the `activate` method, that method has to call `_super`.__
+      the `beforeModel` method, that method has to call `_super`.__
+
+      Using this mixin is optional. Without using it, the session's events will not
+      be automatically translated into route actions but would have to be handled
+      inidivially, e.g. in an initializer:
+
+      ```javascript
+      Ember.Application.initializer({
+        name:       'authentication',
+        after:      'simple-auth',
+        initialize: function(container, application) {
+          var applicationRoute = container.lookup('route:application');
+          var session          = container.lookup('simple-auth-session:main');
+          // handle the session events
+          session.on('sessionAuthenticationSucceeded', function() {
+            applicationRoute.transitionTo('index');
+          });
+        }
+      });
+      ```
 
       @class ApplicationRouteMixin
-      @namespace $mainModule
+      @namespace SimpleAuth
+      @module simple-auth/mixins/application-route-mixin
       @extends Ember.Mixin
       @static
     */
     __exports__["default"] = Ember.Mixin.create({
       /**
-        @method activate
+        @method beforeModel
         @private
       */
-      activate: function() {
+      beforeModel: function(transition) {
         var _this = this;
         Ember.A([
           'sessionAuthenticationSucceeded',
@@ -409,26 +491,28 @@ define("ember-simple-auth/mixins/application_route_mixin",
         ]).forEach(function(event) {
           _this.get(Configuration.sessionPropertyName).on(event, function(error) {
             Array.prototype.unshift.call(arguments, event);
-            _this.send.apply(_this, arguments);
+            var target = transition.isActive ? transition : _this;
+            target.send.apply(target, arguments);
           });
         });
       },
 
       actions: {
         /**
-          This action triggers transition to the `authenticationRoute` specified in
-          [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup). It can be used in
-          templates as shown above. It is also triggered automatically by
-          [Ember.SimpleAuth.AuthenticatedRouteMixin](#Ember-SimpleAuth-AuthenticatedRouteMixin)
-          whenever a route that requries authentication is accessed but the session
-          is not currently authenticated.
+          This action triggers transition to the
+          [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+          It can be used in templates as shown above. It is also triggered
+          automatically by the
+          [`AuthenticatedRouteMixin`](#SimpleAuth-AuthenticatedRouteMixin) whenever
+          a route that requries authentication is accessed but the session is not
+          currently authenticated.
 
           __For an application that works without an authentication route (e.g.
           because it opens a new window to handle authentication there), this is
-          the method to override, e.g.:__
+          the action to override, e.g.:__
 
           ```javascript
-          App.ApplicationRoute = Ember.Route.extend(Ember.SimpleAuth.ApplicationRouteMixin, {
+          App.ApplicationRoute = Ember.Route.extend(SimpleAuth.ApplicationRouteMixin, {
             actions: {
               authenticateSession: function() {
                 this.get('session').authenticate('authenticator:custom', {});
@@ -447,10 +531,10 @@ define("ember-simple-auth/mixins/application_route_mixin",
           This action is triggered whenever the session is successfully
           authenticated. If there is a transition that was previously intercepted
           by
-          [AuthenticatedRouteMixin#beforeModel](#Ember-SimpleAuth-AuthenticatedRouteMixin-beforeModel)
-          it will retry that. If there is no such transition, this action
-          transitions to the `routeAfterAuthentication` specified in
-          [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup).
+          [`AuthenticatedRouteMixin#beforeModel`](#SimpleAuth-AuthenticatedRouteMixin-beforeModel)
+          it will retry it. If there is no such transition, this action transitions
+          to the
+          [`Configuration.routeAfterAuthentication`](#SimpleAuth-Configuration-routeAfterAuthentication).
 
           @method actions.sessionAuthenticationSucceeded
         */
@@ -468,12 +552,12 @@ define("ember-simple-auth/mixins/application_route_mixin",
           This action is triggered whenever session authentication fails. The
           `error` argument is the error object that the promise the authenticator
           returns rejects with. (see
-          [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)).
+          [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
 
           It can be overridden to display error messages etc.:
 
           ```javascript
-          App.ApplicationRoute = Ember.Route.extend(Ember.SimpleAuth.ApplicationRouteMixin, {
+          App.ApplicationRoute = Ember.Route.extend(SimpleAuth.ApplicationRouteMixin, {
             actions: {
               sessionAuthenticationFailed: function(error) {
                 this.controllerFor('application').set('loginErrorMessage', error.message);
@@ -483,16 +567,16 @@ define("ember-simple-auth/mixins/application_route_mixin",
           ```
 
           @method actions.sessionAuthenticationFailed
-          @param {any} error The error the promise returned by the authenticator rejects with, see [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)
+          @param {any} error The error the promise returned by the authenticator rejects with, see [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)
         */
         sessionAuthenticationFailed: function(error) {
         },
 
         /**
           This action invalidates the session (see
-          [Ember.SimpleAuth.Session#invalidate](#Ember-SimpleAuth-Session-invalidate)).
+          [`Session#invalidate`](#SimpleAuth-Session-invalidate)).
           If invalidation succeeds, it reloads the application (see
-          [Ember.SimpleAuth.ApplicationRouteMixin#sessionInvalidationSucceeded](#Ember-SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
+          [`ApplicationRouteMixin#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
 
           @method actions.invalidateSession
         */
@@ -520,7 +604,7 @@ define("ember-simple-auth/mixins/application_route_mixin",
           default.
 
           @method actions.sessionInvalidationFailed
-          @param {any} error The error the promise returned by the authenticator rejects with, see [Ember.SimpleAuth.Authenticators.Base#invalidate](#Ember-SimpleAuth-Authenticators-Base-invalidate)
+          @param {any} error The error the promise returned by the authenticator rejects with, see [`Authenticators.Base#invalidate`](#SimpleAuth-Authenticators-Base-invalidate)
         */
         sessionInvalidationFailed: function(error) {
         },
@@ -529,7 +613,7 @@ define("ember-simple-auth/mixins/application_route_mixin",
           This action is invoked when an authorization error occurs (which is
           the case __when the server responds with HTTP status 401__). It
           invalidates the session and reloads the application (see
-          [Ember.SimpleAuth.ApplicationRouteMixin#sessionInvalidationSucceeded](#Ember-SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
+          [`ApplicationRouteMixin#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)).
 
           @method actions.authorizationFailed
         */
@@ -541,7 +625,7 @@ define("ember-simple-auth/mixins/application_route_mixin",
       }
     });
   });
-define("ember-simple-auth/mixins/authenticated_route_mixin", 
+define("simple-auth/mixins/authenticated-route-mixin", 
   ["./../configuration","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -551,23 +635,28 @@ define("ember-simple-auth/mixins/authenticated_route_mixin",
     var Configuration = __dependency1__["default"];
 
     /**
-      The mixin for routes that require the session to be authenticated in order to
-      be accessible. Including this mixin in a route automatically adds a hook that
-      enforces the session to be authenticated and redirect to the
-      `authenticationRoute` specified in
-      [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup) if it is not.
+      This mixin is for routes that require the session to be authenticated to be
+      accessible. Including this mixin in a route automatically adds a hook that
+      enforces the session to be authenticated and redirects to the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute)
+      if it is not.
 
       ```javascript
-        App.ProtectedRoute = Ember.Route.extend(Ember.SimpleAuth.AuthenticatedRouteMixin);
+      // app/routes/protected.js
+      import AuthenticatedRouteMixin from 'simple-auth/mixins/authenticated-route-mixin';
+
+      export default Ember.Route.extend(AuthenticatedRouteMixin);
       ```
 
-      `Ember.SimpleAuth.AuthenticatedRouteMixin` performs the redirect in the
-      `beforeModel` method so that in all methods executed after that the session
-      is guaranteed to be authenticated. __If `beforeModel` is overridden, ensure
-      that the custom implementation calls `this._super(transition)`__ so that the
-      session enforcement code is actually executed.
+      `AuthenticatedRouteMixin` performs the redirect in the `beforeModel` method
+      so that in all methods executed after that the session is guaranteed to be
+      authenticated. __If `beforeModel` is overridden, ensure that the custom
+      implementation calls `this._super(transition)`__ so that the session
+      enforcement code is actually executed.
 
       @class AuthenticatedRouteMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/authenticated-route-mixin
       @extends Ember.Mixin
       @static
     */
@@ -575,11 +664,11 @@ define("ember-simple-auth/mixins/authenticated_route_mixin",
       /**
         This method implements the enforcement of the session being authenticated.
         If the session is not authenticated, the current transition will be aborted
-        and a redirect will be triggered to the `authenticationRoute` specified in
-        [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup). The method also saves
-        the intercepted transition so that it can be retried after the session has
-        been authenticated (see
-        [Ember.SimpleAuth.ApplicationRouteMixin#sessionAuthenticationSucceeded](#Ember-SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)).
+        and a redirect will be triggered to the
+        [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+        The method also saves the intercepted transition so that it can be retried
+        after the session has been authenticated (see
+        [`ApplicationRouteMixin#sessionAuthenticationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)).
 
         @method beforeModel
         @param {Transition} transition The transition that lead to this route
@@ -593,7 +682,7 @@ define("ember-simple-auth/mixins/authenticated_route_mixin",
       }
     });
   });
-define("ember-simple-auth/mixins/authentication_controller_mixin", 
+define("simple-auth/mixins/authentication-controller-mixin", 
   ["./../configuration","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -603,13 +692,15 @@ define("ember-simple-auth/mixins/authentication_controller_mixin",
     var Configuration = __dependency1__["default"];
 
     /**
-      The mixin for the controller that handles the `authenticationRoute` specified
-      in [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup)). It provides the
-      `authenticate` action that will authenticate the session with the configured
-      authenticator (see
-      [Ember.SimpleAuth.AuthenticationControllerMixin#authenticatorFactory](#Ember-SimpleAuth-AuthenticationControllerMixin-authenticatorFactory)).
+      This mixin is for the controller that handles the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute).
+      It provides the `authenticate` action that will authenticate the session with
+      the configured authenticator (see
+      [`AuthenticationControllerMixin#authenticatorFactory`](#SimpleAuth-AuthenticationControllerMixin-authenticatorFactory)).
 
       @class AuthenticationControllerMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/authentication-controller-mixin
       @extends Ember.Mixin
     */
     __exports__["default"] = Ember.Mixin.create({
@@ -626,20 +717,22 @@ define("ember-simple-auth/mixins/authentication_controller_mixin",
         /**
           This action will authenticate the session with the configured
           authenticator (see
-          [Ember.SimpleAuth.AuthenticationControllerMixin#authenticatorFactory](#Ember-SimpleAuth-AuthenticationControllerMixin-authenticatorFactory),
-          [Ember.SimpleAuth.Session#authenticate](#Ember-SimpleAuth-Session-authenticate)).
+          [`AuthenticationControllerMixin#authenticatorFactory`](#SimpleAuth-AuthenticationControllerMixin-authenticatorFactory),
+          [`Session#authenticate`](#SimpleAuth-Session-authenticate)).
 
           @method actions.authenticate
           @param {Object} options Any options the authenticator needs to authenticate the session
         */
         authenticate: function(options) {
+          var authenticatorFactory = this.get('authenticatorFactory');
+          Ember.assert('AuthenticationControllerMixin/LoginControllerMixin require the authenticatorFactory property to be set on the controller', !Ember.isEmpty(authenticatorFactory));
           return this.get(Configuration.sessionPropertyName).authenticate(this.get('authenticatorFactory'), options);
         }
       }
     });
   });
-define("ember-simple-auth/mixins/login_controller_mixin", 
-  ["./../configuration","./authentication_controller_mixin","exports"],
+define("simple-auth/mixins/login-controller-mixin", 
+  ["./../configuration","./authentication-controller-mixin","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
     var global = (typeof window !== 'undefined') ? window : {},
@@ -649,13 +742,13 @@ define("ember-simple-auth/mixins/login_controller_mixin",
     var AuthenticationControllerMixin = __dependency2__["default"];
 
     /**
-      The mixin to use with the controller that handles the `authenticationRoute`
-      specified in
-      [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup) if the used authentication
-      mechanism works with a login form that asks for user credentials. It provides
-      the `authenticate` action that will authenticate the session with the
-      configured authenticator when invoked. __This is a specialization of
-      [Ember.SimpleAuth.AuthenticationControllerMixin](#Ember-SimpleAuth-AuthenticationControllerMixin).__
+      This mixin is for the controller that handles the
+      [`Configuration.authenticationRoute`](#SimpleAuth-Configuration-authenticationRoute)
+      if the used authentication mechanism works with a login form that asks for
+      user credentials. It provides the `authenticate` action that will
+      authenticate the session with the configured authenticator when invoked.
+      __This is a specialization of
+      [`AuthenticationControllerMixin`](#SimpleAuth-AuthenticationControllerMixin).__
 
       Accompanying the controller that this mixin is mixed in the application needs
       to have a `login` template with the fields `identification` and `password` as
@@ -673,14 +766,16 @@ define("ember-simple-auth/mixins/login_controller_mixin",
       ```
 
       @class LoginControllerMixin
-      @extends Ember.SimpleAuth.AuthenticationControllerMixin
+      @namespace SimpleAuth
+      @module simple-auth/mixins/login-controller-mixin
+      @extends SimpleAuth.AuthenticationControllerMixin
     */
     __exports__["default"] = Ember.Mixin.create(AuthenticationControllerMixin, {
       actions: {
         /**
           This action will authenticate the session with the configured
           authenticator (see
-          [Ember.SimpleAuth.LoginControllerMixin#authenticatorFactory](#Ember-SimpleAuth-LoginControllerMixin-authenticatorFactory))
+          [AuthenticationControllerMixin#authenticatorFactory](#SimpleAuth-Authentication-authenticatorFactory))
           if both `identification` and `password` are non-empty. It passes both
           values to the authenticator.
 
@@ -697,7 +792,7 @@ define("ember-simple-auth/mixins/login_controller_mixin",
       }
     });
   });
-define("ember-simple-auth/session", 
+define("simple-auth/session", 
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -707,87 +802,87 @@ define("ember-simple-auth/session",
     /**
       __The session provides access to the current authentication state as well as
       any data the authenticator resolved with__ (see
-      [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)).
-      It is created when Ember.SimpleAuth is set up (see
-      [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup)) and __injected into all
-      controllers and routes so that these parts of the application
-      can always access the current authentication state and other data__,
-      depending on the used authenticator and whether the session is actually
-      authenticated (see
-      [Ember.SimpleAuth.Authenticators.Base](#Ember-SimpleAuth-Authenticators-Base))).
-
-      The session also provides methods to authenticate it and to invalidate itself
+      [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
+      It is created when Ember Simple Auth is set up and __injected into all
+      controllers and routes so that these parts of the application can always
+      access the current authentication state and other data__, depending on the
+      authenticator in use and whether the session is actually authenticated (see
+      [`Authenticators.Base`](#SimpleAuth-Authenticators-Base)).
+
+      The session also provides methods to authenticate and to invalidate itself
       (see
-      [Ember.SimpleAuth.Session#authenticate](#Ember-SimpleAuth-Session-authenticate),
-      [Ember.SimpleAuth.Session#invaldiate](#Ember-SimpleAuth-Session-invaldiate)).
+      [`Session#authenticate`](#SimpleAuth-Session-authenticate),
+      [`Session#invaldiate`](#SimpleAuth-Session-invaldiate)).
       These methods are usually invoked through actions from routes or controllers.
       To authenticate the session manually, simple call the
-      [Ember.SimpleAuth.Session#authenticate](#Ember-SimpleAuth-Session-authenticate)
+      [`Session#authenticate`](#SimpleAuth-Session-authenticate)
       method with the authenticator factory to use as well as any options the
       authenticator needs to authenticate the session:
 
       ```javascript
-        this.get('session').authenticate('authenticatorFactory', { some: 'option' }).then(function() {
-          // authentication was successful
-        }, function() {
-          // authentication failed
-        });
+      this.get('session').authenticate('authenticatorFactory', { some: 'option' }).then(function() {
+        // authentication was successful
+      }, function() {
+        // authentication failed
+      });
       ```
 
-      When the session's authentication state changes or an attempt to change it
-      fails, it will trigger the `'sessionAuthenticationSucceeded'`,
-      `'sessionAuthenticationFailed'`, `'sessionInvalidationSucceeded'` or
-      `'sessionInvalidationFailed'` events.
-
       The session also observes the store and - if it is authenticated - the
       authenticator for changes (see
-      [Ember.SimpleAuth.Authenticators.Base](#Ember-SimpleAuth-Authenticators-Base)
-      end [Ember.SimpleAuth.Stores.Base](#Ember-SimpleAuth-Stores-Base)).
+      [`Authenticators.Base`](#SimpleAuth-Authenticators-Base)
+      end [`Stores.Base`](#SimpleAuth-Stores-Base)).
 
       @class Session
+      @namespace SimpleAuth
+      @module simple-auth/session
       @extends Ember.ObjectProxy
       @uses Ember.Evented
     */
     __exports__["default"] = Ember.ObjectProxy.extend(Ember.Evented, {
       /**
         Triggered __whenever the session is successfully authenticated__. When the
-        application uses the mixin,
-        [Ember.SimpleAuth.ApplicationRouteMixin.actions#sessionAuthenticationSucceeded](#Ember-SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionAuthenticationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationSucceeded)
         will be invoked whenever this event is triggered.
 
         @event sessionAuthenticationSucceeded
       */
       /**
         Triggered __whenever an attempt to authenticate the session fails__. When
-        the application uses the mixin,
-        [Ember.SimpleAuth.ApplicationRouteMixin.actions#sessionAuthenticationFailed](#Ember-SimpleAuth-ApplicationRouteMixin-sessionAuthenticationFailed)
+        the application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionAuthenticationFailed`](#SimpleAuth-ApplicationRouteMixin-sessionAuthenticationFailed)
         will be invoked whenever this event is triggered.
 
         @event sessionAuthenticationFailed
-        @param {Object} error The error object; this depends on the authenticator in use, see [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)
+        @param {Object} error The error object; this depends on the authenticator in use, see [SimpleAuth.Authenticators.Base#authenticate](#SimpleAuth-Authenticators-Base-authenticate)
       */
       /**
         Triggered __whenever the session is successfully invalidated__. When the
-        application uses the mixin,
-        [Ember.SimpleAuth.ApplicationRouteMixin.actions#sessionInvalidationSucceeded](#Ember-SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionInvalidationSucceeded`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationSucceeded)
         will be invoked whenever this event is triggered.
 
         @event sessionInvalidationSucceeded
       */
       /**
         Triggered __whenever an attempt to invalidate the session fails__. When the
-        application uses the mixin,
-        [Ember.SimpleAuth.ApplicationRouteMixin.actions#sessionInvalidationFailed](#Ember-SimpleAuth-ApplicationRouteMixin-sessionInvalidationFailed)
+        application uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#sessionInvalidationFailed`](#SimpleAuth-ApplicationRouteMixin-sessionInvalidationFailed)
         will be invoked whenever this event is triggered.
 
         @event sessionInvalidationFailed
-        @param {Object} error The error object; this depends on the authenticator in use, see [Ember.SimpleAuth.Authenticators.Base#invalidate](#Ember-SimpleAuth-Authenticators-Base-invalidate)
+        @param {Object} error The error object; this depends on the authenticator in use, see [SimpleAuth.Authenticators.Base#invalidate](#SimpleAuth-Authenticators-Base-invalidate)
       */
       /**
         Triggered __whenever the server rejects the authorization information
         passed with a request and responds with status 401__. When the application
-        uses the mixin,
-        [Ember.SimpleAuth.ApplicationRouteMixin.actions#authorizationFailed](#Ember-SimpleAuth-ApplicationRouteMixin-authorizationFailed)
+        uses the
+        [`ApplicationRouteMixin` mixin](#SimpleAuth-ApplicationRouteMixin),
+        [`ApplicationRouteMixin.actions#authorizationFailed`](#SimpleAuth-ApplicationRouteMixin-authorizationFailed)
         will be invoked whenever this event is triggered.
 
         @event authorizationFailed
@@ -804,12 +899,10 @@ define("ember-simple-auth/session",
       */
       authenticatorFactory: null,
       /**
-        The store used to persist session properties. This is assigned during
-        Ember.SimpleAuth's setup and can be configured there
-        (see [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup)).
+        The store used to persist session properties.
 
         @property store
-        @type Ember.SimpleAuth.Stores.Base
+        @type SimpleAuth.Stores.Base
         @readOnly
         @default null
       */
@@ -846,7 +939,7 @@ define("ember-simple-auth/session",
         Authenticates the session with an `authenticator` and appropriate
         `options`. __This delegates the actual authentication work to the
         `authenticator`__ and handles the returned promise accordingly (see
-        [Ember.SimpleAuth.Authenticators.Base#authenticate](#Ember-SimpleAuth-Authenticators-Base-authenticate)).
+        [`Authenticators.Base#authenticate`](#SimpleAuth-Authenticators-Base-authenticate)).
         All data the authenticator resolves with will be saved in the session.
 
         __This method returns a promise itself. A resolving promise indicates that
@@ -877,10 +970,10 @@ define("ember-simple-auth/session",
       /**
         Invalidates the session with the authenticator it is currently
         authenticated with (see
-        [Ember.SimpleAuth.Session#authenticatorFactory](#Ember-SimpleAuth-Session-authenticatorFactory)).
+        [`Session#authenticatorFactory`](#SimpleAuth-Session-authenticatorFactory)).
         __This invokes the authenticator's `invalidate` method and handles the
         returned promise accordingly__ (see
-        [Ember.SimpleAuth.Authenticators.Base#invalidate](#Ember-SimpleAuth-Authenticators-Base-invalidate)).
+        [`Authenticators.Base#invalidate`](#SimpleAuth-Authenticators-Base-invalidate)).
 
         __This method returns a promise itself. A resolving promise indicates that
         the session was successfully invalidated__ while a rejecting promise
@@ -1011,15 +1104,14 @@ define("ember-simple-auth/session",
       }
     });
   });
-define("ember-simple-auth/setup", 
-  ["./configuration","./session","./stores/local_storage","./stores/ephemeral","./initialize_extension","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+define("simple-auth/setup", 
+  ["./configuration","./session","./stores/local-storage","./stores/ephemeral","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
     var Configuration = __dependency1__["default"];
     var Session = __dependency2__["default"];
     var LocalStorage = __dependency3__["default"];
     var Ephemeral = __dependency4__["default"];
-    var initializeExtension = __dependency5__["default"];
 
     function extractLocationOrigin(location) {
       if (Ember.typeOf(location) === 'string') {
@@ -1040,75 +1132,46 @@ define("ember-simple-auth/setup",
     }
 
     var urlOrigins     = {};
-    var documentOrigin = extractLocationOrigin(window.location);
     var crossOriginWhitelist;
-    function shouldAuthorizeRequest(url) {
-      var urlOrigin = urlOrigins[url] = urlOrigins[url] || extractLocationOrigin(url);
-      return crossOriginWhitelist.indexOf(urlOrigin) > -1 || urlOrigin === documentOrigin;
+    function shouldAuthorizeRequest(options) {
+      if (options.crossDomain === false) {
+        return true;
+      }
+      var urlOrigin = urlOrigins[options.url] = urlOrigins[options.url] || extractLocationOrigin(options.url);
+      return crossOriginWhitelist.indexOf(urlOrigin) > -1;
     }
 
     function registerStores(container) {
-      container.register('ember-simple-auth-session-store:local-storage', LocalStorage);
-      container.register('ember-simple-auth-session-store:ephemeral', Ephemeral);
+      container.register('simple-auth-session-store:local-storage', LocalStorage);
+      container.register('simple-auth-session-store:ephemeral', Ephemeral);
     }
 
     /**
-      Sets up Ember.SimpleAuth for the application; this method __should be invoked
-      in a custom initializer__ like this:
-
-      ```javascript
-      Ember.Application.initializer({
-        name: 'authentication',
-        initialize: function(container, application) {
-          Ember.SimpleAuth.setup(container, application);
-        }
-      });
-      ```
-
       @method setup
-      @namespace $mainModule
-      @static
-      @param {Container} container The Ember.js application's dependency injection container
-      @param {Ember.Application} application The Ember.js application instance
-      @param {Object} options
-        @param {String} [options.authorizerFactory] The authorizer factory to use as it is registered with Ember's container, see [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register); when the application does not interact with a server that requires authorized requests, no auzthorizer is needed
-        @param {Object} [options.storeFactory] The store factory to use as it is registered with Ember's container, see [Ember's API docs](http://emberjs.com/api/classes/Ember.Application.html#method_register) - defaults to `session-stores:local-storage`
-        @param {Object} [options.sessionPropertyName] The name for the property that the session is injected with into routes and controllers - defaults to `session`
-        @param {String} [options.authenticationRoute] route to transition to for authentication - defaults to `'login'`
-        @param {String} [options.routeAfterAuthentication] route to transition to after successful authentication - defaults to `'index'`
-        @param {Array[String]} [options.crossOriginWhitelist] Ember.SimpleAuth will never authorize requests going to a different origin than the one the Ember.js application was loaded from; to explicitely enable authorization for additional origins, whitelist those origins - defaults to `[]` _(beware that origins consist of protocol, host and port (port can be left out when it is 80 for HTTP or 443 for HTTPS))_
+      @private
     **/
-    __exports__["default"] = function(container, application, options) {
+    __exports__["default"] = function(container, application) {
+      Configuration.load(container);
       application.deferReadiness();
       registerStores(container);
-      Configuration.extensionInitializers.forEach(function(initializer) {
-        initializer(container, application, options);
-      });
 
-      options                                = options || {};
-      Configuration.routeAfterAuthentication = options.routeAfterAuthentication || Configuration.routeAfterAuthentication;
-      Configuration.authenticationRoute      = options.authenticationRoute || Configuration.authenticationRoute;
-      Configuration.sessionPropertyName      = options.sessionPropertyName || Configuration.sessionPropertyName;
-      Configuration.applicationRootUrl       = container.lookup('router:main').get('rootURL') || '/';
-      crossOriginWhitelist                   = Ember.A(options.crossOriginWhitelist || []).map(function(origin) {
+      var store            = container.lookup(Configuration.storeFactory);
+      var session          = Session.create({ store: store, container: container });
+      crossOriginWhitelist = Ember.A(Configuration.crossOriginWhitelist).map(function(origin) {
         return extractLocationOrigin(origin);
       });
 
-      options.storeFactory = options.storeFactory || 'ember-simple-auth-session-store:local-storage';
-      var store            = container.lookup(options.storeFactory);
-      var session          = Session.create({ store: store, container: container });
-
-      container.register('ember-simple-auth-session:main', session, { instantiate: false });
+      container.register('simple-auth-session:main', session, { instantiate: false });
       Ember.A(['controller', 'route']).forEach(function(component) {
-        container.injection(component, Configuration.sessionPropertyName, 'ember-simple-auth-session:main');
+        container.injection(component, Configuration.sessionPropertyName, 'simple-auth-session:main');
       });
 
-      if (!Ember.isEmpty(options.authorizerFactory)) {
-        var authorizer = container.lookup(options.authorizerFactory);
+      if (!Ember.isEmpty(Configuration.authorizerFactory)) {
+        var authorizer = container.lookup(Configuration.authorizerFactory);
         if (!!authorizer) {
           authorizer.set('session', session);
           Ember.$.ajaxPrefilter(function(options, originalOptions, jqXHR) {
-            if (shouldAuthorizeRequest(options.url)) {
+            if (!authorizer.isDestroyed && shouldAuthorizeRequest(options)) {
               authorizer.authorize(jqXHR, options);
             }
           });
@@ -1119,7 +1182,7 @@ define("ember-simple-auth/setup",
           });
         }
       } else {
-        Ember.Logger.debug('No authorizer factory was specified for Ember.SimpleAuth - specify one if backend requests need to be authorized.');
+        Ember.Logger.debug('No authorizer factory was configured for Ember Simple Auth - specify one if backend requests need to be authorized.');
       }
 
       var advanceReadiness = function() {
@@ -1128,8 +1191,8 @@ define("ember-simple-auth/setup",
       session.restore().then(advanceReadiness, advanceReadiness);
     }
   });
-define("ember-simple-auth/stores/base", 
-  ["../utils/flat_objects_are_equal","exports"],
+define("simple-auth/stores/base", 
+  ["../utils/flat-objects-are-equal","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
     var global = (typeof window !== 'undefined') ? window : {},
@@ -1143,12 +1206,19 @@ define("ember-simple-auth/stores/base",
 
       Stores are used to persist the session's state so it survives a page reload
       and is synchronized across multiple tabs or windows of the same application.
-      The store to be used with the application can be configured during
-      Ember.SimpleAuth's setup
-      (see [Ember.SimpleAuth.setup](#Ember-SimpleAuth-setup)).
+      The store to be used with the application can be configured in the global
+      configuration object:
+
+      ```js
+      window.ENV = window.ENV || {};
+      window.ENV['simple-auth'] = {
+        storeFactory: 'simple-auth-session-store:local-storage'
+      }
+      ```
 
       @class Base
-      @namespace Stores
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/base
       @extends Ember.Object
       @uses Ember.Evented
     */
@@ -1158,7 +1228,7 @@ define("ember-simple-auth/stores/base",
         store. This usually happens because the session is authenticated or
         invalidated in another tab or window.__ The session automatically catches
         that event, passes the updated data to its authenticator's
-        [Ember.SimpleAuth.Authenticators.Base#restore](#Ember-SimpleAuth-Authenticators-Base-restore)
+        [`Authenticators.Base#restore`](#SimpleAuth-Authenticators-Base-restore)
         method and handles the result of that invocation accordingly.
 
         @event sessionDataUpdated
@@ -1168,7 +1238,7 @@ define("ember-simple-auth/stores/base",
       /**
         Persists the `data` in the store.
 
-        `Ember.SimpleAuth.Stores.Base`'s implementation does nothing.
+        `Stores.Base`'s implementation does nothing.
 
         @method persist
         @param {Object} data The data to persist
@@ -1179,8 +1249,7 @@ define("ember-simple-auth/stores/base",
       /**
         Restores all data currently saved in the store as a plain object.
 
-        `Ember.SimpleAuth.Stores.Base`'s implementation always returns an empty
-        plain Object.
+        `Stores.Base`'s implementation always returns an empty plain Object.
 
         @method restore
         @return {Object} The data currently persisted in the store.
@@ -1192,9 +1261,9 @@ define("ember-simple-auth/stores/base",
       /**
         Replaces all data currently saved in the store with the specified `data`.
 
-        `Ember.SimpleAuth.Stores.Base`'s implementation clears the store, then
-        persists the specified `data`. If the store's current content is equal to
-        the specified `data`, nothing is done.
+        `Stores.Base`'s implementation clears the store, then persists the
+        specified `data`. If the store's current content is equal to the specified
+        `data`, nothing is done.
 
         @method replace
         @param {Object} data The data to replace the store's content with
@@ -1209,7 +1278,7 @@ define("ember-simple-auth/stores/base",
       /**
         Clears the store.
 
-        `Ember.SimpleAuth.Stores.Base`'s implementation does nothing.
+        `Stores.Base`'s implementation does nothing.
 
         @method clear
       */
@@ -1217,7 +1286,7 @@ define("ember-simple-auth/stores/base",
       }
     });
   });
-define("ember-simple-auth/stores/ephemeral", 
+define("simple-auth/stores/ephemeral", 
   ["./base","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -1234,10 +1303,11 @@ define("ember-simple-auth/stores/ephemeral",
       __This store is mainly useful for testing.__
 
       _The factory for this store is registered as
-      `'ember-simple-auth-session-store:ephemeral'` in Ember's container._
+      `'simple-auth-session-store:ephemeral'` in Ember's container._
 
       @class Ephemeral
-      @namespace Stores
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/ephemeral
       @extends Stores.Base
     */
     __exports__["default"] = Base.extend({
@@ -1280,8 +1350,8 @@ define("ember-simple-auth/stores/ephemeral",
       }
     });
   });
-define("ember-simple-auth/stores/local_storage", 
-  ["./base","../utils/flat_objects_are_equal","exports"],
+define("simple-auth/stores/local-storage", 
+  ["./base","../utils/flat-objects-are-equal","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
     var global = (typeof window !== 'undefined') ? window : {},
@@ -1294,10 +1364,13 @@ define("ember-simple-auth/stores/local_storage",
       Store that saves its data in the browser's `localStorage`.
 
       _The factory for this store is registered as
-      `'ember-simple-auth-session-store:local-storage'` in Ember's container._
+      `'simple-auth-session-store:local-storage'` in Ember's container._
+
+      __`Stores.LocalStorage` is Ember Simple Auth's default store.__
 
       @class LocalStorage
-      @namespace Stores
+      @namespace SimpleAuth.Stores
+      @module simple-auth/stores/local-storage
       @extends Stores.Base
     */
     __exports__["default"] = Base.extend({
@@ -1411,7 +1484,7 @@ define("ember-simple-auth/stores/local_storage",
       }
     });
   });
-define("ember-simple-auth/utils/flat_objects_are_equal", 
+define("simple-auth/utils/flat-objects-are-equal", 
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -1438,7 +1511,17 @@ define("ember-simple-auth/utils/flat_objects_are_equal",
       return JSON.stringify(sortObject(a)) === JSON.stringify(sortObject(b));
     }
   });
-define("ember-simple-auth/utils/is_secure_url", 
+define("simple-auth/utils/get-global-config", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {};
+
+    __exports__["default"] = function(scope) {
+      return(global.ENV || {})[scope] || {};
+    }
+  });
+define("simple-auth/utils/is-secure-url", 
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -1453,26 +1536,27 @@ define("ember-simple-auth/utils/is_secure_url",
       return link.protocol == 'https:';
     }
   });
-var setup                         = requireModule('ember-simple-auth/setup').default;
-var initializeExtension           = requireModule('ember-simple-auth/initialize_extension').default;
-var Configuration                 = requireModule('ember-simple-auth/configuration').default;
-var Session                       = requireModule('ember-simple-auth/session').default;
-var BaseAuthenticator             = requireModule('ember-simple-auth/authenticators/base').default;
-var BaseAuthorizer                = requireModule('ember-simple-auth/authorizers/base').default;
-var BaseStore                     = requireModule('ember-simple-auth/stores/base').default;
-var LocalStorageStore             = requireModule('ember-simple-auth/stores/local_storage').default;
-var EphemeralStore                = requireModule('ember-simple-auth/stores/ephemeral').default;
-var flatObjectsAreEqual           = requireModule('ember-simple-auth/utils/flat_objects_are_equal').default;
-var isSecureUrl                   = requireModule('ember-simple-auth/utils/is_secure_url').default;
-var ApplicationRouteMixin         = requireModule('ember-simple-auth/mixins/application_route_mixin').default;
-var AuthenticatedRouteMixin       = requireModule('ember-simple-auth/mixins/authenticated_route_mixin').default;
-var AuthenticationControllerMixin = requireModule('ember-simple-auth/mixins/authentication_controller_mixin').default;
-var LoginControllerMixin          = requireModule('ember-simple-auth/mixins/login_controller_mixin').default;
-
-global.Ember.SimpleAuth = {
+var initializer                   = requireModule('simple-auth/initializer').default;
+var setup                         = requireModule('simple-auth/setup').default;
+var Configuration                 = requireModule('simple-auth/configuration').default;
+var Session                       = requireModule('simple-auth/session').default;
+var BaseAuthenticator             = requireModule('simple-auth/authenticators/base').default;
+var BaseAuthorizer                = requireModule('simple-auth/authorizers/base').default;
+var BaseStore                     = requireModule('simple-auth/stores/base').default;
+var LocalStorageStore             = requireModule('simple-auth/stores/local-storage').default;
+var EphemeralStore                = requireModule('simple-auth/stores/ephemeral').default;
+var flatObjectsAreEqual           = requireModule('simple-auth/utils/flat-objects-are-equal').default;
+var isSecureUrl                   = requireModule('simple-auth/utils/is-secure-url').default;
+var getGlobalConfig               = requireModule('simple-auth/utils/get-global-config').default;
+var ApplicationRouteMixin         = requireModule('simple-auth/mixins/application-route-mixin').default;
+var AuthenticatedRouteMixin       = requireModule('simple-auth/mixins/authenticated-route-mixin').default;
+var AuthenticationControllerMixin = requireModule('simple-auth/mixins/authentication-controller-mixin').default;
+var LoginControllerMixin          = requireModule('simple-auth/mixins/login-controller-mixin').default;
+
+global.SimpleAuth = {
   setup: setup,
 
-  initializeExtension: initializeExtension,
+  Configuration: Configuration,
 
   Session: Session,
 
@@ -1485,14 +1569,15 @@ global.Ember.SimpleAuth = {
   },
 
   Stores: {
-    Base: BaseStore,
+    Base:         BaseStore,
     LocalStorage: LocalStorageStore,
-    Ephemeral: EphemeralStore
+    Ephemeral:    EphemeralStore
   },
 
   Utils: {
     flatObjectsAreEqual: flatObjectsAreEqual,
-    isSecureUrl: isSecureUrl
+    isSecureUrl:         isSecureUrl,
+    getGlobalConfig:     getGlobalConfig
   },
 
   ApplicationRouteMixin:         ApplicationRouteMixin,
@@ -1500,4 +1585,6 @@ global.Ember.SimpleAuth = {
   AuthenticationControllerMixin: AuthenticationControllerMixin,
   LoginControllerMixin:          LoginControllerMixin
 };
+
+requireModule('simple-auth/ember');
 })((typeof global !== 'undefined') ? global : window);