activerecord 4.2.0

data/lib/active_record/store.rb

@@ -0,0 +1,205 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveRecord
+  # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
+  # It's like a simple key/value store baked into your record when you don't care about being able to
+  # query that store outside the context of a single record.
+  #
+  # You can then declare accessors to this store that are then accessible just like any other attribute
+  # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
+  # already built around just accessing attributes on the model.
+  #
+  # Make sure that you declare the database column used for the serialized store as a text, so there's
+  # plenty of room.
+  #
+  # You can set custom coder to encode/decode your serialized attributes to/from different formats.
+  # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
+  #
+  # NOTE - If you are using PostgreSQL specific columns like +hstore+ or +json+ there is no need for
+  # the serialization provided by +store+. Simply use +store_accessor+ instead to generate
+  # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
+  # using a symbol.
+  #
+  # Examples:
+  #
+  #   class User < ActiveRecord::Base
+  #     store :settings, accessors: [ :color, :homepage ], coder: JSON
+  #   end
+  #
+  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u.color                          # Accessor stored attribute
+  #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
+  #
+  #   # There is no difference between strings and symbols for accessing custom attributes
+  #   u.settings[:country]  # => 'Denmark'
+  #   u.settings['country'] # => 'Denmark'
+  #
+  #   # Add additional accessors to an existing store through store_accessor
+  #   class SuperUser < User
+  #     store_accessor :settings, :privileges, :servants
+  #   end
+  #
+  # The stored attribute names can be retrieved using +stored_attributes+.
+  #
+  #   User.stored_attributes[:settings] # [:color, :homepage]
+  #
+  # == Overwriting default accessors
+  #
+  # All stored values are automatically available through accessors on the Active Record
+  # object, but sometimes you want to specialize this behavior. This can be done by overwriting
+  # the default accessors (using the same name as the attribute) and calling <tt>super</tt>
+  # to actually change things.
+  #
+  #   class Song < ActiveRecord::Base
+  #     # Uses a stored integer to hold the volume adjustment of the song
+  #     store :settings, accessors: [:volume_adjustment]
+  #
+  #     def volume_adjustment=(decibels)
+  #       super(decibels.to_i)
+  #     end
+  #
+  #     def volume_adjustment
+  #       super.to_i
+  #     end
+  #   end
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :local_stored_attributes
+      end
+    end
+
+    module ClassMethods
+      def store(store_attribute, options = {})
+        serialize store_attribute, IndifferentCoder.new(options[:coder])
+        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+      end
+
+      def store_accessor(store_attribute, *keys)
+        keys = keys.flatten
+
+        _store_accessors_module.module_eval do
+          keys.each do |key|
+            define_method("#{key}=") do |value|
+              write_store_attribute(store_attribute, key, value)
+            end
+
+            define_method(key) do
+              read_store_attribute(store_attribute, key)
+            end
+          end
+        end
+
+        # assign new store attribute and create new hash to ensure that each class in the hierarchy
+        # has its own hash of stored attributes.
+        self.local_stored_attributes ||= {}
+        self.local_stored_attributes[store_attribute] ||= []
+        self.local_stored_attributes[store_attribute] |= keys
+      end
+
+      def _store_accessors_module # :nodoc:
+        @_store_accessors_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def stored_attributes
+        parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
+        if self.local_stored_attributes
+          parent.merge!(self.local_stored_attributes) { |k, a, b| a | b }
+        end
+        parent
+      end
+    end
+
+    protected
+      def read_store_attribute(store_attribute, key)
+        accessor = store_accessor_for(store_attribute)
+        accessor.read(self, store_attribute, key)
+      end
+
+      def write_store_attribute(store_attribute, key, value)
+        accessor = store_accessor_for(store_attribute)
+        accessor.write(self, store_attribute, key, value)
+      end
+
+    private
+      def store_accessor_for(store_attribute)
+        type_for_attribute(store_attribute.to_s).accessor
+      end
+
+      class HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          prepare(object, attribute)
+          object.public_send(attribute)[key]
+        end
+
+        def self.write(object, attribute, key, value)
+          prepare(object, attribute)
+          if value != read(object, attribute, key)
+            object.public_send :"#{attribute}_will_change!"
+            object.public_send(attribute)[key] = value
+          end
+        end
+
+        def self.prepare(object, attribute)
+          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+        end
+      end
+
+      class StringKeyedHashAccessor < HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          super object, attribute, key.to_s
+        end
+
+        def self.write(object, attribute, key, value)
+          super object, attribute, key.to_s, value
+        end
+      end
+
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
+        def self.prepare(object, store_attribute)
+          attribute = object.send(store_attribute)
+          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            attribute = IndifferentCoder.as_indifferent_hash(attribute)
+            object.send :"#{store_attribute}=", attribute
+          end
+          attribute
+        end
+      end
+
+    class IndifferentCoder # :nodoc:
+      def initialize(coder_or_class_name)
+        @coder =
+          if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
+            coder_or_class_name
+          else
+            ActiveRecord::Coders::YAMLColumn.new(coder_or_class_name || Object)
+          end
+      end
+
+      def dump(obj)
+        @coder.dump self.class.as_indifferent_hash(obj)
+      end
+
+      def load(yaml)
+        self.class.as_indifferent_hash(@coder.load(yaml || ''))
+      end
+
+      def self.as_indifferent_hash(obj)
+        case obj
+        when ActiveSupport::HashWithIndifferentAccess
+          obj
+        when Hash
+          obj.with_indifferent_access
+        else
+          ActiveSupport::HashWithIndifferentAccess.new
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tasks/database_tasks.rb

@@ -0,0 +1,296 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class DatabaseAlreadyExists < StandardError; end # :nodoc:
+    class DatabaseNotSupported < StandardError; end # :nodoc:
+
+    # <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 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
+    # want to change the defaults or when you want to use Active Record outside of Rails
+    # (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).
+    #   * +database_configuration+: configuration of your databases (as in +config/database.yml+).
+    #   * +db_dir+: your +db+ directory.
+    #   * +fixtures_path+: a path to fixtures directory.
+    #   * +migrations_paths+: a list of paths to directories with migrations.
+    #   * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
+    #   * +root+: a path to the root of the application.
+    #
+    # Example usage of +DatabaseTasks+ outside Rails could look as such:
+    #
+    #   include ActiveRecord::Tasks
+    #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
+    #   DatabaseTasks.db_dir = 'db'
+    #   # other settings...
+    #
+    #   DatabaseTasks.create_current('production')
+    module DatabaseTasks
+      extend self
+
+      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      attr_accessor :database_configuration
+
+      LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
+
+      def register_task(pattern, task)
+        @tasks ||= {}
+        @tasks[pattern] = task
+      end
+
+      register_task(/mysql/,        ActiveRecord::Tasks::MySQLDatabaseTasks)
+      register_task(/postgresql/,   ActiveRecord::Tasks::PostgreSQLDatabaseTasks)
+      register_task(/sqlite/,       ActiveRecord::Tasks::SQLiteDatabaseTasks)
+
+      def db_dir
+        @db_dir ||= Rails.application.config.paths["db"].first
+      end
+
+      def migrations_paths
+        @migrations_paths ||= Rails.application.paths['db/migrate'].to_a
+      end
+
+      def fixtures_path
+        @fixtures_path ||= if ENV['FIXTURES_PATH']
+                             File.join(root, ENV['FIXTURES_PATH'])
+                           else
+                             File.join(root, 'test', 'fixtures')
+                           end
+      end
+
+      def root
+        @root ||= Rails.root
+      end
+
+      def env
+        @env ||= Rails.env
+      end
+
+      def seed_loader
+        @seed_loader ||= Rails.application
+      end
+
+      def current_config(options = {})
+        options.reverse_merge! :env => env
+        if options.has_key?(:config)
+          @current_config = options[:config]
+        else
+          @current_config ||= ActiveRecord::Base.configurations[options[:env]]
+        end
+      end
+
+      def create(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).create
+      rescue DatabaseAlreadyExists
+        $stderr.puts "#{configuration['database']} already exists"
+      rescue Exception => error
+        $stderr.puts error, *(error.backtrace)
+        $stderr.puts "Couldn't create database for #{configuration.inspect}"
+      end
+
+      def create_all
+        each_local_configuration { |configuration| create configuration }
+      end
+
+      def create_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          create configuration
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      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']}"
+      end
+
+      def drop_all
+        each_local_configuration { |configuration| drop configuration }
+      end
+
+      def drop_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          drop configuration
+        }
+      end
+
+      def migrate
+        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        scope   = ENV['SCOPE']
+        verbose_was, Migration.verbose = Migration.verbose, verbose
+        Migrator.migrate(Migrator.migrations_paths, version) do |migration|
+          scope.blank? || scope == migration.scope
+        end
+      ensure
+        Migration.verbose = verbose_was
+      end
+
+      def charset_current(environment = env)
+        charset ActiveRecord::Base.configurations[environment]
+      end
+
+      def charset(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).charset
+      end
+
+      def collation_current(environment = env)
+        collation ActiveRecord::Base.configurations[environment]
+      end
+
+      def collation(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).collation
+      end
+
+      def purge(configuration)
+        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
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def structure_dump(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_dump(filename)
+      end
+
+      def structure_load(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
+      end
+
+      def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          This method will act on a specific connection in the future.
+          To act on the current connection, use `load_schema_current` instead.
+        MSG
+
+        load_schema_current(format, file)
+      end
+
+      def schema_file(format = ActiveSupport::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
+        end
+      end
+
+      # This method is the successor of +load_schema+. We should rename it
+      # after +load_schema+ went through a deprecation cycle. (Rails > 4.2)
+      def load_schema_for(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        file ||= schema_file(format)
+
+        case format
+        when :ruby
+          check_schema_file(file)
+          ActiveRecord::Base.establish_connection(configuration)
+          load(file)
+        when :sql
+          check_schema_file(file)
+          structure_load(configuration, file)
+        else
+          raise ArgumentError, "unknown format #{format.inspect}"
+        end
+      end
+
+      def load_schema_current_if_exists(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        if File.exist?(file || schema_file(format))
+          load_schema_current(format, file, environment)
+        end
+      end
+
+      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        each_current_configuration(environment) { |configuration|
+          load_schema_for configuration, format, file
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def check_schema_file(filename)
+        unless File.exist?(filename)
+          message = %{#{filename} doesn't exist yet. Run `rake db:migrate` to create it, then try again.}
+          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
+          Kernel.abort message
+        end
+      end
+
+      def load_seed
+        if seed_loader
+          seed_loader.load_seed
+        else
+          raise "You tried to load seed data, but no seed loader is specified. Please specify seed " +
+                "loader with ActiveRecord::Tasks::DatabaseTasks.seed_loader = your_seed_loader\n" +
+                "Seed loader should respond to load_seed method"
+        end
+      end
+
+      private
+
+      def class_for_adapter(adapter)
+        key = @tasks.keys.detect { |pattern| adapter[pattern] }
+        unless key
+          raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
+        end
+        @tasks[key]
+      end
+
+      def each_current_configuration(environment)
+        environments = [environment]
+        # add test environment only if no RAILS_ENV was specified.
+        environments << 'test' if environment == 'development' && ENV['RAILS_ENV'].nil?
+
+        configurations = ActiveRecord::Base.configurations.values_at(*environments)
+        configurations.compact.each do |configuration|
+          yield configuration unless configuration['database'].blank?
+        end
+      end
+
+      def each_local_configuration
+        ActiveRecord::Base.configurations.each_value do |configuration|
+          next unless configuration['database']
+
+          if local_database?(configuration)
+            yield configuration
+          else
+            $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+          end
+        end
+      end
+
+      def local_database?(configuration)
+        configuration['host'].blank? || LOCAL_HOSTS.include?(configuration['host'])
+      end
+    end
+  end
+end