scoped_from 0.1

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.bundle
+.rvmrc
+pkg/*
+spec/test.sqlite3

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,82 @@
+PATH
+  remote: .
+  specs:
+    scoped_from (0.1)
+      activerecord (~> 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionpack (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.4)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.13)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.5)
+    arel (2.0.9)
+    builder (2.1.2)
+    columnize (0.3.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    linecache (0.43)
+    rack (1.2.2)
+    rack-mount (0.6.13)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    railties (3.0.5)
+      actionpack (= 3.0.5)
+      activesupport (= 3.0.5)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    rspec-rails (2.5.0)
+      actionpack (~> 3.0)
+      activesupport (~> 3.0)
+      railties (~> 3.0)
+      rspec (~> 2.5.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    sqlite3 (1.3.3)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+    thor (0.14.6)
+    tzinfo (0.3.25)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 2.5.0)
+  rspec-rails (~> 2.5.0)
+  ruby-debug
+  scoped_from!
+  sqlite3-ruby

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Alexis Toulotte
+
+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.mdown

@@ -0,0 +1,135 @@
+# ScopedFrom
+
+Provides a simple mapping between scopes and controller parameters for
+[Ruby On Rails 3](http://rubyonrails.org/).
+
+Let see a simple example:
+
+First, a model with some scopes:
+
+    class Post < ActiveRecord::Base
+    
+      scope :commented, where('comments_count > 0')
+
+      scope :created_between, lambda { |after, before|
+        where('created_at >= ? AND created_at <= ?', after, before)
+      }
+      
+      scope :search, lambda { |pattern|
+        where('body LIKE ?', "%#{pattern}%")
+      }
+      
+      scope :with_category, lambda { |category_id|
+        where(:category_id, category_id)
+      }
+    
+    end
+    
+After, a controller:
+    
+    class PostsController < ActionController::Base
+    
+      def index
+        @posts = Post.scoped_from(params)
+      end
+    
+    end
+    
+Then, it just filter your model from params:
+    
+    /posts?commented=1
+    /posts?search=rails
+    /posts?search=rails&commented=1&with_category=42
+
+## Accepted scopes
+
+All scopes can be mapped with `scoped_from` method **except** scopes taking a
+`lambda` (or a `Proc`) with an arity greater than 1 (for example:
+`created_between` in the above code).
+
+Scopes with no argument are invoked if parameter value is evaluated as `true`.
+It includes `"true"`, `"yes"`, `"y"`, `"on"`, and `"1"` strings.
+
+## Scopes restriction
+
+You can restrict mapping to some scopes with `:only` option:
+
+    @posts = Post.scoped_from(params, :only => ['commented', 'search'])
+
+You can also exclude some scopes from mapping with `:except` option:
+
+    @posts = Post.scoped_from(params, :except => 'commented')
+
+## Mapping order
+
+If you need to map an SQL order, just pass `order` parameter:
+
+    @posts = Post.scoped_from(:order => 'created_at')
+
+Order direction can be specified using a dot, space or `:` as delimiter:
+    
+    @posts = Post.scoped_from(:order => 'created_at.desc')
+
+Note that order is SQL safe with `scoped_from` method (columns names are
+checked).
+
+## Some cool stuff
+
+If your provide an array as parameter value, scope is invoked with each item
+of the array:
+
+    @posts = Post.scoped_from(:search => ['bar', 'foo'])
+    
+is equivalent to
+    
+    @posts = Post.search('bar').search('foo')
+
+By default, blank parameter values are ignored, you can include them with
+`:include_blank` option:
+
+    @posts = Post.scoped_from(params, :include_blank => true)
+
+You may also want to filter on columns, just specify `:include_columns` option:
+
+    @posts = Post.scoped_from(params, :include_columns => true)
+
+A query string can also be given to `scoped_from` method:
+
+    @posts = Post.scoped_from('with_category=24&search[]=foo&search[]=bar')
+
+Returned scope from `scoped_from` method gives access to an internal query
+object:
+
+    @posts = Post.scoped_from(params)
+    @query = @posts.query
+
+This query provides you some convenience methods like `params`, `order_column`
+and `order_direction`. This object can also be used to save user's search into
+a database or other storage system.
+
+But, you may also have to subclass this query class. You have to create a
+subclass of `ScopedFrom::Query` named `#{RecordClassName}Query`. Here is an
+example:
+
+    class PostQuery < ScopedFrom::Query
+    
+      def category
+        Category.find_by_id(params[:with_category]) if params[:with_category]
+      end
+    
+    end
+
+This class has to be in load path.
+    
+Then into a view:
+
+    <% if @query.category %>
+      <p>All posts of category <%= @query.category.name %></p>
+    <% else %>
+      <p>All posts</p>
+    <% end %>
+
+## Executing test suite
+
+This project is fully tested with [Rspec 2](http://github.com/rspec/rspec).
+Just run `rake` (after a `bundle install`).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: runs specs.'
+task :default => :spec
+
+desc 'Run all specs in spec directory.'
+RSpec::Core::RakeTask.new(:spec)

data/VERSION

@@ -0,0 +1 @@
+0.1

data/init.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/scoped_from')

data/lib/scoped_from/active_record.rb

@@ -0,0 +1,40 @@
+module ScopedFrom
+
+  module ActiveRecord
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      
+      def scope(name, scope_options, &block)
+        super
+        scope_arities[name] = scope_options.is_a?(Proc) ? scope_options.arity : -1
+      end
+      
+      def scope_with_one_argument?(name)
+        scope_arities[name] == 1
+      end
+      
+      def scope_without_argument?(name)
+        [-1, 0].include?(scope_arities[name])
+      end
+      
+      def scoped_from(params, options = {})
+        query_class = "#{name}Query".constantize rescue nil
+        query_class = Query unless query_class.is_a?(Class) && query_class.ancestors.include?(Query)
+        query_class.new(self, params, options).scope
+      end
+      
+      private
+      
+      def scope_arities
+        read_inheritable_attribute(:scope_arities) || write_inheritable_attribute(:scope_arities, ActiveSupport::HashWithIndifferentAccess.new)
+      end
+
+    end
+    
+  end
+  
+end

data/lib/scoped_from/query.rb

@@ -0,0 +1,103 @@
+module ScopedFrom
+  
+  class Query
+
+    ORDER_DIRECTIONS = %w( asc desc ).freeze
+    TRUE_VALUES = %w( true yes y on 1 ).freeze
+    
+    attr_reader :params
+    
+    # Available options are: - :only : to restrict to specified keys.
+    #                        - :except : to ignore specified keys.
+    #                        - :include_blank : to include blank values
+    #                                           (default false).
+    def initialize(scope, params, options = {})
+      @scope = scope.scoped
+      @options = options
+      self.params = params
+    end
+    
+    def order_column
+      parse_order(params['order'])[:column]
+    end
+    
+    def order_direction
+      parse_order(params['order'])[:direction]
+    end
+    
+    def scope
+      scope = @scope
+      params.each do |name, value|
+        [value].flatten.each do |value|
+          scope = scoped(scope, name, value)
+        end
+      end
+      decorate_scope(scope)
+    end
+    
+    protected
+    
+    def decorate_scope(scope)
+      return scope if scope.respond_to?(:query)
+      def scope.query
+        @__query
+      end
+      scope.instance_variable_set('@__query', self)
+      scope
+    end
+    
+    def order_to_sql(value)
+      order = parse_order(value)
+      "#{order[:column]} #{order[:direction].upcase}" if order.present?
+    end
+    
+    def scoped(scope, name, value)
+      if name.to_s == 'order'
+        scope.order(order_to_sql(value))
+      elsif scope.scope_with_one_argument?(name)
+        scope.send(name, value)
+      elsif scope.scope_without_argument?(name)
+        scope.send(name)
+      elsif scope.column_names.include?(name.to_s)
+        scope.scoped(:conditions => { name => value })
+      else
+        scope
+      end
+    end
+    
+    def params=(params)
+      params = params.params if params.is_a?(self.class)
+      params = CGI.parse(params.to_s) unless params.is_a?(Hash)
+      @params = ActiveSupport::HashWithIndifferentAccess.new
+      params.each do |name, value|
+        values = [value].flatten
+        values.delete_if(&:blank?) unless @options[:include_blank]
+        next if values.empty?
+        if name.to_s == 'order'
+          order = parse_order(values.last)
+          @params[name] = "#{order[:column]}.#{order[:direction]}" if order.present?
+        elsif @scope.scope_without_argument?(name)
+          @params[name] = true if values.any? { |value| true?(value) }
+        elsif @scope.scope_with_one_argument?(name) || @options[:include_columns].present? && @scope.column_names.include?(name.to_s)
+          value = values.many? ? values : values.first
+          @params[name] = @params[name] ? [@params[name], value].flatten : value
+        end
+      end
+      @params.slice!(*[@options[:only]].flatten) if @options[:only].present?
+      @params.except!(*[@options[:except]].flatten) if @options[:except].present?
+    end
+    
+    def parse_order(value)
+      column, direction = value.to_s.split(/[\.:\s]+/, 2)
+      direction = direction.to_s.downcase
+      direction = ORDER_DIRECTIONS.first unless ORDER_DIRECTIONS.include?(direction)
+      @scope.column_names.include?(column) ? { :column => column, :direction => direction } : {}
+    end
+    
+    def true?(value)
+      TRUE_VALUES.include?(value.to_s.strip.downcase)
+    end
+    
+  end
+  
+end

data/lib/scoped_from.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'cgi'
+require 'active_record'
+require 'active_support/core_ext/object/to_query'
+
+module ScopedFrom
+  
+  class << self
+    
+    def version
+      @@version ||= File.read(File.expand_path(File.dirname(__FILE__) + '/../VERSION')).strip.freeze
+    end
+    
+  end
+  
+end
+
+lib_path = File.expand_path(File.dirname(__FILE__) + '/scoped_from')
+
+require "#{lib_path}/active_record"
+require "#{lib_path}/query"
+
+ActiveRecord::Base.send(:include, ScopedFrom::ActiveRecord)

data/scoped_from.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name = 'scoped_from'
+  s.version = File.read(File.expand_path(File.dirname(__FILE__) + '/VERSION')).strip
+  s.platform = Gem::Platform::RUBY
+  s.author = 'Alexis Toulotte'
+  s.email = 'al@alweb.org'
+  s.homepage = 'https://github.com/alexistoulotte/scoped_from'
+  s.summary = 'Mapping between scopes and parameters for Rails'
+  s.description = 'Provides a simple mapping between Active Record scopes and controller parameters for Ruby On Rails 3'
+
+  s.rubyforge_project = 'scoped_from'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'activerecord', '~> 3.0.0'
+
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'rspec-rails', '~> 2.5.0'
+  s.add_development_dependency 'ruby-debug'
+  s.add_development_dependency 'sqlite3-ruby'
+end

data/spec/mocks/comment.rb

@@ -0,0 +1,2 @@
+class Comment < ActiveRecord::Base
+end

data/spec/mocks/comment_query.rb

@@ -0,0 +1,2 @@
+class CommentQuery < ScopedFrom::Query
+end

data/spec/mocks/post.rb

@@ -0,0 +1,2 @@
+class Post < ActiveRecord::Base
+end

data/spec/mocks/user.rb

@@ -0,0 +1,14 @@
+class User < ActiveRecord::Base
+  
+  scope :enabled, :conditions => { :enabled => true }
+  scope :search, lambda { |pattern|
+    where('firstname LIKE ? OR lastname LIKE ?', "%#{pattern}%", "%#{pattern}%")
+  }
+  scope :created_between, lambda { |after, before|
+    where('created_at >= ? AND created_at <= ?', after, before)
+  }
+  scope :latest, lambda {
+    where('created_at >= ?', 1.week.ago)
+  }
+  
+end

data/spec/mocks/user_query.rb

@@ -0,0 +1,2 @@
+class UserQuery < String
+end

data/spec/mocks/vote.rb

@@ -0,0 +1,2 @@
+class Vote < ActiveRecord::Base
+end

data/spec/mocks/vote_query.rb

@@ -0,0 +1,2 @@
+module VoteQuery
+end

data/spec/scoped_from/active_record_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe ScopedFrom::ActiveRecord do
+
+  describe '#scope_with_one_argument?' do
+
+    it 'is true if scope has one argument' do
+      User.should be_scope_with_one_argument(:search)
+      User.should be_scope_with_one_argument('search')
+    end
+    
+    it 'is false if scope has no argument' do
+      User.should_not be_scope_with_one_argument(:latest)
+      User.should_not be_scope_with_one_argument('latest')
+    end
+    
+    it 'is false if scope has more than one argument' do
+      User.should_not be_scope_with_one_argument(:created_between)
+      User.should_not be_scope_with_one_argument('created_between')
+    end
+    
+    it 'is false if scope is not a proc' do
+      User.should_not be_scope_with_one_argument(:enabled)
+      User.should_not be_scope_with_one_argument('enabled')
+    end
+    
+    it 'is false if scope does not exist' do
+      User.should_not be_scope_with_one_argument(:foo)
+      User.should_not be_scope_with_one_argument('foo')
+    end
+    
+  end
+  
+  describe 'scope_without_argument?' do
+    
+    it 'is true if scope has no argument' do
+      User.should be_scope_without_argument(:latest)
+      User.should be_scope_without_argument('latest')
+    end
+    
+    it 'is true if scope is not a proc' do
+      User.should be_scope_without_argument(:enabled)
+      User.should be_scope_without_argument('enabled')
+    end
+    
+    it 'is false if scope has one argument' do
+      User.should_not be_scope_without_argument(:search)
+      User.should_not be_scope_without_argument('search')
+    end
+    
+    it 'is false if scope has more than one argument' do
+      User.should_not be_scope_without_argument(:created_between)
+      User.should_not be_scope_without_argument('created_between')
+    end
+    
+    it 'is false if scope does not exist' do
+      User.should_not be_scope_without_argument(:foo)
+      User.should_not be_scope_without_argument('foo')
+    end
+    
+  end
+  
+  describe '#scoped_from' do
+    
+    it 'just build a new query and return its scope' do
+      query = mock(:query)
+      query.should_receive(:scope).and_return(42)
+      ScopedFrom::Query.should_receive(:new).with(User, 'foo', :except => 'bam').and_return(query)
+      User.scoped_from('foo', :except => 'bam').should == 42
+    end
+    
+    it 'build scopes' do
+      User.scoped_from(:search => 'jane').should == [users(:jane)]
+      User.scoped_from(:search => 'john').should == [users(:john)]
+    end
+    
+    it 'can be chained with other scopes' do
+      User.scoped_from(:search => 'jane').should == [users(:jane)]
+      User.enabled.scoped_from(:search => 'jane').should == []
+    end
+    
+    it 'can be used with order as parameter' do
+      User.scoped_from(:order => 'firstname').first.should == users(:jane)
+      User.scoped_from(:order => 'firstname.desc').first.should == users(:john)
+    end
+    
+    it 'builds a ScopedFrom::Query' do
+      User.scoped_from({}).query.class.should be(ScopedFrom::Query)
+    end
+    
+    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is not defined' do
+      Post.scoped_from({}).query.class.should be(ScopedFrom::Query)
+      Object.const_defined?('PostQuery').should be_false
+      expect {
+        PostQuery
+      }.to raise_error(NameError, 'uninitialized constant PostQuery')
+    end
+    
+    it 'builds a #{Class}Query if #{RecordClassName}Query is defined and is a ScopedFrom::Query' do
+      Comment.scoped_from({}).query.class.should be(CommentQuery)
+      Comment.where(:foo => 'bar').scoped_from({}).query.class.should be(CommentQuery)
+      CommentQuery.should be_a(Class)
+      CommentQuery.ancestors.should include(ScopedFrom::Query)
+    end
+    
+    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is defined but not a subclass of ScopedFrom::Query' do
+      User.scoped_from({}).query.class.should be(ScopedFrom::Query)
+      Object.const_defined?('UserQuery').should be_true
+      UserQuery.should be_a(Class)
+      UserQuery.ancestors.should_not include(ScopedFrom::Query)
+    end
+    
+    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is defined but is a module' do
+      Vote.scoped_from({}).query.class.should be(ScopedFrom::Query)
+      Object.const_defined?('VoteQuery').should be_true
+      VoteQuery.should be_a(Module)
+    end
+    
+  end
+  
+end

data/spec/scoped_from/query_spec.rb

@@ -0,0 +1,426 @@
+require 'spec_helper'
+
+describe ScopedFrom::Query do
+  
+  def query(scope = User, params = {}, options = {})
+    ScopedFrom::Query.new(scope, params, options)
+  end
+  
+  describe '#initialize' do
+    
+    it 'invokes #scoped method on specified scope' do
+      User.should_receive(:scoped)
+      ScopedFrom::Query.new(User, {})
+    end
+    
+  end
+  
+  describe '#order_column' do
+    
+    it 'is column specified into "order" parameter' do
+      query(User, :order => 'firstname').order_column.should == 'firstname'
+      query(User, :order => 'lastname.desc').order_column.should == 'lastname'
+    end
+    
+    it 'is nil if column does not exist' do
+      query(User, :order => 'foo').order_column.should be_nil
+    end
+    
+    it 'is nil if "order" param is not specified' do
+      query(User, :search => 'foo').order_column.should be_nil
+    end
+    
+  end
+  
+  describe '#order_direction' do
+    
+    it 'is direction specified into "order" parameter' do
+      query(User, :order => 'firstname.asc').order_direction.should == 'asc'
+      query(User, :order => 'firstname.desc').order_direction.should == 'desc'
+    end
+    
+    it 'is "asc" if direction is not specified' do
+      query(User, :order => 'firstname').order_direction.should == 'asc'
+    end
+    
+    it 'is "asc" if direction is invalid' do
+      query(User, :order => 'firstname.foo').order_direction.should == 'asc'
+    end
+    
+    it 'is direction even specified in another case' do
+      query(User, :order => 'firstname.ASc').order_direction.should == 'asc'
+      query(User, :order => 'firstname.DeSC').order_direction.should == 'desc'
+    end
+    
+    it 'is nil if column does not exist' do
+      query(User, :order => 'foo.desc').order_direction.should be_nil
+    end
+    
+    it 'is nil if "order" param is not specified' do
+      query(User, :search => 'foo').order_direction.should be_nil
+    end
+    
+  end
+  
+  describe '#params' do
+    
+    it 'returns params specified at initialization' do
+      query(User, :search => 'foo', 'enabled' => true).params.should == { 'search' => 'foo', 'enabled' => true }
+    end
+    
+    it 'returns an hash with indifferent access' do
+      query(User, 'search' => 'bar').params.should be_a(ActiveSupport::HashWithIndifferentAccess)
+      query(User, 'search' => 'bar').params[:search].should == 'bar'
+      query(User, :search => 'bar').params['search'].should == 'bar'
+    end
+    
+    it 'can be converted to query string' do
+      query(User, :search => ['foo', 'bar'], 'enabled' => '1').params.to_query.should == 'enabled=true&search[]=foo&search[]=bar'
+    end
+    
+  end
+  
+  describe '#params=' do
+    
+    it 'does not fails if nil is given' do
+      query(User, nil).params.should == {}
+    end
+    
+    it 'removes values that are not scopes' do
+      query(User, :foo => 'bar', 'search' => 'foo', :enabled => true).params.should == { 'search' => 'foo', 'enabled' => true }
+    end
+    
+    it 'removes blank values' do
+      query(User, 'enabled' => true, 'search' => " \n").params.should == { 'enabled' => true }
+    end
+    
+    it 'is case sensitive' do
+      query(User, 'Enabled' => true, "SEARCH" => 'bar').params.should be_empty
+    end
+    
+    it 'parse query string' do
+      query(User, 'search=foo%26baz&latest=true').params.should == { 'search' => 'foo&baz', 'latest' => true }
+    end
+    
+    it 'removes blank values from query string' do
+      query(User, 'search=baz&toto=&bar=%20').params.should == { 'search' => 'baz' }
+    end
+    
+    it 'unescapes UTF-8 chars' do
+      query(User, 'search=%C3%A9').params.should == { 'search' => 'é' }
+    end
+    
+    it 'can have multiple values (from hash)' do
+      query(User, :search => ['bar', 'baz']).params.should == { 'search' => ['bar', 'baz'] }
+    end
+    
+    it 'can have multiple values (from query string)' do
+      query(User, 'search=bar&search=baz').params.should == { 'search' => ['bar', 'baz'] }
+    end
+    
+    it 'removes blank values from array' do
+      query(User, :search => [nil, 'bar', "\n ", 'baz']).params.should == { 'search' => ['bar', 'baz'] }
+    end
+    
+    it 'converts value to true (or remove it) if scope takes no argument' do
+      query(User, :latest => 'y').params.should == { 'latest' => true }
+      query(User, :latest => 'no').params.should == {}
+    end
+    
+    it 'converts array value to true (or remove it) if scope takes no argument' do
+      query(User, :latest => ['no', 'yes']).params.should == { 'latest' => true }
+      query(User, :latest => ['no', nil]).params.should == {}
+      query(User, :latest => ['fo']).params.should == {}
+    end
+    
+    it 'flats array' do
+      query(User, :search => [nil, ['bar', '', 'foo', ["\n ", 'baz']]]).params.should == { 'search' => ['bar', 'foo', 'baz'] }
+    end
+    
+    it 'change array with a single value in one value' do
+      query(User, :search => [nil, 'bar', "\n"]).params.should == { 'search' => 'bar' }
+    end
+    
+    it 'does not modify given hash' do
+      hash = { :search => 'foo', :enabled => '1', :bar => 'foo' }
+      query(User, hash)
+      hash.should == { :search => 'foo', :enabled => '1', :bar => 'foo' }
+    end
+    
+    it 'does not modify given array' do
+      items = ['bar', 'foo', nil]
+      query(User, :search => items)
+      items.should == ['bar', 'foo', nil]
+    end
+    
+    it 'accepts :only option' do
+      query(User, { :search => 'bar', :enabled => 'true' }, :only => [:search]).params.should == { 'search' => 'bar' }
+      query(User, { :search => 'bar', :enabled => 'true' }, :only => 'search').params.should == { 'search' => 'bar' }
+    end
+    
+    it 'accepts :except option' do
+      query(User, { :search => 'bar', :enabled => true }, :except => [:search]).params.should == { 'enabled' => true }
+      query(User, { :search => 'bar', :enabled => true }, :except => 'search').params.should == { 'enabled' => true }
+    end
+    
+    it 'accepts a query instance' do
+      query(User, query(User, :search => 'toto')).params.should == { 'search' => 'toto' }
+    end
+    
+    it 'preserve blank values if :include_blank option is true' do
+      query(User, { :search => "\n ", 'enabled' => true }, :include_blank => true).params.should == { 'search' => "\n ", 'enabled' => true }
+    end
+    
+    it 'preserve blank values from array if :include_blank option is true' do
+      query(User, { 'search' => ["\n ", 'toto', 'titi'] }, :include_blank => true).params.should == { 'search' => ["\n ", 'toto', 'titi'] }
+      query(User, { 'search' => [] }, :include_blank => true).params.should == {}
+    end
+    
+    it 'also preserve blank on query string if :include_blank option is true' do
+      query(User, 'search=%20&enabled=true&search=foo', :include_blank => true).params.should == { 'search' => [' ', 'foo'], 'enabled' => true }
+    end
+    
+    it 'removes column values' do
+      query(User, 'firstname' => 'Jane', 'foo' => 'bar').params.should == {}
+    end
+    
+    it 'include column values if :include_columns option is specified' do
+      query(User, { 'firstname' => 'Jane', 'foo' => 'bar' }, :include_columns => true).params.should == { 'firstname' => 'Jane' }
+      query(User, { :firstname => 'Jane', :foo => 'bar' }, :include_columns => true).params.should == { 'firstname' => 'Jane' }
+      query(User, { 'firstname' => ['Jane', 'John'], 'foo' => 'bar' }, :include_columns => true).params.should == { 'firstname' => ['Jane', 'John'] }
+      query(User, { 'firstname' => "\n ", 'foo' => 'bar' }, :include_columns => true).params.should == {}
+      query(User, { 'firstname' => "\n ", 'foo' => 'bar' }, :include_columns => true, :include_blank => true).params.should == { 'firstname' => "\n " }
+    end
+    
+    it 'maps an "order"' do
+      query(User, { 'order' => 'firstname.asc' }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'does not map "order" if column is invalid' do
+      query(User, { 'order' => 'foo.asc' }).params.should == {}
+    end
+    
+    it 'use "asc" order direction by default' do
+      query(User, { 'order' => 'firstname' }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'use "asc" order direction if invalid' do
+      query(User, { 'order' => 'firstname.bar' }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'use "desc" order direction if specified' do
+      query(User, { 'order' => 'firstname.desc' }).params.should == { 'order' => 'firstname.desc' }
+    end
+    
+    it 'order direction is case insensitive' do
+      query(User, { 'order' => 'firstname.Asc' }).params.should == { 'order' => 'firstname.asc' }
+      query(User, { 'order' => 'firstname.DESC' }).params.should == { 'order' => 'firstname.desc' }
+    end
+    
+    it 'order can be specified as symbol' do
+      query(User, { :order => 'firstname.desc' }).params.should == { 'order' => 'firstname.desc' }
+    end
+    
+    it "order is case sensitive" do
+      query(User, { 'Order' => 'firstname.desc' }).params.should == {}
+    end
+    
+    it 'use last "order" if many are specified' do
+      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC'] }).params.should == { 'order' => 'lastname.desc' }
+      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => 'firstname.desc' }
+    end
+    
+    it 'order can be delimited by a space' do
+      query(User, { 'order' => 'firstname ASC' }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'order can be delimited by any white space' do
+      query(User, { 'order' => "firstname\nASC" }).params.should == { 'order' => 'firstname.asc' }
+      query(User, { 'order' => "firstname\t   ASC" }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'order can be delimited by a ":"' do
+      query(User, { 'order' => "firstname:ASC" }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+    it 'order can be delimited by more than one delimiter' do
+      query(User, { 'order' => "firstname :.  ASC" }).params.should == { 'order' => 'firstname.asc' }
+    end
+    
+  end
+  
+  describe '#scope' do
+    
+    it 'does not execute any query' do
+      User.should_not_receive(:connection)
+      query(User, :enabled => true).scope
+    end
+    
+    it 'works with scopes with a lambda without arguments' do
+      users(:jane).update_attribute(:created_at, 10.days.ago)
+      query(User, :latest => true).scope.should == [users(:john)]
+      query(User, :latest => false).scope.should == [users(:john), users(:jane)]
+    end
+    
+    it 'does not modify scope specified at initialization' do
+      scope = User.search('foo')
+      q = query(scope, :enabled => true)
+      expect {
+        expect {
+          q.scope
+        }.to_not change { q.instance_variable_get('@scope') }
+      }.to_not change { scope }
+    end
+    
+    it 'returns scope (#scoped) specified at construction if params are empty' do
+      query.scope.should_not == User
+      query.scope.should == User.scoped
+    end
+    
+    it 'invokes many times scope if an array is given' do
+      query(User, :search => ['John', 'Doe']).scope.should == [users(:john)]
+      query(User, :search => ['John', 'Done']).scope.should == []
+      query(User, :search => ['John', 'Doe']).params.should == { 'search' => ['John', 'Doe'] }
+    end
+    
+    it 'invokes many times scope if given twice (as string & symbol)' do
+      query(User, :search => 'John', 'search' => 'Done').params['search'].size.should be(2)
+      query(User, :search => 'John', 'search' => 'Done').params['search'].should include('John', 'Done')
+      
+      
+      query(User, :search => 'John', 'search' => ['Did', 'Done']).params['search'].size.should be(3)
+      query(User, :search => 'John', 'search' => ['Did', 'Done']).params['search'].should include('John', 'Did', 'Done')
+    end
+    
+    it 'invokes last order if an array is given' do
+      query(User, :order => ['lastname', 'firstname']).scope.should == [users(:jane), users(:john)]
+      query(User, :order => ['lastname', 'firstname.desc']).scope.should == [users(:john), users(:jane)]
+      query(User, :order => ['firstname.desc', 'lastname']).scope.order_values.should == ['lastname ASC']
+    end
+    
+    it 'defines #query method on returned scoped' do
+      query(User).scope.should respond_to(:query)
+    end
+    
+    it 'does not defines #query method on scope if already defined' do
+      class User
+        def self.query
+          42
+        end
+      end
+      begin
+        User.query.should be(42)
+        query(User).scope.query.should be(42)
+      ensure
+        class User
+          class << self
+            remove_method :query
+          end
+        end
+      end
+    end
+    
+    it 'does not define #query method for future scopes' do
+      query(User).scope.query.should be_present
+      User.should_not respond_to(:query)
+      User.scoped.should_not respond_to(:query)
+      User.enabled.should_not respond_to(:query)
+    end
+    
+    it 'defined #query method returns query' do
+      q = query(User)
+      q.scope.query.should be_a(ScopedFrom::Query)
+      q.scope.query.should be(q)
+    end
+    
+  end
+  
+  describe '#scoped' do
+    
+    it 'returns given scope if it has no scope with specified name' do
+      query.send(:scoped, User, :foo, true).should == User
+    end
+    
+    it 'returns given scope if scope takes more than 1 argument' do
+      query.send(:scoped, User, :created_between, true).should == User
+    end
+    
+    it 'invokes scope without arguments if scope takes not argument' do
+      query.send(:scoped, User.scoped, :enabled, true).should == [users(:john)]
+      query.send(:scoped, User.scoped, :enabled, ' 1 ').should == [users(:john)]
+      query.send(:scoped, User.scoped, :enabled, 'off').should == [users(:john)]
+    end
+    
+    it 'invokes scope with value has argument if scope takes one argument' do
+      query.send(:scoped, User.scoped, :search, 'doe').should == [users(:john), users(:jane)]
+      query.send(:scoped, User.scoped, :search, 'john').should == [users(:john)]
+      query.send(:scoped, User.scoped, :search, 'jane').should == [users(:jane)]
+    end
+    
+    it 'scope on column conditions' do
+      query.send(:scoped, User.scoped, :firstname, 'Jane').should == [users(:jane)]
+    end
+    
+    it 'invokes "order"' do
+      query.send(:scoped, User.scoped, :order, 'firstname.asc').should == [users(:jane), users(:john)]
+      query.send(:scoped, User.scoped, :order, 'firstname.desc').should == [users(:john), users(:jane)]
+    end
+    
+  end
+  
+  describe '#true?' do
+    
+    it 'is true if true is given' do
+      query.send(:true?, true).should be_true
+    end
+    
+    it 'is true if "true" is given' do
+      query.send(:true?, 'true').should be_true
+      query.send(:true?, 'True').should be_true
+    end
+    
+    it 'is true if "1" is given' do
+      query.send(:true?, '1').should be_true
+    end
+    
+    it 'is true if "on" is given' do
+      query.send(:true?, 'on').should be_true
+      query.send(:true?, 'ON ').should be_true
+    end
+    
+    it 'is true if "yes" is given' do
+      query.send(:true?, 'yes').should be_true
+      query.send(:true?, ' Yes ').should be_true
+    end
+    
+    it 'is true if "y" is given' do
+      query.send(:true?, 'y').should be_true
+      query.send(:true?, 'Y ').should be_true
+    end
+    
+    it 'is false if false is given' do
+      query.send(:true?, false).should be_false
+    end
+    
+    it 'is false if "false" is given' do
+      query.send(:true?, 'false').should be_false
+      query.send(:true?, 'FsALSE').should be_false
+    end
+    
+    it 'is false if "0" is given' do
+      query.send(:true?, '0').should be_false
+    end
+    
+    it 'is false if "off" is given' do
+      query.send(:true?, "off").should be_false
+      query.send(:true?, "Off").should be_false
+    end
+    
+    it 'is false otherwise' do
+      query.send(:true?, 42).should be_false
+      query.send(:true?, 'bam').should be_false
+    end
+    
+  end
+  
+end

data/spec/scoped_from_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ScopedFrom do
+  
+  describe '.version' do
+    
+    it 'is a string' do
+      ScopedFrom.version.should be_a(String)
+    end
+    
+    it 'is with correct format' do
+      ScopedFrom.version.should match(/^\d+\.\d+(\.\d+)?/)
+    end
+    
+    it 'is freezed' do
+      expect {
+        ScopedFrom.version.gsub!('.', '#')
+      }.to raise_error(TypeError, "can't modify frozen string")
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require File.dirname(__FILE__) + '/../lib/scoped_from'
+
+# Support 
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Mocks
+ActiveSupport::Dependencies.autoload_paths << "#{File.dirname(__FILE__)}/mocks"
+
+RSpec.configure do |config|
+  config.mock_with(:rspec)
+  
+  config.include(UserMacro)
+  
+  config.before(:each) do
+    Comment.delete_all
+    Post.delete_all
+    User.delete_all
+    Vote.delete_all
+    
+    create_user(:john, :firstname => 'John', :lastname => 'Doe', :enabled => true)
+    create_user(:jane, :firstname => 'Jane', :lastname => 'Doe', :enabled => false)
+  end
+end

data/spec/support/bootsrap/database.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => "#{File.dirname(__FILE__)}/../../test.sqlite3", :timeout => 5000)
+
+ActiveRecord::Base.connection.create_table(:comments, :force => true)
+ActiveRecord::Base.connection.create_table(:posts, :force => true)
+ActiveRecord::Base.connection.create_table(:users, :force => true) do |t|
+  t.string :firstname, :null => false
+  t.string :lastname, :null => false
+  t.boolean :enabled, :null => false
+  t.timestamps
+end
+ActiveRecord::Base.connection.create_table(:votes, :force => true)

data/spec/support/macros/user_macro.rb

@@ -0,0 +1,13 @@
+module UserMacro
+  
+  USERS = {}
+  
+  def create_user(label, attributes)
+    USERS[label] = User.create!(attributes)
+  end
+  
+  def users(label)
+    USERS[label]
+  end
+  
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification 
+name: scoped_from
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Alexis Toulotte
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-18 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Provides a simple mapping between Active Record scopes and controller parameters for Ruby On Rails 3
+email: al@alweb.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.mdown
+- Rakefile
+- VERSION
+- init.rb
+- lib/scoped_from.rb
+- lib/scoped_from/active_record.rb
+- lib/scoped_from/query.rb
+- scoped_from.gemspec
+- spec/mocks/comment.rb
+- spec/mocks/comment_query.rb
+- spec/mocks/post.rb
+- spec/mocks/user.rb
+- spec/mocks/user_query.rb
+- spec/mocks/vote.rb
+- spec/mocks/vote_query.rb
+- spec/scoped_from/active_record_spec.rb
+- spec/scoped_from/query_spec.rb
+- spec/scoped_from_spec.rb
+- spec/spec_helper.rb
+- spec/support/bootsrap/database.rb
+- spec/support/macros/user_macro.rb
+has_rdoc: true
+homepage: https://github.com/alexistoulotte/scoped_from
+licenses: []
+
+post_install_message: 
+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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: scoped_from
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: Mapping between scopes and parameters for Rails
+test_files: 
+- spec/mocks/comment.rb
+- spec/mocks/comment_query.rb
+- spec/mocks/post.rb
+- spec/mocks/user.rb
+- spec/mocks/user_query.rb
+- spec/mocks/vote.rb
+- spec/mocks/vote_query.rb
+- spec/scoped_from/active_record_spec.rb
+- spec/scoped_from/query_spec.rb
+- spec/scoped_from_spec.rb
+- spec/spec_helper.rb
+- spec/support/bootsrap/database.rb
+- spec/support/macros/user_macro.rb