sorcery 0.8.6 → 0.9.1

data/lib/sorcery/model.rb

@@ -19,17 +19,28 @@ module Sorcery
       # This runs the options block set in the initializer on the model class.
       ::Sorcery::Controller::Config.user_config.tap{|blk| blk.call(@sorcery_config) if blk}
 
-      init_mongoid_support! if defined?(Mongoid) and self.ancestors.include?(Mongoid::Document)
-      init_mongo_mapper_support! if defined?(MongoMapper) and self.ancestors.include?(MongoMapper::Document)
-      init_datamapper_support! if defined?(DataMapper) and self.ancestors.include?(DataMapper::Resource)
-
+      define_base_fields
       init_orm_hooks!
 
       @sorcery_config.after_config << :add_config_inheritance if @sorcery_config.subclasses_inherit_config
       @sorcery_config.after_config.each { |c| send(c) }
     end
 
-    protected
+    private
+
+    def define_base_fields
+      self.class_eval do
+        sorcery_config.username_attribute_names.each do |username|
+          sorcery_adapter.define_field username, String, length: 255
+        end
+        unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
+          sorcery_adapter.define_field sorcery_config.email_attribute_name, String, length: 255
+        end
+        sorcery_adapter.define_field sorcery_config.crypted_password_attribute_name, String, length: 255
+        sorcery_adapter.define_field sorcery_config.salt_attribute_name, String, length: 255
+      end
+
+    end
 
     # includes required submodules into the model class,
     # which usually is called User.
@@ -47,77 +58,17 @@ module Sorcery
       end
     end
 
-    # defines mongoid fields on the model class,
-    # using 1.8.x hash syntax to perserve compatibility.
-    def init_mongoid_support!
-      self.class_eval do
-        sorcery_config.username_attribute_names.each do |username|
-          field username,         :type => String
-        end
-        field sorcery_config.email_attribute_name,            :type => String unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
-        field sorcery_config.crypted_password_attribute_name, :type => String
-        field sorcery_config.salt_attribute_name,             :type => String
-      end
-    end
-
-    # defines mongo_mapper fields on the model class,
-    def init_mongo_mapper_support!
-      self.class_eval do
-        sorcery_config.username_attribute_names.each do |username|
-          key username, String
-        end
-        key sorcery_config.email_attribute_name, String unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
-        key sorcery_config.crypted_password_attribute_name, String
-        key sorcery_config.salt_attribute_name, String
-      end
-    end
-
-    # defines datamapper fields on the model class
-    def init_datamapper_support!
-      self.class_eval do
-        sorcery_config.username_attribute_names.each do |username|
-          property username, String, :length => 255
-        end
-        unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
-          property sorcery_config.email_attribute_name, String, :length => 255
-        end
-        property sorcery_config.crypted_password_attribute_name, String, :length => 255
-        property sorcery_config.salt_attribute_name, String, :length => 255
-      end
-    end
-
     # add virtual password accessor and ORM callbacks.
     def init_orm_hooks!
-      if defined?(DataMapper) and self.ancestors.include?(DataMapper::Resource)
-        init_datamapper_hooks!
-        return
-      end
-      self.class_eval do
-        attr_accessor @sorcery_config.password_attribute_name
-        #attr_protected @sorcery_config.crypted_password_attribute_name, @sorcery_config.salt_attribute_name
-        before_save :encrypt_password, :if => Proc.new { |record|
-          record.send(sorcery_config.password_attribute_name).present?
-        }
-        after_save :clear_virtual_password, :if => Proc.new { |record|
-          record.send(sorcery_config.password_attribute_name).present?
-        }
-      end
-    end
+      sorcery_adapter.define_callback :before, :validation, :encrypt_password, if: Proc.new {|record|
+        record.send(sorcery_config.password_attribute_name).present?
+      }
 
-    def init_datamapper_hooks!
-      self.class_eval do
-        attr_accessor @sorcery_config.password_attribute_name
-        before :valid? do
-          if self.send(sorcery_config.password_attribute_name).present?
-            encrypt_password
-          end
-        end
-        after :save do
-          if self.send(sorcery_config.password_attribute_name).present?
-            clear_virtual_password
-          end
-        end
-      end
+      sorcery_adapter.define_callback :after, :save, :clear_virtual_password, if: Proc.new {|record|
+        record.send(sorcery_config.password_attribute_name).present?
+      }
+
+      attr_accessor sorcery_config.password_attribute_name
     end
 
     module ClassMethods
@@ -139,12 +90,15 @@ module Sorcery
           credentials[0].downcase!
         end
 
-        user = find_by_credentials(credentials)
+        user = sorcery_adapter.find_by_credentials(credentials)
+
+        if user.respond_to?(:active_for_authentication?)
+          return nil if !user.active_for_authentication?
+        end
 
         set_encryption_attributes
 
-        _salt = user.send(@sorcery_config.salt_attribute_name) if user && !@sorcery_config.salt_attribute_name.nil? && !@sorcery_config.encryption_provider.nil?
-        user if user && @sorcery_config.before_authenticate.all? {|c| user.send(c)} && credentials_match?(user.send(@sorcery_config.crypted_password_attribute_name),credentials[1],_salt)
+        user if user && @sorcery_config.before_authenticate.all? {|c| user.send(c)} && user.valid_password?(credentials[1])
       end
 
       # encrypt tokens using current encryption_provider.
@@ -163,13 +117,7 @@ module Sorcery
         @sorcery_config.encryption_provider.stretches = @sorcery_config.stretches if @sorcery_config.encryption_provider.respond_to?(:stretches) && @sorcery_config.stretches
         @sorcery_config.encryption_provider.join_token = @sorcery_config.salt_join_token if @sorcery_config.encryption_provider.respond_to?(:join_token) && @sorcery_config.salt_join_token
       end
-
-      # Calls the configured encryption provider to compare the supplied password with the encrypted one.
-      def credentials_match?(crypted, *tokens)
-        return crypted == tokens.join if @sorcery_config.encryption_provider.nil?
-        @sorcery_config.encryption_provider.matches?(crypted, *tokens)
-      end
-
+      
       def add_config_inheritance
         self.class_eval do
           def self.inherited(subclass)
@@ -198,6 +146,16 @@ module Sorcery
         send(sorcery_config.crypted_password_attribute_name).nil?
       end
 
+      # Calls the configured encryption provider to compare the supplied password with the encrypted one.
+      def valid_password?(pass)
+        _crypted = self.send(sorcery_config.crypted_password_attribute_name)  
+        return _crypted == pass if sorcery_config.encryption_provider.nil?
+
+        _salt = self.send(sorcery_config.salt_attribute_name) unless sorcery_config.salt_attribute_name.nil?
+
+        sorcery_config.encryption_provider.matches?(_crypted, pass, _salt)
+      end
+
       protected
 
       # creates new salt and saves it.
@@ -223,100 +181,14 @@ module Sorcery
         config = sorcery_config
         mail = config.send(mailer).send(config.send(method),self)
         if defined?(ActionMailer) and config.send(mailer).kind_of?(Class) and config.send(mailer) < ActionMailer::Base
-          mail.deliver
-        end
-      end
-    end
-
-    # Each class which calls 'activate_sorcery!' receives an instance of this class.
-    # Every submodule which gets loaded may add accessors to this class so that all
-    # options will be configured from a single place.
-    class Config
-
-      attr_accessor :username_attribute_names,           # change default username attribute, for example, to use :email
-                                                        # as the login.
-
-                    :password_attribute_name,           # change *virtual* password attribute, the one which is used
-                                                        # until an encrypted one is generated.
-
-                    :email_attribute_name,              # change default email attribute.
-
-                    :downcase_username_before_authenticating, # downcase the username before trying to authenticate, default is false
-
-                    :crypted_password_attribute_name,   # change default crypted_password attribute.
-                    :salt_join_token,                   # what pattern to use to join the password with the salt
-                    :salt_attribute_name,               # change default salt attribute.
-                    :stretches,                         # how many times to apply encryption to the password.
-                    :encryption_key,                    # encryption key used to encrypt reversible encryptions such as
-                                                        # AES256.
-
-                    :subclasses_inherit_config,         # make this configuration inheritable for subclasses. Useful for
-                                                        # ActiveRecord's STI.
-
-                    :submodules,                        # configured in config/application.rb
-                    :before_authenticate,               # an array of method names to call before authentication
-                                                        # completes. used internally.
-
-                    :after_config                       # an array of method names to call after configuration by user.
-                                                        # used internally.
-
-      attr_reader   :encryption_provider,               # change default encryption_provider.
-                    :custom_encryption_provider,        # use an external encryption class.
-                    :encryption_algorithm               # encryption algorithm name. See 'encryption_algorithm=' below
-                                                        # for available options.
-
-      def initialize
-        @defaults = {
-          :@submodules                           => [],
-          :@username_attribute_names              => [:email],
-          :@password_attribute_name              => :password,
-          :@downcase_username_before_authenticating => false,
-          :@email_attribute_name                 => :email,
-          :@crypted_password_attribute_name      => :crypted_password,
-          :@encryption_algorithm                 => :bcrypt,
-          :@encryption_provider                  => CryptoProviders::BCrypt,
-          :@custom_encryption_provider           => nil,
-          :@encryption_key                       => nil,
-          :@salt_join_token                      => "",
-          :@salt_attribute_name                  => :salt,
-          :@stretches                            => nil,
-          :@subclasses_inherit_config            => false,
-          :@before_authenticate                  => [],
-          :@after_config                         => []
-        }
-        reset!
-      end
-
-      # Resets all configuration options to their default values.
-      def reset!
-        @defaults.each do |k,v|
-          instance_variable_set(k,v)
-        end
-      end
-
-      def username_attribute_names=(fields)
-        @username_attribute_names = fields.kind_of?(Array) ? fields : [fields]
-      end
-
-      def custom_encryption_provider=(provider)
-        @custom_encryption_provider = @encryption_provider = provider
-      end
-
-      def encryption_algorithm=(algo)
-        @encryption_algorithm = algo
-        @encryption_provider = case @encryption_algorithm.to_sym
-        when :none   then nil
-        when :md5    then CryptoProviders::MD5
-        when :sha1   then CryptoProviders::SHA1
-        when :sha256 then CryptoProviders::SHA256
-        when :sha512 then CryptoProviders::SHA512
-        when :aes256 then CryptoProviders::AES256
-        when :bcrypt then CryptoProviders::BCrypt
-        when :custom then @custom_encryption_provider
-        else raise ArgumentError.new("Encryption algorithm supplied, #{algo}, is invalid")
+          # Rails 4.2 deprecates #deliver
+          if mail.respond_to?(:deliver_now)
+            mail.deliver_now
+          else
+            mail.deliver
+          end
         end
       end
-
     end
 
   end

data/lib/sorcery/providers/base.rb

@@ -13,6 +13,17 @@ module Sorcery
         @user_info_mapping = {}
       end
 
+      def auth_hash(access_token, hash={})
+        return hash if access_token.nil?
+
+        token_hash = hash.dup
+        token_hash[:token] = access_token.token if access_token.respond_to?(:token)
+        token_hash[:refresh_token] = access_token.refresh_token if access_token.respond_to?(:refresh_token)
+        token_hash[:expires_at] = access_token.expires_at if access_token.respond_to?(:expires_at)
+        token_hash[:expires_in] = access_token.expires_at if access_token.respond_to?(:expires_in)
+        token_hash
+      end
+
       def self.name
         super.gsub(/Sorcery::Providers::/, '').downcase
       end

data/lib/sorcery/providers/facebook.rb

@@ -12,16 +12,18 @@ module Sorcery
 
       attr_reader   :mode, :param_name, :parse
       attr_accessor :access_permissions, :display, :scope, :token_url,
-                    :user_info_path
+                    :user_info_path, :auth_path, :api_version
 
       def initialize
         super
 
         @site           = 'https://graph.facebook.com'
-        @user_info_path = '/me'
-        @scope          = 'email,offline_access'
+        @auth_site      = 'https://www.facebook.com'
+        @user_info_path = 'me'
+        @scope          = 'email'
         @display        = 'page'
         @token_url      = 'oauth/access_token'
+        @auth_path      = 'dialog/oauth'
         @mode           = :query
         @parse          = :query
         @param_name     = 'access_token'
@@ -30,7 +32,7 @@ module Sorcery
       def get_user_hash(access_token)
         response = access_token.get(user_info_path)
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)
           h[:uid] = h[:user_info]['id']
         end
@@ -44,8 +46,17 @@ module Sorcery
 
       # overrides oauth2#authorize_url to allow customized scope.
       def authorize_url
+
+        # Fix: replace default oauth2 options, specially to prevent the Faraday gem which
+        # concatenates with "/", removing the Facebook api version
+        options = {
+          site:          File::join(@site, api_version.to_s),
+          authorize_url: File::join(@auth_site, api_version.to_s, auth_path),
+          token_url:     token_url
+        }
+
         @scope = access_permissions.present? ? access_permissions.join(',') : scope
-        super
+        super(options)
       end
 
       # tries to login the user from access token

data/lib/sorcery/providers/github.rb

@@ -25,8 +25,10 @@ module Sorcery
       def get_user_hash(access_token)
         response = access_token.get(user_info_path)
 
-        {}.tap do |h|
-          h[:user_info] = JSON.parse(response.body)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body).tap do |uih|
+            uih['email'] = primary_email(access_token) if scope =~ /user/
+          end
           h[:uid] = h[:user_info]['id']
         end
       end
@@ -46,6 +48,13 @@ module Sorcery
         get_access_token(args, token_url: token_url, token_method: :post)
       end
 
+      def primary_email(access_token)
+        response = access_token.get(user_info_path + "/emails")
+        emails = JSON.parse(response.body)
+        primary = emails.find{|i| i['primary'] }
+        primary && primary['email'] || emails.first && emails.first['email']
+      end
+
     end
   end
 end

data/lib/sorcery/providers/google.rb

@@ -25,7 +25,7 @@ module Sorcery
       def get_user_hash(access_token)
         response = access_token.get(user_info_url)
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)
           h[:uid] = h[:user_info]['id']
         end

data/lib/sorcery/providers/heroku.rb

@@ -0,0 +1,57 @@
+module Sorcery
+  module Providers
+
+    # This class adds support for OAuth with heroku.com.
+
+    # config.heroku.key = <key>
+    # config.heroku.secret = <secret>
+    # config.heroku.callback_url = "<host>/oauth/callback?provider=heroku"
+    # config.heroku.scope = "read"
+    # config.heroku.user_info_mapping = {:email => "email", :name => "email" }
+
+    # NOTE:
+    # The full path must be set for OAuth Callback URL when configuring the API Client Information on Heroku.
+
+    class Heroku < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_path, :scope, :token_url, :user_info_path
+
+      def initialize
+        super
+
+        @scope          = nil
+        @site           = 'https://id.heroku.com'
+        @user_info_path = 'https://api.heroku.com/account'
+        @auth_path      = '/oauth/authorize'
+        @token_url      = '/oauth/token'
+        @user_info_path = '/account'
+        @state          = SecureRandom.hex(16)
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_path)
+        body = JSON.parse(response.body)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = body
+          h[:uid] = body['id'].to_s
+          h[:email] = body['email'].to_s
+        end
+      end
+
+      def login_url(params, session)
+        authorize_url({ authorize_url: auth_path })
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, session)
+        raise "Invalid state. Potential Cross Site Forgery" if params[:state] != state
+        args = { }.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+        get_access_token(args, token_url: token_url, token_method: :post)
+      end
+    end
+  end
+end

data/lib/sorcery/providers/jira.rb

@@ -0,0 +1,77 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Jira
+    #
+    #   config.jira.key = <key>
+    #   config.jira.secret = <secret>
+    #   ...
+    #
+    class Jira < Base
+
+      include Protocols::Oauth
+
+      attr_accessor :access_token_path, :authorize_path, :request_token_path,
+                    :user_info_path, :site, :signature_method, :private_key_file, :callback_url
+
+
+      def initialize
+        @configuration = {
+            authorize_path: '/authorize',
+            request_token_path: '/request-token',
+            access_token_path: '/access-token'
+        }
+        @user_info_path = '/users/me'
+      end
+
+      # Override included get_consumer method to provide authorize_path
+      #read extra configurations
+      def get_consumer
+        @configuration = @configuration.merge({
+            site: site,
+            signature_method: signature_method,
+            consumer_key: key,
+            private_key_file: private_key_file
+        })
+        ::OAuth::Consumer.new(@key, @secret, @configuration)
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_path)
+
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)['users'].first
+          h[:uid] = user_hash[:user_info]['id'].to_s
+        end
+      end
+
+      # calculates and returns the url to which the user should be redirected,
+      # to get authenticated at the external provider's site.
+      def login_url(params, session)
+        req_token = get_request_token
+        session[:request_token]         = req_token.token
+        session[:request_token_secret]  = req_token.secret
+
+        #it was like that -> redirect_to authorize_url({ request_token: req_token.token, request_token_secret: req_token.secret })
+        #for some reason Jira does not need these parameters
+
+        get_request_token(
+          session[:request_token],
+          session[:request_token_secret]
+        ).authorize_url
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, session)
+        args = {
+          oauth_verifier:       params[:oauth_verifier],
+          request_token:        session[:request_token],
+          request_token_secret: session[:request_token_secret]
+        }
+
+        args.merge!({ code: params[:code] }) if params[:code]
+        get_access_token(args)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/linkedin.rb

@@ -34,7 +34,7 @@ module Sorcery
         fields = self.user_info_fields.join(',')
         response = access_token.get("#{@user_info_path}:(#{fields})", 'x-li-format' => 'json')
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)
           h[:uid] = h[:user_info]['id'].to_s
         end

data/lib/sorcery/providers/liveid.rb

@@ -26,7 +26,7 @@ module Sorcery
         access_token.token_param = 'access_token'
         response = access_token.get(user_info_url)
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)
           h[:uid] = h[:user_info]['id']
         end

data/lib/sorcery/providers/salesforce.rb

@@ -0,0 +1,50 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with salesforce.com.
+    #
+    #   config.salesforce.key = <key>
+    #   config.salesforce.secret = <secret>
+    #   ...
+    #
+    class Salesforce < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_url, :token_url, :scope
+
+      def initialize
+        super
+
+        @site          = 'https://login.salesforce.com'
+        @auth_url      = '/services/oauth2/authorize'
+        @token_url     = '/services/oauth2/token'
+      end
+
+      def get_user_hash(access_token)
+        user_info_url = access_token.params['id']
+        response = access_token.get(user_info_url)
+
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)
+          h[:uid] = h[:user_info]['user_id']
+        end
+      end
+
+      # calculates and returns the url to which the user should be redirected,
+      # to get authenticated at the external provider's site.
+      def login_url(params, session)
+        authorize_url({ authorize_url: auth_url })
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+
+        get_access_token(args, token_url: token_url, token_method: :post)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/twitter.rb

@@ -27,7 +27,7 @@ module Sorcery
       def get_user_hash(access_token)
         response = access_token.get(user_info_path)
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)
           h[:uid] = h[:user_info]['id'].to_s
         end

data/lib/sorcery/providers/vk.rb

@@ -19,24 +19,26 @@ module Sorcery
         @user_info_url  = 'https://api.vk.com/method/getProfiles'
         @auth_path      = '/authorize'
         @token_path     = '/access_token'
-        @scope          = ''
+        @scope          = 'email'
       end
 
       def get_user_hash(access_token)
-        user_hash = {}
+        user_hash = auth_hash(access_token)
 
         params = {
           access_token: access_token.token,
           uids:         access_token.params['user_id'],
           fields:       user_info_mapping.values.join(','),
-          scope:        scope,
+          scope:        scope
         }
 
         response = access_token.get(user_info_url, params: params)
         if user_hash[:user_info] = JSON.parse(response.body)
           user_hash[:user_info] = user_hash[:user_info]['response'][0]
-          user_hash[:user_info]['full_name'] = [user_hash[:user_info]['first_name'], user_hash[:user_info]['last_name']].join
+          user_hash[:user_info]['full_name'] = [user_hash[:user_info]['first_name'], user_hash[:user_info]['last_name']].join(' ')
+
           user_hash[:uid] = user_hash[:user_info]['uid']
+          user_hash[:user_info]['email'] = access_token.params['email']
         end
         user_hash
       end

data/lib/sorcery/providers/xing.rb

@@ -32,9 +32,9 @@ module Sorcery
       def get_user_hash(access_token)
         response = access_token.get(user_info_path)
 
-        {}.tap do |h|
+        auth_hash(access_token).tap do |h|
           h[:user_info] = JSON.parse(response.body)['users'].first
-          h[:uid] = user_hash[:user_info]['id'].to_s
+          h[:uid] = h[:user_info]['id'].to_s
         end
       end
 

data/lib/sorcery/test_helpers/internal.rb

@@ -30,14 +30,14 @@ module Sorcery
 
       def create_new_user(attributes_hash = nil)
         @user = build_new_user(attributes_hash)
-        @user.sorcery_save(:raise_on_failure => true)
+        @user.sorcery_adapter.save(:raise_on_failure => true)
         @user
       end
 
       def create_new_external_user(provider, attributes_hash = nil)
         user_attributes_hash = attributes_hash || {:username => 'gizmo'}
         @user = User.new(user_attributes_hash)
-        @user.sorcery_save(:raise_on_failure => true)
+        @user.sorcery_adapter.save(:raise_on_failure => true)
         @user.authentications.create!({:provider => provider, :uid => 123})
         @user
       end
@@ -47,7 +47,7 @@ module Sorcery
 
         user_attributes_hash = attributes_hash || {:username => 'gizmo'}
         @user = User.new(user_attributes_hash)
-        @user.sorcery_save(:raise_on_failure => true)
+        @user.sorcery_adapter.save(:raise_on_failure => true)
         @user.send(authentication_association).create!({:provider => provider, :uid => 123})
         @user
       end
@@ -58,6 +58,10 @@ module Sorcery
         end
       end
 
+      def update_model(&block)
+        User.class_exec(&block)
+      end
+
       private
 
       # reload user class between specs