activerecord 4.2.0

data/lib/active_record/schema_dumper.rb

@@ -0,0 +1,251 @@
+require 'stringio'
+require 'active_support/core_ext/big_decimal'
+
+module ActiveRecord
+  # = Active Record Schema Dumper
+  #
+  # This class is used to dump the database schema for some connection to some
+  # output format (i.e., ActiveRecord::Schema).
+  class SchemaDumper #:nodoc:
+    private_class_method :new
+
+    ##
+    # :singleton-method:
+    # A list of tables which should not be dumped to the schema.
+    # Acceptable values are strings as well as regexp.
+    # This setting is only used if ActiveRecord::Base.schema_format == :ruby
+    cattr_accessor :ignore_tables
+    @@ignore_tables = []
+
+    class << self
+      def dump(connection=ActiveRecord::Base.connection, stream=STDOUT, config = ActiveRecord::Base)
+        new(connection, generate_options(config)).dump(stream)
+        stream
+      end
+
+      private
+        def generate_options(config)
+          {
+            table_name_prefix: config.table_name_prefix,
+            table_name_suffix: config.table_name_suffix
+          }
+        end
+    end
+
+    def dump(stream)
+      header(stream)
+      extensions(stream)
+      tables(stream)
+      trailer(stream)
+      stream
+    end
+
+    private
+
+      def initialize(connection, options = {})
+        @connection = connection
+        @types = @connection.native_database_types
+        @version = Migrator::current_version rescue nil
+        @options = options
+      end
+
+      def header(stream)
+        define_params = @version ? "version: #{@version}" : ""
+
+        if stream.respond_to?(:external_encoding) && stream.external_encoding
+          stream.puts "# encoding: #{stream.external_encoding.name}"
+        end
+
+        stream.puts <<HEADER
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(#{define_params}) do
+
+HEADER
+      end
+
+      def trailer(stream)
+        stream.puts "end"
+      end
+
+      def extensions(stream)
+        return unless @connection.supports_extensions?
+        extensions = @connection.extensions
+        if extensions.any?
+          stream.puts "  # These are extensions that must be enabled in order to support this database"
+          extensions.each do |extension|
+            stream.puts "  enable_extension #{extension.inspect}"
+          end
+          stream.puts
+        end
+      end
+
+      def tables(stream)
+        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) unless ignored?(tbl)
+          end
+        end
+      end
+
+      def table(table, stream)
+        columns = @connection.columns(table)
+        begin
+          tbl = StringIO.new
+
+          # first dump primary key column
+          pk = @connection.primary_key(table)
+
+          tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+          pkcol = columns.detect { |c| c.name == pk }
+          if pkcol
+            if pk != 'id'
+              tbl.print %Q(, primary_key: "#{pk}")
+            elsif pkcol.sql_type == 'bigint'
+              tbl.print ", id: :bigserial"
+            elsif pkcol.sql_type == 'uuid'
+              tbl.print ", id: :uuid"
+              tbl.print %Q(, default: "#{pkcol.default_function}") if pkcol.default_function
+            end
+          else
+            tbl.print ", id: false"
+          end
+          tbl.print ", force: :cascade"
+          tbl.puts " do |t|"
+
+          # then dump all non-primary key columns
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+            next if column.name == pk
+            @connection.column_spec(column, @types)
+          end.compact
+
+          # find all migration keys used in this table
+          keys = @connection.migration_keys
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map { |key|
+            column_specs.map { |spec|
+              spec[key] ? spec[key].length + 2 : 0
+            }.max
+          }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+
+        stream
+      end
+
+      def indexes(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          add_index_statements = indexes.map do |index|
+            statement_parts = [
+              "add_index #{remove_prefix_and_suffix(index.table).inspect}",
+              index.columns.inspect,
+              "name: #{index.name.inspect}",
+            ]
+            statement_parts << 'unique: true' if index.unique
+
+            index_lengths = (index.lengths || []).compact
+            statement_parts << "length: #{Hash[index.columns.zip(index.lengths)].inspect}" if index_lengths.any?
+
+            index_orders = index.orders || {}
+            statement_parts << "order: #{index.orders.inspect}" if index_orders.any?
+            statement_parts << "where: #{index.where.inspect}" if index.where
+            statement_parts << "using: #{index.using.inspect}" if index.using
+            statement_parts << "type: #{index.type.inspect}" if index.type
+
+            "  #{statement_parts.join(', ')}"
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
+        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|
+          ignored === remove_prefix_and_suffix(table_name)
+        end
+      end
+  end
+end

data/lib/active_record/schema_migration.rb

@@ -0,0 +1,56 @@
+require 'active_record/scoping/default'
+require 'active_record/scoping/named'
+require 'active_record/base'
+
+module ActiveRecord
+  class SchemaMigration < ActiveRecord::Base
+    class << self
+      def primary_key
+        nil
+      end
+
+      def table_name
+        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      end
+
+      def index_name
+        "#{table_name_prefix}unique_#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      end
+
+      def table_exists?
+        connection.table_exists?(table_name)
+      end
+
+      def create_table(limit=nil)
+        unless table_exists?
+          version_options = {null: false}
+          version_options[:limit] = limit if limit
+
+          connection.create_table(table_name, id: false) do |t|
+            t.column :version, :string, version_options
+          end
+          connection.add_index table_name, :version, unique: true, name: index_name
+        end
+      end
+
+      def drop_table
+        if table_exists?
+          connection.remove_index table_name, name: index_name
+          connection.drop_table(table_name)
+        end
+      end
+
+      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
+      super.to_i
+    end
+  end
+end

data/lib/active_record/scoping.rb

@@ -0,0 +1,87 @@
+require 'active_support/per_thread_registry'
+
+module ActiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      end
+    end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att,value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+    def initialize_internals_callback
+      super
+      populate_with_current_scope_attributes
+    end
+
+    # This class stores the +:current_scope+ and +:ignore_default_scope+ values
+    # for different classes. The registry is stored as a thread local, which is
+    # accessed through +ScopeRegistry.current+.
+    #
+    # This class allows you to store and get the scope values on different
+    # classes and different types of scopes. For example, if you are attempting
+    # to get the current_scope for the +Board+ model, then you would use the
+    # following code:
+    #
+    #   registry = ActiveRecord::Scoping::ScopeRegistry
+    #   registry.set_value_for(:current_scope, "Board", some_new_scope)
+    #
+    # Now when you run:
+    #
+    #   registry.value_for(:current_scope, "Board")
+    #
+    # You will obtain whatever was defined in +some_new_scope+. The +value_for+
+    # and +set_value_for+ methods are delegated to the current +ScopeRegistry+
+    # object, so the above example code can also be called as:
+    #
+    #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
+    #       "Board", some_new_scope)
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        if !VALID_SCOPE_TYPES.include?(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/scoping/default.rb

@@ -0,0 +1,134 @@
+module ActiveRecord
+  module Scoping
+    module Default
+      extend ActiveSupport::Concern
+
+      included do
+        # Stores the default scope for the class.
+        class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+
+        self.default_scopes = []
+      end
+
+      module ClassMethods
+        # Returns a scope for the model without the previously set scopes.
+        #
+        #   class Post < ActiveRecord::Base
+        #     def self.default_scope
+        #       where published: true
+        #     end
+        #   end
+        #
+        #   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 previously set scopes.
+        #
+        #   Post.unscoped {
+        #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+        #   }
+        def unscoped
+          block_given? ? relation.scoping { yield } : relation
+        end
+
+        def before_remove_const #:nodoc:
+          self.current_scope = nil
+        end
+
+        protected
+
+        # Use this macro in your model to set a default scope for all operations on
+        # the model.
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_scope { where(published: true) }
+        #   end
+        #
+        #   Article.all # => SELECT * FROM articles WHERE published = true
+        #
+        # The +default_scope+ is also applied while creating/building a record.
+        # It is not applied while updating a record.
+        #
+        #   Article.new.published    # => true
+        #   Article.create.published # => true
+        #
+        # (You can also pass any object which responds to +call+ to the
+        # +default_scope+ macro, and it will be called when building the
+        # default scope.)
+        #
+        # If you use multiple +default_scope+ declarations in your model then
+        # they will be merged together:
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_scope { where(published: true) }
+        #     default_scope { where(rating: 'G') }
+        #   end
+        #
+        #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+        #
+        # This is also the case with inheritance and module includes where the
+        # parent or module defines a +default_scope+ and the child or including
+        # class defines a second one.
+        #
+        # If you need to do more complex things with a default scope, you can
+        # alternatively define it as a class method:
+        #
+        #   class Article < ActiveRecord::Base
+        #     def self.default_scope
+        #       # Should return a scope, you can call 'super' here etc.
+        #     end
+        #   end
+        def default_scope(scope = nil)
+          scope = Proc.new if block_given?
+
+          if scope.is_a?(Relation) || !scope.respond_to?(:call)
+            raise ArgumentError,
+              "Support for calling #default_scope without a block is removed. For example instead " \
+              "of `default_scope where(color: 'red')`, please use " \
+              "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+              "self.default_scope.)"
+          end
+
+          self.default_scopes += [scope]
+        end
+
+        def build_default_scope(base_rel = relation) # :nodoc:
+          if !Base.is_a?(method(:default_scope).owner)
+            # The user has defined their own default scope method, so call that
+            evaluate_default_scope { default_scope }
+          elsif default_scopes.any?
+            evaluate_default_scope do
+              default_scopes.inject(base_rel) do |default_scope, scope|
+                default_scope.merge(base_rel.scoping { scope.call })
+              end
+            end
+          end
+        end
+
+        def ignore_default_scope? # :nodoc:
+          ScopeRegistry.value_for(:ignore_default_scope, self)
+        end
+
+        def ignore_default_scope=(ignore) # :nodoc:
+          ScopeRegistry.set_value_for(:ignore_default_scope, self, ignore)
+        end
+
+        # The ignore_default_scope flag is used to prevent an infinite recursion
+        # situation where a default scope references a scope which has a default
+        # scope which references a scope...
+        def evaluate_default_scope # :nodoc:
+          return if ignore_default_scope?
+
+          begin
+            self.ignore_default_scope = true
+            yield
+          ensure
+            self.ignore_default_scope = false
+          end
+        end
+      end
+    end
+  end
+end