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]
- 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.
- #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 |
# File 'lib/counter_culture/counter.rb', line 8 def initialize(model, relation, ) @model = model @relation = relation.is_a?(Enumerable) ? relation : [relation] if .fetch(:execute_after_commit, false) fail("execute_after_commit was removed; updates now run within the transaction") end @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) end |
Instance Method Details
#attribute_changed?(obj, attr) ⇒ Boolean
226 227 228 229 230 231 232 |
# File 'lib/counter_culture/counter.rb', line 226 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
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 |
# File 'lib/counter_culture/counter.rb', line 36 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 instance.paper_trail.save_with_version(validate: false) else instance.paper_trail.touch_with_version end end end klass.where(primary_key => id_to_change).update_all updates.join(', ') 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
122 123 124 125 126 127 128 129 130 131 |
# File 'lib/counter_culture/counter.rb', line 122 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
110 111 112 113 114 115 116 |
# File 'lib/counter_culture/counter.rb', line 110 def counter_delta_magnitude_for(obj) if delta_magnitude.is_a?(Proc) delta_magnitude.call(obj) else delta_magnitude end end |
#first_level_relation_changed?(instance) ⇒ Boolean
218 219 220 221 222 223 224 |
# File 'lib/counter_culture/counter.rb', line 218 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
276 277 278 279 |
# File 'lib/counter_culture/counter.rb', line 276 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
281 282 283 284 285 |
# File 'lib/counter_culture/counter.rb', line 281 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
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
# File 'lib/counter_culture/counter.rb', line 145 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
134 135 136 |
# File 'lib/counter_culture/counter.rb', line 134 def full_primary_key(klass) "#{klass.quoted_table_name}.#{klass.quoted_primary_key}" end |
#polymorphic? ⇒ Boolean
234 235 236 237 238 239 240 |
# File 'lib/counter_culture/counter.rb', line 234 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
287 288 289 290 291 292 293 294 295 296 297 |
# File 'lib/counter_culture/counter.rb', line 287 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
246 247 248 |
# File 'lib/counter_culture/counter.rb', line 246 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
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 |
# File 'lib/counter_culture/counter.rb', line 200 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
259 260 261 262 263 264 265 266 267 268 |
# File 'lib/counter_culture/counter.rb', line 259 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
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 |
# File 'lib/counter_culture/counter.rb', line 170 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 |