scoped_from 0.6.0 → 0.6.1

data/Gemfile

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

data/Gemfile.lock

@@ -1,53 +1,53 @@
 PATH
   remote: .
   specs:
-    scoped_from (0.6.0)
+    scoped_from (0.6.1)
       activerecord (~> 3.2.0)
       activesupport (~> 3.2.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    actionpack (3.2.1)
-      activemodel (= 3.2.1)
-      activesupport (= 3.2.1)
+    actionpack (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
       builder (~> 3.0.0)
       erubis (~> 2.7.0)
       journey (~> 1.0.1)
       rack (~> 1.4.0)
-      rack-cache (~> 1.1)
+      rack-cache (~> 1.2)
       rack-test (~> 0.6.1)
       sprockets (~> 2.1.2)
-    activemodel (3.2.1)
-      activesupport (= 3.2.1)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
       builder (~> 3.0.0)
-    activerecord (3.2.1)
-      activemodel (= 3.2.1)
-      activesupport (= 3.2.1)
-      arel (~> 3.0.0)
+    activerecord (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.2.1)
+    activesupport (3.2.3)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    arel (3.0.0)
+    arel (3.0.2)
     builder (3.0.0)
     diff-lcs (1.1.3)
     erubis (2.7.0)
     hike (1.2.1)
     i18n (0.6.0)
-    journey (1.0.1)
-    json (1.6.5)
-    multi_json (1.0.4)
+    journey (1.0.3)
+    json (1.7.1)
+    multi_json (1.3.4)
     rack (1.4.1)
-    rack-cache (1.1)
+    rack-cache (1.2)
       rack (>= 0.4)
     rack-ssl (1.3.2)
       rack
     rack-test (0.6.1)
       rack (>= 1.0)
-    railties (3.2.1)
-      actionpack (= 3.2.1)
-      activesupport (= 3.2.1)
+    railties (3.2.3)
+      actionpack (= 3.2.3)
+      activesupport (= 3.2.3)
       rack-ssl (~> 1.3.2)
       rake (>= 0.8.7)
       rdoc (~> 3.4)
@@ -55,35 +55,35 @@ GEM
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
-    rspec-rails (2.8.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.0)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    rspec-rails (2.10.1)
       actionpack (>= 3.0)
       activesupport (>= 3.0)
       railties (>= 3.0)
-      rspec (~> 2.8.0)
-    sprockets (2.1.2)
+      rspec (~> 2.10.0)
+    sprockets (2.1.3)
       hike (~> 1.2)
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
-    sqlite3 (1.3.5)
+    sqlite3 (1.3.6)
     sqlite3-ruby (1.3.3)
       sqlite3 (>= 1.3.3)
     thor (0.14.6)
     tilt (1.3.3)
-    tzinfo (0.3.31)
+    tzinfo (0.3.33)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  rspec (~> 2.8.0)
-  rspec-rails (~> 2.8.0)
+  rspec (~> 2.10.0)
+  rspec-rails (~> 2.10.0)
   scoped_from!
   sqlite3-ruby

data/README.mdown

@@ -5,20 +5,12 @@ Provides a simple mapping between scopes and controller parameters for
 
 ## Installation
 
-### As a gem
-
 Just add this into your `Gemfile`:
 
     gem 'scoped_from'
 
 Then, just run `bundle install`.
 
-### As a plugin
-
-From your application path, execute:
-
-    rails plugin install git://github.com/alexistoulotte/scoped_from.git
-
 ## Example
 
 First, a model with some scopes:
@@ -146,4 +138,4 @@ Then into a view:
 ## Executing test suite
 
 This project is fully tested with [Rspec 2](http://github.com/rspec/rspec).
-Just run `rake` (after a `bundle install`).
+Just run `bundle exec rake` (after a `bundle install`).

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/lib/scoped_from/active_record.rb

@@ -1,37 +1,37 @@
 module ScopedFrom
 
   module ActiveRecord
-    
+
     extend ActiveSupport::Concern
-    
+
     included do |base|
       base.class_attribute(:scope_arities)
       base.scope_arities = ActiveSupport::HashWithIndifferentAccess.new
     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 = "#{name}Query".safe_constantize
         query_class = Query unless query_class.is_a?(Class) && query_class.ancestors.include?(Query)
         query_class.new(self, params, options).scope
       end
-      
+
     end
-    
+
   end
-  
+
 end

data/lib/scoped_from/query.rb

@@ -1,13 +1,13 @@
 module ScopedFrom
-  
+
   class Query
 
     FALSE_VALUES = %w( false no n off 0 ).freeze
     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.
     def initialize(scope, params, options = {})
@@ -15,15 +15,15 @@ module ScopedFrom
       @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|
@@ -33,9 +33,9 @@ module ScopedFrom
       end
       decorate_scope(scope)
     end
-    
+
     protected
-    
+
     def decorate_scope(scope)
       return scope if scope.respond_to?(:query)
       def scope.query
@@ -44,16 +44,16 @@ module ScopedFrom
       scope.instance_variable_set('@__query', self)
       scope
     end
-    
+
     def false?(value)
       FALSE_VALUES.include?(value.to_s.strip.downcase)
     end
-    
+
     def order_to_sql(value)
       order = parse_order(value)
       "#{order[:column]} #{order[:direction].upcase}" if order.present?
     end
-    
+
     def params=(params)
       params = params.params if params.is_a?(self.class)
       params = CGI.parse(params.to_s) unless params.is_a?(Hash)
@@ -82,14 +82,14 @@ module ScopedFrom
       @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 parse_orders(values)
       [].tap do |orders|
         values.each do |value|
@@ -98,7 +98,7 @@ module ScopedFrom
         end
       end
     end
-    
+
     def scoped(scope, name, value)
       if name.to_s == 'order'
         scope.order(order_to_sql(value))
@@ -112,11 +112,11 @@ module ScopedFrom
         scope
       end
     end
-    
+
     def true?(value)
       TRUE_VALUES.include?(value.to_s.strip.downcase)
     end
-    
+
   end
-  
+
 end

data/lib/scoped_from.rb

@@ -6,15 +6,15 @@ require 'active_support/concern'
 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')

data/scoped_from.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'activerecord', '~> 3.2.0'
   s.add_dependency 'activesupport', '~> 3.2.0'
 
-  s.add_development_dependency 'rspec', '~> 2.8.0'
-  s.add_development_dependency 'rspec-rails', '~> 2.8.0'
+  s.add_development_dependency 'rspec', '~> 2.10.0'
+  s.add_development_dependency 'rspec-rails', '~> 2.10.0'
   s.add_development_dependency 'sqlite3-ruby'
 end

data/spec/mocks/user.rb

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

data/spec/scoped_from/active_record_spec.rb

@@ -8,86 +8,86 @@ describe ScopedFrom::ActiveRecord 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
@@ -95,27 +95,27 @@ describe ScopedFrom::ActiveRecord do
         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

@@ -1,188 +1,188 @@
-# encoding: UTF-8
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe ScopedFrom::Query do
-  
+
   def query(scope = User, params = {}, options = {})
     ScopedFrom::Query.new(scope, params, options)
   end
-  
+
   describe '#false?' do
-    
+
     it 'is true if false is given' do
       query.send(:false?, false).should be_true
     end
-    
+
     it 'is true if "false" is given' do
       query.send(:false?, 'false').should be_true
       query.send(:false?, 'False').should be_true
     end
-    
+
     it 'is true if "0" is given' do
       query.send(:false?, '0').should be_true
     end
-    
+
     it 'is true if "off" is given' do
       query.send(:false?, 'off').should be_true
       query.send(:false?, 'OFF ').should be_true
     end
-    
+
     it 'is true if "no" is given' do
       query.send(:false?, 'no').should be_true
       query.send(:false?, ' No ').should be_true
     end
-    
+
     it 'is true if "n" is given' do
       query.send(:false?, 'n').should be_true
       query.send(:false?, 'N ').should be_true
     end
-    
+
     it 'is false if true is given' do
       query.send(:false?, true).should be_false
     end
-    
+
     it 'is false if "true" is given' do
       query.send(:false?, 'true').should be_false
       query.send(:false?, 'TrUe').should be_false
     end
-    
+
     it 'is false if "1" is given' do
       query.send(:false?, '1').should be_false
     end
-    
+
     it 'is false if "on" is given' do
       query.send(:false?, "on").should be_false
       query.send(:false?, "On").should be_false
     end
-    
+
     it 'is false otherwise' do
       query.send(:false?, 42).should be_false
       query.send(:false?, 'bam').should be_false
     end
-    
+
   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%5B%5D=foo&search%5B%5D=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 '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 '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 value to true (or false) if column is a boolean one' do
       query(User, :admin => 'y').params.should == { 'admin' => true }
       query(User, :admin => 'False').params.should == { 'admin' => false }
       query(User, :admin => 'bar').params.should == {}
       query(User, :admin => ['y', false]).params.should == {}
     end
-    
+
     it 'converts array value to true (or remove it) if scope takes no argument' do
       query(User, :latest => true).params.should == { 'latest' => true }
       query(User, :latest => ['Yes']).params.should == { 'latest' => true }
@@ -190,144 +190,144 @@ describe ScopedFrom::Query do
       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' => [nil, 'bar', '', 'foo', "\n ", 'baz'] }
     end
-    
+
     it 'change array with a single value in one value' do
       query(User, :search => ['bar']).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' }
       query(User, { :search => 'bar', :firstname => 'Jane', :enabled => 'true' }, :only => 'search').params.should == { 'search' => 'bar' }
       query(User, { :search => 'bar', :firstname => 'Jane', :enabled => 'true' }, :only => ['search', :firstname]).params.should == { 'search' => 'bar', 'firstname' => 'Jane' }
     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 }
       query(User, { :search => 'bar', :firstname => 'Jane', :enabled => true }, :except => 'search').params.should == { 'enabled' => true, 'firstname' => 'Jane' }
       query(User, { :search => 'bar', :firstname => 'Jane', :enabled => true }, :except => ['search', :firstname]).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' do
       query(User, { :search => "\n ", 'enabled' => true }).params.should == { 'search' => "\n ", 'enabled' => true }
     end
-    
+
     it 'preserve blank values from array' do
       query(User, { 'search' => ["\n ", 'toto', 'titi'] }).params.should == { 'search' => ["\n ", 'toto', 'titi'] }
       query(User, { 'search' => [] }).params.should == {}
     end
-    
+
     it 'also preserve blank on query string' do
       query(User, 'search=%20&enabled=true&search=foo').params.should == { 'search' => [' ', 'foo'], 'enabled' => true }
     end
-    
+
     it 'includes column values' do
       query(User, 'firstname' => 'Jane', 'foo' => 'bar').params.should == { 'firstname' => 'Jane' }
       query(User, :firstname => 'Jane', 'foo' => 'bar').params.should == { 'firstname' => 'Jane' }
     end
-    
+
     it 'exclude column values if :exclude_columns option is specified' do
       query(User, { :enabled => true, 'firstname' => 'Jane', 'foo' => 'bar' }, :exclude_columns => true).params.should == { 'enabled' => true }
       query(User, { :enabled => true, :firstname => 'Jane', :foo => 'bar' }, :exclude_columns => true).params.should == { 'enabled' => true }
     end
-    
+
     it 'scopes have priority on columns' do
       query(User, :enabled => false).params.should == {}
     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 'many order can be specified' do
       query(User, { 'order' => ['firstname.Asc', 'lastname.DESC'] }).params.should == { 'order' => ['firstname.asc', 'lastname.desc'] }
       query(User, { 'order' => ['firstname.Asc', 'firstname.desc'] }).params.should == { 'order' => 'firstname.asc' }
       query(User, { 'order' => ['firstname.Asc', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.asc', 'lastname.desc'] }
       query(User, { 'order' => ['firstname.Asc', 'foo', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.asc', 'lastname.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)
@@ -337,138 +337,138 @@ describe ScopedFrom::Query do
         }.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 == ['firstname DESC', 'lastname ASC']
     end
-    
+
     it 'defines #query method on returned scoped' do
       query(User).scope.should respond_to(:query)
     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 no arguments' 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

@@ -1,23 +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(/can't modify frozen string/i)
     end
-    
+
   end
-  
+
 end

data/spec/spec_helper.rb

@@ -2,23 +2,21 @@ ENV["RAILS_ENV"] ||= 'test'
 
 require File.dirname(__FILE__) + '/../lib/scoped_from'
 
-# Support 
+# 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, :admin => true)
     create_user(:jane, :firstname => 'Jane', :lastname => 'Doe', :enabled => false, :admin => false)
   end

data/spec/support/macros/user_macro.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_from
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-07 00:00:00.000000000 Z
+date: 2012-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70097913921820 !ruby/object:Gem::Requirement
+  requirement: &70282866988720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70097913921820
+  version_requirements: *70282866988720
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70097913920840 !ruby/object:Gem::Requirement
+  requirement: &70282866987480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,32 +32,32 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70097913920840
+  version_requirements: *70282866987480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70097913920000 !ruby/object:Gem::Requirement
+  requirement: &70282866986780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.10.0
   type: :development
   prerelease: false
-  version_requirements: *70097913920000
+  version_requirements: *70282866986780
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &70097913919120 !ruby/object:Gem::Requirement
+  requirement: &70282867000940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.10.0
   type: :development
   prerelease: false
-  version_requirements: *70097913919120
+  version_requirements: *70282867000940
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &70097913918540 !ruby/object:Gem::Requirement
+  requirement: &70282867000520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70097913918540
+  version_requirements: *70282867000520
 description: Provides a simple mapping between Active Record scopes and controller
   parameters for Ruby On Rails 3
 email: al@alweb.org
@@ -81,7 +81,6 @@ files:
 - README.mdown
 - Rakefile
 - VERSION
-- init.rb
 - lib/scoped_from.rb
 - lib/scoped_from/active_record.rb
 - lib/scoped_from/query.rb
@@ -113,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1127072327386759365
+      hash: 1157272612327936896
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,10 +121,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1127072327386759365
+      hash: 1157272612327936896
 requirements: []
 rubyforge_project: scoped_from
-rubygems_version: 1.8.15
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Mapping between scopes and parameters for Rails

data/init.rb

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