refinerycms 0.9.6.34 → 0.9.7

data/vendor/plugins/authlogic/lib/authlogic/acts_as_authentic/persistence_token.rb

@@ -1,68 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # Maintains the persistence token, the token responsible for persisting sessions. This token
-    # gets stores in the session and the cookie.
-    module PersistenceToken
-      def self.included(klass)
-        klass.class_eval do
-          add_acts_as_authentic_module(Methods)
-        end
-      end
-
-      # Methods for the persistence token.
-      module Methods
-        def self.included(klass)
-          klass.class_eval do
-            extend ClassMethods
-            include InstanceMethods
-
-            if respond_to?(:after_password_set) && respond_to?(:after_password_verification)
-              after_password_set :reset_persistence_token
-              after_password_verification :reset_persistence_token!, :if => :reset_persistence_token?
-            end
-
-            validates_presence_of :persistence_token
-            validates_uniqueness_of :persistence_token, :if => :persistence_token_changed?
-
-            before_validation :reset_persistence_token, :if => :reset_persistence_token?
-          end
-        end
-
-        # Class level methods for the persistence token.
-        module ClassMethods
-          # Resets ALL persistence tokens in the database, which will require all users to reauthenticate.
-          def forget_all
-            # Paginate these to save on memory
-            records = nil
-            i = 0
-            begin
-              records = find(:all, :limit => 50, :offset => i)
-              records.each { |record| record.forget! }
-              i += 50
-            end while !records.blank?
-          end
-        end
-
-        # Instance level methods for the persistence token.
-        module InstanceMethods
-          # Resets the persistence_token field to a random hex value.
-          def reset_persistence_token
-            self.persistence_token = Authlogic::Random.hex_token
-          end
-
-          # Same as reset_persistence_token, but then saves the record.
-          def reset_persistence_token!
-            reset_persistence_token
-            save_without_session_maintenance(false)
-          end
-          alias_method :forget!, :reset_persistence_token!
-
-          private
-            def reset_persistence_token?
-              persistence_token.blank?
-            end
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/acts_as_authentic/restful_authentication.rb

@@ -1,61 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # This module is responsible for transitioning existing applications from the restful_authentication plugin.
-    module RestfulAuthentication
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-        end
-      end
-
-      module Config
-        # Switching an existing app to Authlogic from restful_authentication? No problem, just set this true and your users won't know
-        # anything changed. From your database perspective nothing will change at all. Authlogic will continue to encrypt passwords
-        # just like restful_authentication, so your app won't skip a beat. Although, might consider transitioning your users to a newer
-        # and stronger algorithm. Checkout the transition_from_restful_authentication option.
-        #
-        # * <tt>Default:</tt> false
-        # * <tt>Accepts:</tt> Boolean
-        def act_like_restful_authentication(value = nil)
-          r = rw_config(:act_like_restful_authentication, value, false)
-          set_restful_authentication_config if value
-          r
-        end
-        alias_method :act_like_restful_authentication=, :act_like_restful_authentication
-
-        # This works just like act_like_restful_authentication except that it will start transitioning your users to the algorithm you
-        # specify with the crypto provider option. The next time they log in it will resave their password with the new algorithm
-        # and any new record will use the new algorithm as well. Make sure to update your users table if you are using the default
-        # migration since it will set crypted_password and salt columns to a maximum width of 40 characters which is not enough.
-        def transition_from_restful_authentication(value = nil)
-          r = rw_config(:transition_from_restful_authentication, value, false)
-          set_restful_authentication_config if value
-          r
-        end
-        alias_method :transition_from_restful_authentication=, :transition_from_restful_authentication
-
-        private
-          def set_restful_authentication_config
-            crypto_provider_key = act_like_restful_authentication ? :crypto_provider : :transition_from_crypto_providers
-            self.send("#{crypto_provider_key}=", CryptoProviders::Sha1)
-            if !defined?(::REST_AUTH_SITE_KEY) || ::REST_AUTH_SITE_KEY.nil?
-              class_eval("::REST_AUTH_SITE_KEY = ''") if !defined?(::REST_AUTH_SITE_KEY)
-              CryptoProviders::Sha1.stretches = 1
-            end
-          end
-      end
-
-      module InstanceMethods
-        private
-          def act_like_restful_authentication?
-            self.class.act_like_restful_authentication == true
-          end
-
-          def transition_from_restful_authentication?
-            self.class.transition_from_restful_authentication == true
-          end
-      end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/acts_as_authentic/session_maintenance.rb

@@ -1,139 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # This is one of my favorite features that I think is pretty cool. It's things like this that make a library great
-    # and let you know you are on the right track.
-    #
-    # Just to clear up any confusion, Authlogic stores both the record id and the persistence token in the session.
-    # Why? So stale sessions can not be persisted. It stores the id so it can quickly find the record, and the
-    # persistence token to ensure no sessions are stale. So if the persistence token changes, the user must log
-    # back in.
-    #
-    # Well, the persistence token changes with the password. What happens if the user changes his own password?
-    # He shouldn't have to log back in, he's the one that made the change.
-    #
-    # That being said, wouldn't it be nice if their session and cookie information was automatically updated?
-    # Instead of cluttering up your controller with redundant session code. The same thing goes for new
-    # registrations.
-    #
-    # That's what this module is all about. This will automatically maintain the cookie and session values as
-    # records are saved.
-    module SessionMaintenance
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          add_acts_as_authentic_module(Methods)
-        end
-      end
-
-      module Config
-        # This is more of a convenience method. In order to turn off automatic maintenance of sessions just
-        # set this to false, or you can also set the session_ids method to a blank array. Both accomplish
-        # the same thing. This method is a little clearer in it's intentions though.
-        #
-        # * <tt>Default:</tt> true
-        # * <tt>Accepts:</tt> Boolean
-        def maintain_sessions(value = nil)
-          rw_config(:maintain_sessions, value, true)
-        end
-        alias_method :maintain_sessions=, :maintain_sessions
-
-        # As you may know, authlogic sessions can be separate by id (See Authlogic::Session::Base#id). You can
-        # specify here what session ids you want auto maintained. By default it is the main session, which has
-        # an id of nil.
-        #
-        # * <tt>Default:</tt> [nil]
-        # * <tt>Accepts:</tt> Array
-        def session_ids(value = nil)
-          rw_config(:session_ids, value, [nil])
-        end
-        alias_method :session_ids=, :session_ids
-
-        # The name of the associated session class. This is inferred by the name of the model.
-        #
-        # * <tt>Default:</tt> "#{klass.name}Session".constantize
-        # * <tt>Accepts:</tt> Class
-        def session_class(value = nil)
-          const = "#{base_class.name}Session".constantize rescue nil
-          rw_config(:session_class, value, const)
-        end
-        alias_method :session_class=, :session_class
-      end
-
-      module Methods
-        def self.included(klass)
-          klass.class_eval do
-            before_save :get_session_information, :if => :update_sessions?
-            before_save :maintain_sessions, :if => :update_sessions?
-          end
-        end
-
-        # Save the record and skip session maintenance all together.
-        def save_without_session_maintenance(*args)
-          self.skip_session_maintenance = true
-          result = save(*args)
-          self.skip_session_maintenance = false
-          result
-        end
-
-        private
-          def skip_session_maintenance=(value)
-            @skip_session_maintenance = value
-          end
-
-          def skip_session_maintenance
-            @skip_session_maintenance ||= false
-          end
-
-          def update_sessions?
-            !skip_session_maintenance && session_class && session_class.activated? && self.class.maintain_sessions == true && !session_ids.blank? && persistence_token_changed?
-          end
-
-          def get_session_information
-            # Need to determine if we are completely logged out, or logged in as another user
-            @_sessions = []
-
-            session_ids.each do |session_id|
-              session = session_class.find(session_id, self)
-              @_sessions << session if session && session.record
-            end
-          end
-
-          def maintain_sessions
-            if @_sessions.empty?
-              create_session
-            else
-              update_sessions
-            end
-          end
-
-          def create_session
-            # We only want to automatically login into the first session, since this is the main session. The other sessions are sessions
-            # that need to be created after logging into the main session.
-            session_id = session_ids.first
-            session_class.create(*[self, self, session_id].compact)
-
-            return true
-          end
-
-          def update_sessions
-            # We found sessions above, let's update them with the new info
-            @_sessions.each do |stale_session|
-              next if stale_session.record != self
-              stale_session.unauthorized_record = self
-              stale_session.save
-            end
-
-            return true
-          end
-
-          def session_ids
-            self.class.session_ids
-          end
-
-          def session_class
-            self.class.session_class
-          end
-      end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/acts_as_authentic/single_access_token.rb

@@ -1,65 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # This module is responsible for maintaining the single_access token. For more information the single access token and how to use it,
-    # see the Authlogic::Session::Params module.
-    module SingleAccessToken
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          add_acts_as_authentic_module(Methods)
-        end
-      end
-
-      # All configuration for the single_access token aspect of acts_as_authentic.
-      module Config
-        # The single access token is used for authentication via URLs, such as a private feed. That being said,
-        # if the user changes their password, that token probably shouldn't change. If it did, the user would have
-        # to update all of their URLs. So be default this is option is disabled, if you need it, feel free to turn
-        # it on.
-        #
-        # * <tt>Default:</tt> false
-        # * <tt>Accepts:</tt> Boolean
-        def change_single_access_token_with_password(value = nil)
-          rw_config(:change_single_access_token_with_password, value, false)
-        end
-        alias_method :change_single_access_token_with_password=, :change_single_access_token_with_password
-      end
-
-      # All method, for the single_access token aspect of acts_as_authentic.
-      module Methods
-        def self.included(klass)
-          return if !klass.column_names.include?("single_access_token")
-
-          klass.class_eval do
-            include InstanceMethods
-            validates_uniqueness_of :single_access_token, :if => :single_access_token_changed?
-            before_validation :reset_single_access_token, :if => :reset_single_access_token?
-            after_password_set(:reset_single_access_token, :if => :change_single_access_token_with_password?) if respond_to?(:after_password_set)
-          end
-        end
-
-        module InstanceMethods
-          # Resets the single_access_token to a random friendly token.
-          def reset_single_access_token
-            self.single_access_token = Authlogic::Random.friendly_token
-          end
-
-          # same as reset_single_access_token, but then saves the record.
-          def reset_single_access_token!
-            reset_single_access_token
-            save_without_session_maintenance
-          end
-
-          protected
-            def reset_single_access_token?
-              single_access_token.blank?
-            end
-
-            def change_single_access_token_with_password?
-              self.class.change_single_access_token_with_password == true
-            end
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/acts_as_authentic/validations_scope.rb

@@ -1,32 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # Allows you to scope everything to specific fields.
-    # See the Config submodule for more info.
-    # For information on how to scope off of a parent object see Authlogic::AuthenticatesMany
-    module ValidationsScope
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-        end
-      end
-
-      # All configuration for the scope feature.
-      module Config
-        # Allows you to scope everything to specific field(s). Works just like validates_uniqueness_of.
-        # For example, let's say a user belongs to a company, and you want to scope everything to the
-        # company:
-        #
-        #   acts_as_authentic do |c|
-        #     c.validations_scope = :company_id
-        #   end
-        #
-        # * <tt>Default:</tt> nil
-        # * <tt>Accepts:</tt> Symbol or Array of symbols
-        def validations_scope(value = nil)
-          rw_config(:validations_scope, value)
-        end
-        alias_method :validations_scope=, :validations_scope
-      end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/authenticates_many/association.rb

@@ -1,42 +0,0 @@
-module Authlogic
-  module AuthenticatesMany
-    # An object of this class is used as a proxy for the authenticates_many relationship. It basically allows you to "save" scope details
-    # and call them on an object, which allows you to do the following:
-    #
-    #   @account.user_sessions.new
-    #   @account.user_sessions.find
-    #   # ... etc
-    #
-    # You can call all of the class level methods off of an object with a saved scope, so that calling the above methods scopes the user
-    # sessions down to that specific account. To implement this via ActiveRecord do something like:
-    #
-    #   class User < ActiveRecord::Base
-    #     authenticates_many :user_sessions
-    #   end
-    class Association
-      attr_accessor :klass, :find_options, :id
-
-      def initialize(klass, find_options, id)
-        self.klass = klass
-        self.find_options = find_options
-        self.id = id
-      end
-
-      [:create, :create!, :find, :new].each do |method|
-        class_eval <<-"end_eval", __FILE__, __LINE__
-          def #{method}(*args)
-            klass.with_scope(scope_options) do
-              klass.#{method}(*args)
-            end
-          end
-        end_eval
-      end
-      alias_method :build, :new
-
-      private
-        def scope_options
-          {:find_options => find_options, :id => id}
-        end
-    end
-  end
-end

data/vendor/plugins/authlogic/lib/authlogic/authenticates_many/base.rb

@@ -1,55 +0,0 @@
-module Authlogic
-  # This allows you to scope your authentication. For example, let's say all users belong to an account, you want to make sure only users
-  # that belong to that account can actually login into that account. Simple, just do:
-  #
-  #   class Account < ActiveRecord::Base
-  #     authenticates_many :user_sessions
-  #   end
-  #
-  # Now you can scope sessions just like everything else in ActiveRecord:
-  #
-  #   @account.user_sessions.new(*args)
-  #   @account.user_sessions.create(*args)
-  #   @account.user_sessions.find(*args)
-  #   # ... etc
-  #
-  # Checkout the authenticates_many method for a list of options.
-  # You may also want to checkout Authlogic::ActsAsAuthentic::Scope to scope your model.
-  module AuthenticatesMany
-    module Base
-      # Allows you set essentially set up a relationship with your sessions. See module definition above for more details.
-      #
-      # === Options
-      #
-      # * <tt>session_class:</tt> default: "#{name}Session",
-      #   This is the related session class.
-      #
-      # * <tt>relationship_name:</tt> default: options[:session_class].klass_name.underscore.pluralize,
-      #   This is the name of the relationship you want to use to scope everything. For example an Account has many Users. There should be a relationship
-      #   called :users that you defined with a has_many. The reason we use the relationship is so you don't have to repeat yourself. The relatonship
-      #   could have all kinds of custom options. So instead of repeating yourself we essentially use the scope that the relationship creates.
-      #
-      # * <tt>find_options:</tt> default: nil,
-      #   By default the find options are created from the relationship you specify with :relationship_name. But if you want to override this and
-      #   manually specify find_options you can do it here. Specify options just as you would in ActiveRecord::Base.find.
-      #
-      # * <tt>scope_cookies:</tt> default: false
-      #   By the nature of cookies they scope theirself if you are using subdomains to access accounts. If you aren't using subdomains you need to have
-      #   separate cookies for each account, assuming a user is logging into mroe than one account. Authlogic can take care of this for you by
-      #   prefixing the name of the cookie and sessin with the model id. You just need to tell Authlogic to do this by passing this option.
-      def authenticates_many(name, options = {})
-        options[:session_class] ||= name.to_s.classify.constantize
-        options[:relationship_name] ||= options[:session_class].klass_name.underscore.pluralize
-        class_eval <<-"end_eval", __FILE__, __LINE__
-          def #{name}
-            find_options = #{options[:find_options].inspect} || #{options[:relationship_name]}.scope(:find)
-            find_options.delete_if { |key, value| ![:conditions, :include, :joins].include?(key.to_sym) || value.nil? }
-            @#{name} ||= Authlogic::AuthenticatesMany::Association.new(#{options[:session_class]}, find_options, #{options[:scope_cookies] ? "self.class.model_name.underscore + '_' + self.send(self.class.primary_key).to_s" : "nil"})
-          end
-        end_eval
-      end
-    end
-
-    ::ActiveRecord::Base.extend(Base) if defined?(::ActiveRecord)
-  end
-end