challah 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5dd9f7607415478ba95197e94b636bf004fa112
-  data.tar.gz: 8eee2c44ece6a0791b97cb84e31150318ae13304
+  metadata.gz: f03909894b61ef1fdbfc44ee6f84b221e10abe97
+  data.tar.gz: 66cb9a87b30a57581d45afaebdcde5e8e748b81f
 SHA512:
-  metadata.gz: 6b9275f0926d1242f954a94103e6fb1df0026c69822af518f0453fcf1012b7dd2b802645b93aefdf275d05524a083e2715f7331de095751f14a8358c1e18eebb
-  data.tar.gz: b215eaeb180a41a500ab9a0e690942c4a9237094fe320711f6c4354e349f3bf1fab2948489554b8c64219208b9e308af1ef2f5f21cbad3885012bdaced7240c4
+  metadata.gz: c392131e19fa54603ffda28f8466888440635c71a97e55ff1401c02efb0faab5e46ed6d2089e86cf083ab03410e0bf88fdb71621191d7aadccc29642243be6d3
+  data.tar.gz: 1db8e607039db9d51cd02d9f9de641f7756a92f034331b96a73d7e93b43144f8ae6c7c88564a6856d2bce7d51c67dc0ea980daba5ee31b064ab903905f0091a9

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Challah 1.2.2
+
+* Bug fix for “A copy of User has been removed from the module tree but is still active!” error in Rails development mode. Fix was to not cache the `User` model reference from within the engine.
+
 ## Challah 1.2.1
 
 * Bug fixed when loading `challah/test` in minitest.

data/lib/challah.rb

@@ -60,7 +60,7 @@ module Challah
   end
 
   def self.user
-    @user ||= options[:user].to_s.safe_constantize
+    options[:user].to_s.safe_constantize
   end
 
   # Set up techniques engines

data/lib/challah/audit.rb

@@ -1,10 +1,10 @@
 module Challah
-  # The audit methods are included into ActiveRecord::Base automatically and add 
-  # basic audit trail functionality for your models. Certain columns will be 
+  # The audit methods are included into ActiveRecord::Base automatically and add
+  # basic audit trail functionality for your models. Certain columns will be
   # updated with the current user's id if provided at save time.
   #
   # For new records, the following fields will be updated if +current_user+ is provided:
-  # 
+  #
   # * created_by
   # * created_user_id
   #
@@ -28,17 +28,17 @@ module Challah
   #       end
   #
   module Audit
-    def self.included(base)
-      base.class_eval do
-        before_save :before_save_audit
-      end
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :before_save_audit
     end
-    
+
     # @private
     def initialize_dup(other)
       clear_audit_attributes
     end
-    
+
     def current_user=(value)
       @current_user_id = (Object === value ? value[:id] : value)
     end
@@ -54,53 +54,54 @@ module Challah
 
       @current_user_id
     end
-    
+
     private
-      def before_save_audit
-        if new_record?
-          all_audit_attributes.each do |attr_name|
-            attr_name = attr_name.to_s
-            column = column_for_attribute(attr_name)
 
-            if column || @attributes.has_key?(attr_name)
-              write_attribute(attr_name, current_user_id)
-            end     
+    def before_save_audit
+      if new_record?
+        all_audit_attributes.each do |attr_name|
+          attr_name = attr_name.to_s
+          column = column_for_attribute(attr_name)
+
+          if column || @attributes.has_key?(attr_name)
+            write_attribute(attr_name, current_user_id)
           end
-        else
-          audit_attributes_for_update.each do |column|
-            if respond_to?(column) && respond_to?("#{column}=")
-              column = column.to_s
-              next if attribute_changed?(column) # don't update the column if we already manually did
-              write_attribute(column, current_user_id)
-            end
+        end
+      else
+        audit_attributes_for_update.each do |column|
+          if respond_to?(column) && respond_to?("#{ column }=")
+            column = column.to_s
+            next if attribute_changed?(column) # don't update the column if we already manually did
+            write_attribute(column, current_user_id)
           end
         end
       end
-      
-      # @private
-      def audit_attributes_for_update
-        [ :updated_by, :modifed_by, :updated_user_id ]
-      end
-      
-      # @private
-      def audit_attributes_for_create
-        [ :created_by, :created_user_id ]
-      end
-      
-      # @private
-      def all_audit_attributes
-        audit_attributes_for_update + audit_attributes_for_create
-      end
-      
-      # Clear attributes and changed_attributes
-      def clear_audit_attributes
-        all_audit_attributes.each do |attribute_name|
-          if respond_to?(attribute_name) && respond_to?("#{attribute_name}=")
-            write_attribute(attribute_name, nil)
-          end
-          
-          changed_attributes.delete(attribute_name)
+    end
+
+    # @private
+    def audit_attributes_for_update
+      [ :updated_by, :modifed_by, :updated_user_id ]
+    end
+
+    # @private
+    def audit_attributes_for_create
+      [ :created_by, :created_user_id ]
+    end
+
+    # @private
+    def all_audit_attributes
+      audit_attributes_for_update + audit_attributes_for_create
+    end
+
+    # Clear attributes and changed_attributes
+    def clear_audit_attributes
+      all_audit_attributes.each do |attribute_name|
+        if respond_to?(attribute_name) && respond_to?("#{ attribute_name }=")
+          write_attribute(attribute_name, nil)
         end
+
+        changed_attributes.delete(attribute_name)
       end
+    end
   end
-end
+end

data/lib/challah/concerns/user/findable.rb

@@ -14,32 +14,30 @@ module Challah
       # Find a user instance by username first, or email address if needed.
       # If no user is found matching, return nil
       def find_for_session(username_or_email)
-        return nil if username_or_email.to_s.blank?
+        return if username_or_email.to_s.blank?
 
-        result = nil
-
-        if username_or_email.to_s.include?('@')
-          result = where(email: username_or_email).first
-        end
+        username_or_email = username_or_email.downcase.strip
+        find_by_email(username_or_email) || find_by_authorization(username_or_email)
+      end
 
-        if !result
-          uid = username_or_email.to_s.downcase.strip
+      def inactive
+        where.not(active: true)
+      end
 
-          authorization = self.authorization_model
-          authorization = authorization.where(provider: :password, uid: uid)
-          authorization = authorization.first
+      protected
 
-          if authorization
-            result = authorization.user
-          end
+      def find_by_authorization(uid)
+        authorization = self.authorization_model
+        result = authorization.where(provider: :password, uid: uid).first
+        if result
+          result.user
         end
-
-        result
       end
 
-      def inactive
-        where.not(active: true)
+      def find_by_email(email)
+        return unless email.include?('@')
+        where(email: email).first
       end
     end
   end
-end
+end

data/lib/challah/controller.rb

@@ -2,10 +2,10 @@ module Challah
   # These methods are added into ActionController::Base and are available in all
   # of your app's controllers.
   module Controller
-    # @private
-    def self.included(base)
-      base.send(:include, InstanceMethods)
-      base.send(:extend, ClassMethods)
+    extend ActiveSupport::Concern
+
+    included do
+      extend ClassMethods
     end
 
     module ClassMethods
@@ -41,79 +41,78 @@ module Challah
       alias_method :login_required, :signin_required
     end
 
-    module InstanceMethods
-      protected
-        # Is there currently a logged in user? Returns true if it is safe to use
-        # the {#current_user current_user} method.
-        #
-        # @note This method is also available as a helper in your views.
-        #
-        # @see #current_user current_user
-        #
-        # @return [Boolean] Is there a user logged in?
-        def current_user?
-          !!current_user
-        end
+    protected
 
-        # Alias for current_user?
-        def signed_in?
-          current_user?
-        end
-        alias_method :logged_in?, :signed_in?
+    # Is there currently a logged in user? Returns true if it is safe to use
+    # the {#current_user current_user} method.
+    #
+    # @note This method is also available as a helper in your views.
+    #
+    # @see #current_user current_user
+    #
+    # @return [Boolean] Is there a user logged in?
+    def current_user?
+      !!current_user
+    end
 
-        # The user that is currently logged into this session. If there is no
-        # user logged in, nil will be returned.
-        #
-        # @note This method is also available as a helper in your views.
-        #
-        # @return [User, nil] The current authenticated user.
-        def current_user
-          @current_user ||= current_user_session.user
-        end
+    # Alias for current_user?
+    def signed_in?
+      current_user?
+    end
+    alias_method :logged_in?, :signed_in?
 
-        # The current authentication session, if one exists. A {Session} object will be
-        # returned regardless of its valid status. If an invalid session is returned, the
-        # {Session#user user} attribute will be nil.
-        #
-        # @return [Session] The current browser session.
-        def current_user_session
-          @current_user_session ||= Challah::Session.find(request, params, user_model)
-        end
+    # The user that is currently logged into this session. If there is no
+    # user logged in, nil will be returned.
+    #
+    # @note This method is also available as a helper in your views.
+    #
+    # @return [User, nil] The current authenticated user.
+    def current_user
+      @current_user ||= current_user_session.user
+    end
 
-        # Restrict a controller to only authenticated users. If someone tries to access
-        # a restricted action and is not logged in, they will be redirected to the
-        # login page.
-        #
-        # This method is an alias for:
-        #
-        #   restrict_to_authenticated
-        #
-        # @example
-        #   class YourController < ApplicationController
-        #     before_filter :login_required
-        #
-        #     # ...
-        #   end
-        #
-        # @example Specifing certain actions.
-        #   class YourOtherController < ApplicationController
-        #     before_filter :login_required, :only => [ :create, :update, :destroy ]
-        #
-        #     # ...
-        #   end
-        #
-        # @see Controller::ClassMethods#restrict_to_authenticated restrict_to_authenticated
-        def signin_required
-          unless signed_in?
-            session[:return_to] = request.url
-            redirect_to signin_path and return
-          end
-        end
-        alias_method :login_required, :signin_required
+    # The current authentication session, if one exists. A {Session} object will be
+    # returned regardless of its valid status. If an invalid session is returned, the
+    # {Session#user user} attribute will be nil.
+    #
+    # @return [Session] The current browser session.
+    def current_user_session
+      @current_user_session ||= Challah::Session.find(request, params, user_model)
+    end
 
-        def user_model
-          @_user_model ||= Challah.user
-        end
+    # Restrict a controller to only authenticated users. If someone tries to access
+    # a restricted action and is not logged in, they will be redirected to the
+    # login page.
+    #
+    # This method is an alias for:
+    #
+    #   restrict_to_authenticated
+    #
+    # @example
+    #   class YourController < ApplicationController
+    #     before_filter :login_required
+    #
+    #     # ...
+    #   end
+    #
+    # @example Specifing certain actions.
+    #   class YourOtherController < ApplicationController
+    #     before_filter :login_required, :only => [ :create, :update, :destroy ]
+    #
+    #     # ...
+    #   end
+    #
+    # @see Controller::ClassMethods#restrict_to_authenticated restrict_to_authenticated
+    def signin_required
+      unless signed_in?
+        session[:return_to] = request.url
+        redirect_to signin_path and return
+      end
+    end
+    alias_method :login_required, :signin_required
+
+    def user_model
+      @_challah_user_model ||= Challah.user
     end
   end
-end
+end

data/lib/challah/cookie_store.rb

@@ -14,9 +14,10 @@ module Challah
     end
 
     protected
-      def validation_cookie_value(value = nil)
-        value = session_cookie_value unless value
-        Encrypter.md5(value, request.user_agent, request.remote_ip)
-      end
+
+    def validation_cookie_value(value = nil)
+      value = session_cookie_value unless value
+      Encrypter.md5(value, request.user_agent, request.remote_ip)
+    end
   end
-end
+end

data/lib/challah/encrypter.rb

@@ -39,11 +39,20 @@ module Challah
       false
     end
 
-    class << self
-      # Setup some pass through convenience methods that use default options
-      %w( hash md5 encrypt compare ).each do |f|
-        class_eval "def #{f}(*args); new.#{f}(*args); end"
-      end
+    def self.compare(*args)
+      new().compare(*args)
+    end
+
+    def self.encrypt(*args)
+      new().encrypt(*args)
+    end
+
+    def self.hash(*args)
+      new().hash(*args)
+    end
+
+    def self.md5(*args)
+      new().md5(*args)
     end
   end
 end

data/lib/challah/engine.rb

@@ -1,5 +1,4 @@
 module Challah
-
   class Engine < ::Rails::Engine
 
     initializer 'challah.router' do |app|
@@ -18,45 +17,42 @@ module Challah
       end
     end
 
-    class << self
-      # Set up controller methods
-      def setup_action_controller!
-        if defined?(ActionController)
-          ActionController::Base.send(:include, Challah::Controller)
-          ActionController::Base.send(:helper_method,
-            :current_user_session,
-            :current_user,
-            :current_user?,
-            :logged_in?,
-            :signed_in?
-          )
-
-          # Load any ActionController/Challah plugins
-          Challah.plugins.values.each do |plugin|
-            plugin.action_controller.each do |proc|
-              proc.call
-            end
+    # Set up controller methods
+    def self.setup_action_controller!
+      if defined?(ActionController)
+        ActionController::Base.send(:include, Challah::Controller)
+        ActionController::Base.send(:helper_method,
+          :current_user_session,
+          :current_user,
+          :current_user?,
+          :logged_in?,
+          :signed_in?
+        )
+
+        # Load any ActionController/Challah plugins
+        Challah.plugins.values.each do |plugin|
+          plugin.action_controller.each do |proc|
+            proc.call
           end
         end
       end
+    end
 
-      # Set up active record with Challah methods
-      def setup_active_record!
-        if defined?(ActiveRecord)
-          Challah.options[:logger] = ActiveRecord::Base.logger
+    # Set up active record with Challah methods
+    def self.setup_active_record!
+      if defined?(ActiveRecord)
+        Challah.options[:logger] = ActiveRecord::Base.logger
 
-          ActiveRecord::Base.send(:include, Challah::ActiveRecordExtensions)
-          ActiveRecord::Base.send(:include, Challah::Audit)
+        ActiveRecord::Base.send(:include, Challah::ActiveRecordExtensions)
+        ActiveRecord::Base.send(:include, Challah::Audit)
 
-          # Load any ActiveRecord/Challah plugins
-          Challah.plugins.values.each do |plugin|
-            plugin.active_record.each do |proc|
-              proc.call
-            end
+        # Load any ActiveRecord/Challah plugins
+        Challah.plugins.values.each do |plugin|
+          plugin.active_record.each do |proc|
+            proc.call
           end
         end
       end
     end
   end
-
 end

data/lib/challah/session.rb

@@ -96,72 +96,71 @@ module Challah
       super(sym, *args, &block)
     end
 
-    class << self
-      # Manually create a new Session
-      def create(user_or_user_id, request = nil, params = nil, user_model = nil)
-        user_model = Challah.user if user_model.nil?
+    # Manually create a new Session
+    def self.create(user_or_user_id, request = nil, params = nil, user_model = nil)
+      user_model = Challah.user if user_model.nil?
 
-        user_record = user_model === user_or_user_id ? user_or_user_id : user_model.find_by_id(user_or_user_id)
+      user_record = user_model === user_or_user_id ? user_or_user_id : user_model.find_by_id(user_or_user_id)
 
-        session = Session.new(request, params, user_model)
+      session = Session.new(request, params, user_model)
 
-        if user_record and user_record.active?
-          session.user = user_record
-          session.persist = true
-        end
-
-        session
+      if user_record and user_record.active?
+        session.user = user_record
+        session.persist = true
       end
 
-      # Manually create a session, and save it.
-      def create!(user_or_user_id, request = nil, params = nil, user_model = nil)
-        session = create(user_or_user_id, request, params, user_model)
-        session.save
-        session
-      end
+      session
+    end
 
-      # Clear out any existing sessions
-      def destroy
-        session = Session.find
-        session.destroy if session
-        session
-      end
+    # Manually create a session, and save it.
+    def self.create!(user_or_user_id, request = nil, params = nil, user_model = nil)
+      session = create(user_or_user_id, request, params, user_model)
+      session.save
+      session
+    end
 
-      # Load any existing session from the session store
-      def find(*args)
-        session = Session.new(*args)
-        session.find
-        session
-      end
+    # Clear out any existing sessions
+    def self.destroy
+      session = Session.find
+      session.destroy if session
+      session
+    end
+
+    # Load any existing session from the session store
+    def self.find(*args)
+      session = Session.new(*args)
+      session.find
+      session
     end
 
     protected
-      # Try and authenticate against the various auth techniques. If one
-      # technique works, then just exist and make the session active.
-      def authenticate!
-        Challah.techniques.values.each do |klass|
-          technique = klass.new(self)
-          technique.user_model = user_model if technique.respond_to?(:"user_model=")
-
-          @user = technique.authenticate
-
-          if @user
-            @persist = technique.respond_to?(:persist?) ? technique.persist? : false
-            break
-          end
-        end
+
+    # Try and authenticate against the various auth techniques. If one
+    # technique works, then just exist and make the session active.
+    def authenticate!
+      Challah.techniques.values.each do |klass|
+        technique = klass.new(self)
+        technique.user_model = user_model if technique.respond_to?(:"user_model=")
+
+        @user = technique.authenticate
 
         if @user
-          # Only update user record if persistence is on for the technique.
-          # Otherwise this builds up quick (one session for each API call)
-          if @persist
-            @user.successful_authentication!(ip)
-          end
+          @persist = technique.respond_to?(:persist?) ? technique.persist? : false
+          break
+        end
+      end
 
-          return @valid = true
+      if @user
+        # Only update user record if persistence is on for the technique.
+        # Otherwise this builds up quick (one session for each API call)
+        if @persist
+          @user.successful_authentication!(ip)
         end
 
-        @valid = false
+        return @valid = true
       end
+
+      @valid = false
+    end
   end
-end
+end

data/lib/challah/simple_cookie_store.rb

@@ -28,107 +28,108 @@ module Challah
     end
 
     private
-      def clear
-        cookies.delete(session_cookie_name, domain: domain)
-        cookies.delete(validation_cookie_name, domain: domain)
-      end
 
-      def cookie_values
-        session_cookie && session_cookie.to_s.split(joiner)
-      end
+    def clear
+      cookies.delete(session_cookie_name, domain: domain)
+      cookies.delete(validation_cookie_name, domain: domain)
+    end
 
-      def cookies
-        request.cookie_jar
-      end
+    def cookie_values
+      session_cookie && session_cookie.to_s.split(joiner)
+    end
 
-      def default_cookie_prefix
-        Challah.options[:cookie_prefix]
-      end
+    def cookies
+      request.cookie_jar
+    end
 
-      def domain
-        request.session_options[:domain]
-      end
+    def default_cookie_prefix
+      Challah.options[:cookie_prefix]
+    end
 
-      # Do the cookies exist, and are they valid?
-      def existing?
-        exists = false
+    def domain
+      request.session_options[:domain]
+    end
 
-        if session_cookie and validation_cookie
-          session_tmp = session_cookie.to_s
-          validation_tmp = validation_cookie.to_s
+    # Do the cookies exist, and are they valid?
+    def existing?
+      exists = false
 
-          if validation_tmp == validation_cookie_value(session_tmp)
-            exists = true
-          end
-        end
+      if session_cookie and validation_cookie
+        session_tmp = session_cookie.to_s
+        validation_tmp = validation_cookie.to_s
 
-        exists
+        if validation_tmp == validation_cookie_value(session_tmp)
+          exists = true
+        end
       end
 
-      def expiration
-        @expiration ||= 1.month.from_now
-      end
+      exists
+    end
 
-      def joiner
-        '@'
-      end
+    def expiration
+      @expiration ||= 1.month.from_now
+    end
 
-      def prefix
-        @prefix ||= [ default_cookie_prefix, user_model_id ].compact.join('-')
-      end
+    def joiner
+      '@'
+    end
 
-      def request
-        raise "No Request Provided" unless @session and @session.request
-        @session.request
-      end
+    def prefix
+      @prefix ||= [ default_cookie_prefix, user_model_id ].compact.join('-')
+    end
 
-      def session_cookie
-        cookies[session_cookie_name]
-      end
+    def request
+      raise "No Request Provided" unless @session and @session.request
+      @session.request
+    end
 
-      def session_cookie_name
-        "#{prefix}-s"
-      end
+    def session_cookie
+      cookies[session_cookie_name]
+    end
 
-      def session_cookie_value
-        "#@token#{joiner}#@user_id"
-      end
+    def session_cookie_name
+      "#{prefix}-s"
+    end
 
-      def user_model_id
-        if @session && @session.user_model && @session.user_model.table_name != 'users'
-          Encrypter.md5(@session.user_model.table_name).slice(0..5)
-        end
-      end
+    def session_cookie_value
+      "#@token#{joiner}#@user_id"
+    end
 
-      def validation_cookie
-        cookies[validation_cookie_name]
+    def user_model_id
+      if @session && @session.user_model && @session.user_model.table_name != 'users'
+        Encrypter.md5(@session.user_model.table_name).slice(0..5)
       end
+    end
 
-      def validation_cookie_name
-        "#{prefix}-v"
-      end
+    def validation_cookie
+      cookies[validation_cookie_name]
+    end
 
-      def validation_cookie_value(value = nil)
-        value = session_cookie_value unless value
-        Encrypter.md5(value)
-      end
+    def validation_cookie_name
+      "#{prefix}-v"
+    end
 
-      def write_cookies!
-        cookies[session_cookie_name] = {
-          value:      session_cookie_value,
-          expires:    expiration,
-          secure:     false,
-          httponly:   true,
-          domain:     domain
-        }
-
-        cookies[validation_cookie_name] = {
-          value:      validation_cookie_value,
-          expires:    expiration,
-          secure:     false,
-          httponly:   true,
-          domain:     domain
-        }
-      end
+    def validation_cookie_value(value = nil)
+      value = session_cookie_value unless value
+      Encrypter.md5(value)
+    end
+
+    def write_cookies!
+      cookies[session_cookie_name] = {
+        value:      session_cookie_value,
+        expires:    expiration,
+        secure:     false,
+        httponly:   true,
+        domain:     domain
+      }
+
+      cookies[validation_cookie_name] = {
+        value:      validation_cookie_value,
+        expires:    expiration,
+        secure:     false,
+        httponly:   true,
+        domain:     domain
+      }
+    end
   end
-end
+end

data/lib/challah/version.rb

@@ -1,3 +1,3 @@
 module Challah
-  VERSION = "1.2.1" unless defined?(::Challah::VERSION)
+  VERSION = "1.2.2" unless defined?(::Challah::VERSION)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: challah
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - John Tornow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-11 00:00:00.000000000 Z
+date: 2014-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Rails 4 authentication and sessions