sorcery 0.8.6 → 0.9.0

data/lib/sorcery/model/submodules/reset_password.rb

@@ -50,13 +50,7 @@ module Sorcery
           base.extend(ClassMethods)
 
           base.sorcery_config.after_config << :validate_mailer_defined
-          base.sorcery_config.after_config << :define_reset_password_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_reset_password_mongo_mapper_fields
-          end
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_reset_password_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_reset_password_fields
 
           base.send(:include, InstanceMethods)
 
@@ -80,45 +74,33 @@ module Sorcery
             raise ArgumentError, msg if @sorcery_config.reset_password_mailer == nil and @sorcery_config.reset_password_mailer_disabled == false
           end
 
-          def define_reset_password_mongoid_fields
-            field sorcery_config.reset_password_token_attribute_name,             :type => String
-            field sorcery_config.reset_password_token_expires_at_attribute_name,  :type => Time
-            field sorcery_config.reset_password_email_sent_at_attribute_name,     :type => Time
+          def define_reset_password_fields
+            sorcery_adapter.define_field sorcery_config.reset_password_token_attribute_name, String
+            sorcery_adapter.define_field sorcery_config.reset_password_token_expires_at_attribute_name, Time
+            sorcery_adapter.define_field sorcery_config.reset_password_email_sent_at_attribute_name, Time
           end
 
-          def define_reset_password_mongo_mapper_fields
-            key sorcery_config.reset_password_token_attribute_name, String
-            key sorcery_config.reset_password_token_expires_at_attribute_name, Time
-            key sorcery_config.reset_password_email_sent_at_attribute_name, Time
-          end
-
-          def define_reset_password_datamapper_fields
-            property sorcery_config.reset_password_token_attribute_name,            String
-            property sorcery_config.reset_password_token_expires_at_attribute_name, Time
-            property sorcery_config.reset_password_email_sent_at_attribute_name,    Time
-            [sorcery_config.reset_password_token_expires_at_attribute_name,
-             sorcery_config.reset_password_email_sent_at_attribute_name].each do |sym|
-               alias_method "orig_#{sym}", sym
-               define_method(sym) do
-                 t = send("orig_#{sym}")
-                 t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-               end
-            end
-          end
         end
 
         module InstanceMethods
-          # generates a reset code with expiration and sends an email to the user.
-          def deliver_reset_password_instructions!
+          # generates a reset code with expiration
+          def generate_reset_password_token!
             config = sorcery_config
-            # hammering protection
-            return false if config.reset_password_time_between_emails && self.send(config.reset_password_email_sent_at_attribute_name) && self.send(config.reset_password_email_sent_at_attribute_name) > config.reset_password_time_between_emails.ago.utc
             attributes = {config.reset_password_token_attribute_name => TemporaryToken.generate_random_token,
                           config.reset_password_email_sent_at_attribute_name => Time.now.in_time_zone}
             attributes[config.reset_password_token_expires_at_attribute_name] = Time.now.in_time_zone + config.reset_password_expiration_period if config.reset_password_expiration_period
-            self.class.transaction do
-              self.update_many_attributes(attributes)
-              send_reset_password_email! unless sorcery_config.reset_password_mailer_disabled
+
+            self.sorcery_adapter.update_attributes(attributes)
+          end
+
+          # generates a reset code with expiration and sends an email to the user.
+          def deliver_reset_password_instructions!
+            config = sorcery_config
+            # hammering protection
+            return false if config.reset_password_time_between_emails.present? && self.send(config.reset_password_email_sent_at_attribute_name) && self.send(config.reset_password_email_sent_at_attribute_name) > config.reset_password_time_between_emails.seconds.ago.utc
+            self.class.sorcery_adapter.transaction do
+              generate_reset_password_token!
+              send_reset_password_email! unless config.reset_password_mailer_disabled
             end
           end
 
@@ -126,11 +108,11 @@ module Sorcery
           def change_password!(new_password)
             clear_reset_password_token
             self.send(:"#{sorcery_config.password_attribute_name}=", new_password)
-            sorcery_save
+            sorcery_adapter.save
           end
 
           protected
-          
+
           def send_reset_password_email!
             generic_send_email(:reset_password_email_method_name, :reset_password_mailer)
           end

data/lib/sorcery/model/submodules/user_activation.rb

@@ -15,7 +15,7 @@ module Sorcery
                                                                           # (sent by email).
 
                           :activation_token_expires_at_attribute_name,    # the attribute name to hold activation code
-                                                                          # expiration date. 
+                                                                          # expiration date.
 
                           :activation_token_expiration_period,            # how many seconds before the activation code
                                                                           # expires. nil for never expires.
@@ -51,33 +51,14 @@ module Sorcery
           end
 
           base.class_eval do
-            if defined?(DataMapper) && self.ancestors.include?(DataMapper::Resource)
-              before :valid? do
-                if self.send(sorcery_config.password_attribute_name).present?
-                  setup_activation
-                end
-              end
-              after :create do
-                if send_activation_needed_email?
-                  send_activation_needed_email!
-                end
-              end
-            else
-              # don't setup activation if no password supplied - this user is created automatically
-              before_create :setup_activation, :if => Proc.new { |user| user.send(sorcery_config.password_attribute_name).present? }
-              # don't send activation needed email if no crypted password created - this user is external (OAuth etc.)
-              after_create  :send_activation_needed_email!, :if => :send_activation_needed_email?
-            end
+            # don't setup activation if no password supplied - this user is created automatically
+            sorcery_adapter.define_callback :before, :create, :setup_activation, :if => Proc.new { |user| user.send(sorcery_config.password_attribute_name).present? }
+            # don't send activation needed email if no crypted password created - this user is external (OAuth etc.)
+            sorcery_adapter.define_callback :after, :create, :send_activation_needed_email!, :if => :send_activation_needed_email?
           end
 
           base.sorcery_config.after_config << :validate_mailer_defined
-          base.sorcery_config.after_config << :define_user_activation_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_user_activation_mongo_mapper_fields
-          end
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_user_activation_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_user_activation_fields
           base.sorcery_config.before_authenticate << :prevent_non_active_login
 
           base.extend(ClassMethods)
@@ -104,58 +85,35 @@ module Sorcery
             raise ArgumentError, msg if @sorcery_config.user_activation_mailer == nil and @sorcery_config.activation_mailer_disabled == false
           end
 
-          def define_user_activation_mongoid_fields
-            self.class_eval do
-              field sorcery_config.activation_state_attribute_name,            :type => String
-              field sorcery_config.activation_token_attribute_name,            :type => String
-              field sorcery_config.activation_token_expires_at_attribute_name, :type => Time
-            end
-          end
-
-          def define_user_activation_mongo_mapper_fields
+          def define_user_activation_fields
             self.class_eval do
-              key sorcery_config.activation_state_attribute_name, String
-              key sorcery_config.activation_token_attribute_name, String
-              key sorcery_config.activation_token_expires_at_attribute_name, Time
-            end
-          end
-
-          def define_user_activation_datamapper_fields
-            self.class_eval do
-              property sorcery_config.activation_state_attribute_name,            String
-              property sorcery_config.activation_token_attribute_name,            String
-              property sorcery_config.activation_token_expires_at_attribute_name, Time
-              [sorcery_config.activation_token_expires_at_attribute_name].each do |sym|
-                alias_method "orig_#{sym}", sym
-                define_method(sym) do
-                  t = send("orig_#{sym}")
-                  t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-                end
-              end
+              sorcery_adapter.define_field sorcery_config.activation_state_attribute_name, String
+              sorcery_adapter.define_field sorcery_config.activation_token_attribute_name, String
+              sorcery_adapter.define_field sorcery_config.activation_token_expires_at_attribute_name, Time
             end
           end
         end
 
         module InstanceMethods
+          def setup_activation
+            config = sorcery_config
+            generated_activation_token = TemporaryToken.generate_random_token
+            self.send(:"#{config.activation_token_attribute_name}=", generated_activation_token)
+            self.send(:"#{config.activation_state_attribute_name}=", "pending")
+            self.send(:"#{config.activation_token_expires_at_attribute_name}=", Time.now.in_time_zone + config.activation_token_expiration_period) if config.activation_token_expiration_period
+          end
+
           # clears activation code, sets the user as 'active' and optionaly sends a success email.
           def activate!
             config = sorcery_config
             self.send(:"#{config.activation_token_attribute_name}=", nil)
             self.send(:"#{config.activation_state_attribute_name}=", "active")
             send_activation_success_email! if send_activation_success_email?
-            sorcery_save(:validate => false, :raise_on_failure => true)
+            sorcery_adapter.save(:validate => false, :raise_on_failure => true)
           end
 
           protected
 
-          def setup_activation
-            config = sorcery_config
-            generated_activation_token = TemporaryToken.generate_random_token
-            self.send(:"#{config.activation_token_attribute_name}=", generated_activation_token)
-            self.send(:"#{config.activation_state_attribute_name}=", "pending")
-            self.send(:"#{config.activation_token_expires_at_attribute_name}=", Time.now.in_time_zone + config.activation_token_expiration_period) if config.activation_token_expiration_period
-          end
-
           # called automatically after user initial creation.
           def send_activation_needed_email!
             generic_send_email(:activation_needed_email_method_name, :user_activation_mailer)
@@ -164,14 +122,14 @@ module Sorcery
           def send_activation_success_email!
             generic_send_email(:activation_success_email_method_name, :user_activation_mailer)
           end
-          
+
           def send_activation_success_email?
             !external? && (
               !(sorcery_config.activation_success_email_method_name.nil? ||
                 sorcery_config.activation_mailer_disabled == true)
             )
           end
-          
+
           def send_activation_needed_email?
             !external? && (
               !(sorcery_config.activation_needed_email_method_name.nil? ||

data/lib/sorcery/model/temporary_token.rb

@@ -3,22 +3,22 @@ require 'securerandom'
 module Sorcery
   module Model
     # This module encapsulates the logic for temporary token.
-    # A temporary token is created to identify a user in scenarios 
+    # A temporary token is created to identify a user in scenarios
     # such as reseting password and activating the user by email.
     module TemporaryToken
       def self.included(base)
         base.extend(ClassMethods)
       end
-      
+
       # Random code, used for salt and temporary tokens.
       def self.generate_random_token
         SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
       end
-      
+
       module ClassMethods
         def load_from_token(token, token_attr_name, token_expiration_date_attr)
           return nil if token.blank?
-          user = find_by_sorcery_token(token_attr_name,token)
+          user = sorcery_adapter.find_by_token(token_attr_name,token)
           if !user.blank? && !user.send(token_expiration_date_attr).nil?
             return Time.now.in_time_zone < user.send(token_expiration_date_attr) ? user : nil
           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

@@ -30,7 +30,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

data/lib/sorcery/providers/github.rb

@@ -25,7 +25,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

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