authgasm 0.9.0 → 0.9.1

data/CHANGELOG.rdoc

@@ -0,0 +1,11 @@
+== 0.9.1 released 2008-10-24
+
+* Changed scope to id. Makes more sense to call it an id and fits better with the ActiveRecord model.
+* Removed saving_from_session flag, apparently it is not needed.
+* Fixed updating sessions to make more sense and be stricter.
+* change last_click_at to last_request_at
+* Only run "after" callbacks if the result is successful.
+
+== 0.9.0 released 2008-10-24
+
+* Initial release.

data/Manifest

@@ -1,3 +1,4 @@
+CHANGELOG.rdoc
 init.rb
 lib/authgasm/acts_as_authentic.rb
 lib/authgasm/controller.rb
@@ -21,10 +22,6 @@ test_app/app/helpers/user_sessions_helper.rb
 test_app/app/helpers/users_helper.rb
 test_app/app/models/user.rb
 test_app/app/models/user_session.rb
-test_app/app/views/asses/edit.html.erb
-test_app/app/views/asses/index.html.erb
-test_app/app/views/asses/new.html.erb
-test_app/app/views/asses/show.html.erb
 test_app/app/views/layouts/application.html.erb
 test_app/app/views/user_sessions/new.html.erb
 test_app/app/views/users/_form.erb

data/README.rdoc

@@ -1,10 +1,16 @@
 = Authgasm
 
-Authgasm is "RESTful rails authentication done right"
+Authgasm is "rails authentication done right"
 
-The last thing we need is another authentication solution for rails, right? That's what I thought. It was disappointing to find that all of the solutions were overly complicated, bloated, made too many assumptions about my app, written poorly, or were just plain confusing. I wanted something simple. Something that feels like it is a part of rails. Something that I could understand and not feel like authentication is this daunting / annoying task that litters my application with redundant code. So I decided to scratch my own itch by creating Authgasm.
+The last thing we need is another authentication solution for rails, right? That's what I thought. It was disappointing to find that all of the current solutions were overly complicated, bloated, poorly written, littered my application with code, and were just plain confusing. They felt very Microsoftish. This is not the simple / elegant rails we all fell in love with. It's like some Microsoft .NET engineers decided to dabble in ruby / rails for a day and their project was to write an authentication solution. That's what went through my head when I was trying out all of the current solutions. It's time someone makes a "rails like" authentication solution. So I give you Authgasm...
 
-Wouldn't it be nice if we could do something like:
+What if you could have authentication up and running in minutes without having to run a generator? All because it's simple, like everything else in rails.
+
+What if creating a user session could be as simple as...
+
+  UserSession.create(params[:user])
+
+What if your user sessions controller could look just like your other controllers...
 
   class UserSessionsController < ApplicationController
     def new
@@ -14,7 +20,7 @@ Wouldn't it be nice if we could do something like:
     def create
       @user_session = UserSession.new(params[:user_session])
       if @user_session.create
-        redirect_to my_account_url
+        redirect_to account_url
       else
         render :action => :new
       end
@@ -38,7 +44,7 @@ Look familiar? If you didn't know any better, you would think UserSession was an
     <%= f.submit "Login" %>
   <% end %>
 
-Oh, and how about this...
+Or how about persisting the session...
 
   class ApplicationController
     before_filter :load_user
@@ -50,7 +56,7 @@ Oh, and how about this...
       end
   end
 
-Authgasm makes this a reality. Hopefully I got your interest. This is just the tip of the ice berg. Keep reading to find out everything Authgasm can do.
+Authgasm makes this a reality. This is just the tip of the ice berg. Keep reading to find out everything Authgasm can do.
 
 == Helpful links
 
@@ -61,8 +67,6 @@ Authgasm makes this a reality. Hopefully I got your interest. This is just the t
 
 == Install and use
 
-Installing Authgasm and setting it up is very simple. Just like rails, Authgasm favors convention over configuration. As a result, it assumes a few things about your app. This guide will walk you through setting up Authgasm in your app and what Authgasm assumes.
-
 === Install the gem / plugin
 
   $ sudo gem install authgasm
@@ -73,37 +77,36 @@ Or as a plugin
 
   script/plugin install git://github.com/binarylogic/authgasm.git
 
-=== Configuration
-
-Before we start, it is important you understand the basics behind Authgasm. Authgasm is split into 2 parts.
+=== Create your session
 
-1. Your model that you will be authenticating with, such as User
-2. Your session that represents a login, such as UserSession
+For this walk through lets assume you are setting up a session for your User model.
 
-Each have their own configuration, so it can be as flexible as you need it to be. What's convenient is that the configuration for your model defaults to the configuration you set in your session. So if you set the configuration in your session, you won't have to repeat yourself in your model.
+Create your user_session.rb file:
 
-For information on configuration please see Searchgasm::ActsAsAuthentic and Authgasm::Session::Config::ClassMethods
+  # app/models/user_session.rb
+  class UserSession < Authgasm::Session::Base
+    # configuration here, just like ActiveRecord, or in an initializer
+    # See Authgasm::Session::Config::ClassMethods for more details
+  end
 
-=== Set up your model
+It is important to set your configuration for your session before you set the configuration for your model. This will save you some time. Your model will try to guess its own configuration based on what you set in the session. These are completely separate, making Authgasm as flexible as it needs to be, but the majority of the time they will be the same and no one likes to repeat their self.
 
-Make sure you have a model that you will be authenticating with. For this example let's say you have a User model:
+=== Ensure proper database fields
 
-  class User < ActiveRecord::Base
-    acts_as_authentic # for options see documentation: Authgasm::ActsAsAuthentic
-  end
-  
 The user model needs to have the following columns. The names of these columns can be changed with configuration.
 
     t.string    :login, :null => false
     t.string    :crypted_password, :null => false
     t.string    :password_salt, :null => false # not needed if you are encrypting your pw instead of using a hash algorithm
     t.string    :remember_token, :null => false
-    t.integer   :loging_count # This is optional, it is a "magic" column, just like "created_at". See below for a list of all magic columns.
+    t.integer   :login_count # This is optional, it is a "magic" column, just like "created_at". See below for a list of all magic columns.
 
-Create your user_session.rb file:
+=== Set up your model
 
-  # app/models/user_session.rb
-  class UserSession < Authgasm::Session::Base
+Make sure you have a model that you will be authenticating with. For this example let's say you have a User model:
+
+  class User < ActiveRecord::Base
+    acts_as_authentic # for options see documentation: Authgasm::ActsAsAuthentic::ClassMethods
   end
 
 Done! Now go use it just like you would with any other ActiveRecord model (see above).
@@ -113,8 +116,8 @@ Done! Now go use it just like you would with any other ActiveRecord model (see a
 Just like ActiveRecord has "magic" columns, such as: created_at and updated_at. Authgasm has its own "magic" columns too:
 
   Column name           Description
-  login_count           Increased every time and explicit login is made. This will *NOT* increase if logging in by a session, cookie, or basic http auth
-  last_click_at         Updates every time the user logs in, either by explicitly logging in, or logging in by cookie, session, or http auth
+  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
+  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.
@@ -129,7 +132,7 @@ Authgasm tries to check the state of the record before creating the session. If
   confirmed?            Has the record been conirmed?
   inactive?             Is the record marked as inactive?
   
-What's neat about these is that these are checked upon any type of login. When logging in explicitly, by cookie, session, or basic http auth. If any of these return false validation will fail and a session will not be created.
+What's neat about this is that these are checked upon any type of login. When logging in explicitly, by cookie, session, or basic http auth. So if you mark a user inactive in the middle of their session they wont be logged back in next time they refresh the page. Giving you complete control.
 
 == Hooks / Callbacks
 
@@ -146,19 +149,64 @@ Just like ActiveRecord you can create your own hooks / callbacks so that you can
 
 == Automatic Session Updating
 
-This is one of my favorite features that I think is pretty cool. What if a user changes their password? You have to re-log them in with the new password, recreate the session, etc, pain in the ass. Or what if a user creates a new user account? You have to do the same thing. It makes your UsersController kind of dirty and it's kind of annoying. What's cool about this is that we pulled the UserSession down into the models, where we can play around with it. Why not have the User model take care of this for us in an after_save? Whoa! Now you don't have to worry about it at all. In fact, the acts_as_authentic method has an option to do this automatically for you. Zing! Man, Authgasm might be a little too awesome. So...
+This is one of my favorite features that I think its pretty cool. It's things like this that make a library great and let you know you are on the right track.
+
+What if a user changes their password? You have to re-log them in with the new password, recreate the session, etc, pain in the ass. Or what if a user creates a new user account? You have to do the same thing. Here's an even better one: what if a user is in the admin area and changes his own password? There might even be another place passwords can change. It shouldn't matter, your code should be written in a way where you don't have to remember to do this.
+
+Instead of updating sessions all over the place, doesn't it make sense to do this at a lower level? Like the User model? You're saying "but Ben, models can't mess around with sessions and cookies". True...but Authgasm can, and you can access Authgasm just like a model. I know in most situations it's not good practice to do this but I view this in the same class as sweepers, and feel like it actually is good practice here. User sessions are directly tied to users, they should be connected on the model level.
+
+Fear not, because the acts_as_authentic method you call in your model takes care of this for you, by adding an after_create and after_update callback to automatically keep the session up to date. You don't have to worry about it anymore. Don't even think about it. Let your UsersController deal with users, not users *AND* sessions. *ANYTIME* the user changes his password in *ANY* way, his session will be updated.
+
+Here is basically how this is done....
 
-  @current_user.password = "my new password"
-  @current_user.confirm_password = "my new password"
-  @current_user.save # automatically updates the sessions for you!
+  class User < ActiveRecord::Base
+    after_create :create_sessions!
+    after_update :update_sessions!
+    
+    private
+      def create_sessions!
+        # create a new UserSession if they are not logged in
+      end
+      
+      def update_sessions!
+        # find their session
+        # check that their session's record is the same one as this one: session.record == self
+        # update the session with the new info: session.update
+      end
+  end
+
+Obviously there is a little more to it than this, but hopefully this clarifies any confusion. Lastly, this can be altered / disabled via a configuration option.
 
 When things come together like this I think its a sign that you are doing something right. Put that in your pipe and smoke it!
 
+== Multiple Sessions / Session Identifiers
+
+You're asking: "why would I want multiple sessions?". Take this example:
+
+You have an app where users login and then need to re-login to view / change their billing information. Similar to how Apples' me.com works, if you've ever used it. What you could do is have the user login with their normal session, then have an entirely new session that represents their "secure" session. But wait, this is 2 users sessions. No problem:
+
+  # regular user session
+  @user_session = UserSession.new
+  @user_session.id
+  # => nil
+  
+  # secure user session
+  @secure_user_session = UserSession.new(:secure)
+  @secure_user_session.id
+  # => :secure
+
+This will keep everything separate. The :secure session will store its info in a separate cookie, separate session, etc. Just set the id and you are good to go. Need to retrieve the session?
+
+  @user_session = UserSession.find
+  @secure_user_session = UserSession.find(:secure)
+
+For more information on ids checkout Authgasm::Session::Base#initialize
+
 == How it works
 
-Interested in how this all works. Basically a before_filter is set in your controller which lets Authgasm know about the current controller object. This allows Authgasm to set sessions, cookies, login via basic http auth, etc. Don't worry, this is thread safe.
+Interested in how all of this all works? Basically a before_filter is automatically set in your controller which lets Authgasm know about the current controller object. This allows Authgasm to set sessions, cookies, login via basic http auth, etc. If you are using rails in a multiple thread environment, don't worry. I kept that in mind and made this is thread safe.
 
-From there is it pretty simple. When you try to create a new session the record is authenticated and then all of the session / cookie magic is done for you.
+From there it is pretty simple. When you try to create a new session the record is authenticated and then all of the session / cookie magic is done for you. The sky is the limit.
 
 
 Copyright (c) 2008 Ben Johnson of [Binary Logic](http://www.binarylogic.com), released under the MIT license

data/authgasm.gemspec

@@ -1,18 +1,18 @@
 
-# Gem::Specification for Authgasm-0.9.0
+# Gem::Specification for Authgasm-0.9.1
 # Originally generated by Echoe
 
 --- !ruby/object:Gem::Specification 
 name: authgasm
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
 autorequire: 
 bindir: bin
 
-date: 2008-10-24 00:00:00 -04:00
+date: 2008-10-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,6 +52,7 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- CHANGELOG.rdoc
 - lib/authgasm/acts_as_authentic.rb
 - lib/authgasm/controller.rb
 - lib/authgasm/session/active_record_trickery.rb
@@ -64,6 +65,7 @@ extra_rdoc_files:
 - lib/authgasm.rb
 - README.rdoc
 files: 
+- CHANGELOG.rdoc
 - init.rb
 - lib/authgasm/acts_as_authentic.rb
 - lib/authgasm/controller.rb
@@ -87,10 +89,6 @@ files:
 - test_app/app/helpers/users_helper.rb
 - test_app/app/models/user.rb
 - test_app/app/models/user_session.rb
-- test_app/app/views/asses/edit.html.erb
-- test_app/app/views/asses/index.html.erb
-- test_app/app/views/asses/new.html.erb
-- test_app/app/views/asses/show.html.erb
 - test_app/app/views/layouts/application.html.erb
 - test_app/app/views/user_sessions/new.html.erb
 - test_app/app/views/users/_form.erb

data/lib/authgasm/acts_as_authentic.rb

@@ -43,7 +43,7 @@ module Authgasm
       # * <tt>password_salt_field:</tt> default: depends on which columns are present, checks: password_salt, pw_salt, salt, if none are present defaults to password_salt. This is the name of the field your salt is stored, only relevant for a hash crypto provider.
       # * <tt>remember_token_field:</tt> default: options[:session_class].remember_token_field, the name of the field your remember token is stored. What the cookie stores so the session can be "remembered"
       # * <tt>logged_in_timeout:</tt> default: 10.minutes, this allows you to specify a time the determines if a user is logged in or out. Useful if you want to count how many users are currently logged in.
-      # * <tt>session_scopes:</tt> default: [nil], the sessions that we want to automatically reset when a user is created or updated so you don't have to worry about this. Set to [] to disable. Should be an array of scopes. See Authgasm::Session::Base#initialize for information on scopes.
+      # * <tt>session_ids:</tt> default: [nil], the sessions that we want to automatically reset when a user is created or updated so you don't have to worry about this. Set to [] to disable. Should be an array of ids. See Authgasm::Session::Base#initialize for information on ids. The order is important. The first id should be your main session, the session they need to log into first. This is generally nil, meaning so explicitly set id.
       def acts_as_authentic(options = {})
         # Setup default options
         options[:session_class] ||= "#{name}Session".constantize
@@ -65,7 +65,7 @@ module Authgasm
           :password_salt
         options[:remember_token_field] ||= options[:session_class].remember_token_field
         options[:logged_in_timeout] ||= 10.minutes
-        options[:session_scopes] ||= [nil]
+        options[:session_ids] ||= [nil]
         
         # Validations
         case options[:login_field_type]
@@ -91,11 +91,12 @@ module Authgasm
         end
         
         after_create :create_sessions!
-        after_create :update_sessions!
+        after_update :update_sessions!
         
         # Attributes
         attr_writer "confirm_#{options[:password_field]}"
-        attr_accessor "tried_to_set_#{options[:password_field]}", :saving_from_session
+        attr_accessor "tried_to_set_#{options[:password_field]}"
+        attr_protected "tried_to_set_#{options[:password_field]}"
         
         # Class methods
         class_eval <<-"end_eval", __FILE__, __LINE__
@@ -167,15 +168,32 @@ module Authgasm
           
           protected
             def create_sessions!
-              #{options[:session_scopes].inspect}.each { |scope| #{options[:session_class]}.create(self) }
+              return if !#{options[:session_class]}.activated? || #{options[:session_ids].inspect}.blank?
+              
+              # 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 = #{options[:session_ids].inspect}.first
+              
+              # If we are already logged in, ignore this completely. All that we care about is updating ourself.
+              next if #{options[:session_class]}.find(*[session_id].compact)
+              
+              # Log me in
+              args = [self, session_id].compact
+              #{options[:session_class]}.create(*args)
             end
             
             def update_sessions!
-              #{options[:session_scopes].inspect}.each { |scope| #{options[:session_class]}.update(self) }
-            end
-            
-            def saving_from_session?
-              saving_from_session == true
+              return if !#{options[:session_class]}.activated?
+              
+              #{options[:session_ids].inspect}.each do |session_id|
+                session = #{options[:session_class]}.find(*[session_id].compact)
+                
+                # Ignore if we can't find the session or the session isn't this record
+                next if !session || session.record != self
+                
+                # We know we are logged in and this is our record, update the session
+                session.update
+              end
             end
             
             def tried_to_set_password?

data/lib/authgasm/session/active_record_trickery.rb

@@ -17,10 +17,6 @@ module Authgasm
       end
       
       module InstanceMethods # :nodoc:
-        def id
-          nil
-        end
-      
         def new_record?
           true
         end

data/lib/authgasm/session/base.rb

@@ -44,11 +44,15 @@ module Authgasm
         #     @current_user = @user_session && @user_session.record
         #   end
         #
-        # Accepts a single parameter as the scope. See initialize for more information on scopes.
-        def find(scope = nil)
-          args = [scope].compact
+        # Accepts a single parameter as the id. See initialize for more information on ids. Lastly, how it finds the session can be modified via configuration.
+        def find(id = nil)
+          args = [id].compact
           session = new(*args)
-          return session if session.valid_session? || session.valid_cookie?(true) || session.valid_http_auth?(true)
+          find_with.each do |find_method|
+            args = []
+            args << true unless find_method == :session
+            return session if session.send("valid_#{find_method}?", *args)
+          end
           nil
         end
         
@@ -89,7 +93,7 @@ module Authgasm
           end
       end
     
-      attr_accessor :login_with, :remember_me, :scope
+      attr_accessor :login_with, :remember_me, :id
       attr_reader :record, :unauthorized_record
     
       # You can initialize a session by doing any of the following:
@@ -98,18 +102,18 @@ module Authgasm
       #   UserSession.new(login, password)
       #   UserSession.new(:login => login, :password => password)
       #
-      # If a user has more than one session you need to pass a scope so that Authgasm knows how to differentiate the sessions. The scope MUST be a Symbol.
+      # If a user has more than one session you need to pass an id so that Authgasm knows how to differentiate the sessions. The id MUST be a Symbol.
       #
-      #   UserSession.new(:my_scope)
-      #   UserSession.new(login, password, :my_scope)
-      #   UserSession.new({:login => loing, :password => password}, :my_scope)
+      #   UserSession.new(:my_id)
+      #   UserSession.new(login, password, :my_id)
+      #   UserSession.new({:login => loing, :password => password}, :my_id)
       #
-      # Scopes are rarely used, but they can be useful. For example, what if users allow other users to login into their account via proxy? Now that user can "technically" be logged into 2 accounts at once.
-      # To solve this just pass a scope called :proxy, or whatever you want. Authgasm will separate everything out.s
+      # Ids are rarely used, but they can be useful. For example, what if users allow other users to login into their account via proxy? Now that user can "technically" be logged into 2 accounts at once.
+      # To solve this just pass a id called :proxy, or whatever you want. Authgasm will separate everything out.
       def initialize(*args)
         create_configurable_methods!
         
-        self.scope = args.pop if args.last.is_a?(Symbol)
+        self.id = args.pop if args.last.is_a?(Symbol)
         
         case args.size
         when 1
@@ -153,7 +157,6 @@ module Authgasm
               record.current_login_ip = controller.request.remote_ip
             end
             
-            record.saving_from_session = true
             record.save(false)
           end
           
@@ -186,6 +189,7 @@ module Authgasm
         @record = nil
         cookies.delete cookie_key
         session[session_key] = nil
+        true
       end
       
       # Errors when authentication fails, just like ActiveRecord errors. In fact it uses the same exact class.
@@ -267,9 +271,8 @@ module Authgasm
         # Now lets set the session to make things easier on successive requests. This is nice when logging in from a cookie, the next requests will be right from the session, which is quicker.
         if set_session
           session[session_key] = record.id
-          if record.class.column_names.include?("last_click_at")
-            record.last_click_at = Time.now
-            record.saving_from_session = true
+          if record.class.column_names.include?("last_request_at")
+            record.last_request_at = Time.now
             record.save(false)
           end
         end

data/lib/authgasm/session/callbacks.rb

@@ -18,28 +18,28 @@ module Authgasm
       def create_with_callbacks(updating = false) # :nodoc:
         run_callbacks(:before_create)
         result = create_without_callbacks(updating)
-        run_callbacks(:after_create)
+        run_callbacks(:after_create) if result
         result
       end
       
       def destroy_with_callbacks # :nodoc:
         run_callbacks(:before_destroy)
         result = destroy_without_callbacks
-        run_callbacks(:after_destroy)
+        run_callbacks(:after_destroy) if result
         result
       end
       
       def update_with_callbacks # :nodoc:
         run_callbacks(:before_update)
         result = update_without_callbacks
-        run_callbacks(:after_update)
+        run_callbacks(:after_update) if result
         result
       end
       
       def valid_with_callbacks?(set_session = false) # :nodoc:
         run_callbacks(:before_validation)
         result = valid_without_callbacks?(set_session)
-        run_callbacks(:after_validation)
+        run_callbacks(:after_validation) if result
         result
       end
     end

data/lib/authgasm/session/config.rb

@@ -57,7 +57,7 @@ module Authgasm
         attr_writer :cookie_separator
         
         # 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 scope is set it will be inserted into the beginning of the string. Exmaple:
+        # Also, if a id is set it will be inserted into the beginning of the string. Exmaple:
         #
         #   session = UserSession.new(:super_high_secret)
         #   session.cookie_key => "super_high_secret_user_credentials"
@@ -84,6 +84,15 @@ module Authgasm
         end
         attr_writer :find_by_login_method
         
+        # Calling UserSession.find tries to find the user session by session, then cookie, then basic http auth. This option allows you to change the order or remove any of these.
+        #
+        # * <tt>Default:</tt> [:session, :cookie, :http_auth]
+        # * <tt>Accepts:</tt> Array, and can only use any of the 3 options above
+        def find_with
+          @find_with ||= [:session, :cookie, :http_auth]
+        end
+        attr_writer :find_with
+        
         # The name of the method you want Authgasm to create for storing the login / username. Keep in mind this is just for your Authgasm::Session, if you want it can be something completely different
         # than the field in your model. So if you wanted people to login with a field called "login" and then find users by email this is compeltely doable. See the find_by_login_method configuration option for
         # more details.
@@ -155,7 +164,7 @@ module Authgasm
       
       module InstanceMethods # :nodoc:
         def cookie_key
-          key_parts = [scope, self.class.cookie_key].compact
+          key_parts = [id, self.class.cookie_key].compact
           key_parts.join("_")
         end
         
@@ -180,7 +189,7 @@ module Authgasm
         end
         
         def session_key
-          key_parts = [scope, self.class.session_key].compact
+          key_parts = [id, self.class.session_key].compact
           key_parts.join("_")
         end
       

data/lib/authgasm/version.rb

@@ -44,7 +44,7 @@ module Authgasm # :nodoc:
 
     MAJOR = 0
     MINOR = 9
-    TINY  = 0
+    TINY  = 1
 
     # The current version as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

data/test_app/app/views/users/show.html.erb

@@ -5,6 +5,10 @@
     <td>Login:</td>
     <td><%= @current_user.login %></td>
   </tr>
+  <tr>
+    <td>Login count:</td>
+    <td><%= @current_user.login_count %></td>
+  </tr>
   <tr>
     <td>First name:</td>
     <td><%= @current_user.first_name %></td>

data/test_app/db/migrate/20081023040052_create_users.rb

@@ -2,6 +2,7 @@ class CreateUsers < ActiveRecord::Migration
   def self.up
     create_table :users do |t|
       t.timestamps
+      t.integer :login_count, :null => false, :default => 0
       t.string :login, :null => false
       t.string :crypted_password
       t.string :password_salt

data/test_app/db/schema.rb

@@ -14,7 +14,8 @@ ActiveRecord::Schema.define(:version => 20081023040052) do
   create_table "users", :force => true do |t|
     t.datetime "created_at"
     t.datetime "updated_at"
-    t.string   "login",            :null => false
+    t.integer  "login_count",      :default => 0, :null => false
+    t.string   "login",                           :null => false
     t.string   "crypted_password"
     t.string   "password_salt"
     t.string   "remember_token"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: authgasm
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-24 00:00:00 -04:00
+date: 2008-10-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,7 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- CHANGELOG.rdoc
 - lib/authgasm/acts_as_authentic.rb
 - lib/authgasm/controller.rb
 - lib/authgasm/session/active_record_trickery.rb
@@ -61,6 +62,7 @@ extra_rdoc_files:
 - lib/authgasm.rb
 - README.rdoc
 files: 
+- CHANGELOG.rdoc
 - init.rb
 - lib/authgasm/acts_as_authentic.rb
 - lib/authgasm/controller.rb
@@ -84,10 +86,6 @@ files:
 - test_app/app/helpers/users_helper.rb
 - test_app/app/models/user.rb
 - test_app/app/models/user_session.rb
-- test_app/app/views/asses/edit.html.erb
-- test_app/app/views/asses/index.html.erb
-- test_app/app/views/asses/new.html.erb
-- test_app/app/views/asses/show.html.erb
 - test_app/app/views/layouts/application.html.erb
 - test_app/app/views/user_sessions/new.html.erb
 - test_app/app/views/users/_form.erb

data/test_app/app/views/asses/edit.html.erb

@@ -1,12 +0,0 @@
-<h1>Editing ass</h1>
-
-<% form_for(@ass) do |f| %>
-  <%= f.error_messages %>
-
-  <p>
-    <%= f.submit "Update" %>
-  </p>
-<% end %>
-
-<%= link_to 'Show', @ass %> |
-<%= link_to 'Back', asses_path %>

data/test_app/app/views/asses/index.html.erb

@@ -1,18 +0,0 @@
-<h1>Listing asses</h1>
-
-<table>
-  <tr>
-  </tr>
-
-<% for ass in @asses %>
-  <tr>
-    <td><%= link_to 'Show', ass %></td>
-    <td><%= link_to 'Edit', edit_ass_path(ass) %></td>
-    <td><%= link_to 'Destroy', ass, :confirm => 'Are you sure?', :method => :delete %></td>
-  </tr>
-<% end %>
-</table>
-
-<br />
-
-<%= link_to 'New ass', new_ass_path %>

data/test_app/app/views/asses/new.html.erb

@@ -1,11 +0,0 @@
-<h1>New ass</h1>
-
-<% form_for(@ass) do |f| %>
-  <%= f.error_messages %>
-
-  <p>
-    <%= f.submit "Create" %>
-  </p>
-<% end %>
-
-<%= link_to 'Back', asses_path %>

data/test_app/app/views/asses/show.html.erb

@@ -1,3 +0,0 @@
-
-<%= link_to 'Edit', edit_ass_path(@ass) %> |
-<%= link_to 'Back', asses_path %>