ubiquitous_user 0.4.1 → 0.5.0

data/.gitignore

@@ -0,0 +1,30 @@
+## MAC OS
+.DS_Store
+
+## NetBeans
+nbproject
+
+## RubyMine
+.idea
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+.bundle
+tmp
+Gemfile.lock
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
+
+source "http://rubygems.org"
+
+# Install the dependencies defined on ubiquitous_user.gemspec
+gemspec

data/README.md

@@ -0,0 +1,117 @@
+Ubiquitous User
+===============
+
+Many web applications required you to log in before being able to interact with
+them; which poses a real barer of entry for new users. You need users to have
+accounts for many tasks, but you don't need those accounts to be any more than
+an id. No username, no password, no profile.
+
+This library is an implementation of that. You add the UbiquitousUser::Usable
+mixin to your ApplicationController and after that call user to get a 
+current_user. When a new user is saved, it'll automatically store the id in the
+session[:user_id] in the controller to mark this new user as the logged in user.
+
+When a user logs in what you have to do is set the user, which is just doing
+
+    current_user = userObject
+
+The user model and how to authenticate is your responsibility; ubiquity_user
+doesn't try solve those problem.
+
+Since people just accessing your web site will have a user, people that is
+already registered at your web site may have an anonymous user with activity in
+it. You should try to merge it.
+
+ubiquity_user is designed for and tested in Rails 3.X. It wight work on Rails
+2.X but it might also require some fixes (which might be welcome). It also 
+works fine with omni_auth.
+
+
+Where?
+------
+
+The canonical places for this gem are:
+
+* http://github.com/pupeno/ubiquitous_user
+* http://rubygems.org/gems/ubiquitous_user
+* http://rdoc.info/projects/pupeno/ubiquitous_user
+
+
+How to use it
+-------------
+
+In your application_controller.rb be sure to add the mixin to
+ApplicationController, like this:
+
+    class ApplicationController < ActionController::Base
+      include UbiquitousUser::Usable
+    
+      #...
+    end
+
+After that you can use user anywhere, for example:
+
+    @item.recommender = current_user
+
+or
+
+    <%=h current_user.name %>
+
+You can use current_user= in the controllers, for example:
+
+    class SessionsController < ApplicationController
+      def destroy
+        self.current_user = nil
+        # ...
+      end
+      
+      def create
+        # ...
+        self.current_user = user
+      end
+      
+      # ...
+    end
+
+
+The model
+---------
+
+Ubiquitous User expects you to have a model for your users called User
+(configurable). You could create such a model with the following command:
+
+    rails generate model User
+
+
+Configuration
+-------------
+
+If your user model is not called User or the method to create a new one isn't
+:new, then you can configure Ubiquity User to work with the alternatives:
+
+    UbiquitousUser::Config::user_model = :User
+    UbiquitousUser::Config::user_model_new = :new
+
+
+API Documentation
+-----------------
+
+Up to date api documentation should be automatically generated on
+http://rdoc.info/projects/pupeno/ubiquitous_user
+
+
+Note on patches and pull requests
+---------------------------------
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+---------
+
+Copyright (c) 2009, 2010, 2011 José Pablo Fernández. See LICENSE for details.

data/Rakefile

@@ -1,59 +1,32 @@
-# coding: utf-8
-# Copyright 2010 J. Pablo Fernández
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
 
-require 'rubygems'
-require 'rake'
+$:.unshift File.expand_path("../lib", __FILE__)
+require "ubiquitous_user/version"
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "ubiquitous_user"
-    gem.summary = "Helpers to get and retrieve users ubiquitously"
-    gem.description = "Create accounts for users right away, even when they are anonymous."
-    gem.email = "pupeno@pupeno.com"
-    gem.homepage = "http://github.com/pupeno/ubiquitous_user"
-    gem.authors = ["J. Pablo Fernández"]
-    gem.add_dependency "actionpack", ">= 2.0.0"
-    gem.files = %w(LICENSE README.rdoc Rakefile VERSION) + Dir.glob("{lib,generators}/**/*")
-    #gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
+require "bundler"
+Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/test_*.rb"
   test.verbose = true
 end
+task :default => :test
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+require "rcov/rcovtask"
+Rcov::RcovTask.new do |test|
+  test.libs << "test"
+  test.pattern = "test/**/test_*.rb"
+  test.verbose = true
 end
 
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
+require "rake/rdoctask"
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "Ubiquitous User #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('LICENSE')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "Ubiquitous User #{UbiquitousUser::VERSION}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("LICENSE")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end

data/generators/ubiquitous_user/templates/initializer.rb

@@ -1,6 +1,4 @@
 # Configure ubiquitous user. For more information see http://github.com/pupeno/ubiquitous_user
 
-# UsableConfig::user_model = :User
-# UsableConfig::user_model_new = :new
-# UsableConfig::user_model_save = :save
-# UsableConfig::user_model_name = :name
+# UbiquitousUser::Config::user_model = :User
+# UbiquitousUser::Config::user_model_new = :new

data/generators/ubiquitous_user/ubiquitous_user_generator.rb

@@ -1,12 +1,12 @@
-# coding: utf-8
-# Copyright 2010 J. Pablo Fernández
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
 
 class UbiquitousUserGenerator < Rails::Generator::Base
   def manifest
     record do |m|
       m.file 'initializer.rb', 'config/initializers/ubiquitous_user.rb'
-      
+
       m.readme 'INSTALL'
     end
   end
-end
+end

data/lib/ubiquitous_user.rb

@@ -1,101 +1,6 @@
-# coding: utf-8
-# Copyright 2010 J. Pablo Fernández
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
 
-module UsableConfig
-  @user_model = :User
-  @user_model_new = :new
-  @user_model_save = :save!
-  @user_model_name = :name
-  
-  # Class that defines the user model.
-  attr_accessor :user_model
-  module_function :user_model, :user_model=
-  # Method used to create a new user, of class user_model
-  attr_accessor :user_model_new
-  module_function :user_model_new, :user_model_new=
-  # Method used to save the user.
-  attr_accessor :user_model_save
-  module_function :user_model_save, :user_model_save=
-  # Method used to get the name of the user.
-  attr_accessor :user_model_name
-  module_function :user_model_name, :user_model_name=
-
-  def user_model_class  # :nodoc:
-    Object.const_get(user_model)
-  end
-  module_function :user_model_class
-end
-
-module UsableHelpers
-  # Helper method to get the current user. It will always return a user but the
-  # user may not be in the database. If options[:create] is true, then the user
-  # will be in the database (although it may be a ghost user).
-  def user
-    # Find the user in the database if session[:user_id] is defined and @ubiquitous_user is not.
-    @ubiquitous_user = UsableConfig::user_model_class.find_by_id(session[:user_id]) if session[:user_id] != nil and @ubiquitous_user == nil
-    
-    # Create a new user object if @ubiquitous_user is not defined.
-    @ubiquitous_user = UsableConfig::user_model_class.send(UsableConfig::user_model_new) if @ubiquitous_user == nil
-    
-    # If the object is new, let's get ready to mark the user as logged in when saving.
-    if @ubiquitous_user.new_record? or @ubiquitous_user.id != session[:user_id]
-      controller = self
-      # Read more about this technique on http://stackoverflow.com/questions/2495550/define-a-method-that-is-a-closure-in-ruby
-      klass = class << @ubiquitous_user; self; end
-      klass.send(:define_method, :after_save) do
-        super
-        controller.session[:user_id] = self.id
-      end
-    end
-    
-    return @ubiquitous_user
-  end
-  
-  # <b>DEPRECATED:</b> Please use <tt>user</tt> instead. Call
-  # <tt>user.save!</tt> if you really needed it saved.
-  def user!
-    warn "[DEPRECATION] use 'user' instead, call 'user.save!' if you really needed it saved"
-    return user
-  end
-  
-  # Helper method to check whether a user is logged in or not
-  def user_logged_in?
-    user_id = session[:user_id]
-    user_id != nil and UsableConfig::user_model_class.find_by_id(user_id) != nil and session[:user_name] != nil
-  end
-end
-
-ActionController::Base.class_eval do
-  helper UsableHelpers
-end
-
-module UsableClass
-  def authorize(message = "Please log in.", key = :warning)
-    Proc.new do |controller|
-      unless controller.user_logged_in?
-        # flash, redirect_to and new_session_url are protected. Thank god this is Ruby, not Java.
-        controller.send(:flash)[key] = message
-        begin
-          controller.send(:redirect_to, :back)
-        rescue ActionController::RedirectBackError
-          controller.send(:redirect_to, controller.send(:new_session_url))
-        end
-      end
-    end
-  end
-  module_function :authorize
-end
-
-module Usable
-  include UsableHelpers
-  
-  def user=(new_user)
-    session[:user_id] = new_user != nil ? new_user.id : nil
-    session[:user_name] = new_user != nil ? new_user.send(UsableConfig::user_model_name) : nil
-    @ubiquitous_user = new_user
-  end
-  
-  def authorize
-    ::UsableClass.authorize().call(self)
-  end
-end
+require "ubiquitous_user/config"
+require "ubiquitous_user/ubiquitous_user"
+require "ubiquitous_user/version"

data/lib/ubiquitous_user/config.rb

@@ -0,0 +1,21 @@
+# Copyright © 2011, José Pablo Fernández
+
+module UbiquitousUser
+  module Config
+    @user_model = :User
+    @user_model_new = :new
+
+    # Class that defines the user model.
+    attr_accessor :user_model
+    module_function :user_model, :user_model=
+    # Method used to create a new user, of class user_model
+    attr_accessor :user_model_new
+    module_function :user_model_new, :user_model_new=
+
+    def user_model_class # :nodoc:
+      Object.const_get(user_model)
+    end
+
+    module_function :user_model_class
+  end
+end

data/lib/ubiquitous_user/ubiquitous_user.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
+
+module UbiquitousUser
+  module Helpers
+    # Helper method to get the current user. It will always return a user but the
+    # user may not be in the database. If options[:create] is true, then the user
+    # will be in the database (although it may be a ghost user).
+    def current_user
+      # Find the user in the database if session[:user_id] is defined and @ubiquitous_user is not.
+      @ubiquitous_user = UbiquitousUser::Config::user_model_class.find_by_id(session[:user_id]) if session[:user_id] != nil and @ubiquitous_user == nil
+
+      # Create a new user object if @ubiquitous_user is not defined.
+      @ubiquitous_user = UbiquitousUser::Config::user_model_class.send(UbiquitousUser::Config::user_model_new) if @ubiquitous_user == nil
+
+      # If the object is new, let's get ready to mark the user as logged in when saving.
+      if @ubiquitous_user.new_record? or @ubiquitous_user.id != session[:user_id]
+        if !@ubiquitous_user.respond_to? :mark_user_as_logged_in_in_the_session
+          UbiquitousUser::Config::user_model_class.class_eval do
+            after_save :mark_user_as_logged_in_in_the_session
+
+            def mark_user_as_logged_in_in_the_session
+              if !@session_reference_by_ubiquitous_user.nil?
+                @session_reference_by_ubiquitous_user[:user_id] = id
+              end
+            end
+          end
+        end
+        @ubiquitous_user.instance_variable_set "@session_reference_by_ubiquitous_user", self.session
+      end
+
+      return @ubiquitous_user
+    end
+  end
+
+  # TODO: should this really be top level?
+  ::ActionController::Base.class_eval do
+    helper UbiquitousUser::Helpers
+  end
+
+  module Usable
+    include UbiquitousUser::Helpers
+
+    def current_user=(new_user)
+      session[:user_id] = new_user != nil ? new_user.id : nil
+      @ubiquitous_user = new_user
+    end
+  end
+end
+

data/lib/ubiquitous_user/version.rb

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
+
+module UbiquitousUser
+  VERSION = "0.5.0" unless defined?(::UbiquitousUser::VERSION)
+end

data/test/helper.rb

@@ -1,50 +1,84 @@
-# coding: utf-8
-# Copyright 2010 J. Pablo Fernández
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
 
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require "rubygems"
+require "test/unit"
+require "shoulda"
+require "mocha"
 
 # Minimum set ActionController required to test ubiquitous_user
 module ActionController
   class Base
     @@helpers = []
-    
+
     def self.helper(h)
       @@helpers << h
     end
   end
-  
+
   class RedirectBackError < Exception
   end
 end
 
+class Model
+  attr_accessor :id
+  @@after_save_methods = []
+
+  def self.after_save(method)
+    @@after_save_methods << method
+  end
+
+  def self.find_by_id(user_id)
+    user = User.new
+    user.id = user_id
+    return user
+  end
+
+  def save
+    self.id = object_id if id.nil?
+    @@after_save_methods.each do |m|
+      send(m)
+    end
+  end
+
+  def save!
+    save
+  end
+
+  def new_record?
+    id.nil?
+  end
+end
+
 # Default user model.
-class User
+class User < Model
 end
 
 # An alternative user model.
-class Person
+class Person < Model
+  class <<self
+    alias_method :new_person, :new
+
+    def new
+      raise "This method shouldn't ever be called."
+    end
+  end
 end
 
-require 'ubiquitous_user'
+require "ubiquitous_user"
 
 class Controller
-  include Usable
-  extend UsableClass
-  
+  include UbiquitousUser::Usable
+
   # Simulate session and flash
   def initialize
     @session = {}
     @flash = {}
   end
+
   attr_accessor :session
   attr_accessor :flash
-  
+
   # Allow access to @ubiquitous_user, only for testing purposes.
   attr_accessor :ubiquitous_user
-end
+end

data/test/test_ubiquitous_user.rb

@@ -1,224 +1,87 @@
-# coding: utf-8
-# Copyright 2010 J. Pablo Fernández
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
 
-require 'helper'
+require "helper"
 
 class TestUbiquitousUser < Test::Unit::TestCase
-  context "A controller and a mock user" do
+  context "A controller" do
     setup do
       @controller = Controller.new
-      @user = mock("User")
-      
       # Just to be sure we are starting from scratch
       assert_nil @controller.ubiquitous_user
+      assert_nil @controller.session[:user_id]
     end
-    
-    should "create a new user object on Controller#user" do
-      @user.expects(:new_record?).returns(true)
-      User.expects(:new).returns(@user)
-      
-      user = @controller.user
-      
-      assert_equal @user, user
-      assert_equal @user, @controller.ubiquitous_user
-    end
-    
-    should "should return previous user object on Controller#user" do
-      @user.expects(:new_record?).returns(true)
-      @controller.ubiquitous_user = @user
-      
-      user = @controller.user
-      
-      assert_equal @user, user
+
+    should "create a new user object on current_user" do
+      user = @controller.current_user
+      assert_equal User, user.class
+      assert_equal @controller.ubiquitous_user, user
+      assert user.new_record?
     end
-    
-    should "find a user on Controller#user if there's a user_id on session" do
-      user_id = 42
-      @controller.session[:user_id] = user_id
-      @user.expects(:new_record?).returns(true)
-      User.expects(:find_by_id).with(user_id).returns(@user)
-      
-      user = @controller.user
-      
-      assert_equal @user, user
-      assert_equal @user, @controller.ubiquitous_user
+
+    should "find a user on current_user if there's a user_id on session" do
+      @controller.session[:user_id] = 42
+      user = @controller.current_user
+      assert_equal @controller.session[:user_id], user.id
     end
-    
-    should "set the session user_id when saving a user" do
-      user_id = 43
-      User.expects(:new).returns(@user)
-      @user.expects(:new_record?).returns(true)
-      @user.expects(:save!)
-      @user.expects(:id).returns(user_id)
-      @user.expects(:after_save)
 
-      user = @controller.user
+    should "set the session user_id when saving a user" do
+      user = @controller.current_user
       user.save!
-      # save! should be calling after_save, but it isn't because it's a mock, so
-      # let's call it manually
-      user.after_save
-
-      assert_equal @user, user
-      assert_equal @user, @controller.ubiquitous_user
-      assert_equal user_id, @controller.session[:user_id]
-    end
-#
-#    should "not save an existing user even when requested on Controller#user" do
-#      user_id = 44
-#      @controller.session[:user_id] = user_id
-#      User.expects(:find_by_id).with(user_id).returns(@user)
-#      @user.expects(:new_record?).returns(false)
-#
-#      user = @controller.user!
-#
-#      assert_equal @user, user
-#      assert_equal @user, @controller.ubiquitous_user
-#    end
-    
-    should "set user on Controller#user=" do
-      user_id = 45
-      user_name = "Alex"
-      @user.expects(:id).returns(user_id)
-      @user.expects(:name).returns(user_name)
-      
-      @controller.user = @user
-      
-      assert_equal @user, @controller.ubiquitous_user
-      assert_equal user_id, @controller.session[:user_id]
-      assert_equal user_name, @controller.session[:user_name]
+      assert_not_nil user.id
+      assert_not_nil @controller.session[:user_id]
+      assert_equal user.id, @controller.session[:user_id]
     end
-    
-    should "unset user on Controller#user=(nil)" do
-      @controller.user = nil
-      
+
+    should "unset user on current_user=(nil)" do
+      @controller.current_user = nil
+
       assert_equal nil, @controller.ubiquitous_user
       assert_equal nil, @controller.session[:user_id]
-      assert_equal nil, @controller.session[:user_name]
-    end
-    
-    should "say no user is logged in when none is on Controller#user_logged_in?" do
-      user_logged_in = @controller.user_logged_in?
-      
-      assert !user_logged_in
-    end
-    
-    should "say no user is logged in when an anonymously registered user is in on Controller#user_logged_in?" do
-      user_id = 46
-      @controller.session[:user_id] = user_id
-      User.expects(:find_by_id).with(user_id).returns(@user)
-      
-      user_logged_in = @controller.user_logged_in?
-      
-      assert !user_logged_in
-    end
-    
-    should "say a user is logged in when it is on Controller#user_logged_in?" do
-      user_id = 46
-      user_name = "Brad"
-      @controller.session[:user_id] = user_id
-      @controller.session[:user_name] = user_name
-      User.expects(:find_by_id).with(user_id).returns(@user)
-      
-      user_logged_in = @controller.user_logged_in?
-      
-      assert user_logged_in
-    end
-    
-    should "redirect back with a flash message when user not logged in on Controller.authorize" do
-      msg = "Log in you user!"
-      key = :error
-      
-      authorize = Controller.send(:authorize, msg, key)
-      
-      assert authorize.instance_of? Proc
-      
-      @controller.expects(:redirect_to).with(:back)
-      
-      authorize.call(@controller)
-      assert_equal msg, @controller.flash[key]
-    end
-    
-    should "redirect to new_session_url with a flash message when user not logged in and there's no :back on Controller.authorize" do
-      msg = "Log in you user!"
-      key = :error
-      
-      authorize = Controller.send(:authorize, msg, key)
-      
-      assert authorize.instance_of? Proc
-      
-      new_session_url = "/login"
-      @controller.expects(:redirect_to).with(:back).raises(ActionController::RedirectBackError)
-      @controller.expects(:new_session_url).returns(new_session_url)
-      @controller.expects(:redirect_to).with(new_session_url)
-      
-      authorize.call(@controller)
-      assert_equal msg, @controller.flash[key]
     end
-    
-    should "redirect back with a flash message when user not logged in on Controller#authorize" do
-      @controller.expects(:redirect_to).with(:back)
-      
-      @controller.authorize
-      assert_equal "Please log in.", @controller.flash[:warning]
-    end
-    
-    context "with custom usable config" do
+
+    context "and a user" do
       setup do
-        @orig_config = UsableConfig.clone
-        UsableConfig.user_model = :Person
-        UsableConfig.user_model_new = :new_person
-        UsableConfig.user_model_save = :save_person!
-        UsableConfig.user_model_name = :full_name
+        @user = User.new
+        assert_nil @user.id
       end
-      
-      teardown do
-        UsableConfig.user_model = @orig_config.user_model
-        UsableConfig.user_model_new = @orig_config.user_model_new
-        UsableConfig.user_model_save = @orig_config.user_model_save
-        UsableConfig.user_model_name = @orig_config.user_model_name
+
+      should "should return previous user object on current_user" do
+        @controller.ubiquitous_user = @user
+        assert_equal @user, @controller.current_user
+        assert_nil @controller.session[:user_id]
+      end
+
+      context "that is saved" do
+        setup do
+          @user.save!
+          assert_not_nil @user.id
+        end
+
+        should "set user on current_user=" do
+          @controller.current_user = @user
+
+          assert_equal @user, @controller.ubiquitous_user
+          assert_equal @user.id, @controller.session[:user_id]
+        end
       end
-      
-      should "create a new user object on #user" do
-        @user.expects(:new_record?).returns(true)
-        Person.expects(:new_person).returns(@user)
-        assert_equal @user, @controller.user
-        assert_equal @user, @controller.ubiquitous_user
+    end
+
+    context "with custom config" do
+      setup do
+        @orig_config = UbiquitousUser::Config.clone
+        UbiquitousUser::Config.user_model = :Person
+        UbiquitousUser::Config.user_model_new = :new_person
       end
-      
-#      should "save a new user when requested on #user" do
-#        user_id = 43
-#        Person.expects(:new_person).returns(@user)
-#        @user.expects(:new_record?).returns(true)
-#        @user.expects(:save_person!)
-#        @user.expects(:id).returns(user_id)
-#        assert_equal @user, @controller.user!
-#        assert_equal @user, @controller.ubiquitous_user
-#        assert_equal user_id, @controller.session[:user_id]
-#      end
-      
-      should "set user on Controller#user=" do
-        user_id = 45
-        user_name = "Alex"
-        @user.expects(:id).returns(user_id)
-        @user.expects(:full_name).returns(user_name)
-        
-        @controller.user = @user
-        
-        assert_equal @user, @controller.ubiquitous_user
-        assert_equal user_id, @controller.session[:user_id]
-        assert_equal user_name, @controller.session[:user_name]
+
+      teardown do
+        UbiquitousUser::Config.user_model = @orig_config.user_model
+        UbiquitousUser::Config.user_model_new = @orig_config.user_model_new
       end
-      
-      should "say a user is logged in when it is on #user_logged_in?" do
-        user_id = 46
-        user_name = "Brad"
-        @controller.session[:user_id] = user_id
-        @controller.session[:user_name] = user_name
-        Person.expects(:find_by_id).with(user_id).returns(@user)
-        
-        user_logged_in = @controller.user_logged_in?
-        
-        assert user_logged_in
+
+      should "create a new user object on #current_user" do
+        person = @controller.current_user
+        assert_equal Person, person.class
       end
     end
   end

data/ubiquitous_user.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+# Copyright © 2011, José Pablo Fernández
+
+$:.unshift File.expand_path("../lib", __FILE__)
+require "ubiquitous_user/version"
+
+Gem::Specification.new do |s|
+  s.name = "ubiquitous_user"
+  s.version = UbiquitousUser::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["J. Pablo Fernández"]
+  s.email = ["pupeno@pupeno.com"]
+  s.homepage = "http://github.com/pupeno/ubiquitous_user"
+  s.summary = "Helpers to get and retrieve users ubiquitously"
+  s.description = "Create accounts for users right away, even when they are anonymous."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project = "ubiquitous_user"
+
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "rcov"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test}/*`.split("\n")
+
+  #s.rdoc_options = ["--charset=UTF-8"]
+end
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ubiquitous_user
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 11
+  prerelease: 
   segments: 
   - 0
-  - 4
-  - 1
-  version: 0.4.1
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - "J. Pablo Fern\xC3\xA1ndez"
@@ -14,71 +15,97 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 +01:00
+date: 2011-04-23 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: actionpack
+  name: shoulda
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
-        - 2
-        - 0
         - 0
-        version: 2.0.0
-  type: :runtime
+        version: "0"
+  type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Create accounts for users right away, even when they are anonymous.
-email: pupeno@pupeno.com
+email: 
+- pupeno@pupeno.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- Gemfile
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
-- VERSION
 - generators/ubiquitous_user/templates/INSTALL
 - generators/ubiquitous_user/templates/initializer.rb
 - generators/ubiquitous_user/ubiquitous_user_generator.rb
 - lib/ubiquitous_user.rb
+- lib/ubiquitous_user/config.rb
+- lib/ubiquitous_user/ubiquitous_user.rb
+- lib/ubiquitous_user/version.rb
+- test/helper.rb
+- test/test_ubiquitous_user.rb
+- ubiquitous_user.gemspec
 has_rdoc: true
 homepage: http://github.com/pupeno/ubiquitous_user
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 23
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.6
+rubyforge_project: ubiquitous_user
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Helpers to get and retrieve users ubiquitously
-test_files: 
-- test/helper.rb
-- test/test_ubiquitous_user.rb
+test_files: []
+

data/README.rdoc

@@ -1,195 +0,0 @@
-= Ubiquitous User
-
-Many web applications required you to log in before being able to interact with
-them; which poses a real barer of entry for new users. You need users to have
-accounts for many tasks, but you don't need those accounts to be any more than
-an id. No username, no password, no profile.
-
-This library is an implementation of that. You add the Usable mixin to your
-ApplicationController and after that call user to get a user. When a new user
-is saved, it'll automatically store the session[:user_id] in the controller to
-mark this new user as the logged in user.
-
-When a user log ins what you have to do is set the user, which is just doing
-user = userObject.
-
-This library also provides an authorize method, to use as a filter for those
-actions that really require a logged in user.
-
-The user model and how to authenticate is your responsibility; ubiquity_user
-doesn't try solve those problem (not yet at least). I may recommend
-{rails_openid}[http://github.com/pupeno/rails_openid] for authentication, but
-maybe it's only because I wrote it.
-
-Since people just accessing your web site will have a user, people that is
-already registered at your web site may have an anonymous user with activity in
-it. You should try to merge it.
-
-== Installation
-
-This gem is provided through RubyGems.org so you need to have gem configured to
-pull gems from RubyGems.org.
-
-=== Enabling RubyGems.org (formerly known as GemCutter)
-
-You can skip this if you have RubyGems.org enabled (which is going to be the
-default in the future anyway). A properly configured environment should list
-rubygems.org or gemcutter.org in the gem sources, like:
-
-  $ gem sources
-  *** CURRENT SOURCES ***
-
-  http://rubygems.org/
-
-If you don't have it, you can probably add it this way:
-
-  $ gem source -a http://rubygems.org/
-
-=== Installing ubiquitous_user manually
-
-It's simple a matter of running:
-
-  $ gem install ubiquitous_user
-
-and that's it. Let me know if something breaks.
-
-=== Installing through your Ruby on Rails 3 project
-
-In the +Gemfile+ file of your Ruby on Rails project you'll need to add:
-
-  gem "ubiquitous_user"
-
-after that run
-
-  bundle install
-
-and watch the magic happen, all required gems will be installed. Configuring
-your Rails project like that is something you'll need anyway, so this is my
-recommended way.
-
-=== Installing through your Ruby on Rails 2.3 project
-
-In the +environment.rb+ file of your Ruby on Rails project you'll have some
-commented out lines like this:
-
-  # config.gem "bj"
-  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
-  # config.gem "sqlite3-ruby", :lib => "sqlite3"
-  # config.gem "aws-s3", :lib => "aws/s3"
-
-After those you can just add
-
-  config.gem "ubiquitous_user"
-
-and then run
-
-  $ rake gems:install
-
-and you'll get this and all the gems your Rails project need installed.
-Configuring your Rails project like that is something you'll need anyway, so
-this is my recommended way.
-
-== How to use it
-
-In your application_controller.rb be sure to add the mixin to
-ApplicationController, like this:
-
-  class ApplicationController < ActionController::Base
-    include Usable
-    
-    #...
-  end
-
-After that you can use user anywhere, for example:
-
-  @item.recommender = user
-
-or
-
-  <%=h user.name %>
-
-You can use user= and authorize in the controllers, for example:
-
-  class SessionsController < ApplicationController
-    def destroy
-      self.user = nil
-      # ...
-    end
-    
-    def create
-      # ...
-      self.user = user
-    end
-    
-    # ...
-  end
-  
-  class ProfilesController < ApplicationController
-    before_filter :authorize
-    # ...
-  end
-
-Another interesting method is the authorize generator, which allows you to
-specify the message you want to give when the authorization is not granted. For
-example:
-
-  class ProfilesController < ApplicationController
-    before_filter :only => [:edit, :update], &authorize("You gotta log in to do that!")
-    # ...
-  end
-
-But for that you also need to add an "extend", like this:
-
-  class ApplicationController < ActionController::Base
-    include Usable
-    extend UsableClass
-    
-    #...
-  end
-
-== The model
-
-Ubiquitous User expects you to have a model for your users called User
-(configurable) with a name field (also configurable). You could create such a
-model with the following command:
-
-  ./script/generate model User name:string
-
-The name can be the real name, the username or anything. Ubiquitous user doesn't
-make any assumptions about how you authenticate users.
-
-== Customize
-
-ubiquitous_user expects your user model to be named User. That's not
-configurable yet. What is configurable is the two methods it calls on user. You
-can do this kind of configuration in config/initializers/ubiquitous_user.rb for
-example:
-
-  UsableConfig::user_model = :Account
-  UsableConfig::user_model_new = :new_account
-  UsableConfig::user_model_save = :save_bypassing_non_essential_validation
-  UsableConfig::user_model_name = :name_or_else
-
-== API Documentation
-
-Up to date api documentation should be automatically generated on
-http://rdoc.info/projects/pupeno/ubiquitous_user
-
-== Metrics
-
-You con find the metrics for this gem automatically generated at
-http://getcaliper.com/caliper/project?repo=git%3A%2F%2Fgithub.com%2Fpupeno%2Fubiquitous_user.git
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2009 J. Pablo Fernández. See LICENSE for details.

data/VERSION

@@ -1 +0,0 @@
-0.4.1