sorcery 0.8.2 → 0.9.0

data/lib/generators/sorcery/templates/initializer.rb

@@ -27,6 +27,12 @@ Rails.application.config.sorcery.configure do |config|
   # config.cookie_domain =
 
 
+  # Allow the remember_me cookie to be set through AJAX
+  # Default: `true`
+  #
+  # config.remember_me_httponly =
+
+
   # -- session timeout --
   # How long in seconds to keep the session alive.
   # Default: `3600`
@@ -67,7 +73,7 @@ Rails.application.config.sorcery.configure do |config|
 
 
   # -- external --
-  # What providers are supported by this app, i.e. [:twitter, :facebook, :github, :linkedin, :xing, :google, :liveid] .
+  # What providers are supported by this app, i.e. [:twitter, :facebook, :github, :linkedin, :xing, :google, :liveid, :salesforce] .
   # Default: `[]`
   #
   # config.external_providers =
@@ -101,7 +107,7 @@ Rails.application.config.sorcery.configure do |config|
   # config.xing.user_info_mapping = {first_name: "first_name", last_name: "last_name"}
   #
   #
-  # Twitter wil not accept any requests nor redirect uri containing localhost,
+  # Twitter will not accept any requests nor redirect uri containing localhost,
   # make sure you use 0.0.0.0:3000 to access your app in development
   #
   # config.twitter.key = ""
@@ -114,6 +120,7 @@ Rails.application.config.sorcery.configure do |config|
   # config.facebook.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=facebook"
   # config.facebook.user_info_mapping = {:email => "name"}
   # config.facebook.access_permissions = ["email", "publish_stream"]
+  # config.facebook.display = "page"
   #
   # config.github.key = ""
   # config.github.secret = ""
@@ -139,12 +146,35 @@ Rails.application.config.sorcery.configure do |config|
   # config.liveid.callback_url = "http://mydomain.com:3000/oauth/callback?provider=liveid"
   # config.liveid.user_info_mapping = {:username => "name"}
 
+  # For information about JIRA API:
+  # https://developer.atlassian.com/display/JIRADEV/JIRA+REST+API+Example+-+OAuth+authentication
+  # to obtain the consumer key and the public key you can use the jira-ruby gem https://github.com/sumoheavy/jira-ruby
+  # or run openssl req -x509 -nodes -newkey rsa:1024 -sha1 -keyout rsakey.pem -out rsacert.pem to obtain the public key
+  # Make sure you have configured the application link properly
+
+  # config.jira.key = "1234567"
+  # config.jira.secret = "jiraTest"
+  # config.jira.site = "http://localhost:2990/jira/plugins/servlet/oauth"
+  # config.jira.signature_method =  "RSA-SHA1"
+  # config.jira.private_key_file = "rsakey.pem"
+
+  # For information about Salesforce API:
+  # https://developer.salesforce.com/signup &
+  # https://www.salesforce.com/us/developer/docs/api_rest/
+  # Salesforce callback_url must be https. You can run the following to generate self-signed ssl cert
+  # openssl req -new -newkey rsa:2048 -sha1 -days 365 -nodes -x509 -keyout server.key -out server.crt
+  # Make sure you have configured the application link properly
+  # config.salesforce.key = '123123'
+  # config.salesforce.secret = 'acb123'
+  # config.salesforce.callback_url = "https://127.0.0.1:9292/oauth/callback?provider=salesforce"
+  # config.salesforce.scope = "full"
+  # config.salesforce.user_info_mapping = {:email => "email"}
 
   # --- user config ---
   config.user_config do |user|
     # -- core --
     # specify username attributes, for example: [:username, :email].
-    # Default: `[:username]`
+    # Default: `[:email]`
     #
     # user.username_attribute_names =
 
@@ -217,11 +247,6 @@ Rails.application.config.sorcery.configure do |config|
 
 
     # -- remember_me --
-    # allow the remember_me cookie to settable through AJAX
-    # Default: `true`
-    #
-    # user.remember_me_httponly =
-
     # How long in seconds the session length will be
     # Default: `604800`
     #
@@ -330,7 +355,7 @@ Rails.application.config.sorcery.configure do |config|
     # user.reset_password_expiration_period =
 
 
-    # hammering protection, how long to wait before allowing another email to be sent.
+    # hammering protection, how long in seconds to wait before allowing another email to be sent.
     # Default: `5 * 60`
     #
     # user.reset_password_time_between_emails =
@@ -400,7 +425,7 @@ Rails.application.config.sorcery.configure do |config|
     # user.last_activity_at_attribute_name =
 
 
-    # How long since last activity is he user defined logged out?
+    # How long since last activity is the user defined logged out?
     # Default: `10 * 60`
     #
     # user.activity_timeout =

data/lib/generators/sorcery/templates/migration/activity_logging.rb

@@ -1,19 +1,10 @@
 class SorceryActivityLogging < ActiveRecord::Migration
-  def self.up
+  def change
     add_column :<%= model_class_name.tableize %>, :last_login_at,     :datetime, :default => nil
     add_column :<%= model_class_name.tableize %>, :last_logout_at,    :datetime, :default => nil
     add_column :<%= model_class_name.tableize %>, :last_activity_at,  :datetime, :default => nil
     add_column :<%= model_class_name.tableize %>, :last_login_from_ip_address, :string, :default => nil
-    
-    add_index :<%= model_class_name.tableize %>, [:last_logout_at, :last_activity_at]
-  end
 
-  def self.down
-    remove_index :<%= model_class_name.tableize %>, [:last_logout_at, :last_activity_at]
-    
-    remove_column :<%= model_class_name.tableize %>, :last_login_from_ip_address
-    remove_column :<%= model_class_name.tableize %>, :last_activity_at
-    remove_column :<%= model_class_name.tableize %>, :last_logout_at
-    remove_column :<%= model_class_name.tableize %>, :last_login_at
+    add_index :<%= model_class_name.tableize %>, [:last_logout_at, :last_activity_at]
   end
 end

data/lib/generators/sorcery/templates/migration/brute_force_protection.rb

@@ -1,13 +1,9 @@
 class SorceryBruteForceProtection < ActiveRecord::Migration
-  def self.up
+  def change
     add_column :<%= model_class_name.tableize %>, :failed_logins_count, :integer, :default => 0
     add_column :<%= model_class_name.tableize %>, :lock_expires_at, :datetime, :default => nil
     add_column :<%= model_class_name.tableize %>, :unlock_token, :string, :default => nil
-  end
 
-  def self.down
-    remove_column :<%= model_class_name.tableize %>, :lock_expires_at
-    remove_column :<%= model_class_name.tableize %>, :failed_logins_count
-    remove_column :<%= model_class_name.tableize %>, :unlock_token
+    add_index :<%= model_class_name.tableize %>, :unlock_token
   end
-end
+end

data/lib/generators/sorcery/templates/migration/core.rb

@@ -1,16 +1,13 @@
 class SorceryCore < ActiveRecord::Migration
-  def self.up
+  def change
     create_table :<%= model_class_name.tableize %> do |t|
-      t.string :username,         :null => false  # if you use another field as a username, for example email, you can safely remove this field.
-      t.string :email,            :default => nil # if you use this field as a username, you might want to make it :null => false.
-      t.string :crypted_password, :default => nil
-      t.string :salt,             :default => nil
+      t.string :email,            :null => false
+      t.string :crypted_password
+      t.string :salt
 
       t.timestamps
     end
-  end
 
-  def self.down
-    drop_table :<%= model_class_name.tableize %>
+    add_index :<%= model_class_name.tableize %>, :email, unique: true
   end
 end

data/lib/generators/sorcery/templates/migration/external.rb

@@ -1,14 +1,12 @@
 class SorceryExternal < ActiveRecord::Migration
-  def self.up
+  def change
     create_table :authentications do |t|
       t.integer :<%= model_class_name.tableize.singularize %>_id, :null => false
       t.string :provider, :uid, :null => false
 
       t.timestamps
     end
-  end
 
-  def self.down
-    drop_table :authentications
+    add_index :<%= model_class_name.tableize %>, [:provider, :uid]
   end
-end
+end

data/lib/generators/sorcery/templates/migration/remember_me.rb

@@ -1,15 +1,8 @@
 class SorceryRememberMe < ActiveRecord::Migration
-  def self.up
+  def change
     add_column :<%= model_class_name.tableize %>, :remember_me_token, :string, :default => nil
     add_column :<%= model_class_name.tableize %>, :remember_me_token_expires_at, :datetime, :default => nil
-    
-    add_index :<%= model_class_name.tableize %>, :remember_me_token
-  end
 
-  def self.down
-    remove_index :<%= model_class_name.tableize %>, :remember_me_token
-    
-    remove_column :<%= model_class_name.tableize %>, :remember_me_token_expires_at
-    remove_column :<%= model_class_name.tableize %>, :remember_me_token
+    add_index :<%= model_class_name.tableize %>, :remember_me_token
   end
 end

data/lib/generators/sorcery/templates/migration/reset_password.rb

@@ -1,17 +1,9 @@
 class SorceryResetPassword < ActiveRecord::Migration
-  def self.up
+  def change
     add_column :<%= model_class_name.tableize %>, :reset_password_token, :string, :default => nil
     add_column :<%= model_class_name.tableize %>, :reset_password_token_expires_at, :datetime, :default => nil
     add_column :<%= model_class_name.tableize %>, :reset_password_email_sent_at, :datetime, :default => nil
-    
-    add_index :<%= model_class_name.tableize %>, :reset_password_token
-  end
 
-  def self.down
-    remove_index :<%= model_class_name.tableize %>, :reset_password_token
-    
-    remove_column :<%= model_class_name.tableize %>, :reset_password_email_sent_at
-    remove_column :<%= model_class_name.tableize %>, :reset_password_token_expires_at
-    remove_column :<%= model_class_name.tableize %>, :reset_password_token
+    add_index :<%= model_class_name.tableize %>, :reset_password_token
   end
 end

data/lib/generators/sorcery/templates/migration/user_activation.rb

@@ -1,17 +1,9 @@
 class SorceryUserActivation < ActiveRecord::Migration
-  def self.up
+  def change
     add_column :<%= model_class_name.tableize %>, :activation_state, :string, :default => nil
     add_column :<%= model_class_name.tableize %>, :activation_token, :string, :default => nil
     add_column :<%= model_class_name.tableize %>, :activation_token_expires_at, :datetime, :default => nil
-    
-    add_index :<%= model_class_name.tableize %>, :activation_token
-  end
 
-  def self.down
-    remove_index :<%= model_class_name.tableize %>, :activation_token
-    
-    remove_column :<%= model_class_name.tableize %>, :activation_token_expires_at
-    remove_column :<%= model_class_name.tableize %>, :activation_token
-    remove_column :<%= model_class_name.tableize %>, :activation_state
+    add_index :<%= model_class_name.tableize %>, :activation_token
   end
 end

data/lib/sorcery/adapters/active_record_adapter.rb

@@ -0,0 +1,120 @@
+module Sorcery
+  module Adapters
+    class ActiveRecordAdapter < BaseAdapter
+      def update_attributes(attrs)
+        attrs.each do |name, value|
+          @model.send(:"#{name}=", value)
+        end
+        primary_key = @model.class.primary_key
+        @model.class.where(:"#{primary_key}" => @model.send(:"#{primary_key}")).update_all(attrs)
+      end
+
+      def save(options = {})
+        mthd = options.delete(:raise_on_failure) ? :save! : :save
+        @model.send(mthd, options)
+      end
+
+      def increment(field)
+        @model.increment!(field)
+      end
+
+      def find_authentication_by_oauth_credentials(relation_name, provider, uid)
+        @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+        conditions = {
+          @user_config.provider_uid_attribute_name => uid,
+          @user_config.provider_attribute_name     => provider
+        }
+
+        @model.public_send(relation_name).where(conditions).first
+      end
+
+      class << self
+        def define_field(name, type, options={})
+          # AR fields are defined through migrations, only validator here
+        end
+
+        def define_callback(time, event, method_name, options={})
+          @klass.send "#{time}_#{event}", method_name, options.slice(:if)
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          conditions = {
+            @user_config.provider_uid_attribute_name => uid,
+            @user_config.provider_attribute_name     => provider
+          }
+
+          @klass.where(conditions).first
+        end
+
+        def find_by_remember_me_token(token)
+          @klass.where(@klass.sorcery_config.remember_me_token_attribute_name => token).first
+        end
+
+        def find_by_credentials(credentials)
+          relation = nil
+
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            if @klass.sorcery_config.downcase_username_before_authenticating
+              condition = @klass.arel_table[attribute].lower.eq(@klass.arel_table.lower(credentials[0]))
+            else
+              condition = @klass.arel_table[attribute].eq(credentials[0])
+            end
+
+            if relation.nil?
+              relation = condition
+            else
+              relation = relation.or(condition)
+            end
+          end
+
+          @klass.where(relation).first
+        end
+
+        def find_by_token(token_attr_name, token)
+          condition = @klass.arel_table[token_attr_name].eq(token)
+
+          @klass.where(condition).first
+        end
+
+        def find_by_activation_token(token)
+          @klass.where(@klass.sorcery_config.activation_token_attribute_name => token).first
+        end
+
+        def find_by_id(id)
+          @klass.find_by_id(id)
+        end
+
+        def find_by_username(username)
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            if @klass.sorcery_config.downcase_username_before_authenticating
+              username = username.downcase
+            end
+
+            result = @klass.where(attribute => username).first
+            return result if result
+          end
+        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} IS NOT NULL") \
+            .where("#{config.last_logout_at_attribute_name} IS NULL OR #{config.last_activity_at_attribute_name} > #{config.last_logout_at_attribute_name}") \
+            .where("#{config.last_activity_at_attribute_name} > ? ", config.activity_timeout.seconds.ago.utc.to_s(:db))
+        end
+
+        def transaction(&blk)
+          @klass.tap(&blk)
+        end
+      end
+    end
+
+
+  end
+end

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