authpwn_rails 0.12.1 → 0.13.0

data/Gemfile.lock

@@ -47,11 +47,11 @@ GEM
       json (>= 1.6.1)
       oauth2 (>= 0.5.0)
       rails (>= 3.1.0)
-    flexmock (1.0.3)
+    flexmock (1.0.4)
     git (1.2.5)
     hashie (1.2.0)
     hike (1.2.1)
-    httpauth (0.1)
+    httpauth (0.2.0)
     i18n (0.6.1)
     jeweler (1.8.4)
       bundler (~> 1.0)
@@ -83,7 +83,7 @@ GEM
       rack (>= 0.4)
     rack-ssl (1.3.2)
       rack
-    rack-test (0.6.1)
+    rack-test (0.6.2)
       rack (>= 1.0)
     rails (3.2.8)
       actionmailer (= 3.2.8)
@@ -106,10 +106,10 @@ GEM
       json (~> 1.4)
     rest-client (1.6.7)
       mime-types (>= 1.16)
-    simplecov (0.6.4)
+    simplecov (0.7.1)
       multi_json (~> 1.0)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
     sprockets (2.1.3)
       hike (~> 1.2)
       rack (~> 1.0)
@@ -117,7 +117,7 @@ GEM
     sqlite3 (1.3.6)
     thor (0.16.0)
     tilt (1.3.3)
-    treetop (1.4.10)
+    treetop (1.4.11)
       polyglot
       polyglot (>= 0.3.1)
     tzinfo (0.3.33)

data/VERSION

@@ -1 +1 @@
-0.12.1
+0.13.0

data/app/models/{credentials/token.rb → tokens/base.rb}

@@ -15,12 +15,12 @@ unless SecureRandom.respond_to? :urlsafe_base64
 end
 
 # :namespace
-module Credentials
+module Tokens
 
-# Associates a secret token code with the account.
+# Credential that associates a secret token code with the account.
 #
 # Subclasses of this class are in the tokens namespace.
-class Token < ::Credential
+class Base < ::Credential
   # The secret token code.
   alias_attribute :code, :name
   # Token names are random, so we can expect they'll be unique across the
@@ -41,11 +41,11 @@ class Token < ::Credential
   # Returns the authenticated User instance, or a symbol indicating the reason
   # why the (potentially valid) token code was rejected.
   def self.authenticate(code)
-    credential = self.with_code code
+    credential = self.with_code(code).first
     credential ? credential.authenticate : :invalid
   end
 
-  # The token matching a secret code.
+  # Scope that uses a secret code.
   def self.with_code(code)
     # NOTE 1: The where query must be performed off the root type, otherwise
     #         Rails will try to guess the right values for the 'type' column,
@@ -54,13 +54,8 @@ class Token < ::Credential
     #         (e.g., email or Facebook OAuth token) will be required, so we
     #         pre-fetch them.
     credential = Credential.where(:name => code).
-                            includes(:user => :credentials).first
-
-    if credential.is_a? Credentials::Token
-      credential
-    else
-      nil
-    end
+        where(Credential.arel_table[:type].matches('Tokens::%')).
+        includes(:user => :credentials)
   end
 
   # Authenticates a user using this token.
@@ -97,7 +92,7 @@ class Token < ::Credential
   # @param [String] key data associated with the token
   # @param [Class] klass the ActiveRecord class that will be instantiated;
   #     it should be a subclass of Token
-  # @return [Credentials::Token] a newly created and saved token with a random
+  # @return [Tokens::Base] a newly created and saved token with a random
   #     code
   def self.random_for(user, key = nil, klass = nil)
     klass ||= self
@@ -120,9 +115,14 @@ class Token < ::Credential
   def to_param
     code
   end
-  class <<self
-    alias_method :find_by_param, :with_code
+
+  # Scope using the value returned by Token#to_param.
+  #
+  # @param [String] param value returned by Token#to_param
+  # @return [ActiveRecord::Relation]
+  def self.with_param(param)
+    where(:name => param)
   end
-end  # class Credentials::Token
+end  # class Tokens::Base
 
-end  # namespace Credentials
+end  # namespace Tokens

data/app/models/tokens/email_verification.rb

@@ -2,7 +2,7 @@
 module Tokens
 
 # A token that verifies the user's ownership of their e-mail address.
-class EmailVerification < OneTime
+class EmailVerification < Tokens::OneTime
   # The e-mail address verified by this token.
   #
   # Note that it's useful to keep track of the exact e-mail address that the

data/app/models/tokens/one_time.rb

@@ -1,8 +1,8 @@
 # :namespace
 module Tokens
-  
+
 # One-time tokens can only be used once to authenticate an account.
-class OneTime < Credentials::Token
+class OneTime < Tokens::Base
   # Updates the token's state to reflect that it was used for authentication.
   #
   # One-time tokens become invalid after they are spent.

data/app/models/tokens/password_reset.rb

@@ -2,7 +2,7 @@
 module Tokens
 
 # Lets the user to change their password without knowing the old one.
-class PasswordReset < OneTime
+class PasswordReset < Tokens::OneTime
   # Decent compromise between convenience and security.
   self.expires_after = 3.days
 

data/app/models/tokens/session_uid.rb

@@ -1,7 +1,7 @@
 # :namespace
 module Tokens
 
-class SessionUid < Credentials::Token
+class SessionUid < Tokens::Base
   # The session UID.
   alias_attribute :suid, :name
 

data/authpwn_rails.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "authpwn_rails"
-  s.version = "0.12.1"
+  s.version = "0.13.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Victor Costan"]
-  s.date = "2012-10-05"
+  s.date = "2012-10-13"
   s.description = "Works with Facebook."
   s.email = "victor@costan.us"
   s.extra_rdoc_files = [
@@ -30,7 +30,7 @@ Gem::Specification.new do |s|
     "app/models/credentials/email.rb",
     "app/models/credentials/facebook.rb",
     "app/models/credentials/password.rb",
-    "app/models/credentials/token.rb",
+    "app/models/tokens/base.rb",
     "app/models/tokens/email_verification.rb",
     "app/models/tokens/one_time.rb",
     "app/models/tokens/password_reset.rb",

data/lib/authpwn_rails/generators/templates/credentials.yml

@@ -35,8 +35,8 @@ john_facebook:
 
 jane_token:
   user: jane
-  type: Credentials::Token
-  name: "6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c"
+  type: Tokens::Base
+  name: 6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c
 
 john_token:
   user: john

data/lib/authpwn_rails/generators/templates/session_controller_test.rb

@@ -23,7 +23,7 @@ class SessionControllerTest < ActionController::TestCase
     post :create, :email => @email_credential.email, :password => 'password'
     assert_equal @user, session_current_user, 'session'
     assert_redirected_to session_url
-    assert_nil Credentials::Token.with_code(old_token.code),
+    assert_nil Tokens::Base.with_code(old_token.code).first,
                'old session not purged'
   end
 

data/lib/authpwn_rails/session.rb

@@ -32,7 +32,7 @@ module ControllerInstanceMethods
   def set_session_current_user(user)
     # Try to reuse existing sessions.
     if session[:authpwn_suid]
-      token = Tokens::SessionUid.with_code session[:authpwn_suid]
+      token = Tokens::SessionUid.with_code(session[:authpwn_suid]).first
       if token
         if token.user == user
           token.touch

data/lib/authpwn_rails/session_controller.rb

@@ -119,7 +119,7 @@ module SessionController
 
   # GET /session/token/token-code
   def token
-    if token = Credentials::Token.with_code(params[:code])
+    if token = Tokens::Base.with_code(params[:code]).first
       auth = token.authenticate
     else
       auth = :invalid

data/lib/authpwn_rails/test_extensions.rb

@@ -56,7 +56,7 @@ module ControllerTestExtensions
   # The authenticated user in the test session.
   def session_current_user
     return nil unless suid = request.session[:authpwn_suid]
-    Credentials::Token.with_code(suid).user
+    Tokens::Base.with_code(suid).first!.user
   end
 
   # Sets the HTTP Authentication header.

data/lib/authpwn_rails/user_model.rb

@@ -34,11 +34,20 @@ module UserModel
 
   # Class methods on models that include Authpwn::UserModel.
   module ClassMethods
+    # Scope using the value returned by User#to_param.
+    #
+    # @param [String] param value returned by User#to_param
+    # @return [ActiveRecord::Relation]
+    def with_param(param)
+      where(:exuid => param)
+    end
+
     # Queries the database using the value returned by User#to_param.
     #
-    # Returns nil if no matching User exists.
+    # @deprecated use with_param(param).first or .first! instead
+    # @return [User, nil] nil if no matching User exists.
     def find_by_param(param)
-      where(:exuid => param).first
+      with_param(param).first
     end
 
     # Authenticates a user given the information on a signup form.

data/test/cookie_controller_test.rb

@@ -75,7 +75,7 @@ class CookieControllerTest < ActionController::TestCase
     get :show
     assert_response :success
     assert_nil assigns(:current_user), 'current_user set'
-    assert_nil Credentials::Token.with_code(@token.suid),
+    assert_nil Tokens::Base.with_code(@token.suid).first,
                'session token not destroyed'
   end
 
@@ -149,7 +149,7 @@ class CookieControllerTest < ActionController::TestCase
       put :update, :exuid => @user.exuid
     end
     assert_response :success
-    assert_nil Credentials::Token.with_code(old_token.suid),
+    assert_nil Tokens::Base.with_code(old_token.suid).first,
                "old user's token not destroyed"
     assert_not_equal @token.suid, request.session[:authpwn_suid]
 

data/test/credentials/one_time_token_credential_test.rb

@@ -1,21 +1,21 @@
 require File.expand_path('../../test_helper', __FILE__)
 
-class OneTimeTokenCredentialTest < ActiveSupport::TestCase  
+class OneTimeTokenCredentialTest < ActiveSupport::TestCase
   def setup
     @credential = Tokens::OneTime.new(
         :code => 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo')
     @credential.user = users(:bill)
   end
-  
+
   test 'setup' do
     assert @credential.valid?
   end
-  
+
   test 'code required' do
     @credential.code = nil
     assert !@credential.valid?
   end
-  
+
   test 'code uniqueness' do
     @credential.code = credentials(:john_token).code
     assert !@credential.valid?
@@ -25,28 +25,28 @@ class OneTimeTokenCredentialTest < ActiveSupport::TestCase
     @credential.user = nil
     assert !@credential.valid?
   end
-  
+
   test 'spend destroys the token' do
     credential = credentials(:john_token)
     assert_equal Tokens::OneTime, credential.class, 'bad setup'
-    
+
     assert_difference 'Credential.count', -1 do
       credential.spend
     end
     assert credential.frozen?, 'not destroyed'
   end
-  
+
   test 'authenticate spends the token' do
     john = 'YZ-Fo8HX6_NyU6lVZXYi6cMDLV5eAgt35UTF5l8bD6A'
     bogus = 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo'
     assert_difference 'Credential.count', -1, 'token spent' do
-      assert_equal users(:john), Credentials::Token.authenticate(john)
+      assert_equal users(:john), Tokens::Base.authenticate(john)
     end
     assert_no_difference 'Credential.count', 'token mistakenly spent' do
-      assert_equal :invalid, Credentials::Token.authenticate(bogus)
+      assert_equal :invalid, Tokens::Base.authenticate(bogus)
     end
   end
-  
+
   test 'authenticate calls User#auth_bounce_reason' do
     john = 'YZ-Fo8HX6_NyU6lVZXYi6cMDLV5eAgt35UTF5l8bD6A'
     jane = '6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c'
@@ -54,17 +54,17 @@ class OneTimeTokenCredentialTest < ActiveSupport::TestCase
 
     with_blocked_credential credentials(:john_token), :reason do
       assert_no_difference 'Credential.count', 'no token spent' do
-        assert_equal :reason, Credentials::Token.authenticate(john)
+        assert_equal :reason, Tokens::Base.authenticate(john)
       end
     end
   end
-  
+
   test 'instance authenticate spends the token' do
     assert_difference 'Credential.count', -1, 'token spent' do
       assert_equal users(:john), credentials(:john_token).authenticate
     end
   end
-  
+
   test 'instance authenticate calls User#auth_bounce_reason' do
     with_blocked_credential credentials(:john_token), :reason do
       assert_no_difference 'Credential.count', 'token mistakenly spent' do
@@ -72,7 +72,7 @@ class OneTimeTokenCredentialTest < ActiveSupport::TestCase
       end
     end
   end
-  
+
   test 'random_for' do
     token = Tokens::OneTime.random_for users(:john)
     assert token.valid?, 'valid token'

data/test/credentials/session_uid_token_test.rb

@@ -78,8 +78,9 @@ class SessionUidTokenTest < ActiveSupport::TestCase
     assert_difference 'Credential.count', -1 do
       Tokens::SessionUid.remove_expired
     end
-    assert_nil Credentials::Token.with_code(old_token.code)
-    assert_equal fresh_token, Credentials::Token.with_code(fresh_token.code)
+    assert_nil Tokens::Base.with_code(old_token.code).first
+    assert_equal fresh_token,
+                 Tokens::Base.with_code(fresh_token.code).first
   end
 
   test 'random_for' do
@@ -88,7 +89,7 @@ class SessionUidTokenTest < ActiveSupport::TestCase
     assert_difference 'Credential.count', 1 do
       credential = Tokens::SessionUid.random_for user, '1.2.3.4', 'Test/UA'
     end
-    saved_credential = Credentials::Token.with_code credential.code
+    saved_credential = Tokens::Base.with_code(credential.code).first
     assert saved_credential, 'token was not saved'
     assert_equal saved_credential, credential, 'wrong token returned'
     assert_equal user, saved_credential.user

data/test/credentials/token_crendential_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../../test_helper', __FILE__)
 
 class TokenCredentialTest < ActiveSupport::TestCase
   def setup
-    @credential = Credentials::Token.new(
+    @credential = Tokens::Base.new(
         :code => 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo')
     @credential.user = users(:bill)
   end
@@ -28,7 +28,7 @@ class TokenCredentialTest < ActiveSupport::TestCase
 
   test 'spend does nothing' do
     credential = credentials(:jane_token)
-    assert_equal Credentials::Token, credential.class, 'bad setup'
+    assert_equal Tokens::Base, credential.class, 'bad setup'
 
     assert_no_difference 'Credential.count' do
       credential.spend
@@ -36,10 +36,10 @@ class TokenCredentialTest < ActiveSupport::TestCase
   end
 
   test 'random_for' do
-    token = Credentials::Token.random_for users(:john)
+    token = Tokens::Base.random_for users(:john)
     assert token.valid?, 'valid token'
     assert_equal users(:john), token.user
-    assert_equal Credentials::Token, token.class
+    assert_equal Tokens::Base, token.class
     assert !token.new_record?, 'saved token'
     assert_operator users(:john).credentials, :include?, token
   end
@@ -49,38 +49,46 @@ class TokenCredentialTest < ActiveSupport::TestCase
     john2 = 'bDSU4tzfjuob79e3R0ykLcOGTBBYvuBWWJ9V06tQrCE'
     jane = '6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c'
     bogus = 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo'
-    assert_equal credentials(:john_token), Credentials::Token.with_code(john)
-    assert_equal credentials(:jane_token), Credentials::Token.with_code(jane)
+    assert_equal credentials(:john_token),
+                 Tokens::Base.with_code(john).first
+    assert_equal credentials(:jane_token),
+                 Tokens::Base.with_code(jane).first!
     assert_equal credentials(:john_email_token),
-                 Credentials::Token.with_code(john2)
-    assert_nil Credentials::Token.with_code(bogus)
-    assert_nil Credentials::Token.with_code('john@gmail.com')
-    assert_nil Credentials::Token.with_code(credentials(:jane_email).name)
+                 Tokens::Base.with_code(john2).first
+    assert_nil Tokens::Base.with_code(bogus).first
+    assert_raise ActiveRecord::RecordNotFound do
+      Tokens::Base.with_code('john@gmail.com').first!
+    end
+    assert_raise ActiveRecord::RecordNotFound do
+      Tokens::Base.with_code(credentials(:jane_email).name).first!
+    end
   end
 
-  test 'find_by_param' do
-    assert_equal credentials(:john_token), Credentials::Token.
-        find_by_param(credentials(:john_token).to_param)
-    assert_equal credentials(:jane_token), Credentials::Token.
-        find_by_param(credentials(:jane_token).to_param)
-    assert_equal nil, Credentials::Token.find_by_param('bogus token')
-    assert_equal nil, Credentials::Token.find_by_param(nil)
+  test 'with_param' do
+    assert_equal credentials(:john_token), Tokens::Base.
+        with_param(credentials(:john_token).to_param).first
+    assert_equal credentials(:jane_token), Tokens::Base.
+        with_param(credentials(:jane_token).to_param).first!
+    assert_nil Tokens::Base.with_param('bogus token').first
+    assert_raise ActiveRecord::RecordNotFound do
+      Tokens::Base.with_param(nil).first!
+    end
   end
 
   test 'class authenticate' do
     john = 'YZ-Fo8HX6_NyU6lVZXYi6cMDLV5eAgt35UTF5l8bD6A'
     jane = '6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c'
     bogus = 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo'
-    assert_equal users(:john), Credentials::Token.authenticate(john)
-    assert_equal users(:jane), Credentials::Token.authenticate(jane)
-    assert_equal :invalid, Credentials::Token.authenticate(bogus)
+    assert_equal users(:john), Tokens::Base.authenticate(john)
+    assert_equal users(:jane), Tokens::Base.authenticate(jane)
+    assert_equal :invalid, Tokens::Base.authenticate(bogus)
   end
 
   test 'class authenticate on expired tokens' do
     john = 'YZ-Fo8HX6_NyU6lVZXYi6cMDLV5eAgt35UTF5l8bD6A'
     jane = '6TXe1vv7BgOw0BkJ1hzUKO6G08fLk4sVfJ3wPDZHS-c'
 
-    Credentials::Token.all.each do |token|
+    Tokens::Base.all.each do |token|
       token.updated_at = Time.now - 1.year
       flexmock(token.class).should_receive(:expires_after).zero_or_more_times.
                             and_return 1.week
@@ -88,12 +96,12 @@ class TokenCredentialTest < ActiveSupport::TestCase
     end
     assert_difference 'Credential.count', -1,
                       'authenticate deletes expired credential' do
-      assert_equal :invalid, Credentials::Token.authenticate(john),
+      assert_equal :invalid, Tokens::Base.authenticate(john),
                    'expired token'
     end
     assert_difference 'Credential.count', -1,
                       'authenticate deletes expired credential' do
-      assert_equal :invalid, Credentials::Token.authenticate(jane),
+      assert_equal :invalid, Tokens::Base.authenticate(jane),
                    'expired token'
     end
   end
@@ -104,9 +112,9 @@ class TokenCredentialTest < ActiveSupport::TestCase
     bogus = 'AyCMIixa5C7BBqU-XFI7l7IaUFJ4zQZPmcK6oNb3FLo'
 
     with_blocked_credential credentials(:john_token), :reason do
-      assert_equal :reason, Credentials::Token.authenticate(john)
-      assert_equal users(:jane), Credentials::Token.authenticate(jane)
-      assert_equal :invalid, Credentials::Token.authenticate(bogus)
+      assert_equal :reason, Tokens::Base.authenticate(john)
+      assert_equal users(:jane), Tokens::Base.authenticate(jane)
+      assert_equal :invalid, Tokens::Base.authenticate(bogus)
     end
   end
 
@@ -116,14 +124,14 @@ class TokenCredentialTest < ActiveSupport::TestCase
   end
 
   test 'instance authenticate with expired tokens' do
-    token = Credentials::Token.with_code credentials(:jane_token).code
+    token = Tokens::Base.with_code(credentials(:jane_token).code).first
     token.updated_at = Time.now - 1.year
     token.save!
     flexmock(token.class).should_receive(:expires_after).
         zero_or_more_times.and_return 1.week
     assert_equal :invalid, token.authenticate,
                  'expired token'
-    assert_nil Credentials::Token.with_code(credentials(:jane_token).code),
+    assert_nil Tokens::Base.with_code(credentials(:jane_token).code).first,
                'expired token not destroyed'
   end
 

data/test/session_controller_api_test.rb

@@ -94,7 +94,7 @@ class SessionControllerApiTest < ActionController::TestCase
     old_token.save!
     post :create, :email => @email_credential.email, :password => 'password'
     assert_equal @user, session_current_user, 'session'
-    assert_nil Credentials::Token.with_code(old_token.code),
+    assert_nil Tokens::Base.with_code(old_token.code).first,
                'old session not purged'
   end
 
@@ -105,7 +105,7 @@ class SessionControllerApiTest < ActionController::TestCase
     old_token.save!
     post :create, :email => @email_credential.email, :password => 'password'
     assert_equal @user, session_current_user, 'session'
-    assert_equal old_token, Credentials::Token.with_code(old_token.code),
+    assert_equal old_token, Tokens::Base.with_code(old_token.code).first,
                'old session purged'
   end
 
@@ -129,7 +129,7 @@ class SessionControllerApiTest < ActionController::TestCase
                   :format => 'json'
     assert_response :ok
     assert_equal @user, session_current_user, 'session'
-    assert_nil Credentials::Token.with_code(old_token.code),
+    assert_nil Tokens::Base.with_code(old_token.code).first,
                'old session not purged'
   end
 
@@ -165,7 +165,7 @@ class SessionControllerApiTest < ActionController::TestCase
     old_token.save!
     post :create, :email => @email_credential.email, :password => 'fail'
     assert_nil session_current_user, 'session'
-    assert_equal old_token, Credentials::Token.with_code(old_token.code),
+    assert_equal old_token, Tokens::Base.with_code(old_token.code).first,
                'old session purged'
   end
 
@@ -249,7 +249,7 @@ class SessionControllerApiTest < ActionController::TestCase
     assert_redirected_to session_url
     assert_equal @user, assigns(:current_user), 'instance variable'
     assert_equal @user, session_current_user, 'session'
-    assert_nil Credentials::Token.with_code(@token_credential.code),
+    assert_nil Tokens::Base.with_code(@token_credential.code).first,
                'one-time credential is spent'
   end
 
@@ -263,7 +263,7 @@ class SessionControllerApiTest < ActionController::TestCase
     assert_equal session[:_csrf_token], data['csrf']
     assert_equal @user, assigns(:current_user), 'instance variable'
     assert_equal @user, session_current_user, 'session'
-    assert_nil Credentials::Token.with_code(@token_credential.code),
+    assert_nil Tokens::Base.with_code(@token_credential.code).first,
                'one-time credential is spent'
   end
 

data/test/user_test.rb

@@ -40,6 +40,15 @@ class UserTest < ActiveSupport::TestCase
     assert_equal '56789', users(:john).to_param
   end
 
+  test 'with_param' do
+    assert_equal users(:john), User.with_param(users(:john).to_param).first
+    assert_equal users(:jane), User.with_param(users(:jane).to_param).first!
+    assert_equal nil, User.with_param('bogus id').first
+    assert_raise ActiveRecord::RecordNotFound do
+      User.with_param(nil).first!
+    end
+  end
+
   test 'find_by_param' do
     assert_equal users(:john), User.find_by_param(users(:john).to_param)
     assert_equal users(:jane), User.find_by_param(users(:jane).to_param)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: authpwn_rails
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2012-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fbgraph_rails
@@ -192,7 +192,7 @@ files:
 - app/models/credentials/email.rb
 - app/models/credentials/facebook.rb
 - app/models/credentials/password.rb
-- app/models/credentials/token.rb
+- app/models/tokens/base.rb
 - app/models/tokens/email_verification.rb
 - app/models/tokens/one_time.rb
 - app/models/tokens/password_reset.rb
@@ -285,7 +285,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4464495416488992138
+      hash: -1259066968914269566
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: