activerecord 2.3.18 → 3.2.22

data/lib/active_record/dirty.rb

@@ -1,183 +0,0 @@
-module ActiveRecord
-  # Track unsaved attribute changes.
-  #
-  # A newly instantiated object is unchanged:
-  #   person = Person.find_by_name('uncle bob')
-  #   person.changed?       # => false
-  #
-  # Change the name:
-  #   person.name = 'Bob'
-  #   person.changed?       # => true
-  #   person.name_changed?  # => true
-  #   person.name_was       # => 'uncle bob'
-  #   person.name_change    # => ['uncle bob', 'Bob']
-  #   person.name = 'Bill'
-  #   person.name_change    # => ['uncle bob', 'Bill']
-  #
-  # Save the changes:
-  #   person.save
-  #   person.changed?       # => false
-  #   person.name_changed?  # => false
-  #
-  # Assigning the same value leaves the attribute unchanged:
-  #   person.name = 'Bill'
-  #   person.name_changed?  # => false
-  #   person.name_change    # => nil
-  #
-  # Which attributes have changed?
-  #   person.name = 'bob'
-  #   person.changed        # => ['name']
-  #   person.changes        # => { 'name' => ['Bill', 'bob'] }
-  #
-  # Before modifying an attribute in-place:
-  #   person.name_will_change!
-  #   person.name << 'by'
-  #   person.name_change    # => ['uncle bob', 'uncle bobby']
-  module Dirty
-    DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
-
-    def self.included(base)
-      base.attribute_method_suffix *DIRTY_SUFFIXES
-      base.alias_method_chain :write_attribute, :dirty
-      base.alias_method_chain :save,            :dirty
-      base.alias_method_chain :save!,           :dirty
-      base.alias_method_chain :update,          :dirty
-      base.alias_method_chain :reload,          :dirty
-
-      base.class_attribute :partial_updates
-      base.partial_updates = true
-
-      base.send(:extend, ClassMethods)
-    end
-
-    # Do any attributes have unsaved changes?
-    #   person.changed? # => false
-    #   person.name = 'bob'
-    #   person.changed? # => true
-    def changed?
-      !changed_attributes.empty?
-    end
-
-    # List of attributes with unsaved changes.
-    #   person.changed # => []
-    #   person.name = 'bob'
-    #   person.changed # => ['name']
-    def changed
-      changed_attributes.keys
-    end
-
-    # Map of changed attrs => [original value, new value].
-    #   person.changes # => {}
-    #   person.name = 'bob'
-    #   person.changes # => { 'name' => ['bill', 'bob'] }
-    def changes
-      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
-    end
-
-    # Attempts to +save+ the record and clears changed attributes if successful.
-    def save_with_dirty(*args) #:nodoc:
-      if status = save_without_dirty(*args)
-        changed_attributes.clear
-      end
-      status
-    end
-
-    # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-    def save_with_dirty!(*args) #:nodoc:
-      status = save_without_dirty!(*args)
-      changed_attributes.clear
-      status
-    end
-
-    # <tt>reload</tt> the record and clears changed attributes.
-    def reload_with_dirty(*args) #:nodoc:
-      record = reload_without_dirty(*args)
-      changed_attributes.clear
-      record
-    end
-
-    private
-      # Map of change <tt>attr => original value</tt>.
-      def changed_attributes
-        @changed_attributes ||= {}
-      end
-
-      # Handle <tt>*_changed?</tt> for +method_missing+.
-      def attribute_changed?(attr)
-        changed_attributes.include?(attr)
-      end
-
-      # Handle <tt>*_change</tt> for +method_missing+.
-      def attribute_change(attr)
-        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
-      end
-
-      # Handle <tt>*_was</tt> for +method_missing+.
-      def attribute_was(attr)
-        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-      end
-
-      # Handle <tt>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        changed_attributes[attr] = clone_attribute_value(:read_attribute, attr)
-      end
-
-      # Wrap write_attribute to remember original attribute value.
-      def write_attribute_with_dirty(attr, value)
-        attr = attr.to_s
-
-        # The attribute already has an unsaved change.
-        if changed_attributes.include?(attr)
-          old = changed_attributes[attr]
-          changed_attributes.delete(attr) unless field_changed?(attr, old, value)
-        else
-          old = clone_attribute_value(:read_attribute, attr)
-          changed_attributes[attr] = old if field_changed?(attr, old, value)
-        end
-
-        # Carry on.
-        write_attribute_without_dirty(attr, value)
-      end
-
-      def update_with_dirty
-        if partial_updates?
-          # Serialized attributes should always be written in case they've been
-          # changed in place.
-          update_without_dirty(changed | (attributes.keys & self.class.serialized_attributes.keys))
-        else
-          update_without_dirty
-        end
-      end
-
-      def field_changed?(attr, old, value)
-        if column = column_for_attribute(attr)
-          if column.number? && column.null && (old.nil? || old == 0) && value.blank?
-            # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
-            # Hence we don't record it as a change if the value changes from nil to ''.
-            # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-            # be typecast back to 0 (''.to_i => 0)
-            value = nil
-          else
-            value = column.type_cast(value)
-          end
-        end
-
-        old != value
-      end
-
-    module ClassMethods
-      def self.extended(base)
-        base.singleton_class.alias_method_chain(:alias_attribute, :dirty)
-      end
-
-      def alias_attribute_with_dirty(new_name, old_name)
-        alias_attribute_without_dirty(new_name, old_name)
-        DIRTY_SUFFIXES.each do |suffix|
-          module_eval <<-STR, __FILE__, __LINE__ + 1
-            def #{new_name}#{suffix}; self.#{old_name}#{suffix}; end  # def subject_changed?; self.title_changed?; end
-          STR
-        end
-      end
-    end
-  end
-end

data/lib/active_record/named_scope.rb

@@ -1,197 +0,0 @@
-module ActiveRecord
-  module NamedScope
-    # All subclasses of ActiveRecord::Base have one named scope:
-    # * <tt>scoped</tt> - which allows for the creation of anonymous \scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
-    #
-    # These anonymous \scopes tend to be useful when procedurally generating complex queries, where passing
-    # intermediate values (scopes) around as first-class objects is convenient.
-    #
-    # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
-      end
-
-      def scoped(scope, &block)
-        Scope.new(self, scope, &block)
-      end
-
-      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
-      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'}
-      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
-      #   end
-      # 
-      # The above calls to <tt>named_scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red, 
-      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
-      #
-      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it resembles the association object
-      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
-      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
-      # as with the association objects, named \scopes act like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
-      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really was an Array.
-      #
-      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
-      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-      #
-      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which the \scopes were defined. But they are also available to
-      # <tt>has_many</tt> associations. If,
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :shirts
-      #   end
-      #
-      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
-      # only shirts.
-      #
-      # Named \scopes can also be procedural:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
-      #
-      # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'} do
-      #       def dom_id
-      #         'red_shirts'
-      #       end
-      #     end
-      #   end
-      #
-      #
-      # For testing complex named \scopes, you can examine the scoping options using the
-      # <tt>proxy_options</tt> method on the proxy itself.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      #   expected_options = { :conditions => { :colored => 'red' } }
-      #   assert_equal expected_options, Shirt.colored('red').proxy_options
-      def named_scope(name, options = {}, &block)
-        name = name.to_sym
-
-        scopes[name] = lambda do |parent_scope, *args|
-          Scope.new(parent_scope, case options
-            when Hash
-              options
-            when Proc
-              if self.model_name != parent_scope.model_name
-                options.bind(parent_scope).call(*args)
-              else
-                options.call(*args)
-              end
-          end, &block)
-        end
-
-        singleton_class.send :define_method, name do |*args|
-          scopes[name].call(self, *args)
-        end
-      end
-    end
-
-    class Scope
-      attr_reader :proxy_scope, :proxy_options, :current_scoped_methods_when_defined
-      NON_DELEGATE_METHODS = %w(nil? send object_id class extend find size count sum average maximum minimum paginate first last empty? any? respond_to?).to_set
-      [].methods.each do |m|
-        unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s)
-          delegate m, :to => :proxy_found
-        end
-      end
-
-      delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope
-
-      def initialize(proxy_scope, options, &block)
-        options ||= {}
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
-        unless (Scope === proxy_scope || ActiveRecord::Associations::AssociationCollection === proxy_scope)
-          @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
-        end
-        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
-      end
-
-      def reload
-        load_found; self
-      end
-
-      def first(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.first(*args)
-        else
-          find(:first, *args)
-        end
-      end
-
-      def last(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.last(*args)
-        else
-          find(:last, *args)
-        end
-      end
-
-      def size
-        @found ? @found.length : count
-      end
-
-      def empty?
-        @found ? @found.empty? : count.zero?
-      end
-
-      def respond_to?(method, include_private = false)
-        super || @proxy_scope.respond_to?(method, include_private)
-      end
-
-      def any?
-        if block_given?
-          proxy_found.any? { |*block_args| yield(*block_args) }
-        else
-          !empty?
-        end
-      end
-
-      protected
-      def proxy_found
-        @found || load_found
-      end
-
-      private
-      def method_missing(method, *args, &block)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ?  proxy_options[:conditions] : {}}, :reverse_merge) do
-            method = :new if method == :build
-            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined)
-              with_scope current_scoped_methods_when_defined do
-                proxy_scope.send(method, *args, &block)
-              end
-            else
-              proxy_scope.send(method, *args, &block)
-            end
-          end
-        end
-      end
-
-      def load_found
-        @found = find(:all)
-      end
-    end
-  end
-end

data/lib/active_record/serializers/json_serializer.rb

@@ -1,91 +0,0 @@
-require 'active_support/json'
-require 'active_support/core_ext/module/model_naming'
-
-module ActiveRecord #:nodoc:
-  module Serialization
-    def self.included(base)
-      base.cattr_accessor :include_root_in_json, :instance_writer => false
-    end
-
-    # Returns a JSON string representing the model. Some configuration is
-    # available through +options+.
-    #
-    # The option <tt>ActiveRecord::Base.include_root_in_json</tt> controls the
-    # top-level behavior of to_json. In a new Rails application, it is set to 
-    # <tt>true</tt> in initializers/new_rails_defaults.rb. When it is <tt>true</tt>,
-    # to_json will emit a single root node named after the object's type. For example:
-    #
-    #   konata = User.find(1)
-    #   ActiveRecord::Base.include_root_in_json = true
-    #   konata.to_json
-    #   # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
-    #                   "created_at": "2006/08/01", "awesome": true} }
-    #
-    #   ActiveRecord::Base.include_root_in_json = false
-    #   konata.to_json
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true}
-    #
-    # The remainder of the examples in this section assume include_root_in_json is set to
-    # <tt>false</tt>.
-    #
-    # Without any +options+, the returned JSON string will include all
-    # the model's attributes. For example:
-    #
-    #   konata = User.find(1)
-    #   konata.to_json
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true}
-    #
-    # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
-    # included, and work similar to the +attributes+ method. For example:
-    #
-    #   konata.to_json(:only => [ :id, :name ])
-    #   # => {"id": 1, "name": "Konata Izumi"}
-    #
-    #   konata.to_json(:except => [ :id, :created_at, :age ])
-    #   # => {"name": "Konata Izumi", "awesome": true}
-    #
-    # To include any methods on the model, use <tt>:methods</tt>.
-    #
-    #   konata.to_json(:methods => :permalink)
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "permalink": "1-konata-izumi"}
-    #
-    # To include associations, use <tt>:include</tt>.
-    #
-    #   konata.to_json(:include => :posts)
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
-    #                   {"id": 2, author_id: 1, "title": "So I was thinking"}]}
-    #
-    # 2nd level and higher order associations work as well:
-    #
-    #   konata.to_json(:include => { :posts => {
-    #                                  :include => { :comments => {
-    #                                                :only => :body } },
-    #                                  :only => :title } })
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
-    #                    "title": "Welcome to the weblog"},
-    #                   {"comments": [{"body": "Don't think too hard"}],
-    #                    "title": "So I was thinking"}]}
-    def to_json(options = {})
-      super
-    end
-
-    def as_json(options = nil) #:nodoc:
-      hash = Serializer.new(self, options).serializable_record
-      hash = { options[:root] || self.class.model_name.element => hash } if include_root_in_json
-      hash
-    end
-
-    def from_json(json)
-      self.attributes = ActiveSupport::JSON.decode(json)
-      self
-    end
-  end
-end

data/lib/activerecord.rb

@@ -1,2 +0,0 @@
-require 'active_record'
-ActiveSupport::Deprecation.warn 'require "activerecord" is deprecated and will be removed in Rails 3. Use require "active_record" instead.'

data/test/assets/example.log

@@ -1 +0,0 @@
-# Logfile created on Wed Oct 31 16:05:13 +0000 2007 by logger.rb/1.5.2.9

data/test/cases/aaa_create_tables_test.rb

@@ -1,24 +0,0 @@
-# The filename begins with "aaa" to ensure this is the first test.
-require "cases/helper"
-
-class AAACreateTablesTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  def test_load_schema
-    eval(File.read(SCHEMA_ROOT + "/schema.rb"))
-    if File.exists?(adapter_specific_schema_file)
-      eval(File.read(adapter_specific_schema_file))
-    end
-    assert true
-  end
-
-  def test_drop_and_create_courses_table
-    eval(File.read(SCHEMA_ROOT + "/schema2.rb"))
-    assert true
-  end
-
-  private
-  def adapter_specific_schema_file
-    SCHEMA_ROOT + '/' + ActiveRecord::Base.connection.adapter_name.downcase + '_specific_schema.rb'
-  end
-end

data/test/cases/active_schema_test_mysql.rb

@@ -1,122 +0,0 @@
-require "cases/helper"
-
-class ActiveSchemaTest < ActiveRecord::TestCase
-  def setup
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-      alias_method :execute_without_stub, :execute
-      def execute(sql, name = nil) return sql end
-    end
-  end
-
-  def teardown
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-      remove_method :execute
-      alias_method :execute, :execute_without_stub
-    end
-  end
-
-  def test_add_index
-    # add_index calls index_exists? which can't work since execute is stubbed
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:define_method, :index_exists?) do |*|
-      false
-    end
-    expected = "CREATE  INDEX `index_people_on_last_name` ON `people` (`last_name`)"
-    assert_equal expected, add_index(:people, :last_name, :length => nil)
-
-    expected = "CREATE  INDEX `index_people_on_last_name` ON `people` (`last_name`(10))"
-    assert_equal expected, add_index(:people, :last_name, :length => 10)
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(15))"
-    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => 15)
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`)"
-    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => {:last_name => 15})
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(10))"
-    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => {:last_name => 15, :first_name => 10})
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:remove_method, :index_exists?)
-  end
-
-  def test_drop_table
-    assert_equal "DROP TABLE `people`", drop_table(:people)
-  end
-
-  if current_adapter?(:MysqlAdapter)
-    def test_create_mysql_database_with_encoding
-      assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
-      assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
-      assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
-    end
-
-    def test_recreate_mysql_database_with_encoding
-      create_database(:luca, {:charset => 'latin1'})
-      assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => 'latin1'})
-    end
-  end
-
-  def test_add_column
-    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
-  end
-
-  def test_add_column_with_limit
-    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
-  end
-
-  def test_drop_table_with_specific_database
-    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
-  end
-
-  def test_add_timestamps 
-    with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me do |t|
-        end
-        ActiveRecord::Base.connection.add_timestamps :delete_me
-        assert column_present?('delete_me', 'updated_at', 'datetime')
-        assert column_present?('delete_me', 'created_at', 'datetime')
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
-      end
-    end
-  end
-  
-  def test_remove_timestamps 
-    with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me do |t|
-          t.timestamps
-        end
-        ActiveRecord::Base.connection.remove_timestamps :delete_me
-        assert !column_present?('delete_me', 'updated_at', 'datetime')
-        assert !column_present?('delete_me', 'created_at', 'datetime')
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
-      end
-    end
-  end
-
-  private
-    def with_real_execute
-      #we need to actually modify some data, so we make execute point to the original method
-      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-        alias_method :execute_with_stub, :execute
-        alias_method :execute, :execute_without_stub
-      end
-      yield
-    ensure
-      #before finishing, we restore the alias to the mock-up method
-      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-        alias_method :execute, :execute_with_stub
-      end
-    end
-
-
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
-    end
-
-    def column_present?(table_name, column_name, type)
-      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
-      results.first && results.first['Type'] == type
-    end
-end

data/test/cases/active_schema_test_postgresql.rb

@@ -1,24 +0,0 @@
-require 'cases/helper'
-
-class PostgresqlActiveSchemaTest < Test::Unit::TestCase
-  def setup
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
-      alias_method :real_execute, :execute
-      def execute(sql, name = nil) sql end
-    end
-  end
-
-  def teardown
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:alias_method, :execute, :real_execute)
-  end
-
-  def test_create_database_with_encoding
-    assert_equal %(CREATE DATABASE "matt" ENCODING = 'utf8'), create_database(:matt)
-    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, :encoding => :latin1)
-  end
-
-  private
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
-    end
-end