ember_simple_auth-rails 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfe2808004d5666ba68ebd9d4633afe78581d359
-  data.tar.gz: dd554bd70fbf7be5edda64d7058792b1a732a063
+  metadata.gz: 022467e239fda4e5f6fa40982184389608076632
+  data.tar.gz: 5da86ed66985de41be4ba84ecff855235720f901
 SHA512:
-  metadata.gz: 39ad83ffe1e8291c137d2269dbe8136e2a446748a42d3f5a72bd589c45e200937ed67a00d78deb78542011aefb6d29643ae8695f637226c5775d5d746c3c51c8
-  data.tar.gz: 73fdb259e29c3e0066522affda571a2d35a56f539ac9b4b1b6884aafd6523e0350707476c33f37da3e4c248e1c9b2bb03a31e5c8486f6e3ddafce35ed02acf21
+  metadata.gz: d1f7f97d50614589d883b8d879e046ec5a6d9895292da0f9bd5f55d8dbd70ec88a57e07cde23d39a9ed026a785c100d254e519c78f77db6e84972e444a886ad5
+  data.tar.gz: b00e6ce324c7384c4114d24e5c85b661ff2304628ba1e1b48696f666d868ec4fe51fbd2c220cf4f427627b704359c0c78e550d517d8b49d0de35966726ef7cea

data/README.md

@@ -18,7 +18,22 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+require the assets as you always do.
+
+#### >= 0.3.0
+
+```
+# require "ember-simple-auth"
+# require "ember-simple-auth-cookie-store"
+# require "ember-simple-auth-devise"
+# require "ember-simple-auth-oauth2"
+```
+
+#### < 0.3.0
+
+``` 
+# require "ember-simple-auth"
+```
 
 ## Contributing
 

data/lib/ember_simple_auth/rails/version.rb

@@ -1,5 +1,5 @@
 module EmberSimpleAuth
   module Rails
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

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

@@ -0,0 +1,225 @@
+(function(global) {
+
+var define, requireModule;
+
+(function() {
+  var registry = {}, seen = {};
+
+  define = function(name, deps, callback) {
+    registry[name] = { deps: deps, callback: callback };
+  };
+
+  requireModule = function(name) {
+    if (seen.hasOwnProperty(name)) { return seen[name]; }
+    seen[name] = {};
+
+    if (!registry[name]) {
+      throw new Error("Could not find module " + name);
+    }
+
+    var mod = registry[name],
+        deps = mod.deps,
+        callback = mod.callback,
+        reified = [],
+        exports;
+
+    for (var i=0, l=deps.length; i<l; i++) {
+      if (deps[i] === 'exports') {
+        reified.push(exports = {});
+      } else {
+        reified.push(requireModule(resolve(deps[i])));
+      }
+    }
+
+    var value = callback.apply(this, reified);
+    return seen[name] = exports || value;
+
+    function resolve(child) {
+      if (child.charAt(0) !== '.') { return child; }
+      var parts = child.split("/");
+      var parentBase = name.split("/").slice(0, -1);
+
+      for (var i=0, l=parts.length; i<l; i++) {
+        var part = parts[i];
+
+        if (part === '..') { parentBase.pop(); }
+        else if (part === '.') { continue; }
+        else { parentBase.push(part); }
+      }
+
+      return parentBase.join("/");
+    }
+  };
+
+  requireModule.registry = registry;
+})();
+
+define("ember-simple-auth-cookie-store", 
+  ["./ember-simple-auth-cookie-store/stores/cookie","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Cookie = __dependency1__.Cookie;
+
+    __exports__["default"] = Cookie;
+  });
+define("ember-simple-auth-cookie-store/stores/cookie", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {},
+        Ember = global.Ember;
+
+    /**
+      Store that saves its data in session cookies.
+
+      __In order to keep multiple tabs/windows of an application in sync, this
+      store has to periodically (every 500ms) check the cookies__ for changes as
+      there are no events that notify of changes in cookies. The recommended
+      alternative is `Ember.SimpleAuth.Stores.LocalStorage` that also persistently
+      stores data but instead of cookies relies on the `localStorage` API and does
+      not need to poll for external changes.
+
+      This store will trigger the `'updated'` event when any of its cookies is
+      changed from another tab or window.
+
+      _The factory for this store is registered as `'session-store:cookie'` in
+      Ember's container.
+
+      @class Cookie
+      @namespace Stores
+      @extends Stores.Base
+    */
+    var Cookie = Ember.SimpleAuth.Stores.Base.extend({
+      /**
+        The prefix to use for the store's cookie names so they can be distinguished
+        from other cookies.
+
+        @property cookieNamePrefix
+        @type String
+        @default 'ember_simple_auth:'
+      */
+      cookieNamePrefix: 'ember_simple_auth:',
+
+      /**
+        @property _secureCookies
+        @private
+      */
+      _secureCookies: window.location.protocol === 'https:',
+
+      /**
+        @property _syncDataTimeout
+        @private
+      */
+      _syncDataTimeout: null,
+
+      /**
+        @method init
+        @private
+      */
+      init: function() {
+        this.syncData();
+      },
+
+      /**
+        Persists the `data` in session cookies.
+
+        @method persist
+        @param {Object} data The data to persist
+      */
+      persist: function(data) {
+        for (var property in data) {
+          this.write(property, data[property], null);
+        }
+        this._lastData = this.restore();
+      },
+
+      /**
+        Restores all data currently saved in the session cookies identified by the
+        `cookieNamePrefix` (see
+        [Ember.SimpleAuth.Stores.Cookie#cookieNamePrefix](Ember-SimpleAuth-Stores-Cookie-cookieNamePrefix))
+        as a plain object.
+
+        @method restore
+        @return {Object} All data currently persisted in the session cookies
+      */
+      restore: function() {
+        var _this = this;
+        var data  = {};
+        this.knownCookies().forEach(function(cookie) {
+          data[cookie] = _this.read(cookie);
+        });
+        return data;
+      },
+
+      /**
+        Clears the store by deleting all session cookies prefixed with the
+        `cookieNamePrefix` (see
+        [Ember.SimpleAuth.Stores.Cookie#cookieNamePrefix](Ember-SimpleAuth-Stores-Cookie-cookieNamePrefix)).
+
+        @method clear
+      */
+      clear: function() {
+        var _this = this;
+        this.knownCookies().forEach(function(cookie) {
+          _this.write(cookie, null, (new Date(0)).toGMTString());
+        });
+        this._lastData = null;
+      },
+
+      /**
+        @method read
+        @private
+      */
+      read: function(name) {
+        var value = document.cookie.match(new RegExp(this.cookieNamePrefix + name + '=([^;]+)')) || [];
+        return decodeURIComponent(value[1] || '');
+      },
+
+      /**
+        @method write
+        @private
+      */
+      write: function(name, value, expiration) {
+        var expires = Ember.isEmpty(expiration) ? '' : '; expires=' + expiration;
+        var secure  = !!this._secureCookies ? ';secure' : '';
+        document.cookie = this.cookieNamePrefix + name + '=' + encodeURIComponent(value) + expires + secure;
+      },
+
+      /**
+        @method knownCookies
+        @private
+      */
+      knownCookies: function() {
+        var _this = this;
+        return Ember.A(document.cookie.split(/[=;\s]+/)).filter(function(element) {
+          return new RegExp('^' + _this.cookieNamePrefix).test(element);
+        }).map(function(cookie) {
+          return cookie.replace(_this.cookieNamePrefix, '');
+        });
+      },
+
+      /**
+        @method syncData
+        @private
+      */
+      syncData: function() {
+        var data = this.restore();
+        if (!Ember.SimpleAuth.Utils.flatObjectsAreEqual(data, this._lastData)) {
+          this._lastData = data;
+          this.trigger('updated', data);
+        }
+        if (!Ember.testing) {
+          Ember.run.cancel(this._syncDataTimeout);
+          this._syncDataTimeout = Ember.run.later(this, this.syncData, 500);
+        }
+      }
+    });
+
+    __exports__.Cookie = Cookie;
+  });
+global.Ember.SimpleAuth.Stores.Cookie = requireModule('ember-simple-auth-cookie-store').default;
+
+global.Ember.SimpleAuth.initializeExtension(function(container, application, options) {
+  container.register('session-store:cookie', global.Ember.SimpleAuth.Stores.Cookie);
+});
+})((typeof global !== 'undefined') ? global : window);

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

@@ -0,0 +1,244 @@
+(function(global) {
+
+var define, requireModule;
+
+(function() {
+  var registry = {}, seen = {};
+
+  define = function(name, deps, callback) {
+    registry[name] = { deps: deps, callback: callback };
+  };
+
+  requireModule = function(name) {
+    if (seen.hasOwnProperty(name)) { return seen[name]; }
+    seen[name] = {};
+
+    if (!registry[name]) {
+      throw new Error("Could not find module " + name);
+    }
+
+    var mod = registry[name],
+        deps = mod.deps,
+        callback = mod.callback,
+        reified = [],
+        exports;
+
+    for (var i=0, l=deps.length; i<l; i++) {
+      if (deps[i] === 'exports') {
+        reified.push(exports = {});
+      } else {
+        reified.push(requireModule(resolve(deps[i])));
+      }
+    }
+
+    var value = callback.apply(this, reified);
+    return seen[name] = exports || value;
+
+    function resolve(child) {
+      if (child.charAt(0) !== '.') { return child; }
+      var parts = child.split("/");
+      var parentBase = name.split("/").slice(0, -1);
+
+      for (var i=0, l=parts.length; i<l; i++) {
+        var part = parts[i];
+
+        if (part === '..') { parentBase.pop(); }
+        else if (part === '.') { continue; }
+        else { parentBase.push(part); }
+      }
+
+      return parentBase.join("/");
+    }
+  };
+
+  requireModule.registry = registry;
+})();
+
+define("ember-simple-auth-devise", 
+  ["./ember-simple-auth-devise/authenticators/devise","./ember-simple-auth-devise/authorizers/devise","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Authenticator = __dependency1__.Devise;
+    var Authorizer = __dependency2__.Devise;
+
+    __exports__.Authenticator = Authenticator;
+    __exports__.Authorizer = Authorizer;
+  });
+define("ember-simple-auth-devise/authenticators/devise", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {},
+        Ember = global.Ember;
+
+    /**
+      Authenticator that works with the Ruby gem
+      [Devise](https://github.com/plataformatec/devise).
+
+      __As token authentication is not actually part of devise anymore, the server
+      needs to implement some customizations__ to work with this authenticator -
+      see the README and
+      [discussion here](https://gist.github.com/josevalim/fb706b1e933ef01e4fb6).
+
+      _The factory for this authenticator is registered as `'authenticator:devise'`
+      in Ember's container._
+
+      @class Devise
+      @namespace Authenticators
+      @extends Base
+    */
+    var Devise = Ember.SimpleAuth.Authenticators.Base.extend({
+      /**
+        The endpoint on the server the authenticator acquires the auth token
+        and email from.
+
+        @property serverTokenEndpoint
+        @type String
+        @default '/users/sign_in'
+      */
+      serverTokenEndpoint: '/users/sign_in',
+
+      /**
+        Restores the session from a set of session properties; __will return a
+        resolving promise when there's a non-empty `auth_token` and a non-empty
+        `auth_email` in the `properties`__ and a rejecting promise otherwise.
+
+        @method restore
+        @param {Object} properties The properties to restore the session from
+        @return {Ember.RSVP.Promise} A promise that when it resolves results in the session being authenticated
+      */
+      restore: function(properties) {
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          if (!Ember.isEmpty(properties.auth_token) && !Ember.isEmpty(properties.auth_email)) {
+            resolve(properties);
+          } else {
+            reject();
+          }
+        });
+      },
+
+      /**
+        Authenticates the session with the specified `credentials`; the credentials
+        are `POST`ed to the `serverTokenEndpoint` and if they are valid the server
+        returns an auth token and email in response . __If the credentials are
+        valid and authentication succeeds, a promise that resolves with the
+        server's response is returned__, otherwise a promise that rejects with the
+        error is returned.
+
+        @method authenticate
+        @param {Object} options The credentials to authenticate the session with
+        @return {Ember.RSVP.Promise} A promise that resolves when an auth token and email is successfully acquired from the server and rejects otherwise
+      */
+      authenticate: function(credentials) {
+        var _this = this;
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          var data = {
+            email:    credentials.identification,
+            password: credentials.password
+          };
+          _this.makeRequest(data).then(function(response) {
+            Ember.run(function() {
+              resolve(response);
+            });
+          }, function(xhr, status, error) {
+            Ember.run(function() {
+              reject(xhr.responseJSON || xhr.responseText);
+            });
+          });
+        });
+      },
+
+      /**
+        Does nothing
+
+        @method invalidate
+        @return {Ember.RSVP.Promise} A resolving promise
+      */
+      invalidate: function() {
+        return Ember.RSVP.resolve();
+      },
+
+      /**
+        @method makeRequest
+        @private
+      */
+      makeRequest: function(data, resolve, reject) {
+        if (!Ember.SimpleAuth.Utils.isSecureUrl(this.serverTokenEndpoint)) {
+          Ember.Logger.warn('Credentials are transmitted via an insecure connection - use HTTPS to keep them secure.');
+        }
+        return Ember.$.ajax({
+          url:         this.serverTokenEndpoint,
+          type:        'POST',
+          data:        data,
+          dataType:    'json',
+          contentType: 'application/x-www-form-urlencoded'
+        });
+      }
+    });
+
+    __exports__.Devise = Devise;
+  });
+define("ember-simple-auth-devise/authorizers/devise", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var global = (typeof window !== 'undefined') ? window : {},
+        Ember = global.Ember;
+
+    /**
+      Authenticator that works with the Ruby gem
+      [Devise](https://github.com/plataformatec/devise) by adding `auth-token` and
+      `auth-email` headers to requests.
+
+      __As token authentication is not actually part of devise anymore, the server
+      needs to implement some customizations__ to work with this authenticator -
+      see the README and
+      [discussion here](https://gist.github.com/josevalim/fb706b1e933ef01e4fb6).
+
+      _The factory for this authorizer is registered as `'authorizer:devise'` in
+      Ember's container._
+
+      @class Devise
+      @namespace Authorizers
+      @extends Base
+    */
+    var Devise = Ember.SimpleAuth.Authorizers.Base.extend({
+      /**
+        Authorizes an XHR request by sending the `auth_token` and `auth_email`
+        properties from the session in custom headers:
+
+        ```
+        auth-token: <auth_token>
+        auth-email: <auth_email>
+        ```
+
+        @method authorize
+        @param {jqXHR} jqXHR The XHR request to authorize (see http://api.jquery.com/jQuery.ajax/#jqXHR)
+        @param {Object} requestOptions The options as provided to the `$.ajax` method (see http://api.jquery.com/jQuery.ajaxPrefilter/)
+      */
+
+      authorize: function(jqXHR, requestOptions) {
+        var authToken = this.get('session.auth_token');
+        var authEmail = this.get('session.auth_email');
+        if (this.get('session.isAuthenticated') && !Ember.isEmpty(authToken) && !Ember.isEmpty(authEmail)) {
+          if (!Ember.SimpleAuth.Utils.isSecureUrl(requestOptions.url)) {
+            Ember.Logger.warn('Credentials are transmitted via an insecure connection - use HTTPS to keep them secure.');
+          }
+          jqXHR.setRequestHeader('auth-token', authToken);
+          jqXHR.setRequestHeader('auth-email', authEmail);
+        }
+      }
+    });
+
+    __exports__.Devise = Devise;
+  });
+var devise = requireModule('ember-simple-auth-devise');
+
+global.Ember.SimpleAuth.Authenticators.Devise = devise.Authenticator;
+global.Ember.SimpleAuth.Authorizers.Devise    = devise.Authorizer;
+
+global.Ember.SimpleAuth.initializeExtension(function(container, application, options) {
+  container.register('authorizer:devise', global.Ember.SimpleAuth.Authorizers.Devise);
+  container.register('authenticator:devise', global.Ember.SimpleAuth.Authenticators.Devise);
+});
+})((typeof global !== 'undefined') ? global : window);