sorcery 0.8.6 → 0.9.0

data/lib/sorcery/adapters/base_adapter.rb

@@ -0,0 +1,30 @@
+module Sorcery
+  module Adapters
+    class BaseAdapter
+      def initialize(model)
+        @model = model
+      end
+
+      def self.from(klass)
+        @klass = klass
+        self
+      end
+
+      def self.delete_all
+        @klass.delete_all
+      end
+
+      def self.find(id)
+        find_by_id(id)
+      end
+
+      def increment(field)
+        @model.increment(field)
+      end
+
+      def update_attribute(name, value)
+        update_attributes(name => value)
+      end
+    end
+  end
+end

data/lib/sorcery/adapters/data_mapper_adapter.rb

@@ -0,0 +1,176 @@
+module Sorcery
+  module Adapters
+    class DataMapperAdapter < BaseAdapter
+      module Wrapper
+        extend ActiveSupport::Concern
+
+        included do
+          sorcery_adapter.verify_submodules_compatibility!
+        end
+
+        def sorcery_adapter
+          @sorcery_adapter ||= Sorcery::Adapters::DataMapperAdapter.new(self)
+        end
+
+        module ClassMethods
+          def sorcery_adapter
+            Sorcery::Adapters::DataMapperAdapter.from(self)
+          end
+        end
+      end
+
+      def increment(attr)
+        @model[attr] ||= 0
+        @model[attr] += 1
+        @model
+      end
+
+      def update_attributes(attrs)
+        attrs.each do |name, value|
+          value = value.utc if value.is_a?(ActiveSupport::TimeWithZone)
+          @model.send(:"#{name}=", value)
+        end
+        @model.class.get(@model.id).update(attrs)
+      end
+
+      def update_attribute(name, value)
+        update_attributes(name => value)
+      end
+
+      def save(options = {})
+        if options.key?(:validate) && !options[:validate]
+          @model.save!
+        else
+          @model.save
+        end
+      end
+
+      class << self
+        def define_field(name, type, options={})
+          @klass.property name, type, options.slice(:length, :default)
+
+          # Workaround local timezone retrieval problem NOTE dm-core issue #193
+          if type == Time
+            @klass.send(:alias_method, "orig_#{name}", name)
+            @klass.send :define_method, name do
+              t = send("orig_#{name}")
+              t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
+            end
+          end
+        end
+
+        def define_callback(time, event, method_name, options={})
+          event = :valid? if event == :validation
+          condition = options[:if]
+
+          user_klass = @klass
+
+          block = Proc.new do |record|
+            if condition.nil?
+              send(method_name)
+            elsif condition.respond_to?(:call)
+              send(method_name) if condition.call(self)
+            elsif condition.is_a? Symbol
+              send(method_name) if send(condition)
+            end
+          end
+
+          @klass.send(time, event, &block)
+        end
+
+        def find(id)
+          @klass.get(id)
+        end
+
+        def delete_all
+          @klass.destroy
+        end
+
+        # NOTE
+        # DM Adapter dependent
+        # DM creates MySQL tables case insensitive by default
+        # http://datamapper.lighthouseapp.com/projects/20609-datamapper/tickets/1105
+        def find_by_credentials(credentials)
+          credential = credentials[0].dup
+          credential.downcase! if @klass.sorcery_config.downcase_username_before_authenticating
+          @klass.sorcery_config.username_attribute_names.each do |name|
+            @user = @klass.first(name => credential)
+            break if @user
+          end
+          !!@user ? @klass.get(@user.id) : nil
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config = ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          user = @klass.first(@user_config.provider_attribute_name => provider, @user_config.provider_uid_attribute_name => uid)
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        def find_by_token(token_attr_name, token)
+          @klass.first(token_attr_name => token)
+        end
+
+        def find_by_id(id)
+          @klass.get(id)
+        rescue ::DataMapper::ObjectNotFoundError
+          nil
+        end
+
+        def find_by_activation_token(token)
+          user = @klass.first(@klass.sorcery_config.activation_token_attribute_name => token)
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        def find_by_remember_me_token(token)
+          user = @klass.first(@klass.sorcery_config.remember_me_token_attribute_name => token)
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        def find_by_username(username)
+          user = nil
+          @klass.sorcery_config.username_attribute_names.each do |name|
+            user = @klass.first(name => username)
+            break if user
+          end
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        def transaction(&blk)
+          @klass.tap(&blk)
+        end
+
+        def find_by_sorcery_token(token_attr_name, token)
+          user = @klass.first(token_attr_name => token)
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        def find_by_email(email)
+          user = @klass.first(@klass.sorcery_config.email_attribute_name => email)
+          !!user ? @klass.get(user.id) : nil
+        end
+
+        # NOTE
+        # DM Adapter dependent
+        def get_current_users
+          unless @klass.repository.adapter.is_a?(::DataMapper::Adapters::MysqlAdapter)
+            raise 'Unsupported DataMapper Adapter'
+          end
+          config = @klass.sorcery_config
+          ret = @klass.all(config.last_logout_at_attribute_name => nil) |
+                @klass.all(config.last_activity_at_attribute_name.gt => config.last_logout_at_attribute_name)
+          ret = ret.all(config.last_activity_at_attribute_name.not => nil)
+          ret = ret.all(config.last_activity_at_attribute_name.gt => config.activity_timeout.seconds.ago.utc)
+          ret
+        end
+
+        def verify_submodules_compatibility!
+          active_submodules = [::Sorcery::Controller::Config.submodules].flatten
+
+          if active_submodules.include?(:activity_logging) && !repository.adapter.is_a?(::DataMapper::Adapters::MysqlAdapter)
+            raise "DataMapper adapter compatibility error, please check documentation"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorcery/adapters/mongo_mapper_adapter.rb

@@ -0,0 +1,110 @@
+module Sorcery
+  module Adapters
+    class MongoMapperAdapter < BaseAdapter
+      module Wrapper
+        extend ActiveSupport::Concern
+
+        included do
+          extend Sorcery::Model
+        end
+
+        def sorcery_adapter
+          @sorcery_adapter ||= Sorcery::Adapters::MongoMapperAdapter.new(self)
+        end
+
+        module ClassMethods
+          def sorcery_adapter
+            Sorcery::Adapters::MongoMapperAdapter.from(self)
+          end
+        end
+      end
+
+      def increment(attr)
+        @model[attr] ||= 0
+        @model[attr] += 1
+        @model.class.increment(@model.id, attr => 1)
+      end
+
+      def save(options = {})
+        if options.delete(:raise_on_failure) && options[:validate] != false
+          @model.save! options
+        else
+          @model.save options
+        end
+      end
+
+      def update_attributes(attrs)
+        @model.update_attributes(attrs)
+      end
+
+      class << self
+        def define_field(name, type, options={})
+          @klass.key name, type, options.slice(:default)
+        end
+
+        def define_callback(time, event, method_name, options={})
+          @klass.send "#{time}_#{event}", method_name, options.slice(:if)
+        end
+
+        def credential_regex(credential)
+          return { :$regex =>  /^#{Regexp.escape(credential)}$/i } if (@klass.sorcery_config.downcase_username_before_authenticating)
+          return credential
+        end
+
+        def find_by_credentials(credentials)
+          user = nil
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            user = @klass.where(attribute => credential_regex(credentials[0])).first
+            break if user
+          end
+          user
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          @klass.where(@user_config.provider_attribute_name => provider, @user_config.provider_uid_attribute_name => uid).first
+        end
+
+        def find_by_id(id)
+          @klass.find(id)
+        end
+
+        def find_by_username(username)
+          if @klass.sorcery_config.downcase_username_before_authenticating
+            username = username.downcase
+          end
+
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            result = @klass.where(attribute => username).first
+            return result if result
+          end
+        end
+
+        def find_by_activation_token(token)
+          @klass.where(@klass.sorcery_config.activation_token_attribute_name => token).first
+        end
+
+        def find_by_email(email)
+          @klass.where(@klass.sorcery_config.email_attribute_name => email).first
+        end
+
+        def find_by_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def transaction(&blk)
+          @klass.tap(&blk)
+        end
+
+        def find_by_sorcery_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def get_current_users
+          raise "this method is unavailable for MongoMapper"
+        end
+
+      end
+    end
+  end
+end

data/lib/sorcery/adapters/mongoid_adapter.rb

@@ -0,0 +1,97 @@
+module Sorcery
+  module Adapters
+    class MongoidAdapter < BaseAdapter
+      def increment(attr)
+        mongoid_4? ? @model.inc(attr => 1) : @model.inc(attr, 1)
+      end
+
+      def update_attributes(attrs)
+        attrs.each do |name, value|
+          attrs[name] = value.utc if value.is_a?(ActiveSupport::TimeWithZone)
+          @model.send(:"#{name}=", value)
+        end
+        @model.class.where(:_id => @model.id).update_all(attrs)
+      end
+
+      def update_attribute(name, value)
+        update_attributes(name => value)
+      end
+
+      def save(options = {})
+        mthd = options.delete(:raise_on_failure) ? :save! : :save
+        @model.send(mthd, options)
+      end
+
+      def mongoid_4?
+        Gem::Version.new(::Mongoid::VERSION) >= Gem::Version.new("4.0.0.alpha")
+      end
+
+      class << self
+
+        def define_field(name, type, options={})
+          @klass.field name, options.slice(:default).merge(type: type)
+        end
+
+        def define_callback(time, event, method_name, options={})
+          @klass.send "#{time}_#{event}", method_name, options.slice(:if)
+        end
+
+        def credential_regex(credential)
+          return { :$regex =>  /^#{Regexp.escape(credential)}$/i  } if (@klass.sorcery_config.downcase_username_before_authenticating)
+          credential
+        end
+
+        def find_by_credentials(credentials)
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            @user = @klass.where(attribute => credential_regex(credentials[0])).first
+            break if @user
+          end
+          @user
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          @klass.where(@user_config.provider_attribute_name => provider, @user_config.provider_uid_attribute_name => uid).first
+        end
+
+        def find_by_activation_token(token)
+          @klass.where(@klass.sorcery_config.activation_token_attribute_name => token).first
+        end
+
+        def find_by_remember_me_token(token)
+          @klass.where(@klass.sorcery_config.remember_me_token_attribute_name => token).first
+        end
+
+        def transaction(&blk)
+          tap(&blk)
+        end
+
+        def find_by_id(id)
+          @klass.find(id)
+        rescue ::Mongoid::Errors::DocumentNotFound
+          nil
+        end
+
+        def find_by_username(username)
+          query = @klass.sorcery_config.username_attribute_names.map {|name| {name => username}}
+          @klass.any_of(*query).first
+        end
+
+        def find_by_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def find_by_email(email)
+          @klass.where(@klass.sorcery_config.email_attribute_name => email).first
+        end
+
+        def get_current_users
+          config = @klass.sorcery_config
+          @klass.where(config.last_activity_at_attribute_name.ne => nil) \
+          .where("this.#{config.last_logout_at_attribute_name} == null || this.#{config.last_activity_at_attribute_name} > this.#{config.last_logout_at_attribute_name}") \
+          .where(config.last_activity_at_attribute_name.gt => config.activity_timeout.seconds.ago.utc).order_by([:_id,:asc])
+        end
+      end
+    end
+  end
+end

data/lib/sorcery/controller.rb

@@ -103,7 +103,7 @@ module Sorcery
       # @param [<User-Model>] user the user instance.
       # @return - do not depend on the return value.
       def auto_login(user, should_remember = false)
-        session[:user_id] = user.id
+        session[:user_id] = user.id.to_s
         @current_user = user
       end
 
@@ -126,7 +126,9 @@ module Sorcery
       end
 
       def login_from_session
-        @current_user = (user_class.find_by_id(session[:user_id]) if session[:user_id]) || nil
+        @current_user = if session[:user_id]
+                          user_class.sorcery_adapter.find_by_id(session[:user_id])
+                        end
       end
 
       def after_login!(user, credentials = [])
@@ -151,66 +153,5 @@ module Sorcery
 
     end
 
-    module Config
-      class << self
-        attr_accessor :submodules,
-                      :user_class,                    # what class to use as the user class.
-                      :not_authenticated_action,      # what controller action to call for non-authenticated users.
-
-                      :save_return_to_url,            # 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.
-
-                      :cookie_domain,                 # set domain option for cookies
-
-                      :login_sources,
-                      :after_login,
-                      :after_failed_login,
-                      :before_logout,
-                      :after_logout
-
-        def init!
-          @defaults = {
-            :@user_class                           => nil,
-            :@submodules                           => [],
-            :@not_authenticated_action             => :not_authenticated,
-            :@login_sources                        => [],
-            :@after_login                          => [],
-            :@after_failed_login                   => [],
-            :@before_logout                        => [],
-            :@after_logout                         => [],
-            :@save_return_to_url                   => true,
-            :@cookie_domain                        => nil
-          }
-        end
-
-        # Resets all configuration options to their default values.
-        def reset!
-          @defaults.each do |k,v|
-            instance_variable_set(k,v)
-          end
-        end
-
-        def update!
-          @defaults.each do |k,v|
-            instance_variable_set(k,v) if !instance_variable_defined?(k)
-          end
-        end
-
-        def user_config(&blk)
-          block_given? ? @user_config = blk : @user_config
-        end
-
-        def configure(&blk)
-          @configure_blk = blk
-        end
-
-        def configure!
-          @configure_blk.call(self) if @configure_blk
-        end
-      end
-      init!
-      reset!
-    end
-  end
+	end
 end