sorcery 0.3.1 → 0.4.0

data/lib/sorcery/controller/submodules/email.rb

@@ -1,44 +0,0 @@
-# module Sorcery
-#   module Controller
-#     module Submodules
-#       # This module allows you to authenticate to the site using a mail server.
-#       # Let's say your organization is called blup, and everyone has someklutz@blup.com,
-#       # Instead of registering a new username and password for an internal web application,
-#       # why not simply reuse your email credentials?
-#       # Of course this means that if the mail server is down, nobody can authenticate to your app.
-#       # I might add a fallback for that in the future.
-#       module Email
-#         def self.included(base)
-#           base.send(:include, InstanceMethods)
-#           Config.module_eval do
-#             class << self
-#               attr_reader :email_protocols                           # email protocols like pop3, IMAP etc.
-#                                           
-#               def merge_mail_defaults!
-#                 @defaults.merge!(:@email_protocols => [])
-#               end
-#               
-#               def email_protocols=(protocols)
-#                 protocols.each do |protocol|
-#                   include Protocols.const_get(protocol.to_s.split("_").map {|p| p.capitalize}.join(""))
-#                 end
-#               end
-#             end
-#             merge_mail_defaults!
-#           end
-#         end
-# 
-#         module InstanceMethods
-#           protected
-#           
-#           # sends user to authenticate at the provider's website.
-#           # after authentication the user is redirected to the callback defined in the provider config
-#           def login_at(protocol)
-# 
-#           end
-# 
-#         end
-#       end
-#     end
-#   end
-# end

data/lib/sorcery/controller/submodules/oauth.rb

@@ -1,95 +0,0 @@
-module Sorcery
-  module Controller
-    module Submodules
-      # This submodule helps you login users from OAuth providers such as Twitter.
-      # This is the controller part which handles the http requests and tokens passed between the app and the provider.
-      # For more configuration options see Sorcery::Model::Oauth.
-      module Oauth
-        def self.included(base)
-          base.send(:include, InstanceMethods)
-          Config.module_eval do
-            class << self
-              attr_reader :oauth_providers                           # oauth providers like twitter.
-                                          
-              def merge_oauth_defaults!
-                @defaults.merge!(:@oauth_providers => [])
-              end
-              
-              def oauth_providers=(providers)
-                providers.each do |provider|
-                  include Providers.const_get(provider.to_s.split("_").map {|p| p.capitalize}.join(""))
-                end
-              end
-            end
-            merge_oauth_defaults!
-          end
-        end
-
-        module InstanceMethods
-          protected
-          
-          # sends user to authenticate at the provider's website.
-          # after authentication the user is redirected to the callback defined in the provider config
-          def auth_at_provider(provider)
-            @provider = Config.send(provider)
-            args = {}
-            if @provider.respond_to?(:get_request_token)
-              req_token = @provider.get_request_token
-              session[:request_token]         = req_token.token
-              session[:request_token_secret]  = req_token.secret
-              args.merge!({:request_token => req_token.token, :request_token_secret => req_token.secret})
-            end
-            redirect_to @provider.authorize_url(args)
-          end
-          
-          # tries to login the user from access token
-          def login_from_access_token(provider)
-            @provider = Config.send(provider)
-            args = {}
-            args.merge!({:oauth_verifier => params[:oauth_verifier], :request_token => session[:request_token], :request_token_secret => session[:request_token_secret]}) if @provider.respond_to?(:get_request_token)
-            args.merge!({:code => params[:code]}) if params[:code]
-            @access_token = @provider.get_access_token(args)
-            @user_hash = @provider.get_user_hash(@access_token)
-            if user = Config.user_class.load_from_provider(provider,@user_hash[:uid])
-              reset_session
-              login_user(user)
-              user
-            end
-          end
-          
-          def get_user_hash(provider)
-            @provider = Config.send(provider)
-            @provider.get_user_hash(@access_token)
-          end
-          
-          # this method automatically creates a new user from the data in the external user hash.
-          # The mappings from user hash fields to user db fields are set at controller config.
-          # If the hash field you would like to map is nested, use slashes. For example, Given a hash like:
-          #
-          #   "user" => {"name"=>"moishe"}
-          #
-          # You will set the mapping:
-          #
-          #   {:username => "user/name"}
-          #
-          # And this will cause 'moishe' to be set as the value of :username field.
-          def create_from_provider!(provider)
-            provider = provider.to_sym
-            @provider = Config.send(provider)
-            @user_hash = get_user_hash(provider)
-            config = Config.user_class.sorcery_config
-            attrs = {}
-            @provider.user_info_mapping.each do |k,v|
-              (varr = v.split("/")).size > 1 ? attrs.merge!(k => varr.inject(@user_hash[:user_info]) {|hsh,v| hsh[v] }) : attrs.merge!(k => @user_hash[:user_info][v])
-            end
-            Config.user_class.transaction do
-              @user = Config.user_class.create!(attrs)
-              Config.user_class.sorcery_config.authentications_class.create!({config.authentications_user_id_attribute_name => @user.id, config.provider_attribute_name => provider, config.provider_uid_attribute_name => @user_hash[:uid]})
-            end
-            @user
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rails3/app_root/.rspec

@@ -1 +0,0 @@
---colour

data/spec/rails3/app_root/config/database.yml

@@ -1,27 +0,0 @@
-# SQLite version 3.x
-#   gem install sqlite3-ruby (not necessary on OS X Leopard)
-development:
-  adapter: sqlite3
-  database: db/development.sqlite3
-  pool: 5
-  timeout: 5000
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  adapter: sqlite3
-  database: db/test.sqlite3
-  pool: 5
-  timeout: 5000
-
-production:
-  adapter: sqlite3
-  database: db/production.sqlite3
-  pool: 5
-  timeout: 5000
-  
-in_memory:
-  adapter: sqlite3
-  database: ":memory:"
-  verbosity: quiet

data/spec/rails3/app_root/spec/spec_helper.rb

@@ -1,62 +0,0 @@
-$: << File.join(File.dirname(__FILE__), '..', '..', 'lib' )
-
-require 'simplecov'
-SimpleCov.root File.join(File.dirname(__FILE__), "..", "..", "app_root" )
-SimpleCov.start do
-  add_filter "/config/"
-  
-  add_group 'Controllers', 'app/controllers'
-  add_group 'Models', 'app/models'
-  add_group 'Helpers', 'app/helpers'
-  add_group 'Libraries', 'lib'
-  add_group 'Plugins', 'vendor/plugins'
-  add_group 'Migrations', 'db/migrate'
-end
-
-require 'spork'
-
-Spork.prefork do
-  # Set the default environment to sqlite3's in_memory database
-  ENV['RAILS_ENV'] ||= 'in_memory'
-  ENV['RAILS_ROOT'] = 'app_root'
-  
-  # Load the Rails environment and testing framework
-  require "#{File.dirname(__FILE__)}/../config/environment"
-  #require "#{File.dirname(__FILE__)}/../../init" # for plugins
-  require 'rspec/rails'
-
-  RSpec.configure do |config|
-    config.use_transactional_fixtures = true
-    config.use_instantiated_fixtures  = false
-    config.include RSpec::Rails::ControllerExampleGroup, :example_group => { :file_path => /controller(.)*_spec.rb$/ }
-
-    config.before(:suite) do
-      ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/core")
-    end
-
-    config.after(:suite) do
-      ActiveRecord::Migrator.rollback("#{Rails.root}/db/migrate/core")
-    end
-  end
-  
-  #----------------------------------------------------------------
-  # needed when running individual specs
-  require File.join(File.dirname(__FILE__), '..','app','models','user')
-  require File.join(File.dirname(__FILE__), '..','app','models','authentication')
-
-  class TestUser < ActiveRecord::Base
-    activate_sorcery!
-  end
-
-  class TestMailer < ActionMailer::Base
-
-  end
-  
-  include ::Sorcery::TestHelpers
-  include ::Sorcery::TestHelpers::Rails
-  
-end
-
-Spork.each_run do
-  # This code will be run each time you run your specs.
-end

data/spec/sinatra/spec/user_activation_spec.rb

@@ -1,188 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require File.expand_path(File.dirname(__FILE__) + '/../sorcery_mailer')
-
-describe "User with activation submodule" do
-  before(:all) do
-    ActiveRecord::Migrator.migrate("#{APP_ROOT}/db/migrate/activation")
-  end
-  
-  after(:all) do
-    ActiveRecord::Migrator.rollback("#{APP_ROOT}/db/migrate/activation")
-  end
-
-  # ----------------- PLUGIN CONFIGURATION -----------------------
-  describe User, "loaded plugin configuration" do
-    before(:all) do
-      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
-    end
-  
-    after(:each) do
-      User.sorcery_config.reset!
-      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
-    end
-    
-    it "should enable configuration option 'activation_state_attribute_name'" do
-      sorcery_model_property_set(:activation_state_attribute_name, :status)
-      User.sorcery_config.activation_state_attribute_name.should equal(:status)    
-    end
-    
-    it "should enable configuration option 'activation_token_attribute_name'" do
-      sorcery_model_property_set(:activation_token_attribute_name, :code)
-      User.sorcery_config.activation_token_attribute_name.should equal(:code)    
-    end
-    
-    it "should enable configuration option 'user_activation_mailer'" do
-      sorcery_model_property_set(:user_activation_mailer, TestMailer)
-      User.sorcery_config.user_activation_mailer.should equal(TestMailer)    
-    end
-    
-    it "should enable configuration option 'activation_needed_email_method_name'" do
-      sorcery_model_property_set(:activation_needed_email_method_name, :my_activation_email)
-      User.sorcery_config.activation_needed_email_method_name.should equal(:my_activation_email)
-    end
-    
-    it "should enable configuration option 'activation_success_email_method_name'" do
-      sorcery_model_property_set(:activation_success_email_method_name, :my_activation_email)
-      User.sorcery_config.activation_success_email_method_name.should equal(:my_activation_email)
-    end
-    
-    it "if mailer is nil on activation, throw exception!" do
-      expect{sorcery_reload!([:user_activation])}.to raise_error(ArgumentError)
-    end
-  end
-
-  # ----------------- ACTIVATION PROCESS -----------------------
-  describe User, "activation process" do
-    before(:all) do
-      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
-    end
-    
-    it "should generate an activation code on registration" do
-      create_new_user
-      @user.activation_token.should_not be_nil
-    end
-    
-    it "should initialize user state to 'pending'" do
-      create_new_user
-      @user.activation_state.should == "pending"
-    end
-    
-    it "should respond to 'activate!'" do
-      create_new_user
-      @user.should respond_to(:activate!)
-    end
-    
-    it "should clear activation code and change state to 'active' on activation" do
-      create_new_user
-      activation_token = @user.activation_token
-      @user.activate!
-      @user2 = User.find(@user.id) # go to db to make sure it was saved and not just in memory
-      @user2.activation_token.should be_nil
-      @user2.activation_state.should == "active"
-      User.find_by_activation_token(activation_token).should be_nil
-    end
-    
-    it "should send the user an activation email" do
-      old_size = ActionMailer::Base.deliveries.size
-      create_new_user
-      ActionMailer::Base.deliveries.size.should == old_size + 1
-    end
-    
-    it "subsequent saves do not send activation email" do
-      create_new_user
-      old_size = ActionMailer::Base.deliveries.size
-      @user.username = "Shauli"
-      @user.save!
-      ActionMailer::Base.deliveries.size.should == old_size
-    end
-    
-    it "should send the user an activation success email on successful activation" do
-      create_new_user
-      old_size = ActionMailer::Base.deliveries.size
-      @user.activate!
-      ActionMailer::Base.deliveries.size.should == old_size + 1
-    end
-    
-    it "subsequent saves do not send activation success email" do
-      create_new_user
-      @user.activate!
-      old_size = ActionMailer::Base.deliveries.size
-      @user.username = "Shauli"
-      @user.save!
-      ActionMailer::Base.deliveries.size.should == old_size
-    end
-    
-    it "activation needed email is optional" do
-      sorcery_model_property_set(:activation_needed_email_method_name, nil)
-      old_size = ActionMailer::Base.deliveries.size
-      create_new_user
-      ActionMailer::Base.deliveries.size.should == old_size
-    end
-    
-    it "activation success email is optional" do
-      sorcery_model_property_set(:activation_success_email_method_name, nil)
-      create_new_user
-      old_size = ActionMailer::Base.deliveries.size
-      @user.activate!
-      ActionMailer::Base.deliveries.size.should == old_size
-    end
-  end
-
-  describe User, "prevent non-active login feature" do
-    before(:all) do
-      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
-    end
-    
-    it "should not allow a non-active user to authenticate" do
-      create_new_user
-      User.authenticate(@user.username,'secret').should be_false
-    end
-    
-    it "should allow a non-active user to authenticate if configured so" do
-      create_new_user
-      sorcery_model_property_set(:prevent_non_active_users_to_login, false)
-      User.authenticate(@user.username,'secret').should be_true
-    end
-  end
-  
-  describe User, "load_from_activation_token" do
-    before(:all) do
-      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
-    end
-    
-    it "load_from_activation_token should return user when token is found" do
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
-    end
-    
-    it "load_from_activation_token should NOT return user when token is NOT found" do
-      create_new_user
-      User.load_from_activation_token("a").should == nil
-    end
-    
-    it "load_from_activation_token should return user when token is found and not expired" do
-      sorcery_model_property_set(:activation_token_expiration_period, 500)
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
-    end
-    
-    it "load_from_activation_token should NOT return user when token is found and expired" do
-      sorcery_model_property_set(:activation_token_expiration_period, 0.1)
-      create_new_user
-      sleep 0.5
-      User.load_from_activation_token(@user.activation_token).should == nil
-    end
-    
-    it "load_from_activation_token should return nil if token is blank" do
-      User.load_from_activation_token(nil).should == nil
-      User.load_from_activation_token("").should == nil
-    end
-    
-    it "load_from_activation_token should always be valid if expiration period is nil" do
-      sorcery_model_property_set(:activation_token_expiration_period, nil)
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
-    end
-  end
-  
-end

data/spec/sinatra/spec/user_activity_logging_spec.rb

@@ -1,36 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "User with activity logging submodule" do
-  before(:all) do
-  end
-  
-  after(:all) do
-  end
-
-  # ----------------- PLUGIN CONFIGURATION -----------------------
-  describe User, "loaded plugin configuration" do
-    before(:all) do
-      sorcery_reload!([:activity_logging])
-    end
-  
-    after(:each) do
-      User.sorcery_config.reset!
-    end
-    
-    it "should allow configuration option 'last_login_at_attribute_name'" do
-      sorcery_model_property_set(:last_login_at_attribute_name, :login_time)
-      User.sorcery_config.last_login_at_attribute_name.should equal(:login_time)
-    end
-    
-    it "should allow configuration option 'last_logout_at_attribute_name'" do
-      sorcery_model_property_set(:last_logout_at_attribute_name, :logout_time)
-      User.sorcery_config.last_logout_at_attribute_name.should equal(:logout_time)
-    end
-    
-    it "should allow configuration option 'last_activity_at_attribute_name'" do
-      sorcery_model_property_set(:last_activity_at_attribute_name, :activity_time)
-      User.sorcery_config.last_activity_at_attribute_name.should equal(:activity_time)
-    end
-  end
-
-end