has_scope 0.1 → 0.2

data/README.rdoc

@@ -11,14 +11,14 @@ Imagine the following model called graduations:
 You can use those named scopes as filters by declaring them on your controller:
 
   class GraduationsController < ApplicationController
-    has_scope :featured, :boolean => true
+    has_scope :featured, :type => :boolean
     has_scope :by_degree
   end
 
 Now, if you want to apply them to an specific resource, you just need to call <tt>apply_scopes</tt>:
 
   class GraduationsController < ApplicationController
-    has_scope :featured, :boolean => true
+    has_scope :featured, :type => :boolean
     has_scope :by_degree
 
     def index
@@ -40,7 +40,8 @@ Then for each request:
 You can retrieve all the scopes applied in one action with <tt>current_scopes</tt> method.
 In the last case, it would return: { :featured => true, :by_degree => "phd" }.
 
-Please check <tt>has_scope</tt> method for all the supported options.
+<tt>has_scope</tt> support several options (:only, :except, :as, :if, :unless, :default
+and :type), please check the documentation for a detailed description.
 
 == Bugs and Feedback
 

data/Rakefile

@@ -27,7 +27,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |s|
     s.name = "has_scope"
-    s.version = "0.1"
+    s.version = "0.2"
     s.summary = "Maps controller filters to your resource scopes"
     s.email = "contact@plataformatec.com.br"
     s.homepage = "http://github.com/plataformatec/has_scope"

data/lib/has_scope.rb

@@ -1,12 +1,18 @@
 module HasScope
   TRUE_VALUES = ["true", true, "1", 1]
 
+  ALLOWED_TYPES = {
+    :array   => [ Array ],
+    :hash    => [ Hash ],
+    :default => [ String, Numeric ]
+  }
+
   def self.included(base)
     base.class_eval do
       extend ClassMethods
       helper_method :current_scopes
 
-      class_inheritable_accessor :scopes_configuration, :instance_writer => false
+      class_inheritable_hash :scopes_configuration, :instance_writer => false
       self.scopes_configuration ||= {}
     end
   end
@@ -16,8 +22,10 @@ module HasScope
     #
     # == Options
     #
-    # * <tt>:boolean</tt> - When set to true, call the scope only when the param is true or 1,
-    #                       and does not send the value as argument.
+    # * <tt>:type</tt> - Checks the type of the parameter sent. If set to :boolean
+    #                    it just calls the named scope, without any argument. By default,
+    #                    it does not allow hashes or arrays to be given, except if type
+    #                    :hash or :array are set.
     #
     # * <tt>:only</tt> - In which actions the scope is applied. By default is :all.
     #
@@ -33,22 +41,24 @@ module HasScope
     #                      if the scope should NOT apply.
     #
     # * <tt>:default</tt> - Default value for the scope. Whenever supplied the scope
-    #                       is always called. This is useful to add easy pagination.
+    #                       is always called.
     #
     def has_scope(*scopes)
       options = scopes.extract_options!
       options.symbolize_keys!
-      options.assert_valid_keys(:boolean, :only, :except, :if, :unless, :default, :as)
+
+      if options.delete(:boolean)
+        options[:type] ||= :boolean
+        ActiveSupport::Deprecation.warn(":boolean => true is deprecated, use :type => :boolean instead", caller)
+      end
+      options.assert_valid_keys(:type, :only, :except, :if, :unless, :default, :as)
+
+      options[:only]   = Array(options[:only])
+      options[:except] = Array(options[:except])
 
       scopes.each do |scope|
-        self.scopes_configuration[scope]         ||= {}
-        self.scopes_configuration[scope][:as]      = options[:as] || scope
-        self.scopes_configuration[scope][:only]    = Array(options[:only])
-        self.scopes_configuration[scope][:except]  = Array(options[:except])
-
-        [:if, :unless, :boolean, :default].each do |opt|
-          self.scopes_configuration[scope][opt] = options[opt] if options.key?(opt)
-        end
+        self.scopes_configuration[scope] ||= { :as => scope, :type => :default }
+        self.scopes_configuration[scope].merge!(options)
       end
     end
   end
@@ -66,7 +76,7 @@ module HasScope
   #     end
   #   end
   #
-  def apply_scopes(target_object)
+  def apply_scopes(target)
     self.scopes_configuration.each do |scope, options|
       next unless apply_scope_to_action?(options)
       key = options[:as]
@@ -78,17 +88,23 @@ module HasScope
         value = value.call(self) if value.is_a?(Proc)
       end
 
-      if call_scope
-        if options[:boolean]
-          target_object = target_object.send(scope) if current_scopes[key] = TRUE_VALUES.include?(value)
-        else
-          current_scopes[key] = value
-          target_object = target_object.send(scope, value)
-        end
-      end
+      target = apply_scope_by_type(options[:type], key, scope, value, target) if call_scope
     end
 
-    target_object
+    target
+  end
+
+  # Apply the scope taking into account its type.
+  def apply_scope_by_type(type, key, scope, value, target) #:nodoc:
+    if type == :boolean
+      current_scopes[key] = TRUE_VALUES.include?(value)
+      current_scopes[key] ? target.send(scope) : target
+    elsif ALLOWED_TYPES[type].none?{ |klass| value.is_a?(klass) }
+      raise "Expected type :#{type} in params[:#{key}], got :#{value.class}"
+    else
+      current_scopes[key] = value
+      target.send(scope, value)
+    end
   end
 
   # Given an options with :only and :except arrays, check if the scope

data/test/has_scope_test.rb

@@ -5,10 +5,12 @@ end
 
 class TreesController < ApplicationController
   has_scope :color, :unless => :show_all_colors?
-  has_scope :only_tall, :boolean => true, :only => :index, :if => :restrict_to_only_tall_trees?
+  has_scope :only_tall, :type => :boolean, :only => :index, :if => :restrict_to_only_tall_trees?
   has_scope :shadown_range, :default => 10, :except => [ :index, :show, :destroy, :new ]
   has_scope :root_type, :as => :root
   has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
+  has_scope :paginate, :type => :hash
+  has_scope :categories, :type => :array
 
   def index
     @trees = apply_scopes(Tree).all
@@ -107,6 +109,36 @@ class HasScopeTest < ActionController::TestCase
     assert_equal({ :color => 'blue', :only_tall => true }, current_scopes)
   end
 
+  def test_scope_of_type_hash
+    hash = { "page" => "1", "per_page" => "1" }
+    Tree.expects(:paginate).with(hash).returns(Tree)
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :paginate => hash
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :paginate => hash }, current_scopes)
+  end
+
+  def test_scope_of_type_array
+    array = %w(book kitchen sport)
+    Tree.expects(:categories).with(array).returns(Tree)
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :categories => array
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :categories => array }, current_scopes)
+  end
+
+  def test_invalid_type_hash_for_default_type_scope
+    assert_raise RuntimeError do
+      get :index, :color => { :blue => :red }
+    end
+  end
+
+  def test_invalid_type_string_for_hash_type_scope
+    assert_raise RuntimeError do
+      get :index, :paginate => "1"
+    end
+  end
+
   def test_scope_is_called_with_default_value
     Tree.expects(:shadown_range).with(10).returns(Tree).in_sequence
     Tree.expects(:find).with('42').returns(mock_tree).in_sequence

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: has_scope
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - "Jos\xC3\xA9 Valim"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-04 00:00:00 -02:00
+date: 2009-12-22 00:00:00 +01:00
 default_executable: 
 dependencies: []