ubiquitous_user 0.2.1 → 0.3.0

data/README.rdoc

@@ -119,6 +119,24 @@ You can use user= and authorize in the controllers, for example:
     # ...
   end
 
+Another interesting method is the authorize generator, which allows you to
+specify the message you want to give 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
@@ -147,6 +165,11 @@ example:
 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.

data/Rakefile

@@ -54,3 +54,40 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('LICENSE')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+begin
+  require 'metric_fu'
+  MetricFu::Configuration.run do |config|
+    #define which metrics you want to use
+    # config.metrics  = [:churn, :saikuro, :stats, :flog, :flay, :reek, :roodi, :rcov]
+    config.metrics  = [:rcov]
+    # config.graphs   = [:flog, :flay, :reek, :roodi, :rcov]
+    config.graphs   = [:rcov]
+
+    # config.flay     = { :dirs_to_flay => ['app', 'lib']  } 
+    # config.flog     = { :dirs_to_flog => ['app', 'lib']  }
+    # config.reek     = { :dirs_to_reek => ['app', 'lib']  }
+    # config.roodi    = { :dirs_to_roodi => ['app', 'lib'] }
+    # config.saikuro  = { :output_directory => 'scratch_directory/saikuro', 
+    #                     :input_directory => ['app', 'lib'],
+    #                     :cyclo => "",
+    #                     :filter_cyclo => "0",
+    #                     :warn_cyclo => "5",
+    #                     :error_cyclo => "7",
+    #                     :formater => "text"} #this needs to be set to "text"
+    # config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
+    config.rcov     = { :test_files => ['test/**/test_*.rb'],
+                        :rcov_opts => ["--text-report"
+                          #"--sort coverage", 
+                                       #"--no-html", 
+                                      # "--text-coverage",
+                                      # "--no-color",
+                                      # "--profile",
+                                      # "--rails",
+                                      # "--exclude /gems/,/Library/,spec"
+                                       ]
+                                       }
+  end
+rescue LoadError
+  puts "Metric fu not available"
+end

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/ubiquitous_user.rb

@@ -1,7 +1,7 @@
 module UsableConfig
   @user_model = :User
   @user_model_new = :new
-  @user_model_save = :save
+  @user_model_save = :save!
   @user_model_name = :name
   
   # Class that defines the user model.
@@ -29,13 +29,13 @@ module UsableHelpers
   # will be in the database (although it may be a ghost user).
   def user(options = {:save => false})
     # Find the user in the database if session[:user_id] is defined and @ubiquitous_user is not.
-    @ubiquitous_user = UsableConfig::user_model_class.find(session[:user_id]) if session[:user_id] != nil and @ubiquitous_user == nil
+    @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
+    @ubiquitous_user = UsableConfig::user_model_class.send(UsableConfig::user_model_new) if @ubiquitous_user == nil
     
     # If the object is new and we are asked to save, do it.
-    if @ubiquitous_user.new_record? and options[:save]
+    if options[:save] and @ubiquitous_user.new_record?
       # Save the user in the database and set the session user_id for latter.
       @ubiquitous_user.send(UsableConfig::user_model_save)
       session[:user_id] = @ubiquitous_user.id
@@ -48,25 +48,45 @@ module UsableHelpers
   def user!
     return user(:save => true)
   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=(u)
-    session[:user_id] = u != nil ? u.id : nil
-    session[:user_name] = u != nil ? u.send(UsableConfig::user_model_name) : nil
-    user
+  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
-    unless UsableConfig::user_model_class.find_by_id(session[:user_id]) and session[:user_name] != nil
-      flash[:notice] = "Please log in."
-      redirect_to new_session_url
-    end
+    ::UsableClass.authorize().call(self)
   end
 end

data/test/helper.rb

@@ -1,10 +1,48 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'mocha'
+require 'ruby-debug'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'ubiquitous_user'
 
-class Test::Unit::TestCase
+# 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
+
+# Default user model.
+class User
+end
+
+# An alternative user model.
+class Person
 end
+
+require 'ubiquitous_user'
+
+class Controller
+  include Usable
+  extend UsableClass
+  
+  # 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

data/test/test_ubiquitous_user.rb

@@ -0,0 +1,213 @@
+require 'helper'
+
+class TestUbiquitousUser < Test::Unit::TestCase
+  context "A controller and a mock user" do
+    setup do
+      @controller = Controller.new
+      @user = mock("User")
+      
+      # Just to be sure we are starting from scratch
+      assert_nil @controller.ubiquitous_user
+    end
+    
+    should "create a new user object on Controller#user" do
+      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
+      @controller.ubiquitous_user = @user
+      
+      user = @controller.user
+      
+      assert_equal @user, user
+    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(:find_by_id).with(user_id).returns(@user)
+      
+      user = @controller.user
+      
+      assert_equal @user, user
+      assert_equal @user, @controller.ubiquitous_user
+    end
+    
+    should "save a new user when requested on Controller#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 = @controller.user!
+      
+      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]
+    end
+    
+    should "unset user on Controller#user=(nil)" do
+      @controller.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
+      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
+      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
+      end
+      
+      should "create a new user object on #user" do
+        Person.expects(:new_person).returns(@user)
+        assert_equal @user, @controller.user
+        assert_equal @user, @controller.ubiquitous_user
+      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]
+      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
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ubiquitous_user
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - "J. Pablo Fern\xC3\xA1ndez"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +01:00
+date: 2009-12-26 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,4 +70,4 @@ specification_version: 3
 summary: Helpers to get and retrieve users ubiquitously
 test_files: 
 - test/helper.rb
-- test/test_ubiquitous-user.rb
+- test/test_ubiquitous_user.rb

data/test/test_ubiquitous-user.rb

@@ -1,7 +0,0 @@
-require 'helper'
-
-class TestUbiquitousUser < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end