Merge branch 'master' into fuuu

* master:
  Do not show optional (.:format) block for wildcard route [#6605 state:resolved]
  pushing id insertion and prefetch primary keys down to Relation#insert
  use prepared statements to fetch the last insert id
  escaping binary data encoding when inserting to sqlite3. Thanks Naruse! [#6559 state:resolved]
  schemas set by set_table_name are respected by the mysql adapter. [#5322 state:resolved]
  Reapply extensions when using except and only
  SJIS is an alias to Windows-31J in ruby trunk. Use SHIFT_JIS for this test
  Improved resolver docs a bit
  [action_view] docs for FileSystemResolver
  [action_view] added custom patterns to template resolver

20 files changed, 256 insertions, 45 deletions

diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index cc6b8aa82d..1dba1d416c 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -107,7 +107,7 @@ module ActionDispatch
             if @options[:format] == false
               @options.delete(:format)
               path
-            elsif path.include?(":format") || path.end_with?('/')
+            elsif path.include?(":format") || path.end_with?('/') || path.match(/^\/?\*/)
               path
             else
               "#{path}(.:format)"
diff --git a/actionpack/lib/action_view/template/resolver.rb b/actionpack/lib/action_view/template/resolver.rb
index 589b2a1a76..6c1063592f 100644
--- a/actionpack/lib/action_view/template/resolver.rb
+++ b/actionpack/lib/action_view/template/resolver.rb
@@ -5,6 +5,25 @@ require "action_view/template"
 module ActionView
   # = Action View Resolver
   class Resolver
+    # Keeps all information about view path and builds virtual path.
+    class Path < String
+      attr_reader :name, :prefix, :partial, :virtual
+      alias_method :partial?, :partial
+
+      def initialize(name, prefix, partial)
+        @name, @prefix, @partial = name, prefix, partial
+        rebuild(@name, @prefix, @partial)
+      end
+
+      def rebuild(name, prefix, partial)
+        @virtual = ""
+        @virtual << "#{prefix}/" unless prefix.empty?
+        @virtual << (partial ? "_#{name}" : name)
+
+        self.replace(@virtual)
+      end
+    end
+
     cattr_accessor :caching
     self.caching = true
 
@@ -41,10 +60,7 @@ module ActionView
 
     # Helpers that builds a path. Useful for building virtual paths.
     def build_path(name, prefix, partial)
-      path = ""
-      path << "#{prefix}/" unless prefix.empty?
-      path << (partial ? "_#{name}" : name)
-      path
+      Path.new(name, prefix, partial)
     end
 
     # Handles templates caching. If a key is given and caching is on
@@ -97,25 +113,24 @@ module ActionView
   end
 
   class PathResolver < Resolver
-    EXTENSION_ORDER = [:locale, :formats, :handlers]
+    EXTENSIONS = [:locale, :formats, :handlers]
+    DEFAULT_PATTERN = ":prefix/:action{.:locale,}{.:formats,}{.:handlers,}"
+
+    def initialize(pattern=nil)
+      @pattern = pattern || DEFAULT_PATTERN
+      super()
+    end
 
     private
 
     def find_templates(name, prefix, partial, details)
       path = build_path(name, prefix, partial)
-      query(path, EXTENSION_ORDER.map { |ext| details[ext] }, details[:formats])
+      extensions = Hash[EXTENSIONS.map { |ext| [ext, details[ext]] }.flatten(0)]
+      query(path, extensions, details[:formats])
     end
 
     def query(path, exts, formats)
-      query = File.join(@path, path)
-
-      query << exts.map { |ext|
-        "{#{ext.compact.map { |e| ".#{e}" }.join(',')},}"
-      }.join
-
-      query.gsub!(/\{\.html,/, "{.html,.text.html,")
-      query.gsub!(/\{\.text,/, "{.text,.text.plain,")
-
+      query = build_query(path, exts)
       templates = []
       sanitizer = Hash.new { |h,k| h[k] = Dir["#{File.dirname(k)}/*"] }
 
@@ -126,12 +141,28 @@ module ActionView
         contents = File.open(p, "rb") {|io| io.read }
 
         templates << Template.new(contents, File.expand_path(p), handler,
-          :virtual_path => path, :format => format, :updated_at => mtime(p))
+          :virtual_path => path.virtual, :format => format, :updated_at => mtime(p))
       end
 
       templates
     end
 
+    # Helper for building query glob string based on resolver's pattern. 
+    def build_query(path, exts)
+      query = @pattern.dup
+      query.gsub!(/\:prefix(\/)?/, path.prefix.empty? ? "" : "#{path.prefix}\\1") # prefix can be empty...
+      query.gsub!(/\:action/, path.partial? ? "_#{path.name}" : path.name)
+
+      exts.each { |ext, variants|
+        query.gsub!(/\:#{ext}/, "{#{variants.compact.uniq.join(',')}}")
+      }
+
+      query.gsub!(/\.{html,/, ".{html,text.html,")
+      query.gsub!(/\.{text,/, ".{text,text.plain,")
+
+      File.expand_path(query, @path)
+    end
+
     # Returns the file mtime from the filesystem.
     def mtime(p)
       File.stat(p).mtime
@@ -149,11 +180,47 @@ module ActionView
     end
   end
 
-  # A resolver that loads files from the filesystem.
+  # A resolver that loads files from the filesystem. It allows to set your own
+  # resolving pattern. Such pattern can be a glob string supported by some variables.
+  #
+  # ==== Examples
+  #
+  # Default pattern, loads views the same way as previous versions of rails, eg. when you're
+  # looking for `users/new` it will produce query glob: `users/new{.{en},}{.{html,js},}{.{erb,haml,rjs},}`
+  #
+  #   FileSystemResolver.new("/path/to/views", ":prefix/:action{.:locale,}{.:formats,}{.:handlers,}")
+  #
+  # This one allows you to keep files with different formats in seperated subdirectories,
+  # eg. `users/new.html` will be loaded from `users/html/new.erb` or `users/new.html.erb`,
+  # `users/new.js` from `users/js/new.erb` or `users/new.js.erb`, etc.
+  #
+  #   FileSystemResolver.new("/path/to/views", ":prefix/{:formats/,}:action{.:locale,}{.:formats,}{.:handlers,}")
+  #
+  # If you don't specify pattern then the default will be used.
+  #
+  # In order to use any of the customized resolvers above in a Rails application, you just need
+  # to configure ActionController::Base.view_paths in an initializer, for example:
+  #
+  #   ActionController::Base.view_paths = FileSystemResolver.new(
+  #     Rails.root.join("app/views"),
+  #     ":prefix{/:locale}/:action{.:formats,}{.:handlers,}"
+  #   )
+  #
+  # ==== Pattern format and variables
+  #
+  # Pattern have to be a valid glob string, and it allows you to use the
+  # following variables:
+  #
+  # * <tt>:prefix</tt> - usualy the controller path
+  # * <tt>:action</tt> - name of the action
+  # * <tt>:locale</tt> - possible locale versions
+  # * <tt>:formats</tt> - possible request formats (for example html, json, xml...)
+  # * <tt>:handlers</tt> - possible handlers (for example erb, haml, builder...)
+  #
   class FileSystemResolver < PathResolver
-    def initialize(path)
+    def initialize(path, pattern=nil)
       raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
-      super()
+      super(pattern)
       @path = File.expand_path(path)
     end
 
diff --git a/actionpack/lib/action_view/testing/resolvers.rb b/actionpack/lib/action_view/testing/resolvers.rb
index 5c5cab7c7d..773dfcbb1d 100644
--- a/actionpack/lib/action_view/testing/resolvers.rb
+++ b/actionpack/lib/action_view/testing/resolvers.rb
@@ -8,8 +8,8 @@ module ActionView #:nodoc:
   class FixtureResolver < PathResolver
     attr_reader :hash
 
-    def initialize(hash = {})
-      super()
+    def initialize(hash = {}, pattern=nil)
+      super(pattern)
       @hash = hash
     end
 
@@ -21,8 +21,8 @@ module ActionView #:nodoc:
 
     def query(path, exts, formats)
       query = ""
-      exts.each do |ext|
-        query << '(' << ext.map {|e| e && Regexp.escape(".#{e}") }.join('|') << '|)'
+      EXTENSIONS.each do |ext|
+        query << '(' << exts[ext].map {|e| e && Regexp.escape(".#{e}") }.join('|') << '|)'
       end
       query = /^(#{Regexp.escape(path)})#{query}$/
 
@@ -32,9 +32,9 @@ module ActionView #:nodoc:
         next unless _path =~ query
         handler, format = extract_handler_and_format(_path, formats)
         templates << Template.new(source, _path, handler,
-          :virtual_path => $1, :format => format, :updated_at => updated_at)
+          :virtual_path => path.virtual, :format => format, :updated_at => updated_at)
       end
-
+      
       templates.sort_by {|t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
     end
   end
diff --git a/actionpack/test/action_dispatch/routing/mapper_test.rb b/actionpack/test/action_dispatch/routing/mapper_test.rb
index 9966234f1b..e21b271907 100644
--- a/actionpack/test/action_dispatch/routing/mapper_test.rb
+++ b/actionpack/test/action_dispatch/routing/mapper_test.rb
@@ -46,6 +46,13 @@ module ActionDispatch
         mapper.match '/one/two/', :to => 'posts#index', :as => :main
         assert_equal '/one/two(.:format)', fakeset.conditions.first[:path_info]
       end
+
+      def test_map_wildcard
+        fakeset = FakeSet.new
+        mapper = Mapper.new fakeset
+        mapper.match '/*path', :to => 'pages#show', :as => :page
+        assert_equal '/*path', fakeset.conditions.first[:path_info]
+      end
     end
   end
 end
diff --git a/actionpack/test/fixtures/custom_pattern/another.html.erb b/actionpack/test/fixtures/custom_pattern/another.html.erb
new file mode 100644
index 0000000000..6d7f3bafbb
--- /dev/null
+++ b/actionpack/test/fixtures/custom_pattern/another.html.erb
@@ -0,0 +1 @@
+Hello custom patterns!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/custom_pattern/html/another.erb b/actionpack/test/fixtures/custom_pattern/html/another.erb
new file mode 100644
index 0000000000..dbd7e96ab6
--- /dev/null
+++ b/actionpack/test/fixtures/custom_pattern/html/another.erb
@@ -0,0 +1 @@
+Another template!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/custom_pattern/html/path.erb b/actionpack/test/fixtures/custom_pattern/html/path.erb
new file mode 100644
index 0000000000..6d7f3bafbb
--- /dev/null
+++ b/actionpack/test/fixtures/custom_pattern/html/path.erb
@@ -0,0 +1 @@
+Hello custom patterns!
\ No newline at end of file
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 034fb6c210..dd86bfed04 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -381,7 +381,7 @@ class LazyViewRenderTest < ActiveSupport::TestCase
     end
 
     def test_render_utf8_template_with_incompatible_external_encoding
-      with_external_encoding Encoding::SJIS do
+      with_external_encoding Encoding::SHIFT_JIS do
         begin
           result = @view.render(:file => "test/utf8.html.erb", :layouts => "layouts/yield")
           flunk 'Should have raised incompatible encoding error'
@@ -392,7 +392,7 @@ class LazyViewRenderTest < ActiveSupport::TestCase
     end
 
     def test_render_utf8_template_with_partial_with_incompatible_encoding
-      with_external_encoding Encoding::SJIS do
+      with_external_encoding Encoding::SHIFT_JIS do
         begin
           result = @view.render(:file => "test/utf8_magic_with_bare_partial.html.erb", :layouts => "layouts/yield")
           flunk 'Should have raised incompatible encoding error'
diff --git a/actionpack/test/template/resolver_patterns_test.rb b/actionpack/test/template/resolver_patterns_test.rb
new file mode 100644
index 0000000000..97b1bad055
--- /dev/null
+++ b/actionpack/test/template/resolver_patterns_test.rb
@@ -0,0 +1,31 @@
+require 'abstract_unit'
+
+class ResolverPatternsTest < ActiveSupport::TestCase
+  def setup
+    path = File.expand_path("../../fixtures/", __FILE__)
+    pattern = ":prefix/{:formats/,}:action{.:formats,}{.:handlers,}"
+    @resolver = ActionView::FileSystemResolver.new(path, pattern)
+  end
+
+  def test_should_return_empty_list_for_unknown_path
+    templates = @resolver.find_all("unknown", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
+    assert_equal [], templates, "expected an empty list of templates"
+  end
+
+  def test_should_return_template_for_declared_path
+    templates = @resolver.find_all("path", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
+    assert_equal 1, templates.size, "expected one template"
+    assert_equal "Hello custom patterns!", templates.first.source
+    assert_equal "custom_pattern/path",    templates.first.virtual_path
+    assert_equal [:html],                  templates.first.formats
+  end
+
+  def test_should_return_all_templates_when_ambigous_pattern
+    templates = @resolver.find_all("another", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
+    assert_equal 2, templates.size, "expected two templates"
+    assert_equal "Another template!",      templates[0].source
+    assert_equal "custom_pattern/another", templates[0].virtual_path
+    assert_equal "Hello custom patterns!", templates[1].source
+    assert_equal "custom_pattern/another", templates[1].virtual_path
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 5c1ce173c8..756c221fad 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -272,6 +272,10 @@ module ActiveRecord
         execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
       end
 
+      def null_insert_value
+        Arel.sql 'DEFAULT'
+      end
+
       def empty_insert_statement_value
         "VALUES(DEFAULT)"
       end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 368c5b2023..e1186209d3 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -504,14 +504,28 @@ module ActiveRecord
         show_variable 'collation_database'
       end
 
-      def tables(name = nil) #:nodoc:
+      def tables(name = nil, database = nil) #:nodoc:
         tables = []
-        result = execute("SHOW TABLES", name)
+        result = execute(["SHOW TABLES", database].compact.join(' IN '), name)
         result.each { |field| tables << field[0] }
         result.free
         tables
       end
 
+      def table_exists?(name)
+        return true if super
+
+        name          = name.to_s
+        schema, table = name.split('.', 2)
+
+        unless table # A table was provided without a schema
+          table  = schema
+          schema = nil
+        end
+
+        tables(nil, schema).include? table
+      end
+
       def drop_table(table_name, options = {})
         super(table_name, options)
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 576450bc3a..5a830a50fb 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -453,7 +453,7 @@ module ActiveRecord
           # If a pk is given, fallback to default sequence name.
           # Don't fetch last insert id for a table without a pk.
           if pk && sequence_name ||= default_sequence_name(table, pk)
-            last_insert_id(table, sequence_name)
+            last_insert_id(sequence_name)
           end
         end
       end
@@ -1038,8 +1038,9 @@ module ActiveRecord
         end
 
         # Returns the current ID of a table's sequence.
-        def last_insert_id(table, sequence_name) #:nodoc:
-          Integer(select_value("SELECT currval('#{sequence_name}')"))
+        def last_insert_id(sequence_name) #:nodoc:
+          r = exec_query("SELECT currval($1)", 'SQL', [[nil, sequence_name]])
+          Integer(r.rows.first.first)
         end
 
         # Executes a SELECT query and returns the results, performing any data type
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index c2cd9e8d5e..c3a7b039ff 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -34,6 +34,14 @@ module ActiveRecord
 
   module ConnectionAdapters #:nodoc:
     class SQLite3Adapter < SQLiteAdapter # :nodoc:
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+          s = column.class.string_to_binary(value).unpack("H*")[0]
+          "x'#{s}'"
+        else
+          super
+        end
+      end
 
       # Returns the current database encoding format as a string, eg: 'UTF-8'
       def encoding
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
index 9ee6b88ab6..ae61d6ce94 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
@@ -336,6 +336,10 @@ module ActiveRecord
         alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
       end
 
+      def null_insert_value
+        Arel.sql 'NULL'
+      end
+
       def empty_insert_statement_value
         "VALUES(NULL)"
       end
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index df7b22080c..17a64b6e86 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -270,17 +270,9 @@ module ActiveRecord
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def create
-      if id.nil? && connection.prefetch_primary_key?(self.class.table_name)
-        self.id = connection.next_sequence_value(self.class.sequence_name)
-      end
-
       attributes_values = arel_attributes_values(!id.nil?)
 
-      new_id = if attributes_values.empty?
-        self.class.unscoped.insert connection.empty_insert_statement_value
-      else
-        self.class.unscoped.insert attributes_values
-      end
+      new_id = self.class.unscoped.insert attributes_values
 
       self.id ||= new_id
 
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 371403f510..8e545f9cad 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -30,15 +30,26 @@ module ActiveRecord
     end
 
     def insert(values)
-      im = arel.compile_insert values
-      im.into @table
-
       primary_key_value = nil
 
       if primary_key && Hash === values
         primary_key_value = values[values.keys.find { |k|
           k.name == primary_key
         }]
+
+        if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
+          primary_key_value = connection.next_sequence_value(klass.sequence_name)
+          values[klass.arel_table[klass.primary_key]] = primary_key_value
+        end
+      end
+
+      im = arel.create_insert
+      im.into @table
+
+      if values.empty? # empty insert
+        im.values = im.create_values [connection.null_insert_value], []
+      else
+        im.insert values
       end
 
       @klass.connection.insert(
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 4150e36a9a..128e0fbd86 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -79,6 +79,9 @@ module ActiveRecord
         result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
       result
     end
 
@@ -100,6 +103,9 @@ module ActiveRecord
         result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
       result
     end
 
diff --git a/activerecord/test/cases/adapters/mysql/schema_test.rb b/activerecord/test/cases/adapters/mysql/schema_test.rb
new file mode 100644
index 0000000000..c6c1d1dad5
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/schema_test.rb
@@ -0,0 +1,36 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlSchemaTest < ActiveRecord::TestCase
+      fixtures :posts
+
+      def setup
+        @connection = ActiveRecord::Base.connection
+        db          = Post.connection_pool.spec.config[:database]
+        table       = Post.table_name
+        @db_name    = db
+
+        @omgpost = Class.new(Post) do
+          set_table_name "#{db}.#{table}"
+          def self.name; 'Post'; end
+        end
+      end
+
+      def test_schema
+        assert @omgpost.find(:first)
+      end
+
+      def test_table_exists?
+        name = @omgpost.table_name
+        assert @connection.table_exists?(name), "#{name} table should exist"
+      end
+
+      def test_table_exists_wrong_schema
+        assert(!@connection.table_exists?("#{@db_name}.zomg"), "table should not exist")
+      end
+    end if current_adapter?(:MysqlAdapter)
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb b/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
index ce0b2f5f5b..d1fc470907 100644
--- a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
@@ -1,8 +1,13 @@
+# encoding: utf-8
 require "cases/helper"
+require 'models/binary'
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLiteAdapterTest < ActiveRecord::TestCase
+      class DualEncoding < ActiveRecord::Base
+      end
+
       def setup
         @ctx = Base.sqlite3_connection :database => ':memory:',
                                       :adapter => 'sqlite3',
@@ -15,6 +20,20 @@ module ActiveRecord
         eosql
       end
 
+      def test_quote_binary_column_escapes_it
+        DualEncoding.connection.execute(<<-eosql)
+          CREATE TABLE dual_encodings (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            name string,
+            data binary
+          )
+        eosql
+        str = "\x80".force_encoding("ASCII-8BIT")
+        binary = DualEncoding.new :name => 'いただきます！', :data => str
+        binary.save!
+        assert_equal str, binary.data
+      end
+
       def test_execute
         @ctx.execute "INSERT INTO items (number) VALUES (10)"
         records = @ctx.execute "SELECT * FROM items"
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 94916f61c5..4c5c871251 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -797,6 +797,10 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.all, all_posts.all
   end
 
+  def test_extensions_with_except
+    assert_equal 2, Topic.named_extension.order(:author_name).except(:order).two
+  end
+
   def test_only
     relation = Post.where(:author_id => 1).order('id ASC').limit(1)
     assert_equal [posts(:welcome)], relation.all
@@ -808,6 +812,10 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.limit(1).all.first, all_posts.first
   end
 
+  def test_extensions_with_only
+    assert_equal 2, Topic.named_extension.order(:author_name).only(:order).two
+  end
+
   def test_anonymous_extension
     relation = Post.where(:author_id => 1).order('id ASC').extending do
       def author