activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/sanitization.rb

@@ -92,7 +92,7 @@ module ActiveRecord
 
         table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
         PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-          connection.visitor.accept b
+          connection.visitor.compile b
         }.join(' AND ')
       end
       alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
@@ -107,6 +107,13 @@ module ActiveRecord
         end.join(', ')
       end
 
+      # Sanitizes a +string+ so that it is safe to use within an SQL
+      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%"
+      def sanitize_sql_like(string, escape_character = "\\")
+        pattern = Regexp.union(escape_character, "%", "_")
+        string.gsub(pattern) { |x| [escape_character, x].join }
+      end
+
       # Accepts an array of conditions. The array has each value
       # sanitized and interpolated into the SQL statement.
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"

data/lib/active_record/schema.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   # = Active Record Schema
   #

data/lib/active_record/schema_dumper.rb

@@ -91,16 +91,17 @@ HEADER
       end
 
       def tables(stream)
-        @connection.tables.sort.each do |tbl|
-          next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
-            case ignored
-            when String; remove_prefix_and_suffix(tbl) == ignored
-            when Regexp; remove_prefix_and_suffix(tbl) =~ ignored
-            else
-              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
-            end
+        sorted_tables = @connection.tables.sort
+
+        sorted_tables.each do |table_name|
+          table(table_name, stream) unless ignored?(table_name)
+        end
+
+        # dump foreign keys at the end to make sure all dependent tables exist.
+        if @connection.supports_foreign_keys?
+          sorted_tables.each do |tbl|
+            foreign_keys(tbl, stream)
           end
-          table(tbl, stream)
         end
       end
 
@@ -213,8 +214,49 @@ HEADER
         end
       end
 
+      def foreign_keys(table, stream)
+        if (foreign_keys = @connection.foreign_keys(table)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            parts = [
+                     'add_foreign_key ' + remove_prefix_and_suffix(foreign_key.from_table).inspect,
+                     remove_prefix_and_suffix(foreign_key.to_table).inspect,
+                    ]
+
+            if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table)
+              parts << ('column: ' + foreign_key.column.inspect)
+            end
+
+            if foreign_key.custom_primary_key?
+              parts << ('primary_key: ' + foreign_key.primary_key.inspect)
+            end
+
+            if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
+              parts << ('name: ' + foreign_key.name.inspect)
+            end
+
+            parts << ('on_update: ' + foreign_key.on_update.inspect) if foreign_key.on_update
+            parts << ('on_delete: ' + foreign_key.on_delete.inspect) if foreign_key.on_delete
+
+            '  ' + parts.join(', ')
+          end
+
+          stream.puts add_foreign_key_statements.sort.join("\n")
+        end
+      end
+
       def remove_prefix_and_suffix(table)
         table.gsub(/^(#{@options[:table_name_prefix]})(.+)(#{@options[:table_name_suffix]})$/,  "\\2")
       end
+
+      def ignored?(table_name)
+        ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String; remove_prefix_and_suffix(table_name) == ignored
+          when Regexp; remove_prefix_and_suffix(table_name) =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+          end
+        end
+      end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -43,6 +43,10 @@ module ActiveRecord
       def normalize_migration_number(number)
         "%.3d" % number.to_i
       end
+
+      def normalized_versions
+        pluck(:version).map { |v| normalize_migration_number v }
+      end
     end
 
     def version

data/lib/active_record/scoping/default.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       end
 
       module ClassMethods
-        # Returns a scope for the model without the +default_scope+.
+        # Returns a scope for the model without the previously set scopes.
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
@@ -19,11 +19,12 @@ module ActiveRecord
         #     end
         #   end
         #
-        #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
-        #   Post.unscoped.all # Fires "SELECT * FROM posts"
+        #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
+        #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
+        #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
         #
         # This method also accepts a block. All queries inside the block will
-        # not use the +default_scope+:
+        # not use the previously set scopes.
         #
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"

data/lib/active_record/serializers/xml_serializer.rb

@@ -180,13 +180,9 @@ module ActiveRecord #:nodoc:
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       def compute_type
         klass = @serializable.class
-        type = if klass.serialized_attributes.key?(name)
-                 super
-               elsif klass.columns_hash.key?(name)
-                 klass.columns_hash[name].type
-               else
-                 NilClass
-               end
+        column = klass.columns_hash[name] || Type::Value.new
+
+        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || column.type
 
         { :text => :string,
           :time => :datetime }[type] || type

data/lib/active_record/statement_cache.rb

@@ -14,13 +14,87 @@ module ActiveRecord
   # The relation returned by the block is cached, and for each +execute+ call the cached relation gets duped.
   # Database is queried when +to_a+ is called on the relation.
   class StatementCache
-    def initialize
-      @relation = yield
-      raise ArgumentError.new("Statement cannot be nil") if @relation.nil?
+    class Substitute; end
+
+    class Query
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def sql_for(binds, connection)
+        @sql
+      end
+    end
+
+    class PartialQuery < Query
+      def initialize values
+        @values = values
+        @indexes = values.each_with_index.find_all { |thing,i|
+          Arel::Nodes::BindParam === thing
+        }.map(&:last)
+      end
+
+      def sql_for(binds, connection)
+        val = @values.dup
+        binds = binds.dup
+        @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+        val.join
+      end
+    end
+
+    def self.query(visitor, ast)
+      Query.new visitor.accept(ast, Arel::Collectors::SQLString.new).value
+    end
+
+    def self.partial_query(visitor, ast, collector)
+      collected = visitor.accept(ast, collector).value
+      PartialQuery.new collected
+    end
+
+    class Params
+      def bind; Substitute.new; end
     end
 
-    def execute
-      @relation.dup.to_a
+    class BindMap
+      def initialize(bind_values)
+        @indexes   = []
+        @bind_values = bind_values
+
+        bind_values.each_with_index do |(_, value), i|
+          if Substitute === value
+            @indexes << i
+          end
+        end
+      end
+
+      def bind(values)
+        bvs = @bind_values.map { |pair| pair.dup }
+        @indexes.each_with_index { |offset,i| bvs[offset][1] = values[i] }
+        bvs
+      end
+    end
+
+    attr_reader :bind_map, :query_builder
+
+    def self.create(connection, block = Proc.new)
+      relation      = block.call Params.new
+      bind_map      = BindMap.new relation.bind_values
+      query_builder = connection.cacheable_query relation.arel
+      new query_builder, bind_map
+    end
+
+    def initialize(query_builder, bind_map)
+      @query_builder = query_builder
+      @bind_map      = bind_map
+    end
+
+    def execute(params, klass, connection)
+      bind_values = bind_map.bind params
+
+      sql = query_builder.sql_for bind_values, connection
+
+      klass.find_by_sql sql, bind_values
     end
+    alias :call :execute
   end
 end

data/lib/active_record/store.rb

@@ -99,7 +99,7 @@ module ActiveRecord
         self.local_stored_attributes[store_attribute] |= keys
       end
 
-      def _store_accessors_module
+      def _store_accessors_module # :nodoc:
         @_store_accessors_module ||= begin
           mod = Module.new
           include mod
@@ -129,10 +129,10 @@ module ActiveRecord
 
     private
       def store_accessor_for(store_attribute)
-        @column_types[store_attribute.to_s].accessor
+        type_for_attribute(store_attribute.to_s).accessor
       end
 
-      class HashAccessor
+      class HashAccessor # :nodoc:
         def self.read(object, attribute, key)
           prepare(object, attribute)
           object.public_send(attribute)[key]
@@ -151,7 +151,7 @@ module ActiveRecord
         end
       end
 
-      class StringKeyedHashAccessor < HashAccessor
+      class StringKeyedHashAccessor < HashAccessor # :nodoc:
         def self.read(object, attribute, key)
           super object, attribute, key.to_s
         end
@@ -161,7 +161,7 @@ module ActiveRecord
         end
       end
 
-      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
         def self.prepare(object, store_attribute)
           attribute = object.send(store_attribute)
           unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)

data/lib/active_record/tasks/database_tasks.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     # <tt>ActiveRecord::Tasks::DatabaseTasks</tt> is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
-    # The tasks defined here are used in rake tasks provided by Active Record.
+    # The tasks defined here are used with Rake tasks provided by Active Record.
     #
     # In order to use DatabaseTasks, a few config values need to be set. All the needed
     # config values are set by Rails already, so it's necessary to do it only if you
@@ -14,7 +14,6 @@ module ActiveRecord
     # (in such case after configuring the database tasks, you can also use the rake tasks
     # defined in Active Record).
     #
-    #
     # The possible config values are:
     #
     #   * +env+: current environment (like Rails.env).
@@ -28,7 +27,7 @@ module ActiveRecord
     # Example usage of +DatabaseTasks+ outside Rails could look as such:
     #
     #   include ActiveRecord::Tasks
-    #   DatabaseTasks.database_configuration = YAML.load(File.read('my_database_config.yml'))
+    #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
     #   DatabaseTasks.db_dir = 'db'
     #   # other settings...
     #
@@ -59,7 +58,11 @@ module ActiveRecord
       end
 
       def fixtures_path
-        @fixtures_path ||= File.join(root, 'test', 'fixtures')
+        @fixtures_path ||= if ENV['FIXTURES_PATH']
+                             File.join(root, ENV['FIXTURES_PATH'])
+                           else
+                             File.join(root, 'test', 'fixtures')
+                           end
       end
 
       def root
@@ -107,6 +110,8 @@ module ActiveRecord
       def drop(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).drop
+      rescue ActiveRecord::NoDatabaseError
+        $stderr.puts "Database '#{configuration['database']}' does not exist"
       rescue Exception => error
         $stderr.puts error, *(error.backtrace)
         $stderr.puts "Couldn't drop #{configuration['database']}"
@@ -122,6 +127,16 @@ module ActiveRecord
         }
       end
 
+      def migrate
+        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        scope   = ENV['SCOPE']
+        Migration.verbose = verbose
+        Migrator.migrate(Migrator.migrations_paths, version) do |migration|
+          scope.blank? || scope == migration.scope
+        end
+      end
+
       def charset_current(environment = env)
         charset ActiveRecord::Base.configurations[environment]
       end
@@ -144,6 +159,18 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(configuration).purge
       end
 
+      def purge_all
+        each_local_configuration { |configuration|
+          purge configuration
+        }
+      end
+
+      def purge_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          purge configuration
+        }
+      end
+
       def structure_dump(*arguments)
         configuration = arguments.first
         filename = arguments.delete_at 1
@@ -157,6 +184,10 @@ module ActiveRecord
       end
 
       def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
+        ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+          This method will act on a specific connection in the future.
+          To act on the current connection, use `load_schema_current` instead.
+        MESSAGE
         load_schema_current(format, file)
       end
 
@@ -167,11 +198,13 @@ module ActiveRecord
         when :ruby
           file ||= File.join(db_dir, "schema.rb")
           check_schema_file(file)
+          purge(configuration)
           ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
           file ||= File.join(db_dir, "structure.sql")
           check_schema_file(file)
+          purge(configuration)
           structure_load(configuration, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
@@ -182,7 +215,6 @@ module ActiveRecord
         each_current_configuration(environment) { |configuration|
           load_schema_for configuration, format, file
         }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -124,26 +124,20 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
       end
 
       def root_password
-        $stdout.print "Please provide the root password for your mysql installation\n>"
+        $stdout.print "Please provide the root password for your MySQL installation\n>"
         $stdin.gets.strip
       end
 
       def prepare_command_options(command)
-        args = {
-          'host'      => '--host',
-          'port'      => '--port',
-          'socket'    => '--socket',
-          'username'  => '--user',
-          'password'  => '--password',
-          'encoding'  => '--default-character-set',
-          'sslca'     => '--ssl-ca',
-          'sslcert'   => '--ssl-cert',
-          'sslcapath' => '--ssl-capath',
-          'sslcipher' => '--ssl-cipher',
-          'sslkey'    => '--ssl-key'
-        }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
-
-        [command, *args]
+        args = [command]
+        args.concat(['--user', configuration['username']]) if configuration['username']
+        args << "--password=#{configuration['password']}"  if configuration['password']
+        args.concat(['--default-character-set', configuration['encoding']]) if configuration['encoding']
+        configuration.slice('host', 'port', 'socket').each do |k, v|
+          args.concat([ "--#{k}", v.to_s ]) if v
+        end
+
+        args
       end
     end
   end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -51,10 +51,10 @@ module ActiveRecord
           search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
         end
 
-        command = "pg_dump -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
+        command = "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
         raise 'Error dumping database' unless Kernel.system(command)
 
-        File.open(filename, "a") { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+        File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename)