activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/fixtures/file.rb

@@ -1,65 +0,0 @@
-begin
-  require 'psych'
-rescue LoadError
-end
-
-require 'erb'
-require 'yaml'
-
-module ActiveRecord
-  class Fixtures
-    class File
-      include Enumerable
-
-      ##
-      # Open a fixture file named +file+.  When called with a block, the block
-      # is called with the filehandle and the filehandle is automatically closed
-      # when the block finishes.
-      def self.open(file)
-        x = new file
-        block_given? ? yield(x) : x
-      end
-
-      def initialize(file)
-        @file = file
-        @rows = nil
-      end
-
-      def each(&block)
-        rows.each(&block)
-      end
-
-      RESCUE_ERRORS = [ ArgumentError ] # :nodoc:
-
-      private
-      if defined?(Psych) && defined?(Psych::SyntaxError)
-        RESCUE_ERRORS << Psych::SyntaxError
-      end
-
-      def rows
-        return @rows if @rows
-
-        begin
-          data = YAML.load(render(IO.read(@file)))
-        rescue *RESCUE_ERRORS => error
-          raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
-        end
-        @rows = data ? validate(data).to_a : []
-      end
-
-      def render(content)
-        ERB.new(content).result
-      end
-
-      # Validate our unmarshalled data.
-      def validate(data)
-        unless Hash === data || YAML::Omap === data
-          raise Fixture::FormatError, 'fixture is not a hash'
-        end
-
-        raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
-        data
-      end
-    end
-  end
-end

data/lib/active_record/identity_map.rb

@@ -1,162 +0,0 @@
-module ActiveRecord
-  # = Active Record Identity Map
-  #
-  # Ensures that each object gets loaded only once by keeping every loaded
-  # object in a map. Looks up objects using the map when referring to them.
-  #
-  # More information on Identity Map pattern:
-  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
-  #
-  # == Configuration
-  #
-  # In order to enable IdentityMap, set <tt>config.active_record.identity_map = true</tt>
-  # in your <tt>config/application.rb</tt> file.
-  #
-  # IdentityMap is disabled by default and still in development (i.e. use it with care).
-  #
-  # == Associations
-  #
-  # Active Record Identity Map does not track associations yet. For example:
-  #
-  #   comment = @post.comments.first
-  #   comment.post = nil
-  #   @post.comments.include?(comment) #=> true
-  #
-  # Ideally, the example above would return false, removing the comment object from the
-  # post association when the association is nullified. This may cause side effects, as
-  # in the situation below, if Identity Map is enabled:
-  #
-  #   Post.has_many :comments, :dependent => :destroy
-  #
-  #   comment = @post.comments.first
-  #   comment.post = nil
-  #   comment.save
-  #   Post.destroy(@post.id)
-  #
-  # Without using Identity Map, the code above will destroy the @post object leaving
-  # the comment object intact. However, once we enable Identity Map, the post loaded
-  # by Post.destroy is exactly the same object as the object @post. As the object @post
-  # still has the comment object in @post.comments, once Identity Map is enabled, the
-  # comment object will be accidently removed.
-  #
-  # This inconsistency is meant to be fixed in future Rails releases.
-  #
-  module IdentityMap
-
-    class << self
-      def enabled=(flag)
-        Thread.current[:identity_map_enabled] = flag
-      end
-
-      def enabled
-        Thread.current[:identity_map_enabled]
-      end
-      alias enabled? enabled
-
-      def repository
-        Thread.current[:identity_map] ||= Hash.new { |h,k| h[k] = {} }
-      end
-
-      def use
-        old, self.enabled = enabled, true
-
-        yield if block_given?
-      ensure
-        self.enabled = old
-        clear
-      end
-
-      def without
-        old, self.enabled = enabled, false
-
-        yield if block_given?
-      ensure
-        self.enabled = old
-      end
-
-      def get(klass, primary_key)
-        record = repository[klass.symbolized_sti_name][primary_key]
-
-        if record.is_a?(klass)
-          ActiveSupport::Notifications.instrument("identity.active_record",
-            :line => "From Identity Map (id: #{primary_key})",
-            :name => "#{klass} Loaded",
-            :connection_id => object_id)
-
-          record
-        else
-          nil
-        end
-      end
-
-      def add(record)
-        repository[record.class.symbolized_sti_name][record.id] = record if contain_all_columns?(record)
-      end
-
-      def remove(record)
-        repository[record.class.symbolized_sti_name].delete(record.id)
-      end
-
-      def remove_by_id(symbolized_sti_name, id)
-        repository[symbolized_sti_name].delete(id)
-      end
-
-      def clear
-        repository.clear
-      end
-
-      private
-
-        def contain_all_columns?(record)
-          (record.class.column_names - record.attribute_names).empty?
-        end
-    end
-
-    # Reinitialize an Identity Map model object from +coder+.
-    # +coder+ must contain the attributes necessary for initializing an empty
-    # model object.
-    def reinit_with(coder)
-      @attributes_cache = {}
-      dirty      = @changed_attributes.keys
-      attributes = self.class.initialize_attributes(coder['attributes'].except(*dirty))
-      @attributes.update(attributes)
-      @changed_attributes.update(coder['attributes'].slice(*dirty))
-      @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
-
-      run_callbacks :find
-
-      self
-    end
-
-    class Middleware
-      class Body #:nodoc:
-        def initialize(target, original)
-          @target   = target
-          @original = original
-        end
-
-        def each(&block)
-          @target.each(&block)
-        end
-
-        def close
-          @target.close if @target.respond_to?(:close)
-        ensure
-          IdentityMap.enabled = @original
-          IdentityMap.clear
-        end
-      end
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        enabled = IdentityMap.enabled
-        IdentityMap.enabled = true
-        status, headers, body = @app.call(env)
-        [status, headers, Body.new(body, enabled)]
-      end
-    end
-  end
-end

data/lib/active_record/observer.rb

@@ -1,121 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-
-module ActiveRecord
-  # = Active Record Observer
-  #
-  # Observer classes respond to life cycle callbacks to implement trigger-like
-  # behavior outside the original class. This is a great way to reduce the
-  # clutter that normally comes when the model class is burdened with
-  # functionality that doesn't pertain to the core responsibility of the
-  # class. Example:
-  #
-  #   class CommentObserver < ActiveRecord::Observer
-  #     def after_save(comment)
-  #       Notifications.comment("admin@do.com", "New comment was posted", comment).deliver
-  #     end
-  #   end
-  #
-  # This Observer sends an email when a Comment#save is finished.
-  #
-  #   class ContactObserver < ActiveRecord::Observer
-  #     def after_create(contact)
-  #       contact.logger.info('New contact added!')
-  #     end
-  #
-  #     def after_destroy(contact)
-  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
-  #     end
-  #   end
-  #
-  # This Observer uses logger to log when specific callbacks are triggered.
-  #
-  # == Observing a class that can't be inferred
-  #
-  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
-  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
-  # differently than the class you're interested in observing, you can use the Observer.observe class method which takes
-  # either the concrete class (Product) or a symbol for that class (:product):
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     observe :account
-  #
-  #     def after_update(account)
-  #       AuditTrail.new(account, "UPDATED")
-  #     end
-  #   end
-  #
-  # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     observe :account, :balance
-  #
-  #     def after_update(record)
-  #       AuditTrail.new(record, "UPDATED")
-  #     end
-  #   end
-  #
-  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
-  #
-  # == Available callback methods
-  #
-  # The observer can implement callback methods for each of the methods described in the Callbacks module.
-  #
-  # == Storing Observers in Rails
-  #
-  # If you're using Active Record within Rails, observer classes are usually stored in app/models with the
-  # naming convention of app/models/audit_observer.rb.
-  #
-  # == Configuration
-  #
-  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration
-  # setting in your <tt>config/application.rb</tt> file.
-  #
-  #   config.active_record.observers = :comment_observer, :signup_observer
-  #
-  # Observers will not be invoked unless you define these in your application configuration.
-  #
-  # == Loading
-  #
-  # Observers register themselves in the model class they observe, since it is the class that
-  # notifies them of events when they occur. As a side-effect, when an observer is loaded its
-  # corresponding model class is loaded.
-  #
-  # Up to (and including) Rails 2.0.2 observers were instantiated between plugins and
-  # application initializers. Now observers are loaded after application initializers,
-  # so observed models can make use of extensions.
-  #
-  # If by any chance you are using observed models in the initialization you can still
-  # load their observers by calling <tt>ModelObserver.instance</tt> before. Observers are
-  # singletons and that call instantiates and registers them.
-  #
-  class Observer < ActiveModel::Observer
-
-    protected
-
-      def observed_classes
-        klasses = super
-        klasses + klasses.map { |klass| klass.descendants }.flatten
-      end
-
-      def add_observer!(klass)
-        super
-        define_callbacks klass
-      end
-
-      def define_callbacks(klass)
-        observer = self
-        observer_name = observer.class.name.underscore.gsub('/', '__')
-
-        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
-          next unless respond_to?(callback)
-          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
-          unless klass.respond_to?(callback_meth)
-            klass.send(:define_method, callback_meth) do |&block|
-              observer.update(callback, self, &block)
-            end
-            klass.send(callback, callback_meth)
-          end
-        end
-      end
-  end
-end

data/lib/active_record/railties/jdbcmysql_error.rb

@@ -1,16 +0,0 @@
-#FIXME Remove if ArJdbcMysql will give.
-module ArJdbcMySQL #:nodoc:
-  class Error < StandardError
-    attr_accessor :error_number, :sql_state
-
-    def initialize msg
-      super
-      @error_number = nil
-      @sql_state    = nil
-    end
-
-    # Mysql gem compatibility
-    alias_method :errno, :error_number
-    alias_method :error, :message
-  end
-end

data/lib/active_record/serializers/xml_serializer.rb

@@ -1,203 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-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:
-    def initialize(*args)
-      super
-      options[:except] = Array.wrap(options[:except]) | Array.wrap(@serializable.class.inheritance_column)
-    end
-
-    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
-
-        { :text => :string,
-          :time => :datetime }[type] || type
-      end
-      protected :compute_type
-    end
-  end
-end