counterwise 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3058578dbb5742b22c61ec6bfbd79253bd39886684760bd1afe2674c4e97eb00
-  data.tar.gz: 8cd7bb0ad3fd770090cd3a156dca65a7d5c6dd9ba607dbcce500c6c94f182a31
+  metadata.gz: 872eddb45910800263c3c79d08192c149f1a93e406b777ace0e37a069b27c581
+  data.tar.gz: f1c75031995349a525f45ef0127dbad1dd8e922a31c638936ebecd5da8995b7e
 SHA512:
-  metadata.gz: 2ebfb183bba510a0e2322e73d7881fed711369575ceb1c48fa128ccacb1482fdec5dbc7b631232d3de0c9f84c4ea4c9620552b96b82212a1751be209ea6d29ec
-  data.tar.gz: 5ed67f84bfffa86e5d438477a4c8f184cfa7b6e0bd26040e56defca7b3ba5877527c57a78b3d9f5868c75860d7b305225c82be24665761b9d3d7952a6bd3809f
+  metadata.gz: acc758026ab1392efd1a18abed79901b51a9b19b3b310e6dcbb71fdf4daec4b06e3c5a191f7232f47a25b1fc402ad054c769daa32d4ea080632cbad5383df939
+  data.tar.gz: a81196e23f65e894f2c31780633255fdf2900fe109ea5a7b240d9cd2d54310c79d8a6511886af1208e441b80214e42dcc455b06c1b3a0b7c8cbbd6af2b5de1f9

data/README.md

@@ -19,6 +19,7 @@ Counting and aggregation library for Rails.
     - [Aggregate a value (e.g. sum of order revenue)](#aggregate-a-value-eg-sum-of-order-revenue)
     - [Hooks](#hooks)
     - [Manual counters](#manual-counters)
+    - [Manually calculating a value](#manually-calculating-a-value)
     - [Calculating a value from other counters](#calculating-a-value-from-other-counters)
     - [Defining a conditional counter](#defining-a-conditional-counter)
   - [Testing](#testing)
@@ -71,6 +72,7 @@ $ rails counter:install:migrations
 `Counter::Value` is the value of a counter. So, for example, a User might have many Posts, so a User would have a `counters` association containing a `Counter::Value` for the number of posts. Counters can be accessed via their name `user.posts_counter` or via the `find_counter` method on the association, e.g. `user.counters.find_counter PostCounter`
 
 ## Basic usage
+
 ### Define a counter
 
 Counters are defined in a seperate class using a small DSL.
@@ -252,6 +254,34 @@ TotalOrderCounter.counter.value #=> 5
 TotalOrderCounter.counter.increment! #=> 6
 ```
 
+### Manually calculating a value
+
+There are edge cases where a counter can't be calculated by associations or other counters. You can tell the counter its value manually, in these cases, by using `calculated_value`. Calculated value takes a lambda and an association. The lambda is called each time an associated record is created, updated, or destroyed.
+
+```ruby
+class RiskyOrdersCounter < Counter::Definition
+  calculated_value ->(customer) { customer.orders.risky.count }, association: :orders
+end
+
+class Customer
+  include Counters::Counter
+  counter RiskyOrdersCounter
+end
+
+class Order
+  include Counter::Changable
+end
+```
+
+You may want to change the auto-generated name of the counter value. In this case, you can provide that with `record_name`.
+
+```ruby
+class RiskyOrdersCounter < Counter::Definition
+  calculated_value ->(customer) { customer.orders.risky.count }, association: :orders
+  record_name :risky_customer_orders
+end
+```
+
 ### Calculating a value from other counters
 
 You may also need have a common need to calculate a value from other counters. For example, given counters for the number of purchases and the number of visits, you might want to calculate the conversion rate. You can do this with a `calculate_from` block.
@@ -326,7 +356,6 @@ We use the `has_changed?` helper to query the ActiveRecord `previous_changes` ha
 
 Conditional counters work best with a single attribute. If the counter is conditional on e.g. confirmed and subscribed, the update tracking logic becomes very complex especially if the values are both updated at the same time. The solution to this is hopefully Rails generated columns in 7.1 so you can store a "subscribed_and_confirmed" column and check the value of that instead. Rails dirty tracking will need to work with generated columns though; see [this PR](https://github.com/rails/rails/pull/48628).
 
-
 ## Testing
 
 ### Using Rspec
@@ -406,9 +435,42 @@ Options:
 
 ---
 
+## Release Instructions
+
+To release a new version of the counterwise gem:
+
+1. **Merge changes**: Ensure all changes are merged into the main branch via pull requests.
+
+2. **Update version**: Bump the version number in `lib/counter/version.rb`:
+
+   ```ruby
+   module Counter
+     VERSION = "x.y.z"  # Update to new version
+   end
+   ```
+
+3. **Commit and push version bump**:
+
+   ```bash
+   git add lib/counter/version.rb
+   git commit -m "Bump version to x.y.z"
+   git push origin main
+   ```
+
+4. **Build and release**:
+   ```bash
+   gem build counter.gemspec
+   gem push counterwise-x.y.z.gem
+   ```
+
+The gem will be available on [RubyGems.org](https://rubygems.org/gems/counterwise) within a few minutes.
+
+---
+
 ## TODO
 
 See the asociated project in Github but roughly I'm thinking:
+
 - Implement the background job pattern for incrementing counters
 - Hierarchical counters. For example, a Site sends many Newsletters and each Newsletter results in many EmailMessages. Each EmailMessage can be marked as spam. How do you create counters for how many spam emails were sent at the Newsletter level and the Site level?
 - Time-based counters for analytics. Instead of a User having one OrderRevenue counter, they would have an OrderRevenue counter for each day. These counters would then be used to produce a chart of their product revenue over the month. Not sure if these are just special counters or something else entirely? Do they use the same ActiveRecord model?

data/app/models/concerns/counter/conditional.rb

@@ -11,6 +11,7 @@ module Counter::Conditional
     end
 
     def accept_item? item, on, increment: true
+      return false if definition.calculated_value?
       return true unless definition.conditional?
 
       conditions = definition.conditions[on]

data/app/models/concerns/counter/increment.rb

@@ -19,18 +19,33 @@ module Counter::Increment
     end
 
     def add_item item
+      if definition.calculated_value?
+        recalc!
+        return
+      end
+
       return unless increment?(item, :create)
 
       increment! by: increment_from_item(item)
     end
 
     def remove_item item
+      if definition.calculated_value?
+        recalc!
+        return
+      end
+
       return unless decrement?(item, :delete)
 
       decrement! by: increment_from_item(item)
     end
 
     def update_item item
+      if definition.calculated_value?
+        recalc!
+        return
+      end
+
       if increment?(item, :update)
         increment! by: increment_from_item(item)
       end

data/app/models/concerns/counter/recalculatable.rb

@@ -2,7 +2,9 @@ module Counter::Recalculatable
   extend ActiveSupport::Concern
 
   def recalc!
-    if definition.calculated?
+    if definition.calculated_value?
+      recalculate_with_value!
+    elsif definition.calculated?
       calculate!
     elsif definition.manual?
       raise Counter::Error.new("Can't recalculate a manual counter")
@@ -26,4 +28,12 @@ module Counter::Recalculatable
   def recalc_scope
     parent.association(definition.association_name).scope
   end
+
+  private
+
+  def recalculate_with_value!
+    with_lock do
+      update!(value: definition.calculated_value.call(parent))
+    end
+  end
 end

data/lib/counter/definition.rb

@@ -34,6 +34,10 @@ class Counter::Definition
   attr_writer :dependent_counters
   # The block to call to calculate the counter
   attr_accessor :calculated_from
+  # The block used to manually set the value
+  attr_accessor :calculated_value
+  # The counter's record name
+  attr_writer :record_name
 
   # Is this a counter which sums a column?
   def sum?
@@ -50,6 +54,11 @@ class Counter::Definition
     @conditional
   end
 
+  # Is this counter using a calculated value?
+  def calculated_value?
+    @calculated_value.present?
+  end
+
   # Is this counter calculated from other counters?
   def calculated?
     !@calculated_from.nil?
@@ -74,11 +83,16 @@ class Counter::Definition
     Counter::Value.find_counter self
   end
 
+  def self.record_name(value)
+    instance.record_name = value.to_s
+  end
+
   # What we record in Counter::Value#name
   def record_name
+    return @record_name if @record_name.present?
     return name if global?
     return "#{model.name.underscore}-#{association_name}" if association_name.present?
-    return "#{model.name.underscore}-#{name}"
+    "#{model.name.underscore}-#{name}"
   end
 
   def conditions
@@ -109,6 +123,17 @@ class Counter::Definition
     instance.method_name = as.to_s
   end
 
+  def self.calculated_value(calculation, association: nil)
+    instance.association_name = association
+    instance.calculated_value = calculation
+    set_default_name
+  end
+
+  def self.set_default_name
+    instance.name ||= to_s.underscore
+    instance.method_name ||= to_s.underscore
+  end
+
   def self.global
     Counter::Definition.instance.global_counters << instance
   end

data/lib/counter/integration/countable.rb

@@ -32,8 +32,11 @@ module Counter::Countable
         parent_association.load_target unless parent_association.loaded?
         parent_model = parent_association.target
         next unless parent_model
-        counter = parent_model.counters.find_or_create_counter!(counter_definition)
-        yield counter if counter
+
+        if parent_model.class.reflect_on_association(:counters) && parent_model.is_a?(counter_definition.model)
+          counter = parent_model.counters.find_or_create_counter!(counter_definition)
+          yield counter if counter
+        end
       end
     end
   end

data/lib/counter/integration/counters.rb

@@ -57,13 +57,24 @@ module Counter::Counters
         definition = definition_class.instance
         definition.model = self
 
+        counter_subquery = ->(counter_class) do
+          record_name = counter_class.instance.record_name
+
+          Counter::Value
+            .select(:value)
+            .where("parent_id = #{table_name}.id AND parent_type = '#{name}' AND name = '#{record_name}'")
+            .limit(1)
+            .to_sql
+        end
+
         scope :with_counter_data_from, ->(*counter_classes) {
           subqueries = ["#{table_name}.*"]
+
           counter_classes.each do |counter_class|
-            sql = Counter::Value.select("value")
-              .where("parent_id = #{table_name}.id AND parent_type = '#{name}' AND name = '#{counter_class.instance.record_name}'").to_sql
-            subqueries << "(#{sql}) AS #{counter_class.instance.name}_data"
+            subquery = counter_subquery.call(counter_class)
+            subqueries << Arel.sql("(#{subquery}) AS #{"#{counter_class.instance.name}_data"}")
           end
+
           select(subqueries)
         }
 
@@ -74,15 +85,16 @@ module Counter::Counters
             counter_class.is_a?(Class) &&
               counter_class.ancestors.include?(Counter::Definition)
           }
-          order_params = {}
-          order_hash.map do |counter_class, direction|
+
+          order_clauses = order_hash.map do |counter_class, direction|
             if counter_class.is_a?(String) || counter_class.is_a?(Symbol)
-              order_params[counter_class] = direction
+              "#{counter_class} #{direction.to_s.upcase}"
             elsif counter_class.ancestors.include?(Counter::Definition)
-              order_params["#{counter_class.instance.name}_data"] = direction
+              "(#{counter_subquery.call(counter_class)}) #{direction.to_s.upcase}"
             end
           end
-          with_counter_data_from(*counter_classes).order(order_params)
+
+          with_counter_data_from(*counter_classes).order(Arel.sql(order_clauses.join(", ")))
         }
 
         scope :with_counters, -> { includes(:counters) }

data/lib/counter/version.rb

@@ -1,3 +1,3 @@
 module Counter
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: counterwise
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Jamie Lawrence
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 description: Counting and aggregation library for Rails.
 email:
 - jamie@ideasasylum.com
@@ -72,7 +71,6 @@ metadata:
   homepage_uri: https://github.com/podia/counter
   source_code_uri: https://github.com/podia/counter
   changelog_uri: https://github.com/podia/counter/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -80,15 +78,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Counters and the counting counters that count them
 test_files: []