has_sunspot_scope 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2009 Plataforma Tecnologia. http://blog.plataformatec.com.br
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,66 @@
+== HasScope
+
+== Block usage
+
+This fork works only for sunspot_rails and i have only used the block variants
+
+  class GraduationsController < ApplicationController
+
+    has_scope :query do |controller, search, value|
+      search.keywords(value)
+    end
+
+    has_scope :category do |controller, search, value|
+      search.with(:category_id, value)
+    end
+
+    def index
+      @search = Graduation.search do |search|
+        apply_scopes(search)
+        search.facet(:category_id, :exclude => scope_return_values[:category] #multi-facet search
+      end
+      @graduations = @search.results
+    end
+  end
+
+You can retrieve all the scopes applied in one action with <tt>current_scopes</tt> method.
+
+== Installation
+
+HasScope is available as gem on Gemcutter, so just run the following:
+
+    sudo gem install has_scope
+
+If you want it as plugin, just do:
+
+    script/plugin install git://github.com/plataformatec/has_scope.git
+
+== Options
+
+HasScope supports several options:
+
+* <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.
+
+* <tt>:except</tt> - In which actions the scope is not applied.
+
+* <tt>:as</tt> - The key in the params hash expected to find the scope. Defaults to the scope name.
+
+* <tt>:using</tt> - The subkeys to be used as args when type is a hash.
+
+* <tt>:if</tt> - Specifies a method, proc or string to call to determine if the scope should apply.
+
+* <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the scope should NOT apply.
+
+* <tt>:default</tt> - Default value for the scope. Whenever supplied the scope is always called.
+
+* <tt>:allow_blank</tt> - Blank values are not sent to scopes by default. Set to true to overwrite.
+
+== Bugs and Feedback
+
+If you discover any bugs or want to drop a line, feel free to create an issue on GitHub.
+
+http://github.com/plataformatec/has_scope/issues
+
+MIT License. Copyright 2009 Plataforma Tecnologia. http://blog.plataformatec.com.br

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test HasScope'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for HasScope'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HasScope'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "has_scope"
+    s.version = "0.5.0"
+    s.summary = "Maps controller filters to your resource scopes"
+    s.email = "contact@plataformatec.com.br"
+    s.homepage = "http://github.com/plataformatec/has_scope"
+    s.description = "Maps controller filters to your resource scopes"
+    s.authors = ['José Valim']
+    s.files =  FileList["[A-Z]*", "lib/**/*", "init.rb"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/init.rb

@@ -0,0 +1 @@
+require 'has_scope'

data/lib/has_scope.rb

@@ -0,0 +1,192 @@
+module HasScope
+  TRUE_VALUES = ["true", true, "1", 1]
+
+  ALLOWED_TYPES = {
+    :array   => [ Array ],
+    :hash    => [ Hash ],
+    :boolean => [ Object ],
+    :default => [ String, Numeric ]
+  }
+
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      helper_method :current_scopes
+      class_inheritable_hash :scopes_configuration, :instance_writer => false
+    end
+  end
+
+  module ClassMethods
+    # Detects params from url and apply as scopes to your classes.
+    #
+    # == Options
+    #
+    # * <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.
+    #
+    # * <tt>:except</tt> - In which actions the scope is not applied. By default is :none.
+    #
+    # * <tt>:as</tt> - The key in the params hash expected to find the scope.
+    #                  Defaults to the scope name.
+    #
+    # * <tt>:using</tt> - If type is a hash, you can provide :using to convert the hash to
+    #                     a named scope call with several arguments.
+    #
+    # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+    #                  if the scope should apply
+    #
+    # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+    #                      if the scope should NOT apply.
+    #
+    # * <tt>:default</tt> - Default value for the scope. Whenever supplied the scope
+    #                       is always called.
+    #
+    # * <tt>:allow_blank</tt> - Blank values are not sent to scopes by default. Set to true to overwrite.
+    #
+    # == Block usage
+    #
+    # has_scope also accepts a block. The controller, current scope and value are yielded
+    # to the block so the user can apply the scope on its own. This is useful in case we
+    # need to manipulate the given value:
+    #
+    #   has_scope :category do |controller, scope, value|
+    #     value != "all" ? scope.by_category(value) : scope
+    #   end
+    #
+    #   has_scope :not_voted_by_me, :type => :boolean do |controller, scope|
+    #     scope.not_voted_by(controller.current_user.id)
+    #   end
+    #
+    def has_scope(*scopes, &block)
+      options = scopes.extract_options!
+      options.symbolize_keys!
+      options.assert_valid_keys(:type, :only, :except, :if, :unless, :default, :as, :using, :allow_blank)
+
+      if options.key?(:using)
+        if options.key?(:type) && options[:type] != :hash
+          raise "You cannot use :using with another :type different than :hash"
+        else
+          options[:type] = :hash
+        end
+
+        options[:using] = Array(options[:using])
+      end
+
+      options[:only]   = Array(options[:only])
+      options[:except] = Array(options[:except])
+
+      self.scopes_configuration ||= {}
+
+      scopes.each do |scope|
+        self.scopes_configuration[scope] ||= { :as => scope, :type => :default, :block => block }
+        self.scopes_configuration[scope].merge!(options)
+      end
+    end
+  end
+
+  protected
+
+  # Receives an object where scopes will be applied to.
+  #
+  #   class GraduationsController < InheritedResources::Base
+  #     has_scope :featured, :type => true, :only => :index
+  #     has_scope :by_degree, :only => :index
+  #
+  #     def index
+  #       @graduations = apply_scopes(Graduation).all
+  #     end
+  #   end
+  #
+  def apply_scopes(target, hash=params)
+    return target unless scopes_configuration
+
+    self.scopes_configuration.each do |scope, options|
+      next unless apply_scope_to_action?(options)
+      key = options[:as]
+
+      if hash.key?(key)
+        value, call_scope = hash[key], true
+      elsif options.key?(:default)
+        value, call_scope = options[:default], true
+        value = value.call(self) if value.is_a?(Proc)
+      end
+
+      value = parse_value(options[:type], key, value)
+
+      if call_scope && (value.present? || options[:allow_blank])
+        current_scopes[key] = value
+        scope_return_values[scope] = call_scope_by_type(options[:type], scope, target, value, options)
+      end
+    end
+
+    target
+  end
+
+  # Set the real value for the current scope if type check.
+  def parse_value(type, key, value) #:nodoc:
+    if type == :boolean
+      TRUE_VALUES.include?(value)
+    elsif value && ALLOWED_TYPES[type].none?{ |klass| value.is_a?(klass) }
+      raise "Expected type :#{type} in params[:#{key}], got #{value.class}"
+    else
+      value
+    end
+  end
+
+  # Call the scope taking into account its type.
+  def call_scope_by_type(type, scope, target, value, options) #:nodoc:
+    block = options[:block]
+
+    if type == :boolean
+      block ? block.call(self, target) : target.send(scope)
+    elsif value && options.key?(:using)
+      value = value.values_at(*options[:using])
+      block ? block.call(self, target, value) : target.send(scope, *value)
+    else
+      block ? block.call(self, target, value) : target.send(scope, value)
+    end
+  end
+
+  # Given an options with :only and :except arrays, check if the scope
+  # can be performed in the current action.
+  def apply_scope_to_action?(options) #:nodoc:
+    return false unless applicable?(options[:if], true) && applicable?(options[:unless], false)
+
+    if options[:only].empty?
+      options[:except].empty? || !options[:except].include?(action_name.to_sym)
+    else
+      options[:only].include?(action_name.to_sym)
+    end
+  end
+
+  # Evaluates the scope options :if or :unless. Returns true if the proc
+  # method, or string evals to the expected value.
+  def applicable?(string_proc_or_symbol, expected) #:nodoc:
+    case string_proc_or_symbol
+      when String
+        eval(string_proc_or_symbol) == expected
+      when Proc
+        string_proc_or_symbol.call(self) == expected
+      when Symbol
+        send(string_proc_or_symbol) == expected
+      else
+        true
+    end
+  end
+
+  # Returns the scopes used in this action.
+  def current_scopes
+    @current_scopes ||= {}
+  end
+
+  # Returns the return-values of the applied scopes in this action.
+  def scope_return_values
+    @scope_return_values ||= {}
+  end
+end
+
+ActionController::Base.send :include, HasScope

data/test/has_scope_test.rb

@@ -0,0 +1,235 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Tree
+end
+
+class TreesController < ApplicationController
+  has_scope :color, :unless => :show_all_colors?
+  has_scope :only_tall, :type => :boolean, :only => :index, :if => :restrict_to_only_tall_trees?
+  has_scope :shadown_range, :default => 10, :except => [ :index, :show, :new ]
+  has_scope :root_type, :as => :root, :allow_blank => true
+  has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
+  has_scope :paginate, :type => :hash
+  has_scope :args_paginate, :type => :hash, :using => [:page, :per_page]
+  has_scope :categories, :type => :array
+
+  has_scope :only_short, :type => :boolean do |controller, scope|
+    scope.only_really_short!(controller.object_id)
+  end
+
+  has_scope :by_category do |controller, scope, value|
+    scope.by_given_category(controller.object_id, value + "_id")
+  end
+
+  def index
+    @trees = apply_scopes(Tree).all
+  end
+
+  def new
+    @tree = apply_scopes(Tree).new
+  end
+
+  def show
+    @tree = apply_scopes(Tree).find(params[:id])
+  end
+  alias :edit :show
+
+  protected
+    def restrict_to_only_tall_trees?
+      true
+    end
+
+    def show_all_colors?
+      false
+    end
+
+    def default_render
+      render :text => action_name
+    end
+end
+
+class HasScopeTest < ActionController::TestCase
+  tests TreesController
+
+  def test_boolean_scope_is_called_when_boolean_param_is_true
+    Tree.expects(:only_tall).with().returns(Tree).in_sequence
+    Tree.expects(:all).returns([mock_tree]).in_sequence
+    get :index, :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :only_tall => true }, current_scopes)
+  end
+
+  def test_boolean_scope_is_not_called_when_boolean_param_is_false
+    Tree.expects(:only_tall).never
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :only_tall => 'false'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({}, current_scopes)
+  end
+
+  def test_scope_is_called_only_on_index
+    Tree.expects(:only_tall).never
+    Tree.expects(:find).with('42').returns(mock_tree)
+    get :show, :only_tall => 'true', :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ }, current_scopes)
+  end
+
+  def test_scope_is_skipped_when_if_option_is_false
+    @controller.stubs(:restrict_to_only_tall_trees?).returns(false)
+    Tree.expects(:only_tall).never
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, current_scopes)
+  end
+
+  def test_scope_is_skipped_when_unless_option_is_true
+    @controller.stubs(:show_all_colors?).returns(true)
+    Tree.expects(:color).never
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :color => 'blue'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, current_scopes)
+  end
+
+  def test_scope_is_called_except_on_index
+    Tree.expects(:shadown_range).with().never
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :shadown_range => 20
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, current_scopes)
+  end
+
+  def test_scope_is_called_with_arguments
+    Tree.expects(:color).with('blue').returns(Tree).in_sequence
+    Tree.expects(:all).returns([mock_tree]).in_sequence
+    get :index, :color => 'blue'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue' }, current_scopes)
+  end
+
+  def test_scope_is_not_called_if_blank
+    Tree.expects(:color).never
+    Tree.expects(:all).returns([mock_tree]).in_sequence
+    get :index, :color => ''
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, current_scopes)
+  end
+
+  def test_scope_is_called_when_blank_if_allow_blank_is_given
+    Tree.expects(:root_type).with('').returns(Tree)
+    Tree.expects(:all).returns([mock_tree]).in_sequence
+    get :index, :root => ''
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :root => '' }, current_scopes)
+  end
+
+  def test_multiple_scopes_are_called
+    Tree.expects(:only_tall).with().returns(Tree)
+    Tree.expects(:color).with('blue').returns(Tree)
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :color => 'blue', :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue', :only_tall => true }, current_scopes)
+  end
+
+  def test_scope_of_type_hash
+    hash = { "page" => "1", "per_page" => "10" }
+    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_hash_with_using
+    hash = { "page" => "1", "per_page" => "10" }
+    Tree.expects(:args_paginate).with("1", "10").returns(Tree)
+    Tree.expects(:all).returns([mock_tree])
+    get :index, :args_paginate => hash
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :args_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
+    get :edit, :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => 10 }, current_scopes)
+  end
+
+  def test_default_scope_value_can_be_overwritten
+    Tree.expects(:shadown_range).with('20').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :edit, :id => '42', :shadown_range => '20'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => '20' }, current_scopes)
+  end
+
+  def test_scope_with_different_key
+    Tree.expects(:root_type).with('outside').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :show, :id => '42', :root => 'outside'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :root => 'outside' }, current_scopes)
+  end
+
+  def test_scope_with_default_value_as_proc
+    session[:height] = 100
+    Tree.expects(:calculate_height).with(100).returns(Tree).in_sequence
+    Tree.expects(:new).returns(mock_tree).in_sequence
+    get :new
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :calculate_height => 100 }, current_scopes)
+   end
+
+   def test_scope_with_boolean_block
+     Tree.expects(:only_really_short!).with(@controller.object_id).returns(Tree)
+     Tree.expects(:all).returns([mock_tree])
+     get :index, :only_short => 'true'
+     assert_equal([mock_tree], assigns(:trees))
+     assert_equal({ :only_short => true }, current_scopes)
+   end
+
+   def test_scope_with_other_block_types
+     Tree.expects(:by_given_category).with(@controller.object_id, 'for_id').returns(Tree)
+     Tree.expects(:all).returns([mock_tree])
+     get :index, :by_category => 'for'
+     assert_equal([mock_tree], assigns(:trees))
+     assert_equal({ :by_category => 'for' }, current_scopes)
+   end
+
+  protected
+
+    def mock_tree(stubs={})
+      @mock_tree ||= mock(stubs)
+    end
+
+    def current_scopes
+      @controller.send :current_scopes
+    end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+require 'test/unit'
+require 'mocha'
+
+# Configure Rails
+ENV["RAILS_ENV"] = "test"
+
+require 'active_support'
+require 'action_controller'
+require 'action_dispatch/middleware/flash'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'has_scope'
+
+HasScope::Routes = ActionDispatch::Routing::RouteSet.new
+HasScope::Routes.draw do
+  match '/:controller(/:action(/:id))'
+end
+
+class ApplicationController < ActionController::Base
+  include HasScope::Routes.url_helpers
+end
+
+class ActiveSupport::TestCase
+  setup do
+    @routes = HasScope::Routes
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: has_sunspot_scope
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Valim"
+- Sebastian Korfmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-23 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Forked from github.com/platformatec/has_scope - Slightly modified to map controller filters to your sunspot search (solr)
+email: korfmann.sebastian@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/has_scope.rb
+- test/has_scope_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/skorfmann/has_scope
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Forked from github.com/platformatec/has_scope - Slightly modified to map controller filters to your sunspot search (solr)
+test_files: 
+- test/has_scope_test.rb
+- test/test_helper.rb