sorcery 0.7.0 → 0.7.1

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,17 +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
-    
-    add_index :users, :reset_password_token
-  end
-
-  def self.down
-    remove_index :users, :reset_password_token
-    
-    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,115 +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
-            @secure = false
-          end
-
-          def [](key)
-            value = @request.cookies[key.to_s]
-          end
-
-          def []=(key, value)
-            if @secure
-              value.merge(:secret => Config.sinatra_cookie_secret)
-              @secure = false
-            end
-            @response.set_cookie(key, value)
-          end
-          
-          # mark cookie as signed, which will light a flag, which will cause the next set_cookie to be encrypted.
-          def signed
-            @secure = true
-            self
-          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/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_names.first), '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