activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/serializers/xml_serializer.rb

@@ -1,193 +0,0 @@
-require 'active_support/core_ext/hash/conversions'
-
-module ActiveRecord #:nodoc:
-  module Serialization
-    include ActiveModel::Serializers::Xml
-
-    # Builds an XML document to represent the model. Some configuration is
-    # available through +options+. However more complicated cases should
-    # override ActiveRecord::Base#to_xml.
-    #
-    # By default the generated XML document will include the processing
-    # instruction and all the object's attributes. For example:
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <id type="integer">1</id>
-    #     <approved type="boolean">false</approved>
-    #     <replies-count type="integer">0</replies-count>
-    #     <bonus-time type="dateTime">2000-01-01T08:28:00+12:00</bonus-time>
-    #     <written-on type="dateTime">2003-07-16T09:28:00+1200</written-on>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
-    # <tt>:skip_instruct</tt>, <tt>:skip_types</tt>, <tt>:dasherize</tt> and <tt>:camelize</tt> .
-    # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
-    # +attributes+ method. The default is to dasherize all column names, but you
-    # can disable this setting <tt>:dasherize</tt> to +false+. Setting <tt>:camelize</tt>
-    # to +true+ will camelize all column names - this also overrides <tt>:dasherize</tt>.
-    # To not have the column type included in the XML output set <tt>:skip_types</tt> to +true+.
-    #
-    # For instance:
-    #
-    #   topic.to_xml(skip_instruct: true, except: [ :id, :bonus_time, :written_on, :replies_count ])
-    #
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <approved type="boolean">false</approved>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # To include first level associations use <tt>:include</tt>:
-    #
-    #   firm.to_xml include: [ :account, :clients ]
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # Additionally, the record being serialized will be passed to a Proc's second
-    # parameter. This allows for ad hoc additions to the resultant document that
-    # incorporate the context of the record being serialized. And by leveraging the
-    # closure created by a Proc, to_xml can be used to add elements that normally fall
-    # outside of the scope of the model -- for example, generating and appending URLs
-    # associated with models.
-    #
-    #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
-    #   firm.to_xml procs: [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <name-reverse>slangis73</name-reverse>
-    #   </firm>
-    #
-    # To include deeper levels of associations pass a hash like this:
-    #
-    #   firm.to_xml include: {account: {}, clients: {include: :address}}
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include any methods on the model being called use <tt>:methods</tt>:
-    #
-    #   firm.to_xml methods: [ :calculated_earnings, :real_earnings ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <calculated-earnings>100000000000000000</calculated-earnings>
-    #     <real-earnings>5</real-earnings>
-    #   </firm>
-    #
-    # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
-    # modified version of the options hash that was given to +to_xml+:
-    #
-    #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
-    #   firm.to_xml procs: [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <abc>def</abc>
-    #   </firm>
-    #
-    # Alternatively, you can yield the builder object as part of the +to_xml+ call:
-    #
-    #   firm.to_xml do |xml|
-    #     xml.creator do
-    #       xml.first_name "David"
-    #       xml.last_name "Heinemeier Hansson"
-    #     end
-    #   end
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <creator>
-    #       <first_name>David</first_name>
-    #       <last_name>Heinemeier Hansson</last_name>
-    #     </creator>
-    #   </firm>
-    #
-    # As noted above, you may override +to_xml+ in your ActiveRecord::Base
-    # subclasses to have complete control about what's generated. The general
-    # form of doing this is:
-    #
-    #   class IHaveMyOwnXML < ActiveRecord::Base
-    #     def to_xml(options = {})
-    #       require 'builder'
-    #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= ::Builder::XmlMarkup.new(indent: options[:indent])
-    #       xml.instruct! unless options[:skip_instruct]
-    #       xml.level_one do
-    #         xml.tag!(:second_level, 'content')
-    #       end
-    #     end
-    #   end
-    def to_xml(options = {}, &block)
-      XmlSerializer.new(self, options).serialize(&block)
-    end
-  end
-
-  class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
-    class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
-      def compute_type
-        klass = @serializable.class
-        column = klass.columns_hash[name] || Type::Value.new
-
-        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || column.type
-
-        { :text => :string,
-          :time => :datetime }[type] || type
-      end
-      protected :compute_type
-    end
-  end
-end

data/lib/active_record/type/big_integer.rb

@@ -1,13 +0,0 @@
-require 'active_record/type/integer'
-
-module ActiveRecord
-  module Type
-    class BigInteger < Integer # :nodoc:
-      private
-
-      def max_value
-        ::Float::INFINITY
-      end
-    end
-  end
-end

data/lib/active_record/type/binary.rb

@@ -1,50 +0,0 @@
-module ActiveRecord
-  module Type
-    class Binary < Value # :nodoc:
-      def type
-        :binary
-      end
-
-      def binary?
-        true
-      end
-
-      def type_cast(value)
-        if value.is_a?(Data)
-          value.to_s
-        else
-          super
-        end
-      end
-
-      def type_cast_for_database(value)
-        return if value.nil?
-        Data.new(super)
-      end
-
-      def changed_in_place?(raw_old_value, value)
-        old_value = type_cast_from_database(raw_old_value)
-        old_value != value
-      end
-
-      class Data # :nodoc:
-        def initialize(value)
-          @value = value.to_s
-        end
-
-        def to_s
-          @value
-        end
-        alias_method :to_str, :to_s
-
-        def hex
-          @value.unpack('H*')[0]
-        end
-
-        def ==(other)
-          other == to_s || super
-        end
-      end
-    end
-  end
-end

data/lib/active_record/type/boolean.rb

@@ -1,30 +0,0 @@
-module ActiveRecord
-  module Type
-    class Boolean < Value # :nodoc:
-      def type
-        :boolean
-      end
-
-      private
-
-      def cast_value(value)
-        if value == ''
-          nil
-        elsif ConnectionAdapters::Column::TRUE_VALUES.include?(value)
-          true
-        else
-          if !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              You attempted to assign a value which is not explicitly `true` or `false`
-              to a boolean column. Currently this value casts to `false`. This will
-              change to match Ruby's semantics, and will cast to `true` in Rails 5.
-              If you would like to maintain the current behavior, you should
-              explicitly handle the values you would like cast to `false`.
-            MSG
-          end
-          false
-        end
-      end
-    end
-  end
-end

data/lib/active_record/type/decimal.rb

@@ -1,40 +0,0 @@
-module ActiveRecord
-  module Type
-    class Decimal < Value # :nodoc:
-      include Numeric
-
-      def type
-        :decimal
-      end
-
-      def type_cast_for_schema(value)
-        value.to_s
-      end
-
-      private
-
-      def cast_value(value)
-        case value
-        when ::Float
-          BigDecimal(value, float_precision)
-        when ::Numeric, ::String
-          BigDecimal(value, precision.to_i)
-        else
-          if value.respond_to?(:to_d)
-            value.to_d
-          else
-            cast_value(value.to_s)
-          end
-        end
-      end
-
-      def float_precision
-        if precision.to_i > ::Float::DIG + 1
-          ::Float::DIG + 1
-        else
-          precision.to_i
-        end
-      end
-    end
-  end
-end

data/lib/active_record/type/decorator.rb

@@ -1,14 +0,0 @@
-module ActiveRecord
-  module Type
-    module Decorator # :nodoc:
-      def init_with(coder)
-        @subtype = coder['subtype']
-        __setobj__(@subtype)
-      end
-
-      def encode_with(coder)
-        coder['subtype'] = __getobj__
-      end
-    end
-  end
-end

data/lib/active_record/type/float.rb

@@ -1,19 +0,0 @@
-module ActiveRecord
-  module Type
-    class Float < Value # :nodoc:
-      include Numeric
-
-      def type
-        :float
-      end
-
-      alias type_cast_for_database type_cast
-
-      private
-
-      def cast_value(value)
-        value.to_f
-      end
-    end
-  end
-end

data/lib/active_record/type/integer.rb

@@ -1,55 +0,0 @@
-module ActiveRecord
-  module Type
-    class Integer < Value # :nodoc:
-      include Numeric
-
-      def initialize(*)
-        super
-        @range = min_value...max_value
-      end
-
-      def type
-        :integer
-      end
-
-      alias type_cast_for_database type_cast
-
-      def type_cast_from_database(value)
-        return if value.nil?
-        value.to_i
-      end
-
-      protected
-
-      attr_reader :range
-
-      private
-
-      def cast_value(value)
-        case value
-        when true then 1
-        when false then 0
-        else
-          result = value.to_i rescue nil
-          ensure_in_range(result) if result
-          result
-        end
-      end
-
-      def ensure_in_range(value)
-        unless range.cover?(value)
-          raise RangeError, "#{value} is out of range for #{self.class} with limit #{limit || 4}"
-        end
-      end
-
-      def max_value
-        limit = self.limit || 4
-        1 << (limit * 8 - 1) # 8 bits per byte with one bit for sign
-      end
-
-      def min_value
-        -max_value
-      end
-    end
-  end
-end

data/lib/active_record/type/mutable.rb

@@ -1,16 +0,0 @@
-module ActiveRecord
-  module Type
-    module Mutable # :nodoc:
-      def type_cast_from_user(value)
-        type_cast_from_database(type_cast_for_database(value))
-      end
-
-      # +raw_old_value+ will be the `_before_type_cast` version of the
-      # value (likely a string). +new_value+ will be the current, type
-      # cast value.
-      def changed_in_place?(raw_old_value, new_value)
-        raw_old_value != type_cast_for_database(new_value)
-      end
-    end
-  end
-end

data/lib/active_record/type/numeric.rb

@@ -1,36 +0,0 @@
-module ActiveRecord
-  module Type
-    module Numeric # :nodoc:
-      def number?
-        true
-      end
-
-      def type_cast(value)
-        value = case value
-                when true then 1
-                when false then 0
-                when ::String then value.presence
-                else value
-                end
-        super(value)
-      end
-
-      def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
-        super || number_to_non_number?(old_value, new_value_before_type_cast)
-      end
-
-      private
-
-      def number_to_non_number?(old_value, new_value_before_type_cast)
-        old_value != nil && non_numeric_string?(new_value_before_type_cast)
-      end
-
-      def non_numeric_string?(value)
-        # 'wibble'.to_i will give zero, we want to make sure
-        # that we aren't marking int zero to string zero as
-        # changed.
-        value.to_s !~ /\A\d+\.?\d*\z/
-      end
-    end
-  end
-end

data/lib/active_record/type/string.rb

@@ -1,36 +0,0 @@
-module ActiveRecord
-  module Type
-    class String < Value # :nodoc:
-      def type
-        :string
-      end
-
-      def changed_in_place?(raw_old_value, new_value)
-        if new_value.is_a?(::String)
-          raw_old_value != new_value
-        end
-      end
-
-      def type_cast_for_database(value)
-        case value
-        when ::Numeric, ActiveSupport::Duration then value.to_s
-        when ::String then ::String.new(value)
-        when true then "t"
-        when false then "f"
-        else super
-        end
-      end
-
-      private
-
-      def cast_value(value)
-        case value
-        when true then "t"
-        when false then "f"
-        # String.new is slightly faster than dup
-        else ::String.new(value.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/active_record/type/time_value.rb

@@ -1,38 +0,0 @@
-module ActiveRecord
-  module Type
-    module TimeValue # :nodoc:
-      def klass
-        ::Time
-      end
-
-      def type_cast_for_schema(value)
-        "'#{value.to_s(:db)}'"
-      end
-
-      private
-
-      def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
-        # Treat 0000-00-00 00:00:00 as nil.
-        return if year.nil? || (year == 0 && mon == 0 && mday == 0)
-
-        if offset
-          time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
-          return unless time
-
-          time -= offset
-          Base.default_timezone == :utc ? time : time.getlocal
-        else
-          ::Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-        end
-      end
-
-      # Doesn't handle time zones.
-      def fast_string_to_time(string)
-        if string =~ ConnectionAdapters::Column::Format::ISO_DATETIME
-          microsec = ($7.to_r * 1_000_000).to_i
-          new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-        end
-      end
-    end
-  end
-end

data/lib/active_record/type/value.rb

@@ -1,101 +0,0 @@
-module ActiveRecord
-  module Type
-    class Value # :nodoc:
-      attr_reader :precision, :scale, :limit
-
-      # Valid options are +precision+, +scale+, and +limit+. They are only
-      # used when dumping schema.
-      def initialize(options = {})
-        options.assert_valid_keys(:precision, :scale, :limit)
-        @precision = options[:precision]
-        @scale = options[:scale]
-        @limit = options[:limit]
-      end
-
-      # The simplified type that this object represents. Returns a symbol such
-      # as +:string+ or +:integer+
-      def type; end
-
-      # Type casts a string from the database into the appropriate ruby type.
-      # Classes which do not need separate type casting behavior for database
-      # and user provided values should override +cast_value+ instead.
-      def type_cast_from_database(value)
-        type_cast(value)
-      end
-
-      # Type casts a value from user input (e.g. from a setter). This value may
-      # be a string from the form builder, or an already type cast value
-      # provided manually to a setter.
-      #
-      # Classes which do not need separate type casting behavior for database
-      # and user provided values should override +type_cast+ or +cast_value+
-      # instead.
-      def type_cast_from_user(value)
-        type_cast(value)
-      end
-
-      # Cast a value from the ruby type to a type that the database knows how
-      # to understand. The returned value from this method should be a
-      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
-      # +nil+
-      def type_cast_for_database(value)
-        value
-      end
-
-      # Type cast a value for schema dumping. This method is private, as we are
-      # hoping to remove it entirely.
-      def type_cast_for_schema(value) # :nodoc:
-        value.inspect
-      end
-
-      # These predicates are not documented, as I need to look further into
-      # their use, and see if they can be removed entirely.
-      def number? # :nodoc:
-        false
-      end
-
-      def binary? # :nodoc:
-        false
-      end
-
-      def klass # :nodoc:
-      end
-
-      # Determines whether a value has changed for dirty checking. +old_value+
-      # and +new_value+ will always be type-cast. Types should not need to
-      # override this method.
-      def changed?(old_value, new_value, _new_value_before_type_cast)
-        old_value != new_value
-      end
-
-      # Determines whether the mutable value has been modified since it was
-      # read. Returns +false+ by default. This method should not be overridden
-      # directly. Types which return a mutable value should include
-      # +Type::Mutable+, which will define this method.
-      def changed_in_place?(*)
-        false
-      end
-
-      def ==(other)
-        self.class == other.class &&
-          precision == other.precision &&
-          scale == other.scale &&
-          limit == other.limit
-      end
-
-      private
-
-      def type_cast(value)
-        cast_value(value) unless value.nil?
-      end
-
-      # Convenience method for types which do not need separate type casting
-      # behavior for user and database inputs. Called by
-      # `type_cast_from_database` and `type_cast_from_user` for all values
-      # except `nil`.
-      def cast_value(value) # :doc:
-        value
-      end
-    end
-  end
-end

data/lib/rails/generators/active_record/migration/templates/create_table_migration.rb

@@ -1,22 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration
-  def change
-    create_table :<%= table_name %> do |t|
-<% attributes.each do |attribute| -%>
-<% if attribute.password_digest? -%>
-      t.string :password_digest<%= attribute.inject_options %>
-<% else -%>
-      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
-<% end -%>
-<% end -%>
-<% if options[:timestamps] %>
-      t.timestamps null: false
-<% end -%>
-    end
-<% attributes_with_index.each do |attribute| -%>
-    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-<% end -%>
-<% attributes.select(&:reference?).reject(&:polymorphic?).each do |attribute| -%>
-    add_foreign_key :<%= table_name %>, :<%= attribute.name.pluralize %>
-<% end -%>
-  end
-end

data/lib/rails/generators/active_record/model/templates/model.rb

@@ -1,10 +0,0 @@
-<% module_namespacing do -%>
-class <%= class_name %> < <%= parent_class_name.classify %>
-<% attributes.select(&:reference?).each do |attribute| -%>
-  belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %><%= ', required: true' if attribute.required? %>
-<% end -%>
-<% if attributes.any?(&:password_digest?) -%>
-  has_secure_password
-<% end -%>
-end
-<% end -%>