Class: CounterCulture::Counter
- Inherits:
-
Object
- Object
- CounterCulture::Counter
- Defined in:
- lib/counter_culture/counter.rb
Constant Summary collapse
- CONFIG_OPTIONS =
[ :column_names, :counter_cache_name, :delta_column, :foreign_key_values, :touch, :delta_magnitude, :execute_after_commit ]
- ACTIVE_RECORD_VERSION =
Gem.loaded_specs["activerecord"].version
Instance Method Summary collapse
- #attribute_changed?(obj, attr) ⇒ Boolean
-
#change_counter_cache(obj, options) ⇒ Object
increments or decrements a counter cache.
-
#counter_cache_name_for(obj) ⇒ Object
Gets the name of the counter cache for a specific object.
-
#counter_delta_magnitude_for(obj) ⇒ Object
Gets the delta magnitude of the counter cache for a specific object.
- #execute_now_or_after_commit(obj, &block) ⇒ Object
- #first_level_relation_changed?(instance) ⇒ Boolean
-
#first_level_relation_foreign_key ⇒ Object
gets the foreign key name of the relation.
- #first_level_relation_foreign_type ⇒ Object
-
#foreign_key_value(obj, relation, was = false) ⇒ Object
gets the value of the foreign key on the given relation.
-
#full_primary_key(klass) ⇒ Object
the string to pass to order() in order to sort by primary key.
-
#initialize(model, relation, options) ⇒ Counter
constructor
A new instance of Counter.
- #polymorphic? ⇒ Boolean
- #previous_model(obj) ⇒ Object
-
#relation_foreign_key(relation) ⇒ Object
gets the foreign key name of the given relation.
-
#relation_klass(relation, source: nil, was: false) ⇒ Object
gets the class of the given relation.
-
#relation_primary_key(relation, source: nil, was: false) ⇒ Object
gets the primary key name of the given relation.
-
#relation_reflect(relation) ⇒ Object
gets the reflect object on the given relation.
Constructor Details
#initialize(model, relation, options) ⇒ Counter
Returns a new instance of Counter.
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
# File 'lib/counter_culture/counter.rb', line 8 def initialize(model, relation, ) @model = model @relation = relation.is_a?(Enumerable) ? relation : [relation] @counter_cache_name = .fetch(:column_name, "#{model.name.demodulize.tableize}_count") @column_names = [:column_names] @delta_column = [:delta_column] @foreign_key_values = [:foreign_key_values] @touch = .fetch(:touch, false) @delta_magnitude = [:delta_magnitude] || 1 @with_papertrail = .fetch(:with_papertrail, false) @execute_after_commit = .fetch(:execute_after_commit, false) if @execute_after_commit begin require 'after_commit_action' rescue LoadError fail(LoadError.new( "You need to include the `after_commit_action` gem in your "\ "gem dependencies to use the execute_after_commit option")) end model.include(AfterCommitAction) end end |
Instance Method Details
#attribute_changed?(obj, attr) ⇒ Boolean
240 241 242 243 244 245 246 |
# File 'lib/counter_culture/counter.rb', line 240 def attribute_changed?(obj, attr) if ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0") obj.saved_changes[attr].present? else obj.send(:attribute_changed?, attr) end end |
#change_counter_cache(obj, options) ⇒ Object
increments or decrements a counter cache
options:
:increment => true to increment, false to decrement
:relation => which relation to increment the count on,
:counter_cache_name => the column name of the counter cache
:counter_column => overrides :counter_cache_name
:delta_column => override the default count delta (1) with the value of this column in the counted record
:was => whether to get the current value or the old value of the
first part of the relation
:with_papertrail => update the column via Papertrail touch_with_version method
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 |
# File 'lib/counter_culture/counter.rb', line 44 def change_counter_cache(obj, ) change_counter_column = .fetch(:counter_column) { counter_cache_name_for(obj) } # default to the current foreign key value id_to_change = foreign_key_value(obj, relation, [:was]) # allow overwriting of foreign key value by the caller id_to_change = foreign_key_values.call(id_to_change) if foreign_key_values if id_to_change && change_counter_column delta_magnitude = if delta_column ([:was] ? attribute_was(obj, delta_column) : obj.public_send(delta_column)) || 0 else counter_delta_magnitude_for(obj) end # increment or decrement? operator = [:increment] ? '+' : '-' klass = relation_klass(relation, source: obj, was: [:was]) # MySQL throws an ambiguous column error if any joins are present and we don't include the # table name. We isolate this change to MySQL because sqlite has the opposite behavior and # throws an exception if the table name is present after UPDATE. quoted_column = if klass.connection.adapter_name == 'Mysql2' "#{klass.quoted_table_name}.#{model.connection.quote_column_name(change_counter_column)}" else "#{model.connection.quote_column_name(change_counter_column)}" end # we don't use Rails' update_counters because we support changing the timestamp updates = [] # this updates the actual counter updates << "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{delta_magnitude}" # and here we update the timestamp, if so desired if touch current_time = obj.send(:current_time_from_proper_timezone) = obj.send(:timestamp_attributes_for_update_in_model) if touch != true # starting in Rails 6 this is frozen = .dup << touch end .each do || updates << "#{} = '#{current_time.to_formatted_s(:db)}'" end end primary_key = relation_primary_key(relation, source: obj, was: [:was]) if @with_papertrail instance = klass.where(primary_key => id_to_change).first if instance if instance.paper_trail.respond_to?(:save_with_version) # touch_with_version is deprecated starting in PaperTrail 9.0.0 current_time = obj.send(:current_time_from_proper_timezone) = obj.send(:timestamp_attributes_for_update_in_model) .each do || instance.send("#{}=", current_time) end execute_now_or_after_commit(obj) do instance.paper_trail.save_with_version(validate: false) end else execute_now_or_after_commit(obj) do instance.paper_trail.touch_with_version end end end end execute_now_or_after_commit(obj) do klass.where(primary_key => id_to_change).update_all updates.join(', ') end end end |
#counter_cache_name_for(obj) ⇒ Object
Gets the name of the counter cache for a specific object
obj: object to calculate the counter cache name for cache_name_finder: object used to calculate the cache name
136 137 138 139 140 141 142 143 144 145 |
# File 'lib/counter_culture/counter.rb', line 136 def counter_cache_name_for(obj) # figure out what the column name is if counter_cache_name.is_a?(Proc) # dynamic column name -- call the Proc counter_cache_name.call(obj) else # static column name counter_cache_name end end |
#counter_delta_magnitude_for(obj) ⇒ Object
Gets the delta magnitude of the counter cache for a specific object
obj: object to calculate the counter cache name for
124 125 126 127 128 129 130 |
# File 'lib/counter_culture/counter.rb', line 124 def counter_delta_magnitude_for(obj) if delta_magnitude.is_a?(Proc) delta_magnitude.call(obj) else delta_magnitude end end |
#execute_now_or_after_commit(obj, &block) ⇒ Object
313 314 315 316 317 318 319 |
# File 'lib/counter_culture/counter.rb', line 313 def execute_now_or_after_commit(obj, &block) if @execute_after_commit obj.execute_after_commit(&block) else block.call end end |
#first_level_relation_changed?(instance) ⇒ Boolean
232 233 234 235 236 237 238 |
# File 'lib/counter_culture/counter.rb', line 232 def first_level_relation_changed?(instance) return true if attribute_changed?(instance, first_level_relation_foreign_key) if polymorphic? return true if attribute_changed?(instance, first_level_relation_foreign_type) end false end |
#first_level_relation_foreign_key ⇒ Object
gets the foreign key name of the relation. will look at the first level only – i.e., if passed an array will consider only its first element
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
290 291 292 293 |
# File 'lib/counter_culture/counter.rb', line 290 def first_level_relation_foreign_key first_relation = relation.first if relation.is_a?(Enumerable) relation_reflect(first_relation).foreign_key end |
#first_level_relation_foreign_type ⇒ Object
295 296 297 298 299 |
# File 'lib/counter_culture/counter.rb', line 295 def first_level_relation_foreign_type return nil unless polymorphic? first_relation = relation.first if relation.is_a?(Enumerable) relation_reflect(first_relation).foreign_type end |
#foreign_key_value(obj, relation, was = false) ⇒ Object
gets the value of the foreign key on the given relation
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
was: whether to get the current or past value from ActiveRecord;
pass true to get the past value, false or nothing to get the
current value
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 |
# File 'lib/counter_culture/counter.rb', line 159 def foreign_key_value(obj, relation, was = false) relation = relation.is_a?(Enumerable) ? relation.dup : [relation] first_relation = relation.first if was first = relation.shift foreign_key_value = attribute_was(obj, relation_foreign_key(first)) klass = relation_klass(first, source: obj, was: was) if foreign_key_value value = klass.where( "#{klass.table_name}.#{relation_primary_key(first, source: obj, was: was)} = ?", foreign_key_value).first end else value = obj end while !value.nil? && relation.size > 0 value = value.send(relation.shift) end return value.try(relation_primary_key(first_relation, source: obj, was: was).try(:to_sym)) end |
#full_primary_key(klass) ⇒ Object
the string to pass to order() in order to sort by primary key
148 149 150 |
# File 'lib/counter_culture/counter.rb', line 148 def full_primary_key(klass) "#{klass.quoted_table_name}.#{klass.quoted_primary_key}" end |
#polymorphic? ⇒ Boolean
248 249 250 251 252 253 254 |
# File 'lib/counter_culture/counter.rb', line 248 def polymorphic? is_polymorphic = relation_reflect(relation)..key?(:polymorphic) if is_polymorphic && !(relation.is_a?(Symbol) || relation.length == 1) raise "Polymorphic associations only supported with one level" end return is_polymorphic end |
#previous_model(obj) ⇒ Object
301 302 303 304 305 306 307 308 309 310 311 |
# File 'lib/counter_culture/counter.rb', line 301 def previous_model(obj) prev = obj.dup changes_method = ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0") ? :saved_changes : :changed_attributes obj.public_send(changes_method).each do |key, value| old_value = ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0") ? value.first : value prev[key] = old_value end prev end |
#relation_foreign_key(relation) ⇒ Object
gets the foreign key name of the given relation
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
260 261 262 |
# File 'lib/counter_culture/counter.rb', line 260 def relation_foreign_key(relation) relation_reflect(relation).foreign_key end |
#relation_klass(relation, source: nil, was: false) ⇒ Object
gets the class of the given relation
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
source [optional]: the source object,
only needed for polymorphic associations,
probably only works with a single relation (symbol, or array of 1 symbol)
was: boolean
we're actually looking for the old value -- only can change for polymorphic relations
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 |
# File 'lib/counter_culture/counter.rb', line 214 def relation_klass(relation, source: nil, was: false) reflect = relation_reflect(relation) if reflect..key?(:polymorphic) raise "Can't work out relation's class without being passed object (relation: #{relation}, reflect: #{reflect})" if source.nil? raise "Can't work out polymorhpic relation's class with multiple relations yet" unless (relation.is_a?(Symbol) || relation.length == 1) # this is the column that stores the polymorphic type, aka the class name type_column = reflect.foreign_type.to_sym # so now turn that into the class that we're looking for here if was attribute_was(source, type_column).try(:constantize) else source.public_send(type_column).try(:constantize) end else reflect.klass end end |
#relation_primary_key(relation, source: nil, was: false) ⇒ Object
gets the primary key name of the given relation
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
source: the model instance that the relationship is linked from,
only needed for polymorphic associations,
probably only works with a single relation (symbol, or array of 1 symbol)
was: boolean
we're actually looking for the old value -- only can change for polymorphic relations
273 274 275 276 277 278 279 280 281 282 |
# File 'lib/counter_culture/counter.rb', line 273 def relation_primary_key(relation, source: nil, was: false) reflect = relation_reflect(relation) klass = nil if reflect..key?(:polymorphic) raise "can't handle multiple keys with polymorphic associations" unless (relation.is_a?(Symbol) || relation.length == 1) raise "must specify source for polymorphic associations..." unless source return relation_klass(relation, source: source, was: was).try(:primary_key) end reflect.association_primary_key(klass) end |
#relation_reflect(relation) ⇒ Object
gets the reflect object on the given relation
relation: a symbol or array of symbols; specifies the relation
that has the counter cache column
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
# File 'lib/counter_culture/counter.rb', line 184 def relation_reflect(relation) relation = relation.is_a?(Enumerable) ? relation.dup : [relation] # go from one relation to the next until we hit the last reflect object klass = model while relation.size > 0 cur_relation = relation.shift reflect = klass.reflect_on_association(cur_relation) raise "No relation #{cur_relation} on #{klass.name}" if reflect.nil? if relation.size > 0 # not necessary to do this at the last link because we won't use # klass again. not calling this avoids the following causing an # exception in the now-supported one-level polymorphic counter cache klass = reflect.klass end end return reflect end |