lockbox_middleware 1.2.1 → 1.2.2

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/callbacks.rb

@@ -1,88 +0,0 @@
-module Authlogic
-  module Session
-    # Between these callsbacks and the configuration, this is the contract between me and you to safely
-    # modify Authlogic's behavior. I will do everything I can to make sure these do not change.
-    #
-    # Check out the sub modules of Authlogic::Session. They are very concise, clear, and to the point. More
-    # importantly they use the same API that you would use to extend Authlogic. That being said, they are great
-    # examples of how to extend Authlogic and add / modify behavior to Authlogic. These modules could easily be pulled out
-    # into their own plugin and become an "add on" without any change.
-    #
-    # Now to the point of this module. Just like in ActiveRecord you have before_save, before_validation, etc.
-    # You have similar callbacks with Authlogic, see the METHODS constant below. The order of execution is as follows:
-    #
-    #   before_persisting
-    #   persist
-    #   after_persisting
-    #   [save record if record.changed?]
-    #   
-    #   before_validation
-    #   before_validation_on_create
-    #   before_validation_on_update
-    #   validate
-    #   after_validation_on_update
-    #   after_validation_on_create
-    #   after_validation
-    #   [save record if record.changed?]
-    #   
-    #   before_save
-    #   before_create
-    #   before_update
-    #   after_update
-    #   after_create
-    #   after_save
-    #   [save record if record.changed?]
-    #   
-    #   before_destroy
-    #   [save record if record.changed?]
-    #   destroy
-    #   after_destroy
-    #
-    # Notice the "save record if changed?" lines above. This helps with performance. If you need to make
-    # changes to the associated record, there is no need to save the record, Authlogic will do it for you.
-    # This allows multiple modules to modify the record and execute as few queries as possible.
-    #
-    # **WARNING**: unlike ActiveRecord, these callbacks must be set up on the class level:
-    #
-    #   class UserSession < Authlogic::Session::Base
-    #     before_validation :my_method
-    #     validate :another_method
-    #     # ..etc
-    #   end
-    #
-    # You can NOT define a "before_validation" method, this is bad practice and does not allow Authlogic
-    # to extend properly with multiple extensions. Please ONLY use the method above.
-    module Callbacks
-      METHODS = [
-        "before_persisting", "persist", "after_persisting",
-        "before_validation", "before_validation_on_create", "before_validation_on_update", "validate",
-        "after_validation_on_update", "after_validation_on_create", "after_validation",
-        "before_save", "before_create", "before_update", "after_update", "after_create", "after_save",
-        "before_destroy", "after_destroy"
-      ]
-      
-      def self.included(base) #:nodoc:
-        base.send :include, ActiveSupport::Callbacks
-        base.define_callbacks *METHODS
-      end
-      
-      private
-        METHODS.each do |method|
-          class_eval <<-"end_eval", __FILE__, __LINE__
-            def #{method}
-              run_callbacks(:#{method}) { |result, object| result == false }
-            end
-          end_eval
-        end
-      
-        def persist
-          run_callbacks(:persist) { |result, object| result == true }
-        end
-        
-        def save_record(alternate_record = nil)
-          r = alternate_record || record
-          r.save_without_session_maintenance(false) if r && r.changed? && !r.readonly?
-        end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/cookies.rb

@@ -1,130 +0,0 @@
-module Authlogic
-  module Session
-    # Handles all authentication that deals with cookies, such as persisting, saving, and destroying.
-    module Cookies
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-          persist :persist_by_cookie
-          after_save :save_cookie
-          after_destroy :destroy_cookie
-        end
-      end
-      
-      # Configuration for the cookie feature set.
-      module Config
-        # The name of the cookie or the key in the cookies hash. Be sure and use a unique name. If you have multiple sessions and they use the same cookie it will cause problems.
-        # Also, if a id is set it will be inserted into the beginning of the string. Exmaple:
-        #
-        #   session = UserSession.new
-        #   session.cookie_key => "user_credentials"
-        #   
-        #   session = UserSession.new(:super_high_secret)
-        #   session.cookie_key => "super_high_secret_user_credentials"
-        #
-        # * <tt>Default:</tt> "#{guessed_klass_name.underscore}_credentials"
-        # * <tt>Accepts:</tt> String
-        def cookie_key(value = nil)
-          rw_config(:cookie_key, value, "#{guessed_klass_name.underscore}_credentials")
-        end
-        alias_method :cookie_key=, :cookie_key
-        
-        # If sessions should be remembered by default or not.
-        #
-        # * <tt>Default:</tt> false
-        # * <tt>Accepts:</tt> Boolean
-        def remember_me(value = nil)
-          rw_config(:remember_me, value, false)
-        end
-        alias_method :remember_me=, :remember_me
-        
-        # The length of time until the cookie expires.
-        #
-        # * <tt>Default:</tt> 3.months
-        # * <tt>Accepts:</tt> Integer, length of time in seconds, such as 60 or 3.months
-        def remember_me_for(value = :_read)
-          rw_config(:remember_me_for, value, 3.months, :_read)
-        end
-        alias_method :remember_me_for=, :remember_me_for
-      end
-      
-      # The methods available for an Authlogic::Session::Base object that make up the cookie feature set.
-      module InstanceMethods
-        # Allows you to set the remember_me option when passing credentials.
-        def credentials=(value)
-          super
-          values = value.is_a?(Array) ? value : [value]
-          case values.first
-          when Hash
-            self.remember_me = values.first.with_indifferent_access[:remember_me] if values.first.with_indifferent_access.key?(:remember_me)
-          else
-            r = values.find { |value| value.is_a?(TrueClass) || value.is_a?(FalseClass) }
-            self.remember_me = r if !r.nil?
-          end
-        end
-        
-        # Is the cookie going to expire after the session is over, or will it stick around?
-        def remember_me
-          return @remember_me if defined?(@remember_me)
-          @remember_me = self.class.remember_me
-        end
-        
-        # Accepts a boolean as a flag to remember the session or not. Basically to expire the cookie at the end of the session or keep it for "remember_me_until".
-        def remember_me=(value)
-          @remember_me = value
-        end
-        
-        # See remember_me
-        def remember_me?
-          remember_me == true || remember_me == "true" || remember_me == "1"
-        end
-        
-        # How long to remember the user if remember_me is true. This is based on the class level configuration: remember_me_for
-        def remember_me_for
-          return unless remember_me?
-          self.class.remember_me_for
-        end
-        
-        # When to expire the cookie. See remember_me_for configuration option to change this.
-        def remember_me_until
-          return unless remember_me?
-          remember_me_for.from_now
-        end
-        
-        private
-          def cookie_key
-            build_key(self.class.cookie_key)
-          end
-          
-          def cookie_credentials
-            controller.cookies[cookie_key] && controller.cookies[cookie_key].split("::")
-          end
-          
-          # Tries to validate the session from information in the cookie
-          def persist_by_cookie
-            persistence_token, record_id = cookie_credentials
-            if !persistence_token.nil?
-              record = record_id.nil? ? search_for_record("find_by_persistence_token", persistence_token) : search_for_record("find_by_#{klass.primary_key}", record_id)
-              self.unauthorized_record = record if record && record.persistence_token == persistence_token
-              valid?
-            else
-              false
-            end
-          end
-          
-          def save_cookie
-            controller.cookies[cookie_key] = {
-              :value => "#{record.persistence_token}::#{record.send(record.class.primary_key)}",
-              :expires => remember_me_until,
-              :domain => controller.cookie_domain
-            }
-          end
-          
-          def destroy_cookie
-            controller.cookies.delete cookie_key, :domain => controller.cookie_domain
-          end
-      end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/existence.rb

@@ -1,93 +0,0 @@
-module Authlogic
-  module Session
-    # Provides methods to create and destroy objects. Basically controls their "existence".
-    module Existence
-      class SessionInvalidError < ::StandardError # :nodoc:
-        def initialize(session)
-          super("Your session is invalid and has the following errors: #{session.errors.full_messages.to_sentence}")
-        end
-      end
-      
-      def self.included(klass)
-        klass.class_eval do
-          extend ClassMethods
-          include InstanceMethods
-          attr_accessor :new_session, :record
-        end
-      end
-      
-      module ClassMethods
-        # A convenince method. The same as:
-        #
-        #   session = UserSession.new(*args)
-        #   session.save
-        #
-        # Instead you can do:
-        #
-        #   UserSession.create(*args)
-        def create(*args, &block)
-          session = new(*args)
-          session.save(&block)
-          session
-        end
-        
-        # Same as create but calls create!, which raises an exception when validation fails.
-        def create!(*args)
-          session = new(*args)
-          session.save!
-          session
-        end
-      end
-      
-      module InstanceMethods
-        # Clears all errors and the associated record, you should call this terminate a session, thus requring
-        # the user to authenticate again if it is needed.
-        def destroy
-          before_destroy
-          save_record
-          errors.clear
-          @record = nil
-          after_destroy
-          true
-        end
-        
-        # Returns true if the session is new, meaning no action has been taken on it and a successful save
-        # has not taken place.
-        def new_session?
-          new_session != false
-        end
-        
-        # After you have specified all of the details for your session you can try to save it. This will
-        # run validation checks and find the associated record, if all validation passes. If validation
-        # does not pass, the save will fail and the erorrs will be stored in the errors object.
-        def save(&block)
-          result = nil
-          if valid?
-            self.record = attempted_record
-
-            before_save
-            new_session? ? before_create : before_update
-            new_session? ? after_create : after_update
-            after_save
-
-            save_record
-            self.new_session = false
-            result = true
-          else
-            result = false
-          end
-
-          yield result if block_given?
-          result
-        end
-
-        # Same as save but raises an exception of validation errors when validation fails
-        def save!
-          result = save
-          raise SessionInvalidError.new(self) unless result
-          result
-        end
-      end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/foundation.rb

@@ -1,63 +0,0 @@
-module Authlogic
-  module Session
-    # Sort of like an interface, it sets the foundation for the class, such as the required methods. This also allows
-    # other modules to overwrite methods and call super on them. It's also a place to put "utility" methods used
-    # throughout Authlogic.
-    module Foundation
-      def self.included(klass)
-        klass.class_eval do
-          extend ClassMethods
-          include InstanceMethods
-        end
-      end
-      
-      module ClassMethods
-        private
-          def rw_config(key, value, default_value = nil, read_value = nil)
-            if value == read_value
-              return read_inheritable_attribute(key) if inheritable_attributes.include?(key)
-              write_inheritable_attribute(key, default_value)
-            else
-              write_inheritable_attribute(key, value)
-            end
-          end
-      end
-      
-      module InstanceMethods
-        def initialize(*args)
-          self.credentials = args
-        end
-        
-        # The credentials you passed to create your session. See credentials= for more info.
-        def credentials
-          []
-        end
-
-        # Set your credentials before you save your session. You can pass a hash of credentials:
-        #
-        #   session.credentials = {:login => "my login", :password => "my password", :remember_me => true}
-        #
-        # or you can pass an array of objects:
-        #
-        #   session.credentails = [my_user_object, true]
-        #
-        # and if you need to set an id, just pass it last. This value need be the last item in the array you pass, since the id is something that
-        # you control yourself, it should never be set from a hash or a form. Examples:
-        #
-        #   session.credentials = [{:login => "my login", :password => "my password", :remember_me => true}, :my_id]
-        #   session.credentials = [my_user_object, true, :my_id]
-        def credentials=(values)
-        end
-        
-        def inspect
-          "#<#{self.class.name}: #{credentials.blank? ? "no credentials provided" : credentials.inspect}>"
-        end
-        
-        private
-          def build_key(last_part)
-            last_part
-          end
-      end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/http_auth.rb

@@ -1,58 +0,0 @@
-module Authlogic
-  module Session
-    # Handles all authentication that deals with basic HTTP auth. Which is authentication built into the HTTP protocol:
-    #
-    #   http://username:password@whatever.com
-    #
-    # Also, if you are not comfortable letting users pass their raw username and password you can always use the single
-    # access token. See Authlogic::Session::Params for more info.
-    module HttpAuth
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-          persist :persist_by_http_auth, :if => :persist_by_http_auth?
-        end
-      end
-      
-      # Configuration for the HTTP basic auth feature of Authlogic.
-      module Config
-        # Do you want to allow your users to log in via HTTP basic auth?
-        #
-        # I recommend keeping this enabled. The only time I feel this should be disabled is if you are not comfortable
-        # having your users provide their raw username and password. Whatever the reason, you can disable it here.
-        #
-        # * <tt>Default:</tt> true
-        # * <tt>Accepts:</tt> Boolean
-        def allow_http_basic_auth(value = nil)
-          rw_config(:allow_http_basic_auth, value, true)
-        end
-        alias_method :allow_http_basic_auth=, :allow_http_basic_auth
-      end
-      
-      # Instance methods for the HTTP basic auth feature of authlogic.
-      module InstanceMethods
-        private
-          def persist_by_http_auth?
-            allow_http_basic_auth? && login_field && password_field
-          end
-        
-          def persist_by_http_auth
-            controller.authenticate_with_http_basic do |login, password|
-              if !login.blank? && !password.blank?
-                send("#{login_field}=", login)
-                send("#{password_field}=", password)
-                return valid?
-              end
-            end
-        
-            false
-          end
-        
-          def allow_http_basic_auth?
-            self.class.allow_http_basic_auth == true
-          end
-      end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/id.rb

@@ -1,41 +0,0 @@
-module Authlogic
-  module Session
-    # Allows you to separate sessions with an id, ultimately letting you create multiple sessions for the same user.
-    module Id
-      def self.included(klass)
-        klass.class_eval do
-          attr_writer :id
-        end
-      end
-      
-      # Setting the id if it is passed in the credentials.
-      def credentials=(value)
-        super
-        values = value.is_a?(Array) ? value : [value]
-        self.id = values.last if values.last.is_a?(Symbol)
-      end
-      
-      # Allows you to set a unique identifier for your session, so that you can have more than 1 session at a time.
-      # A good example when this might be needed is when you want to have a normal user session and a "secure" user session.
-      # The secure user session would be created only when they want to modify their billing information, or other sensitive
-      # information. Similar to me.com. This requires 2 user sessions. Just use an id for the "secure" session and you should be good.
-      #
-      # You can set the id during initialization (see initialize for more information), or as an attribute:
-      #
-      #   session.id = :my_id
-      #
-      # Just be sure and set your id before you save your session.
-      #
-      # Lastly, to retrieve your session with the id check out the find class method.
-      def id
-        @id
-      end
-      
-      private
-        # Used for things like cookie_key, session_key, etc.
-        def build_key(last_part)
-          [id, super].compact.join("_")
-        end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/klass.rb

@@ -1,78 +0,0 @@
-module Authlogic
-  module Session
-    # Handles authenticating via a traditional username and password.
-    module Klass
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-          
-          class << self
-            attr_accessor :configured_klass_methods
-          end
-        end
-      end
-      
-      module Config
-        # Lets you change which model to use for authentication.
-        #
-        # * <tt>Default:</tt> inferred from the class name. UserSession would automatically try User
-        # * <tt>Accepts:</tt> an ActiveRecord class
-        def authenticate_with(klass)
-          @klass_name = klass.name
-          @klass = klass
-        end
-        alias_method :authenticate_with=, :authenticate_with
-        
-        # The name of the class that this session is authenticating with. For example, the UserSession class will
-        # authenticate with the User class unless you specify otherwise in your configuration. See authenticate_with
-        # for information on how to change this value.
-        def klass
-          @klass ||=
-            if klass_name
-              klass_name.constantize
-            else
-              nil
-            end
-        end
-        
-        # Same as klass, just returns a string instead of the actual constant.
-        def klass_name
-          @klass_name ||= guessed_klass_name
-        end
-        
-        # The string of the model name class guessed from the actual session class name.
-        def guessed_klass_name
-          guessed_name = name.scan(/(.*)Session/)[0]
-          guessed_name[0] if guessed_name
-        end
-      end
-      
-      module InstanceMethods
-        # Creating an alias method for the "record" method based on the klass name, so that we can do:
-        #
-        #   session.user
-        #
-        # instead of:
-        #
-        #   session.record
-        def initialize(*args)
-          if !self.class.configured_klass_methods
-            self.class.send(:alias_method, klass_name.demodulize.underscore.to_sym, :record)
-            self.class.configured_klass_methods = true
-          end
-          super
-        end
-        
-        private
-          def klass
-            self.class.klass
-          end
-
-          def klass_name
-            self.class.klass_name
-          end
-      end
-    end
-  end
-end

data/vendor/gems/authlogic-2.1.3/lib/authlogic/session/magic_columns.rb

@@ -1,95 +0,0 @@
-module Authlogic
-  module Session
-    # Just like ActiveRecord has "magic" columns, such as: created_at and updated_at. Authlogic has its own "magic" columns too:
-    #
-    #   Column name           Description
-    #   login_count           Increased every time an explicit login is made. This will *NOT* increase if logging in by a session, cookie, or basic http auth
-    #   failed_login_count    This increases for each consecutive failed login. See Authlogic::Session::BruteForceProtection and the consecutive_failed_logins_limit config option for more details.
-    #   last_request_at       Updates every time the user logs in, either by explicitly logging in, or logging in by cookie, session, or http auth
-    #   current_login_at      Updates with the current time when an explicit login is made.
-    #   last_login_at         Updates with the value of current_login_at before it is reset.
-    #   current_login_ip      Updates with the request remote_ip when an explicit login is made.
-    #   last_login_ip         Updates with the value of current_login_ip before it is reset.
-    module MagicColumns
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-          after_persisting :set_last_request_at, :if => :set_last_request_at?
-          validate :increase_failed_login_count
-          before_save :update_info
-          before_save :set_last_request_at, :if => :set_last_request_at?
-        end
-      end
-      
-      # Configuration for the magic columns feature.
-      module Config
-        # Every time a session is found the last_request_at field for that record is updatd with the current time, if that field exists.
-        # If you want to limit how frequent that field is updated specify the threshold here. For example, if your user is making a
-        # request every 5 seconds, and you feel this is too frequent, and feel a minute is a good threashold. Set this to 1.minute.
-        # Once a minute has passed in between requests the field will be updated.
-        #
-        # * <tt>Default:</tt> 0
-        # * <tt>Accepts:</tt> integer representing time in seconds
-        def last_request_at_threshold(value = nil)
-          rw_config(:last_request_at_threshold, value, 0)
-        end
-        alias_method :last_request_at_threshold=, :last_request_at_threshold
-      end
-      
-      # The methods available for an Authlogic::Session::Base object that make up the magic columns feature.
-      module InstanceMethods
-        private
-          def increase_failed_login_count
-            if invalid_password? && attempted_record.respond_to?(:failed_login_count)
-              attempted_record.failed_login_count ||= 0
-              attempted_record.failed_login_count += 1
-            end
-          end
-        
-          def update_info
-            record.login_count = (record.login_count.blank? ? 1 : record.login_count + 1) if record.respond_to?(:login_count)
-            record.failed_login_count = 0 if record.respond_to?(:failed_login_count)
-          
-            if record.respond_to?(:current_login_at)
-              record.last_login_at = record.current_login_at if record.respond_to?(:last_login_at)
-              record.current_login_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
-            end
-          
-            if record.respond_to?(:current_login_ip)
-              record.last_login_ip = record.current_login_ip if record.respond_to?(:last_login_ip)
-              record.current_login_ip = controller.request.remote_ip
-            end
-          end
-          
-          # This method lets authlogic know whether it should allow the last_request_at field to be updated
-          # with the current time (Time.now). One thing to note here is that it also checks for the existence of a
-          # last_request_update_allowed? method in your controller. This allows you to control this method pragmatically
-          # in your controller.
-          #
-          # For example, what if you had a javascript function that polled the server updating how much time is left in their
-          # session before it times out. Obviously you would want to ignore this request, because then the user would never time out.
-          # So you can do something like this in your controller:
-          #
-          #   def last_request_update_allowed?
-          #     action_name =! "update_session_time_left"
-          #   end
-          #
-          # You can do whatever you want with that method.
-          def set_last_request_at? # :doc:
-            return false if !record || !klass.column_names.include?("last_request_at")
-            return controller.last_request_update_allowed? if controller.responds_to_last_request_update_allowed?
-            record.last_request_at.blank? || last_request_at_threshold.to_i.seconds.ago >= record.last_request_at
-          end
-        
-          def set_last_request_at
-            record.last_request_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
-          end
-          
-          def last_request_at_threshold
-            self.class.last_request_at_threshold
-          end
-      end
-    end
-  end
-end