authem 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c768903ff4928e45f93a0df8fa1620a9485a8078
-  data.tar.gz: 2b9dca77151effe7aa26791163305660d31434bf
+  metadata.gz: 7d89fb3efe1897f6405ff311cc4041995c47b87c
+  data.tar.gz: 55af0e6279f7222c79453826a938844d06fdff59
 SHA512:
-  metadata.gz: cb8715fe07acad644f4784a006b80d308766811b6a9918b4ad3632a2bf6d491750e3941553afbd8001a396bfeb9a7b8db87e0f46cb81be72a005097635559c12
-  data.tar.gz: 6bd3bb132620135a416ddbe9202353ae9fd732d049843eb37b0b79b6bdfd425c3da0176f4e429868dc92e9d6bfa4583d29b829966aeb63bd21d47bd21d0cf621
+  metadata.gz: 1edf72a5c758c9feb280ac87a6edff176d9aebcd49951a72d7f25c7aa26dbfdf3ca516a382ffec2c5d071587780c2943823b7c5a3ee239d84826b4806f3143a0
+  data.tar.gz: 9892818aec6d3b5cd73e06cc2bb3648240a1ec418ae5545e52ddc37434fa242dee28b574db96c294775f028e20b905d927240b3ccda815a3afb5e30e1c5fd810

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+### 2.1.0 ###
+
+* Rails 5 compatibility
+
+### 2.0.2 ###
+
+* Signing up resets CSRF token [[PR](https://github.com/paulelliott/authem/pull/27)]
+
+### 2.0.1 ###
+
+* Add JRuby support
+
 ### 2.0.0 ###
 
 * Complete rewrite from scratch

data/{README.markdown → README.md}

@@ -6,7 +6,7 @@ Authem is an email-based authentication library for ruby web apps.
 
 ## Compatibility
 
-Authem requires Ruby 2.0.0 or newer
+Authem requires Ruby 1.9.3 or newer
 
 [![Build Status](https://secure.travis-ci.org/paulelliott/authem.png)](http://travis-ci.org/paulelliott/authem)
 [![Code Climate](https://codeclimate.com/github/paulelliott/authem.png)](https://codeclimate.com/github/paulelliott/authem)

data/lib/authem.rb

@@ -1,6 +1,14 @@
+require "active_support/all"
 require "authem/railtie"
-require "authem/user"
 require "authem/version"
 
 module Authem
+  autoload :Controller,         "authem/controller"
+  autoload :Role,               "authem/role"
+  autoload :Session,            "authem/session"
+  autoload :Support,            "authem/support"
+  autoload :Token,              "authem/token"
+  autoload :User,               "authem/user"
+  autoload :AmbigousRoleError,  "authem/errors/ambigous_role"
+  autoload :UnknownRoleError,   "authem/errors/unknown_role"
 end

data/lib/authem/controller.rb

@@ -1,6 +1,3 @@
-require "active_support/concern"
-require "authem/role"
-
 module Authem
   module Controller
     extend ActiveSupport::Concern
@@ -10,6 +7,7 @@ module Authem
     module SessionManagementMethods
       def sign_in(model, options={})
         role = options.fetch(:as){ self.class.authem_role_for(model) }
+        session.delete :_csrf_token if session.respond_to?(:delete)
         public_send "sign_in_#{role}", model, options
       end
 

data/lib/authem/railtie.rb

@@ -1,4 +1,3 @@
-require "authem/controller"
 require "rails/railtie"
 
 module Authem

data/lib/authem/role.rb

@@ -1,10 +1,8 @@
-require "authem/support"
-
 module Authem
   class Role
     attr_reader :controller, :name, :options
 
-    METHODS = %w[current sign_in signed_in? require sign_out clear_for deny_access].map(&:to_sym)
+    METHODS = %w[current sign_in signed_in? require_role sign_out clear_for deny_access].map(&:to_sym)
 
     METHODS.each do |method_name|
       define_method method_name do |controller, *args|

data/lib/authem/session.rb

@@ -1,5 +1,4 @@
 require "active_record"
-require "authem/token"
 
 module Authem
   class Session < ::ActiveRecord::Base

data/lib/authem/support.rb

@@ -1,8 +1,3 @@
-require "active_support/core_ext/module/delegation"
-require "authem/session"
-require "authem/errors/ambigous_role"
-require "authem/errors/unknown_role"
-
 module Authem
   class Support
     attr_reader :role, :controller
@@ -15,7 +10,7 @@ module Authem
       if ivar_defined?
         ivar_get
       else
-        ivar_set fetch_subject_by_token
+        ivar_set(fetch_subject_by_token)
       end
     end
 
@@ -45,7 +40,7 @@ module Authem
       Authem::Session.by_subject(record).where(role: role_name).delete_all
     end
 
-    def require
+    def require_role
       unless signed_in?
         session[:return_to_url] = request.url unless request.xhr?
         controller.send "deny_#{role_name}_access"
@@ -87,12 +82,11 @@ module Authem
     end
 
     def save_cookie(auth_session)
-      cookie_value = {
+      cookies.signed[key] = {
         value:   auth_session.token,
         expires: auth_session.expires_at,
         domain:  :all
       }
-      cookies.signed[key] = cookie_value
     end
 
     def get_auth_session_by_token(token)

data/lib/authem/user.rb

@@ -1,5 +1,3 @@
-require "authem/token"
-
 module Authem
   module User
     extend ActiveSupport::Concern

data/lib/authem/version.rb

@@ -1,3 +1,3 @@
 module Authem
-  VERSION = "2.0.1".freeze
+  VERSION = "2.1.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: authem
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Paul Elliott
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2016-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -29,14 +29,14 @@ dependencies:
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
@@ -61,20 +61,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".ruby-gemset"
-- ".ruby-version"
-- ".travis.yml"
-- Appraisals
 - CHANGELOG.md
-- Gemfile
 - LICENSE
-- README.markdown
-- Rakefile
-- authem.gemspec
-- gemfiles/rails_4.0.gemfile
-- gemfiles/rails_4.1.gemfile
+- README.md
 - lib/authem.rb
 - lib/authem/controller.rb
 - lib/authem/errors/ambigous_role.rb
@@ -91,14 +80,6 @@ files:
 - lib/generators/authem/user/templates/create_table_migration.rb
 - lib/generators/authem/user/templates/model.rb
 - lib/generators/authem/user/user_generator.rb
-- spec/controller_spec.rb
-- spec/session_spec.rb
-- spec/spec_helper.rb
-- spec/support/active_record.rb
-- spec/support/i18n.rb
-- spec/support/time.rb
-- spec/token_spec.rb
-- spec/user_spec.rb
 homepage: https://github.com/paulelliott/authem
 licenses:
 - MIT
@@ -119,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Authem authenticates them by email

data/.gitignore

@@ -1,3 +0,0 @@
-pkg
-Gemfile.lock
-gemfiles/*.lock

data/.rspec

@@ -1,2 +0,0 @@
---colour
---format progress

data/.ruby-gemset

@@ -1 +0,0 @@
-authem

data/.ruby-version

@@ -1 +0,0 @@
-ruby-2.1.3

data/.travis.yml

@@ -1,8 +0,0 @@
-gemfile:
-  - gemfiles/rails_4.0.gemfile
-  - gemfiles/rails_4.1.gemfile
-rvm:
-  - jruby-19mode
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1

data/Appraisals

@@ -1,12 +0,0 @@
-appraise "rails-4.1" do
-  gem "activerecord", "~> 4.1.0", require: "active_record"
-  gem "bcrypt", "~> 3.1"
-  gem "railties", "~> 4.0"
-end
-
-appraise "rails-4.0" do
-  gem "activerecord", "~> 4.0.0", require: "active_record"
-  gem "bcrypt", "~> 3.1"
-  gem "railties", "~> 4.0"
-  gem "protected_attributes"
-end

data/Gemfile

@@ -1,11 +0,0 @@
-source "https://rubygems.org"
-
-gem "appraisal"
-
-group :test do
-  gem "rspec", "~> 3.0"
-  gem "rake",  "~> 10.3"
-  gem "sqlite3", platform: :ruby
-  gem "activerecord-jdbcsqlite3-adapter", platform: :jruby
-  gem "pry"
-end

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/setup"
-require "bundler/gem_tasks"
-
-if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
-  require "appraisal/task"
-  Appraisal::Task.new
-  task default: :appraisal
-else
-  require "rspec/core/rake_task"
-  RSpec::Core::RakeTask.new
-  task default: :spec
-end

data/authem.gemspec

@@ -1,25 +0,0 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'authem/version'
-
-Gem::Specification.new do |spec|
-  spec.name                  = "authem"
-  spec.version               = Authem::VERSION
-  spec.authors               = ["Paul Elliott", "Pavel Pravosud"]
-  spec.email                 = ["paul@codingfrontier.com", "pavel@pravosud.com"]
-  spec.summary               = "Authem authenticates them by email"
-  spec.description           = "Authem provides a simple solution for email-based authentication"
-  spec.homepage              = "https://github.com/paulelliott/authem"
-  spec.license               = "MIT"
-
-  spec.required_ruby_version = ">= 1.9.3"
-
-  spec.files                 = `git ls-files`.split($/)
-  spec.test_files            = spec.files.grep("spec")
-  spec.require_path          = "lib"
-
-  spec.add_dependency "activesupport",  ">= 4.0.4"
-  spec.add_dependency "railties",       "~> 4.0"
-  spec.add_dependency "bcrypt",         "~> 3.1"
-end

data/gemfiles/rails_4.0.gemfile

@@ -1,17 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "appraisal"
-gem "activerecord", "~> 4.0.0", :require => "active_record"
-gem "bcrypt", "~> 3.1"
-gem "railties", "~> 4.0"
-gem "protected_attributes"
-
-group :test do
-  gem "rspec", "~> 3.0"
-  gem "rake", "~> 10.3"
-  gem "sqlite3", :platform => :ruby
-  gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
-  gem "pry"
-end

data/gemfiles/rails_4.1.gemfile

@@ -1,16 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "appraisal"
-gem "activerecord", "~> 4.1.0", :require => "active_record"
-gem "bcrypt", "~> 3.1"
-gem "railties", "~> 4.0"
-
-group :test do
-  gem "rspec", "~> 3.0"
-  gem "rake", "~> 10.3"
-  gem "sqlite3", :platform => :ruby
-  gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
-  gem "pry"
-end

data/spec/controller_spec.rb

@@ -1,413 +0,0 @@
-require "spec_helper"
-
-describe Authem::Controller do
-  class User < ActiveRecord::Base
-    self.table_name = :users
-  end
-
-  module MyNamespace
-    class SuperUser < ActiveRecord::Base
-      self.table_name = :users
-    end
-  end
-
-  class BaseController
-    include Authem::Controller
-
-    class << self
-      def helper_methods_list
-        @helper_methods_list ||= []
-      end
-
-      def helper_method(*methods)
-        helper_methods_list.concat methods
-      end
-    end
-
-    def clear_session!
-      session.clear
-    end
-
-    def reloaded
-      original_session, original_cookies = session, cookies
-
-      self.class.new.tap do |controller|
-        controller.class_eval do
-          define_method(:session){ original_session }
-          define_method(:cookies){ original_cookies }
-        end
-      end
-    end
-
-    private
-
-    def session
-      @_session ||= HashWithIndifferentAccess.new
-    end
-
-    def cookies
-      @_cookies ||= Cookies.new
-    end
-  end
-
-  class Cookies < HashWithIndifferentAccess
-    attr_reader :expires_at
-
-    def permanent
-      self
-    end
-
-    alias_method :signed, :permanent
-
-    def []=(key, value)
-      if value.kind_of?(Hash) && value.key?(:expires)
-        @expires_at = value[:expires]
-        super key, value.fetch(:value)
-      else
-        super
-      end
-    end
-
-    def delete(key, *)
-      super key
-    end
-  end
-
-  def build_controller
-    controller_klass.new
-  end
-
-  let(:controller){ build_controller.tap{ |c| allow(c).to receive(:request){ request }}}
-  let(:view_helpers){ controller_klass.helper_methods_list }
-  let(:cookies){ controller.send(:cookies) }
-  let(:session){ controller.send(:session) }
-  let(:reloaded_controller){ controller.reloaded }
-  let(:request_url){ "http://example.com/foo" }
-  let(:request){ double("Request", url: request_url, xhr?: false) }
-
-  context "with one role" do
-    let(:user){ User.create(email: "joe@example.com") }
-    let(:controller_klass){ Class.new(BaseController){ authem_for :user }}
-
-    it "has current_user method" do
-      expect(controller).to respond_to(:current_user)
-    end
-
-    it "has sign_in_user method" do
-      expect(controller).to respond_to(:sign_in_user)
-    end
-
-    it "has clear_all_user_sessions_for method" do
-      expect(controller).to respond_to(:clear_all_user_sessions_for)
-    end
-
-    it "has require_user method" do
-      expect(controller).to respond_to(:require_user)
-    end
-
-    it "has user_signed_in? method" do
-      expect(controller).to respond_to(:user_signed_in?)
-    end
-
-    it "has redirect_back_or_to method" do
-      expect(controller).to respond_to(:redirect_back_or_to)
-    end
-
-    it "can clear all sessions using clear_all_sessions method" do
-      expect(controller).to receive(:clear_all_user_sessions_for).with(user)
-      controller.clear_all_sessions_for user
-    end
-
-    it "defines view helpers" do
-      expect(view_helpers).to include(:current_user)
-      expect(view_helpers).to include(:user_signed_in?)
-    end
-
-    it "raises error when calling clear_all_sessions_for with nil" do
-      expect{ controller.clear_all_sessions_for nil }.to raise_error(ArgumentError)
-      expect{ controller.clear_all_user_sessions_for nil }.to raise_error(ArgumentError)
-    end
-
-    it "can sign in user using sign_in_user method" do
-      controller.sign_in_user user
-      expect(controller.current_user).to eq(user)
-      expect(reloaded_controller.current_user).to eq(user)
-    end
-
-    it "can show status of current session with user_signed_in? method" do
-      expect{ controller.sign_in user }.to change(controller, :user_signed_in?).from(false).to(true)
-      expect{ controller.sign_out user }.to change(controller, :user_signed_in?).from(true).to(false)
-    end
-
-    it "can store session token in a cookie when :remember option is used" do
-      expect{ controller.sign_in user, remember: true }.to change(cookies, :size).by(1)
-    end
-
-    it "throws NotImplementedError when require strategy is not defined" do
-      message = "No strategy for require_user defined. Please define `deny_user_access` method in your controller"
-      expect{ controller.require_user }.to raise_error(NotImplementedError, message)
-    end
-
-    it "can require authenticated user with require_user method" do
-      def controller.deny_user_access; redirect_to :custom_path; end
-      expect(controller).to receive(:redirect_to).with(:custom_path)
-      expect{ controller.require_user }.to change{ session[:return_to_url] }.from(nil).to(request_url)
-    end
-
-    it "sets cookie expiration date when :remember options is used" do
-      controller.sign_in user, remember: true, ttl: 1.week
-      expect(cookies.expires_at).to be_within(1.second).of(1.week.from_now)
-    end
-
-    it "can restore user from cookie when session is lost" do
-      controller.sign_in user, remember: true
-      controller.clear_session!
-      expect(controller.reloaded.current_user).to eq(user)
-    end
-
-    it "does not use cookies by default" do
-      expect{ controller.sign_in user }.not_to change(cookies, :size)
-    end
-
-    it "returns session object on sign in" do
-      result = controller.sign_in_user(user)
-      expect(result).to be_kind_of(::Authem::Session)
-    end
-
-    it "allows to specify ttl using sign_in_user with ttl option" do
-      session = controller.sign_in_user(user, ttl: 40.minutes)
-      expect(session.ttl).to eq(40.minutes)
-    end
-
-    it "forgets user after session has expired" do
-      session = controller.sign_in(user)
-      session.update_column :expires_at, 1.minute.ago
-      expect(reloaded_controller.current_user).to be_nil
-    end
-
-    it "renews session ttl each time it is used" do
-      session = controller.sign_in(user, ttl: 1.day)
-      session.update_column :expires_at, 1.minute.from_now
-      reloaded_controller.current_user
-      expect(session.reload.expires_at).to be_within(1.second).of(1.day.from_now)
-    end
-
-    it "renews cookie expiration date each time it is used" do
-      session = controller.sign_in(user, ttl: 1.day, remember: true)
-      session.update_column :ttl, 30.days
-      reloaded_controller.current_user
-      expect(cookies.expires_at).to be_within(1.second).of(30.days.from_now)
-    end
-
-    it "can sign in using sign_in method" do
-      expect(controller).to receive(:sign_in_user).with(user, {})
-      controller.sign_in user
-    end
-
-    it "allows to specify ttl using sign_in method with ttl option" do
-      session = controller.sign_in(user, ttl: 40.minutes)
-      expect(session.ttl).to eq(40.minutes)
-    end
-
-    it "raises an error when trying to sign in unknown model" do
-      model = MyNamespace::SuperUser.create(email: "admin@example.com")
-      message = "Unknown authem role: #{model.inspect}"
-      expect{ controller.sign_in model }.to raise_error(Authem::UnknownRoleError, message)
-    end
-
-    it "raises an error when trying to sign in nil" do
-      expect{ controller.sign_in nil }.to raise_error(ArgumentError)
-      expect{ controller.sign_in_user nil }.to raise_error(ArgumentError)
-    end
-
-    it "has sign_out_user method" do
-      expect(controller).to respond_to(:sign_out_user)
-    end
-
-    context "when user is signed in" do
-      let(:sign_in_options){ Hash.new }
-
-      before do
-        controller.sign_in user, sign_in_options
-        expect(controller.current_user).to eq(user)
-      end
-
-      after do
-        expect(controller.current_user).to be_nil
-        expect(reloaded_controller.current_user).to be_nil
-      end
-
-      it "can sign out using sign_out_user method" do
-        controller.sign_out_user
-      end
-
-      it "can sign out using sign_out method" do
-        controller.sign_out user
-      end
-
-      context "with cookies" do
-        let(:sign_in_options){{ remember: true }}
-
-        after{ expect(cookies).to be_empty }
-
-        it "removes session token from cookies on sign out" do
-          controller.sign_out_user
-        end
-      end
-    end
-
-    context "with multiple sessions across devices" do
-      let(:first_device){ controller }
-      let(:second_device){ build_controller }
-
-      before do
-        first_device.sign_in user
-        second_device.sign_in user
-      end
-
-      it "signs out all currently active sessions on all devices" do
-        expect{ first_device.clear_all_user_sessions_for user }.to change(Authem::Session, :count).by(-2)
-        expect(second_device.reloaded.current_user).to be_nil
-      end
-    end
-
-    it "raises an error when calling sign_out with nil" do
-      expect{ controller.sign_out nil }.to raise_error(ArgumentError)
-    end
-
-    it "persists session in database" do
-      expect{ controller.sign_in user }.to change(Authem::Session, :count).by(1)
-    end
-
-    it "removes database session on sign out" do
-      controller.sign_in user
-      expect{ controller.sign_out user }.to change(Authem::Session, :count).by(-1)
-    end
-  end
-
-  context "with multiple roles" do
-    let(:admin){ MyNamespace::SuperUser.create(email: "admin@example.com") }
-    let(:controller_klass) do
-      Class.new(BaseController) do
-        authem_for :user
-        authem_for :admin, model: MyNamespace::SuperUser
-      end
-    end
-
-    it "has current_admin method" do
-      expect(controller).to respond_to(:current_admin)
-    end
-
-    it "has sign_in_admin method" do
-      expect(controller).to respond_to(:sign_in_admin)
-    end
-
-    it "can sign in admin using sign_in_admin method" do
-      controller.sign_in_admin admin
-      expect(controller.current_admin).to eq(admin)
-      expect(reloaded_controller.current_admin).to eq(admin)
-    end
-
-    it "can sign in using sign_in method" do
-      expect(controller).to receive(:sign_in_admin).with(admin, {})
-      controller.sign_in admin
-    end
-
-    context "with signed in user and admin" do
-      let(:user){ User.create(email: "joe@example.com") }
-
-      before do
-        controller.sign_in_user user
-        controller.sign_in_admin admin
-      end
-
-      after do
-        expect(controller.current_admin).to eq(admin)
-        expect(reloaded_controller.current_admin).to eq(admin)
-      end
-
-      it "can sign out user separately from admin using sign_out_user" do
-        controller.sign_out_user
-      end
-
-      it "can sign out user separately from admin using sign_out" do
-        controller.sign_out user
-      end
-    end
-  end
-
-  context "multiple roles with same model class" do
-    let(:user){ User.create(email: "joe@example.com") }
-    let(:customer){ User.create(email: "shmoe@example.com") }
-    let(:controller_klass) do
-      Class.new(BaseController) do
-        authem_for :user
-        authem_for :customer, model: User
-      end
-    end
-
-    it "can sign in user separately from customer" do
-      controller.sign_in_user user
-      expect(controller.current_user).to eq(user)
-      expect(controller.current_customer).to be_nil
-      expect(reloaded_controller.current_user).to eq(user)
-      expect(reloaded_controller.current_customer).to be_nil
-    end
-
-    it "can sign in customer and user separately" do
-      controller.sign_in_user user
-      controller.sign_in_customer customer
-      expect(controller.current_user).to eq(user)
-      expect(controller.current_customer).to eq(customer)
-      expect(reloaded_controller.current_user).to eq(user)
-      expect(reloaded_controller.current_customer).to eq(customer)
-    end
-
-    it "raises the error when sign in can't guess the model properly" do
-      message = "Ambigous match for #{user.inspect}: user, customer"
-      expect{ controller.sign_in user }.to raise_error(Authem::AmbigousRoleError, message)
-    end
-
-    it "allows to specify role with special :as option" do
-      expect(controller).to receive(:sign_in_customer).with(user, as: :customer)
-      controller.sign_in user, as: :customer
-    end
-
-    it "raises the error when sign out can't guess the model properly" do
-      message = "Ambigous match for #{user.inspect}: user, customer"
-      expect{ controller.sign_out user }.to raise_error(Authem::AmbigousRoleError, message)
-    end
-  end
-
-  context "redirect after authentication" do
-    let(:controller_klass){ Class.new(BaseController){ authem_for :user }}
-
-    context "with saved url" do
-      before{ session[:return_to_url] = :my_url }
-
-      it "redirects back to saved url if it's available" do
-        expect(controller).to receive(:redirect_to).with(:my_url, notice: "foo")
-        controller.redirect_back_or_to :root, notice: "foo"
-      end
-
-      it "removes values from session after successful redirect" do
-        expect(controller).to receive(:redirect_to).with(:my_url, {})
-        expect{ controller.redirect_back_or_to :root }.to change{ session[:return_to_url] }.from(:my_url).to(nil)
-      end
-    end
-
-    it "redirects to specified url if there is no saved value" do
-      expect(controller).to receive(:redirect_to).with(:root, notice: "foo")
-      controller.redirect_back_or_to :root, notice: "foo"
-    end
-  end
-
-  context "when defining authem" do
-    it "settings do not propagate to parent controller" do
-      parent_klass = Class.new(BaseController){ authem_for :user }
-      child_klass = Class.new(parent_klass){ authem_for :member }
-      expect(child_klass.authem_roles.size).to eq(2)
-      expect(parent_klass.authem_roles.size).to eq(1)
-    end
-  end
-end

data/spec/session_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Authem::Session do
-  class User < ActiveRecord::Base
-    self.table_name = :users
-  end
-
-  let(:user){ User.create(email: "joe@example.com") }
-  let(:role){ :user }
-
-  it "generates secure token on creation" do
-    expect(Authem::Token).to receive(:generate).and_return("a secure token")
-    model = described_class.create(role: role, subject: user)
-    expect(model.token).to eq("a secure token")
-  end
-
-  it "set expires_at attribute according to ttl" do
-    model = described_class.create(role: role, subject: user, ttl: 30.minutes)
-    expect(model.expires_at).to be_within(1.second).of(30.minutes.from_now)
-  end
-
-  it "uses default ttl if value is not provided" do
-    model = described_class.create(role: role, subject: user)
-    expect(model.expires_at).to be_within(1.second).of(30.days.from_now)
-  end
-
-  context "scopes" do
-    def create_session_with_expiration(expires_at)
-      described_class.create(
-        role:       role,
-        subject:    user,
-        expires_at: expires_at
-      )
-    end
-
-    let!(:expired_session){ create_session_with_expiration(1.day.ago) }
-    let!(:active_session){ create_session_with_expiration(1.week.from_now) }
-    let(:active_scope){ described_class.active }
-    let(:expired_scope){ described_class.expired }
-
-    specify ".active filters out expired sessions" do
-      expect(active_scope).to include(active_session)
-      expect(active_scope).not_to include(expired_session)
-    end
-
-    specify ".expired filters out active sessions" do
-      expect(expired_scope).to include(expired_session)
-      expect(expired_scope).not_to include(active_session)
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,4 +0,0 @@
-require "bundler/setup"
-require "authem"
-
-Dir[File.expand_path("../support/**/*.rb", __FILE__)].each(&method(:require))

data/spec/support/active_record.rb

@@ -1,45 +0,0 @@
-require "active_record"
-
-ActiveRecord::Migration.verbose = false
-
-ActiveRecord::Base.establish_connection(
-  adapter:  "sqlite3",
-  database: ":memory:"
-)
-
-class CreateUsersMigration < ActiveRecord::Migration
-  def up
-    create_table :users do |t|
-      t.string :email
-      t.string :password_digest
-      t.string :password_reset_token
-    end
-  end
-end
-
-class CreateSessionsMigration < ActiveRecord::Migration
-  def up
-    create_table :authem_sessions do |t|
-      t.string     :role,       null: false
-      t.references :subject,    null: false, polymorphic: true
-      t.string     :token,      null: false
-      t.datetime   :expires_at, null: false
-      t.integer    :ttl,        null: false
-      t.timestamps
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.before :suite do
-    CreateUsersMigration.new.up
-    CreateSessionsMigration.new.up
-  end
-
-  config.around do |example|
-    ActiveRecord::Base.transaction do
-      example.run
-      raise ActiveRecord::Rollback
-    end
-  end
-end

data/spec/support/i18n.rb

@@ -1 +0,0 @@
-I18n.enforce_available_locales = false

data/spec/support/time.rb

@@ -1 +0,0 @@
-Time.zone_default = ActiveSupport::TimeZone["UTC"]

data/spec/token_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe Authem::Token do
-  context ".generate" do
-    subject{ described_class.generate }
-    it "generates a secure token 60 chars long" do
-      expect(subject.length).to eq(60)
-    end
-  end
-end

data/spec/user_spec.rb

@@ -1,116 +0,0 @@
-require "spec_helper"
-
-describe Authem::User do
-
-  class TestUser < ActiveRecord::Base
-    self.table_name = :users
-    include Authem::User
-
-
-    def self.create(opts={})
-      opts = {email: "joe@example.com", password: "password"}.merge(opts)
-      super(
-        email:                 opts[:email],
-        password:              opts[:password],
-        password_confirmation: opts[:password]
-      )
-    end
-  end
-
-  it "downcases email" do
-    record = TestUser.new
-    record.email = "JOE@EXAMPLE.COM"
-    expect(record.email).to eq("joe@example.com")
-  end
-
-  subject(:user){ TestUser.create }
-
-  context "#authenticate" do
-    it "returns record if password is correct" do
-      expect(user.authenticate("password")).to eq(user)
-    end
-
-    it "returns false if password is incorrect" do
-      expect(user.authenticate("notright")).to be_falsy
-    end
-
-    it "returns false if password is nil" do
-      expect(user.authenticate(nil)).to be_falsy
-    end
-  end
-
-  context "#password_reset_token" do
-    it "generates token on record creation" do
-      expect(user.password_reset_token).to be_present
-    end
-  end
-
-  context "#reset_password" do
-    it "changes the password if on successful update" do
-      expect{ user.reset_password "123", "123" }.to change{ user.reload.password_digest }
-    end
-
-    it "regenerates password reset token on successful update" do
-      expect{ user.reset_password "123", "123" }.to change{ user.reload.password_reset_token }
-    end
-
-    it "does not change password on error" do
-      expect{ user.reset_password "123", "321" }.not_to change{ user.reload.password_digest }
-      expect{ user.reset_password "123", "" }.not_to change{ user.reload.password_digest }
-      expect{ user.reset_password nil, "321" }.not_to change{ user.reload.password_digest }
-      expect{ user.reset_password nil, nil }.not_to change{ user.reload.password_digest }
-    end
-
-    it "does not change password reset token on error" do
-      expect{ user.reset_password "123", "321" }.not_to change{ user.reload.password_reset_token }
-      expect{ user.reset_password "123", "" }.not_to change{ user.reload.password_reset_token }
-      expect{ user.reset_password nil, "321" }.not_to change{ user.reload.password_reset_token }
-      expect{ user.reset_password nil, nil }.not_to change{ user.reload.password_reset_token }
-    end
-
-    it "returns true if when password change is successful" do
-      expect(user.reset_password("123", "123")).to be_truthy
-    end
-
-    it "returns false when confirmation does not match" do
-      expect(user.reset_password("123", "321")).to be_falsy
-    end
-
-    it "adds an error when confirmation does not match" do
-      user.reset_password("123", "321")
-      expect(user.errors).to include(:password_confirmation)
-    end
-
-    it "adds and error when password is blank" do
-      user.reset_password(nil, "")
-      expect(user.errors).to include(:password)
-    end
-
-    it "returns false when password is blank" do
-      expect(user.reset_password("", "")).to be_falsy
-    end
-  end
-
-  context "validations" do
-    it "allows properly formatted emails" do
-      record = TestUser.create(email: "joe@example.com")
-      expect(record.errors).not_to include(:email)
-    end
-
-    it "validates email presence" do
-      record = TestUser.create(email: nil)
-      expect(record.errors).to include(:email)
-    end
-
-    it "validates email format" do
-      record = TestUser.create(email: "joe-at-example-com")
-      expect(record.errors).to include(:email)
-    end
-
-    it "validates email uniqueness" do
-      TestUser.create email: "joe@example.com"
-      record = TestUser.create(email: "JOE@EXAMPLE.COM")
-      expect(record.errors).to include(:email)
-    end
-  end
-end