sorcery 0.6.1 → 0.7.10

data/lib/generators/sorcery_migration/sorcery_migration_generator.rb

@@ -1,24 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/migration'
-
-class SorceryMigrationGenerator < Rails::Generators::Base
-  include Rails::Generators::Migration
-  
-  source_root File.join(File.dirname(__FILE__), 'templates')
-  argument :submodules, :type => :array, :required => true
-  
-  def self.next_migration_number(dirname)
-    if ActiveRecord::Base.timestamped_migrations
-      Time.new.utc.strftime("%Y%m%d%H%M%S")
-    else
-      "%.3d" % (current_migration_number(dirname) + 1)
-    end
-  end
-  
-  def create_migration_file
-    self.submodules.each do |submodule|
-      migration_template "#{submodule}.rb", "db/migrate/sorcery_#{submodule}.rb"
-      sleep 1 # for the timestamp to change
-    end
-  end
-end

data/lib/generators/sorcery_migration/templates/activity_logging.rb

@@ -1,17 +0,0 @@
-class SorceryActivityLogging < ActiveRecord::Migration
-  def self.up
-    add_column :users, :last_login_at,     :datetime, :default => nil
-    add_column :users, :last_logout_at,    :datetime, :default => nil
-    add_column :users, :last_activity_at,  :datetime, :default => nil
-    
-    add_index :users, [:last_logout_at, :last_activity_at]
-  end
-
-  def self.down
-    remove_index :users, [:last_logout_at, :last_activity_at]
-    
-    remove_column :users, :last_activity_at
-    remove_column :users, :last_logout_at
-    remove_column :users, :last_login_at
-  end
-end

data/lib/generators/sorcery_migration/templates/brute_force_protection.rb

@@ -1,11 +0,0 @@
-class SorceryBruteForceProtection < ActiveRecord::Migration
-  def self.up
-    add_column :users, :failed_logins_count, :integer, :default => 0
-    add_column :users, :lock_expires_at, :datetime, :default => nil
-  end
-
-  def self.down
-    remove_column :users, :lock_expires_at
-    remove_column :users, :failed_logins_count
-  end
-end

data/lib/generators/sorcery_migration/templates/remember_me.rb

@@ -1,15 +0,0 @@
-class SorceryRememberMe < ActiveRecord::Migration
-  def self.up
-    add_column :users, :remember_me_token, :string, :default => nil
-    add_column :users, :remember_me_token_expires_at, :datetime, :default => nil
-    
-    add_index :users, :remember_me_token
-  end
-
-  def self.down
-    remove_index :users, :remember_me_token
-    
-    remove_column :users, :remember_me_token_expires_at
-    remove_column :users, :remember_me_token
-  end
-end

data/lib/generators/sorcery_migration/templates/reset_password.rb

@@ -1,13 +0,0 @@
-class SorceryResetPassword < ActiveRecord::Migration
-  def self.up
-    add_column :users, :reset_password_token, :string, :default => nil
-    add_column :users, :reset_password_token_expires_at, :datetime, :default => nil
-    add_column :users, :reset_password_email_sent_at, :datetime, :default => nil
-  end
-
-  def self.down
-    remove_column :users, :reset_password_email_sent_at
-    remove_column :users, :reset_password_token_expires_at
-    remove_column :users, :reset_password_token
-  end
-end

data/lib/generators/sorcery_migration/templates/user_activation.rb

@@ -1,17 +0,0 @@
-class SorceryUserActivation < ActiveRecord::Migration
-  def self.up
-    add_column :users, :activation_state, :string, :default => nil
-    add_column :users, :activation_token, :string, :default => nil
-    add_column :users, :activation_token_expires_at, :datetime, :default => nil
-    
-    add_index :users, :activation_token
-  end
-
-  def self.down
-    remove_index :users, :activation_token
-    
-    remove_column :users, :activation_token_expires_at
-    remove_column :users, :activation_token
-    remove_column :users, :activation_state
-  end
-end

data/lib/sorcery/controller/adapters/sinatra.rb

@@ -1,104 +0,0 @@
-module Sorcery
-  module Controller
-    module Adapters
-      # This module does the magic of translating Rails commands to Sinatra.
-      # This way the Rails code doesn't change, but it actually now calls Sinatra calls.
-      module Sinatra
-        def self.included(base)
-          base.class_eval do
-            class << self
-              # prepend a filter
-              def prepend_filter(type, path = nil, options = {}, &block)
-                return filters[type].unshift block unless path
-                path, options = //, path if path.respond_to?(:each_pair)
-                block, *arguments = compile!(type, path, block, options)
-                prepend_filter(type) do
-                  process_route(*arguments) { instance_eval(&block) }
-                end
-              end
-
-              def after_filter(filter)
-                after do
-                  send(filter)
-                end
-              end
-            end
-          end
-
-          ::Sinatra::Request.class_eval do
-            def authorization
-              env['HTTP_AUTHORIZATION'] ||
-                  env['X-HTTP_AUTHORIZATION'] ||
-                  env['X_HTTP_AUTHORIZATION'] ||
-                  env['REDIRECT_X_HTTP_AUTHORIZATION'] || nil
-            end
-          end
-
-          base.send(:include, SorceryHelpers)
-          base.send(:include, InstanceMethods)
-          base.extend(ClassMethods)
-        end
-
-        module SorceryHelpers
-
-          def request_http_basic_authentication(realm)
-            response.header['WWW-Authenticate'] = %(Basic realm="#{realm}")
-            response.status = 401
-          end
-
-          def authenticate_with_http_basic(&blk)
-            @auth ||= Rack::Auth::Basic::Request.new(request.env)
-            yield @auth.credentials if (@auth.provided? && @auth.basic? && @auth.credentials)
-          end
-
-        end
-
-        module InstanceMethods
-          def reset_session
-            session.clear
-          end
-
-          def redirect_to(*args)
-            args.pop if args.last.is_a?(Hash)
-            redirect(*args)
-          end
-
-          def root_path
-            '/'
-          end
-
-          ::Sinatra.helpers do
-            include SorceryHelpers
-          end
-
-          def cookies
-            @cookie_proxy ||= CookieProxy.new(request, response)
-          end
-        end
-
-        class CookieProxy
-          def initialize(request, response)
-            @request = request
-            @response = response
-          end
-
-          def [](key)
-            @request.cookies[key.to_s]
-          end
-
-          def []=(key, value)
-            @response.set_cookie(key, value)
-          end
-        end
-
-        module ClassMethods
-          def prepend_before_filter(filter)
-            prepend_filter(:before) do
-              send(filter)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sorcery/initializers/initializer.rb

@@ -1,178 +0,0 @@
-# The first thing you need to configure is which modules you need in your app.
-# The default is nothing which will include only core features (password encryption, login/logout).
-# Available submodules are: :user_activation, :http_basic_auth, :remember_me, 
-# :reset_password, :session_timeout, :brute_force_protection, :activity_logging, :external
-Rails.application.config.sorcery.submodules = []
-
-# Here you can configure each submodule's features.
-Rails.application.config.sorcery.configure do |config|
-  # -- core --
-  # config.not_authenticated_action = :not_authenticated              # what controller action to call for
-                                                                      # non-authenticated users. 
-                                                                      # You can also override 'not_authenticated' 
-                                                                      # instead.
-                                                                      
-  # config.save_return_to_url = true                                  # when a non logged in user tries to enter 
-                                                                      # a page that requires login, 
-                                                                      # save the URL he wanted to reach, 
-                                                                      # and send him there after login, using
-                                                                      # 'redirect_back_or_to'.
-
-  # -- session timeout --                                             
-  # config.session_timeout = 3600                                     # how long in seconds to keep the session alive.
-  # config.session_timeout_from_last_action = false                   # use the last action as the beginning of 
-                                                                      # session timeout.
-  
-  # -- http_basic_auth --
-  # config.controller_to_realm_map = {"application" => "Application"} # What realm to display for which controller name.
-                                                                      # For example {"My App" => "Application"}
-  
-  # -- external --
-  # config.external_providers = []                                    # What providers are supported by this app, 
-                                                                      # i.e. [:twitter, :facebook] .
-  # 
-  # config.twitter.key = "eYVNBjBDi33aa9GkA3w"
-  # config.twitter.secret = "XpbeSdCoaKSmQGSeokz5qcUATClRW5u08QWNfv71N8"
-  # config.twitter.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=twitter"
-  # config.twitter.user_info_mapping = {:email => "screen_name"}
-  # 
-  # config.facebook.key = "34cebc81c08a521bc66e212f947d73ec"
-  # config.facebook.secret = "5b458d179f61d4f036ee66a497ffbcd0"
-  # config.facebook.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=facebook"
-  # config.facebook.user_info_mapping = {:email => "name"}
-  
-  # --- user config ---
-  config.user_config do |user|
-    # -- core --
-    # user.username_attribute_name = :username                                        # change default username
-                                                                                      # attribute, for example, 
-                                                                                      # to use :email as the login.
-                                                                                      
-    # user.password_attribute_name = :password                                        # change *virtual* password
-                                                                                      # attribute, the one which is used
-                                                                                      # until an encrypted one is
-                                                                                      # generated.
-                                                                                      
-    # user.email_attribute_name = :email                                              # change default email attribute.
-    
-    # user.crypted_password_attribute_name =  :crypted_password                       # change default crypted_password
-                                                                                      # attribute.
-                                                                                      
-    # user.salt_join_token = ""                                                       # what pattern to use to join the
-                                                                                      # password with the salt
-                                                                                      
-    # user.salt_attribute_name = :salt                                                # change default salt attribute.
-    
-    # user.stretches = nil                                                            # how many times to apply
-                                                                                      # encryption to the password.
-                                                                                      
-    # user.encryption_key = nil                                                       # encryption key used to encrypt
-                                                                                      # reversible encryptions such as
-                                                                                      # AES256.
-                                                                                      
-    # user.custom_encryption_provider = nil                                           # use an external encryption 
-                                                                                      # class.
-                                                                                      
-    # user.encryption_algorithm = :bcrypt                                             # encryption algorithm name. See
-                                                                                      # 'encryption_algorithm=' for
-                                                                                      # available options.
-                                                                                      
-    # user.subclasses_inherit_config = false                                          # make this configuration
-                                                                                      # inheritable for subclasses.
-                                                                                      # Useful for ActiveRecord's STI.
-                                                                                      
-    # -- user_activation --                                                           
-    # user.activation_state_attribute_name = :activation_state                        # the attribute name to hold
-                                                                                      # activation state
-                                                                                      # (active/pending).
-                                                                                      
-    # user.activation_token_attribute_name = :activation_token                        # the attribute name to hold
-                                                                                      # activation code (sent by email).
-                                                                                      
-    # user.activation_token_expires_at_attribute_name = :activation_token_expires_at  # the attribute name to hold
-                                                                                      # activation code expiration date. 
-                                                                                      
-    # user.activation_token_expiration_period =  nil                                  # how many seconds before the
-                                                                                      # activation code expires. nil for
-                                                                                      # never expires.
-                                                                                      
-    # user.user_activation_mailer = nil                                               # your mailer class. Required.
-    
-    # user.activation_needed_email_method_name = :activation_needed_email             # activation needed email method
-                                                                                      # on your mailer class.
-                                                                                      
-    # user.activation_success_email_method_name = :activation_success_email           # activation success email method
-                                                                                      # on your mailer class.
-                                                                                      
-    # user.prevent_non_active_users_to_login = true                                   # do you want to prevent or allow
-                                                                                      # users that did not activate by
-                                                                                      # email to login?                     
-                                                                  
-    # -- reset_password --                                        
-    # user.reset_password_token_attribute_name = :reset_password_token                          # reset password code
-                                                                                                # attribute name.
-                                                                                                
-    # user.reset_password_token_expires_at_attribute_name = :reset_password_token_expires_at    # expires at attribute
-                                                                                                # name.
-                                                                                                
-    # user.reset_password_email_sent_at_attribute_name = :reset_password_email_sent_at          # when was email sent,
-                                                                                                # used for hammering
-                                                                                                # protection.
-                                                                                                
-    # user.reset_password_mailer = nil                                                          # mailer class. Needed.
-    
-    # user.reset_password_email_method_name = :reset_password_email                             # reset password email
-                                                                                                # method on your mailer
-                                                                                                # class.
-                                                                                                
-    # user.reset_password_expiration_period = nil                                               # how many seconds
-                                                                                                # before the reset
-                                                                                                # request expires. nil
-                                                                                                # for never expires.
-                                                                                                
-    # user.reset_password_time_between_emails = 5 * 60                                          # hammering protection,
-                                                                                                # how long to wait
-                                                                                                # before allowing
-                                                                                                # another email to be
-                                                                                                # sent.
-                                                                  
-    # -- brute_force_protection --                                
-    # user.failed_logins_count_attribute_name = :failed_logins_count                  # failed logins attribute name.
-    
-    # user.lock_expires_at_attribute_name = :lock_expires_at                          # this field indicates whether
-                                                                                      # user is banned and when it will
-                                                                                      # be active again.
-                                                                                      
-    # user.consecutive_login_retries_amount_limit = 50                                # how many failed logins allowed.
-    
-    # user.login_lock_time_period = 60 * 60                                           # how long the user should be
-                                                                                      # banned. in seconds. 0 for
-                                                                                      # permanent.
-                                                                  
-    # -- activity logging --                                      
-    # user.last_login_at_attribute_name = :last_login_at                              # last login attribute name.
-    # user.last_logout_at_attribute_name = :last_logout_at                            # last logout attribute name.
-    # user.last_activity_at_attribute_name = :last_activity_at                        # last activity attribute name.
-    # user.activity_timeout = 10 * 60                                                 # how long since last activity is
-                                                                                      # the user defined logged out?
-                                                                                      
-    # -- external --                                                                     
-    # user.authentications_class = nil                                                # class which holds the various
-                                                                                      # external provider data for this
-                                                                                      # user.
-                                                                                      
-    # user.authentications_user_id_attribute_name = :user_id                          # user's identifier in
-                                                                                      # authentications class.
-                                                                                      
-    # user.provider_attribute_name = :provider                                        # provider's identifier in
-                                                                                      # authentications class.
-                                                                                      
-    # user.provider_uid_attribute_name = :uid                                         # user's external unique
-                                                                                      # identifier in authentications
-                                                                                      # class.
-  end
-
-  # This line must come after the 'user config' block.
-  config.user_class = "User"                                                          # define which model authenticates
-                                                                                      # with sorcery.
-end

data/lib/sorcery/sinatra.rb

@@ -1,4 +0,0 @@
-if defined?(Sinatra::Base)
-  Sinatra::Base.send(:include, Sorcery::Controller::Adapters::Sinatra)
-  Sinatra::Base.send(:include, Sorcery::Controller)
-end

data/lib/sorcery/test_helpers/internal/sinatra.rb

@@ -1,74 +0,0 @@
-module Sorcery
-  module TestHelpers
-    module Internal
-      module Sinatra
-        include ::Sorcery::TestHelpers::Sinatra::CookieSessionMethods
-        include ::Sorcery::TestHelpers::Sinatra::InstanceMethods
-
-        class ::Sinatra::Application
-          class << self
-            attr_accessor :sorcery_vars
-          end
-          @sorcery_vars = {}
-
-          # NOTE: see before and after test filters in filters.rb
-
-          def save_instance_vars
-            instance_variables.each do |var|
-              self.class.sorcery_vars[:"#{var.to_s.delete("@")}"] = instance_variable_get(var)
-            end
-          end
-        end
-
-        ::RSpec::Matchers.define :redirect_to do |expected|
-          match do |actual|
-            actual.status == 302 && actual.location == expected
-          end
-        end
-
-        def clear_user_without_logout
-          get_sinatra_app(subject).instance_variable_set(:@current_user, nil)
-        end
-
-        def assigns
-          ::Sinatra::Application.sorcery_vars
-        end
-
-        def sorcery_reload!(submodules = [], options = {})
-          reload_user_class
-
-          # return to no-module configuration
-          ::Sorcery::Controller::Config.init!
-          ::Sorcery::Controller::Config.reset!
-
-          # clear all filters
-          ::Sinatra::Application.instance_variable_set(:@filters, {:before => [], :after => []})
-          load File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec', 'sinatra', 'filters.rb')
-          ::Sinatra::Application.send(:include, ::Filters)
-
-          # configure
-          ::Sorcery::Controller::Config.submodules = submodules
-          ::Sorcery::Controller::Config.user_class = nil
-          ::Sinatra::Application.send(:include, Sorcery::Controller::Adapters::Sinatra)
-          ::Sinatra::Application.send(:include, Sorcery::Controller)
-          ::Sorcery::Controller::Config.user_class = "User"
-
-          ::Sorcery::Controller::Config.user_config do |user|
-            options.each do |property, value|
-              user.send(:"#{property}=", value)
-            end
-          end
-          User.authenticates_with_sorcery!
-        end
-
-        def sorcery_controller_property_set(property, value)
-          ::Sorcery::Controller::Config.send(:"#{property}=", value)
-        end
-
-        def sorcery_controller_external_property_set(provider, property, value)
-          ::Sorcery::Controller::Config.send(provider).send(:"#{property}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/sorcery/test_helpers/internal/sinatra_modular.rb

@@ -1,74 +0,0 @@
-module Sorcery
-  module TestHelpers
-    module Internal
-      module SinatraModular
-        include ::Sorcery::TestHelpers::Sinatra::CookieSessionMethods
-        include ::Sorcery::TestHelpers::Sinatra::InstanceMethods
-
-        class ::Modular
-          class << self
-            attr_accessor :sorcery_vars
-          end
-          @sorcery_vars = {}
-
-          # NOTE: see before and after test filters in filters.rb
-
-          def save_instance_vars
-            instance_variables.each do |var|
-              self.class.sorcery_vars[:"#{var.to_s.delete("@")}"] = instance_variable_get(var)
-            end
-          end
-        end
-
-        ::RSpec::Matchers.define :redirect_to do |expected|
-          match do |actual|
-            actual.status == 302 && actual.location == expected
-          end
-        end
-
-        def clear_user_without_logout
-          get_sinatra_app(subject).instance_variable_set(:@current_user, nil)
-        end
-
-        def assigns
-          ::Modular.sorcery_vars
-        end
-
-        def sorcery_reload!(submodules = [], options = {})
-          reload_user_class
-
-          # return to no-module configuration
-          ::Sorcery::Controller::Config.init!
-          ::Sorcery::Controller::Config.reset!
-
-          # clear all filters
-          ::Sinatra::Base.instance_variable_set(:@filters, {:before => [], :after => []})
-          require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec', 'sinatra', 'filters')
-          ::Sinatra::Base.send(:include, ::Filters)
-
-          # configure
-          ::Sorcery::Controller::Config.submodules = submodules
-          ::Sorcery::Controller::Config.user_class = nil
-          ::Sinatra::Base.send(:include, Sorcery::Controller::Adapters::Sinatra)
-          ::Sinatra::Base.send(:include, Sorcery::Controller)
-          ::Sorcery::Controller::Config.user_class = "User"
-
-          ::Sorcery::Controller::Config.user_config do |user|
-            options.each do |property, value|
-              user.send(:"#{property}=", value)
-            end
-          end
-          User.authenticates_with_sorcery!
-        end
-
-        def sorcery_controller_property_set(property, value)
-          ::Sorcery::Controller::Config.send(:"#{property}=", value)
-        end
-
-        def sorcery_controller_external_property_set(provider, property, value)
-          ::Sorcery::Controller::Config.send(provider).send(:"#{property}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/sorcery/test_helpers/sinatra.rb

@@ -1,88 +0,0 @@
-module Sorcery
-  module TestHelpers
-    module Sinatra
-      def self.included(base)
-        base.send(:include, InstanceMethods)
-        base.send(:include, CookieSessionMethods)
-        ::Sinatra::Base.class_eval do
-          class << self
-            attr_accessor :rack_test_session
-          end
-
-          def self.inherited(subclass)
-            super
-            subclass.class_eval do
-              class << self
-                attr_accessor :rack_test_session
-              end
-            end
-          end
-
-          include CookieSessionMethods
-
-          def rack_test_session
-            self.class.rack_test_session
-          end
-        end
-      end
-
-      module InstanceMethods
-        def get_sinatra_app(app)
-          while !app.kind_of? ::Sinatra::Base do
-            app = app.instance_variable_get(:@app)
-          end
-          app
-        end
-
-        def login_user(user=nil)
-          user ||= @user
-          get_sinatra_app(app).send(:login_user, user)
-          get_sinatra_app(app).send(:after_login!, user, [user.send(user.sorcery_config.username_attribute_name), 'secret'])
-        end
-
-        def logout_user
-          get_sinatra_app(app).send(:logout)
-        end
-      end
-
-      module CookieSessionMethods
-        class SessionData
-          def initialize(cookies)
-            @cookies = cookies
-            @data = cookies['rack.session']
-            if @data
-              @data = @data.unpack("m*").first
-              @data = Marshal.load(@data)
-            else
-              @data = {}
-            end
-          end
-
-          def [](key)
-            @data[key]
-          end
-
-          def []=(key, value)
-            @data[key] = value
-            session_data = Marshal.dump(@data)
-            session_data = [session_data].pack("m*")
-            @cookies.merge("rack.session=#{Rack::Utils.escape(session_data)}", URI.parse("//example.org//"))
-            raise "session variable not set" unless @cookies['rack.session'] == session_data
-          end
-
-          def clear
-            @data = {}
-          end
-        end
-
-        def session
-          SessionData.new(cookies)
-        end
-
-        def cookies
-          rack_test_session.instance_variable_get(:@rack_mock_session).cookie_jar
-        end
-      end
-    end
-  end
-end

data/spec/rails3/Rakefile.unused

@@ -1,7 +0,0 @@
-# Add your own tasks in files placed in lib/tasks ending in .rake,
-# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-
-require File.expand_path('../config/application', __FILE__)
-require 'rake'
-
-AppRoot::Application.load_tasks