/usr/lib/ruby/vendor_ruby/active_record/identity_map.rb is in ruby-activerecord-3.2 3.2.16-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | 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
|