calculate-all 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cd324cd911d0d4998540ce59b30addac7a8e9842676f1adbf75b5bf6adee1c0
-  data.tar.gz: 26ff146cce10d207334d6232e72dae5d8d558246fd47f58da7571a6e84bbba7a
+  metadata.gz: f15872602a35e41a3619150837e69840e82da1d2a42bd058a7c6986092024a97
+  data.tar.gz: f3665c7b64a083c5f24fd861e6ef22a5dde177e4a68eab9638449e26f89e2dc7
 SHA512:
-  metadata.gz: 1570c270af925b14130207b5905235d02f19960fc83f2ae189c67cd482a06538b341a031279daea5c8dc01933eb5303c0cc5db30a7fb706a4ff111c79bac4ec4
-  data.tar.gz: 38f29b21183c14901b61790e5e4a69ce70918e2c99bac4ba4a714a5ee8a1be4466bfcc6ab6cfd93e43a098041d8cbedfa4206c2adc1d6ce766111cdbd0db26f1
+  metadata.gz: 5d7ed4f530ff56be9378644b209add40b415bedf363425599a10a7d3fc14b1d0cb0920dd6744f5c334ae83f0ec9296b161d8bc387a2e4f93c1a849d7764e571a
+  data.tar.gz: 164b353805bf7fdd12e10087186c20a805231f68922c4d46a42e7c8f02307165d36592cbcf0c67d2a27f61e6dbb43c9cd7ab2934b9a64112ef239cf4e50edf05

data/.github/workflows/build.yml

@@ -6,8 +6,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - ruby: "3.1"
+        - ruby: "3.4"
           gemfile: Gemfile
+        - ruby: "3.1"
+          gemfile: gemfiles/activerecord70.gemfile
         - ruby: "3.0"
           gemfile: gemfiles/activerecord61.gemfile
         - ruby: "2.7"
@@ -18,7 +20,7 @@ jobs:
           gemfile: gemfiles/activerecord51.gemfile
         - ruby: "2.6"
           gemfile: gemfiles/activerecord50.gemfile
-        - ruby: "2.5"
+        - ruby: "2.3"
           gemfile: gemfiles/activerecord42.gemfile
     runs-on: ubuntu-latest
     env:

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.3.1
+
+* Fix some arguments exceptions
+
+## 0.3.0
+
+* Allow expression shortcuts as attribute values too for renaming
+* Allow grouping expressions to be returned in rows too
+* Breaking change: only single *string* expression argument is returning unwrapped rows now.
+  Single expression shortcut like `:count` will be expanded to `{count: value}` rows.
+
 ## 0.2.2
 
 * Added support for Groupdate 4+ (Andrew <acekane1@gmail.com>)

data/Gemfile

@@ -4,10 +4,14 @@ gemspec
 
 gem "rake"
 gem "minitest"
-gem "activerecord", "~> 7.0.0"
-gem "groupdate", "~> 5.2.0"
+gem "minitest-reporters"
+gem "activerecord", "~> 8.0.0"
+gem "groupdate", "~> 6"
 gem "pg"
 gem "mysql2"
-gem "sqlite3", "~> 1.4"
+gem "sqlite3", ">= 2.1"
+
+gem "irb"
+gem "ostruct"
 
 gem "standardrb", require: false

data/README.md

@@ -1,50 +1,61 @@
 # CalculateAll
 
 Provides the `#calculate_all` method for your Active Record models, scopes and relations.
-It's a small addition to Active Record's `#count`, `#maximum`, `#minimum`, `#average` and `#sum`.
+It's a small addition to Active Record's `#count`, `#maximum`, `#minimum`, `#average`, `#sum`
+and `#calculate`.
 It allows you to fetch all of the above, as well as other aggregate function results,
 in a single request, with support for grouping.
 
-Currently tested with Postgres, MySQL and sqlite3, ruby >= 2.3, rails >= 4, groupdate >= 4.
+Should be useful for dashboards, timeseries stats, and charts.
+
+Currently tested with PostgreSQL, MySQL and SQLite3, ruby >= 2.3, rails >= 4, groupdate >= 4.
 
 ## Usage
 
+(example SQL snippets are given for PostgreSQL)
+
 ```ruby
-stats = Order.group(:department_id).group(:payment_method).calculate_all(
+stats = Order.group(:department_id).group(:payment_method).order(:payment_method).calculate_all(
+  :payment_method,
   :count,
-  :count_distinct_user_id,
   :price_max,
   :price_min,
   :price_avg,
-  price_median: 'percentile_cont(0.5) within group (order by price desc)'
+  total_users: :count_distinct_user_id,
+  price_median: "percentile_cont(0.5) within group (order by price asc)",
+  plan_ids: "array_agg(distinct plan_id order by plan_id)",
+  earnings: "sum(price) filter (where status = 'paid')"
 )
-#
-#   (2.2ms)  SELECT department_id, payment_method, percentile_cont(0.5) within group (order by price desc),
-#      COUNT(*), COUNT(DISTINCT user_id), MAX(price), MIN(price), AVG(price) FROM "orders" GROUP BY "department_id", "payment_method"
-#
+#   Order Pluck (20.0ms)  SELECT "orders"."department_id", "payment_method", COUNT(*), MAX(price), MIN(price), AVG(price),
+#        COUNT(DISTINCT user_id), percentile_cont(0.5) within group (order by price asc),
+#        array_agg(distinct plan_id order by plan_id), sum(price) filter (where status = 'paid')
+#      FROM "orders" GROUP BY "orders"."department_id", "payment_method" ORDER BY "payment_method" ASC
 # => {
-#   [1, "cash"] => {
+#   [1, "card"] => {
+#     payment_method: "card",
 #     count: 10,
-#     count_distinct_user_id: 5,
 #     price_max: 500,
 #     price_min: 100,
 #     price_avg: 0.3e3,
-#     price_median: 0.4e3
+#     total_users: 5,
+#     price_median: 0.4e3,
+#     plan_ids: [4, 7, 12],
+#     earnings: 2340
 #   },
-#   [1, "card"] => {
+#   [1, "cash"] => {
 #     ...
 #   }
 # }
 ```
 
-(median example works in Postgres only, but check out very cool https://github.com/ankane/active_median)
-
 ## Rationale
 
 Active Record makes it really easy to use most common database aggregate functions like COUNT(), MAX(), MIN(), AVG(), SUM().
-But there's a whole world of other [powerful functions](http://www.postgresql.org/docs/current/functions-aggregate.html) in
-Postgres, which I can’t recommend enough, especially if you’re working with statistics or business intelligence.
-MySQL has some useful ones [as well](https://dev.mysql.com/doc/refman/9.3/en/aggregate-functions.html).
+But there's a whole world of other aggregate functions in
+[PostgreSQL](http://www.postgresql.org/docs/current/functions-aggregate.html),
+[MySQL](https://dev.mysql.com/doc/refman/9.3/en/aggregate-functions.html)
+and [SQLite](https://www.sqlite.org/lang_aggfunc.html)
+which I can’t recommend enough, especially if you’re working with statistics or business intelligence.
 
 Also, in many cases, you’ll need multiple metrics at once. Typically, the database performs a full scan of the table for each metric.
 However, it can calculate all of them in a single scan and a single request.
@@ -53,26 +64,23 @@ However, it can calculate all of them in a single scan and a single request.
 
 ## Arguments
 
-`#calculate_all` accepts a list of expression aliases and/or expression mappings.
-It can be a single string of SQL,
+`#calculate_all` accepts a single SQL expression with aggregate functions,
 
 ```ruby
-  Model.calculate_all('SUM(price) / COUNT(DISTINCT user_id)')
+  Model.calculate_all('CAST(SUM(price) as decimal) / COUNT(DISTINCT user_id)')
 ```
 
-a hash of expressions with arbitrary symbol keys
+or arbitrary symbols and keyword arguments with SQL snippets, aggregate function shortcuts or previously given grouping values.
 
 ```ruby
-  Model.calculate_all(total: 'COUNT(*)', average_spendings: 'SUM(price) / COUNT(DISTINCT user_id)')
+  Model.group(:currency).calculate_all(
+    :average_price, :currency, total: :sum_price, average_spendings: 'SUM(price)::decimal / COUNT(DISTINCT user_id)'
+  )
 ```
-and/or a list of one or more symbols without expressions, in which case `#calculate_all` tries to guess
-what you wanted from it.
 
-```ruby
-  Model.calculate_all(:count, :average_price, :sum_price)
-```
+For convenience, `calculate_all(:count, :avg_column)` is the same as `calculate_all(count: :count, avg_column: :avg_column)`
 
-It's not so smart right now, but here's a cheatsheet:
+Here's a cheatsheet of recognized shortcuts:
 
 | symbol                                                                 | would fetch
 |------------------------------------------------------------------------|------------
@@ -84,6 +92,8 @@ It's not so smart right now, but here's a cheatsheet:
 | `:avg_column1`, `:column1_avg`, `:average_column1`, `:column1_average` | `AVG(column1)`
 | `:sum_column1`, `:column1_sum`                                         | `SUM(column1)`
 
+Other functions are a bit too database specific, and are better to be given with an explicit SQL snippet.
+
 Please don't put values from unverified sources (like HTML form or javascript call) into expression list,
 it could result in malicious SQL injection.
 
@@ -92,23 +102,20 @@ it could result in malicious SQL injection.
 `#calculate_all` tries to mimic magic of Active Record's `#group`, `#count` and `#pluck`
 so result type depends on arguments and on groupings.
 
-If you have no `group()` on underlying scope, `#calculate_all` will return just one result.
+If you have no `group()` on underlying scope, `#calculate_all` will return just one row.
 
 ```ruby
-# Same as Order.distinct.count(:user_id), so probably a useless example.
-# But you can use any expression with aggregate functions there.
-Order.calculate_all('COUNT(DISTINCT user_id)')
-# => 50
+Order.calculate_all(:price_sum)
+# => {price_sum: 123500}
 ```
 
 If you have a single `group()`, it will return a hash of results with simple keys.
 
 ```ruby
-# Again, Order.group(:department_id).distinct.count(:user_id) would do the same.
 Order.group(:department_id).calculate_all(:count_distinct_user_id)
 # => {
-#   1 => 20,
-#   2 => 10,
+#   1 => {count_distinct_user_id: 20},
+#   2 => {count_distinct_user_id: 10},
 #   ...
 # }
 ```
@@ -116,25 +123,36 @@ Order.group(:department_id).calculate_all(:count_distinct_user_id)
 If you have two or more groupings, each result will have an array as a key.
 
 ```ruby
-Order.group(:department_id).group(:department_method).calculate_all(:count_distinct_user_id)
+Order.group(:department_id).group(:payment_method).calculate_all(:count)
 # => {
-#   [1, "cash"] => 5,
-#   [1, "card"] => 15,
-#   [2, "cash"] => 1,
+#   [1, "cash"] => {count: 5},
+#   [1, "card"] => {count: 15},
+#   [2, "cash"] => {count: 1},
 #   ...
 # }
 ```
 
-If you provide only one argument to `#calculate_all`, its calculated value will be returned as-is.
-Otherwise, the results will be returned as hash(es) with symbol keys.
+If you provide only one *string* argument to `#calculate_all`, its calculated value will be returned as-is.
+This is just to make grouped companion to `Model.group(...).count` and friends, but for arbitrary expressions
+with aggregate functions.
+
+```ruby
+Order.group(:payment_method).calculate_all('CAST(SUM(price) AS decimal) / COUNT(DISTINCT user_id)')
+# => {
+#   "card" => 0.524e3,
+#   "cash" => 0.132e3
+# }
+```
 
-so, `Order.calculate_all(:count)` will return just a single integer, but
+Otherwise, the results will be returned as hash(es) with symbol keys.
 
 ```ruby
-Order.group(:department_id).group(:payment_method).calculate_all(:min_price, expr1: 'count(distinct user_id)')
+Order.group(:department_id).group(:payment_method).calculate_all(
+  :min_price, type: :payment_method, expr1: 'count(distinct user_id)'
+)
 # => {
-#   [1, 'cash'] => {min_price: 100, expr1: 5},
-#   [1, 'card'] => {min_price: 150, expr2: 15},
+#   [1, 'cash'] => {min_price: 100, type: 'cash', expr1: 5},
+#   [1, 'card'] => {min_price: 150, type: 'card', expr1: 15},
 #   ...
 # }
 ```
@@ -151,7 +169,7 @@ Order.group(:country_id).calculate_all(:count, :avg_price) { |count:, avg_price:
 #   2 => "10 orders, 200 dollars average"
 # }
 
-Order.group(:country_id).calculate_all(:avg_price) { |avg_price| avg_price.to_i }
+Order.group(:country_id).calculate_all("AVG(price)") { |avg_price| avg_price.to_i }
 # => {
 #   1 => 120,
 #   2 => 200
@@ -159,6 +177,17 @@ Order.group(:country_id).calculate_all(:avg_price) { |avg_price| avg_price.to_i
 
 Order.calculate_all(:count, :max_price, &OpenStruct.method(:new))
 # => #<OpenStruct max_price=500, count=15>
+
+Stats = Data.define(:count, :max_price) do
+  # needed only for groupdate to provide defaults for empty periods
+  def initialize(count: 0, max_price: nil) = super
+end
+Order.group_by_year(:created_at).calculate_all(*Stats.members, &Stats.method(:new))
+# => {
+#   Wed, 01 Jan 2014 => #<data Stats count=2, max_price=700>,
+#   Thu, 01 Jan 2015 => #<data Stats count=0, max_price=nil>,
+#   Fri, 01 Jan 2016 => #<data Stats count=3, max_price=800>
+# }
 ```
 
 ## groupdate compatibility
@@ -198,9 +227,17 @@ Or install it yourself as:
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
 Run `BUNDLE_GEMFILE=gemfiles/activerecord60.gemfile bundle` then `BUNDLE_GEMFILE=gemfiles/activerecord60.gemfile rake`
-to test agains specific active record version.
+to test against specific active record version.
+
+To experiment you can load a test database and jump to IRB with
+
+```sh
+   rake VERBOSE=1 CONSOLE=1 TESTOPTS="--name=test_console" test:postgresql
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version
+number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags,
+and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/Rakefile

@@ -1,10 +1,22 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+ADAPTERS = %w[postgresql mysql sqlite]
+
+ADAPTERS.each do |adapter|
+  namespace :test do
+    task("env:#{adapter}") { ENV["ADAPTER"] = adapter }
+
+    Rake::TestTask.new(adapter => "env:#{adapter}") do |t|
+      t.description = "Run tests for #{adapter}"
+      t.libs << "test"
+      t.libs << "lib"
+      t.test_files = FileList["test/**/*_test.rb"]
+    end
+  end
 end
 
+desc "Run all adapter tests"
+task test: ADAPTERS.map { |adapter| "test:#{adapter}" }
+
 task default: :test

data/calculate-all.gemspec

@@ -18,5 +18,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_dependency "activesupport", ">= 4.0.0"
 end

data/gemfiles/activerecord42.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest", "~> 5.0"
+gem "minitest-reporters"
 gem "activerecord", "~> 4.2.0"
 gem "groupdate", "~> 3.0.0"
 gem "pg", "~> 0.15"

data/gemfiles/activerecord50.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest"
+gem "minitest-reporters"
 gem "activerecord", "~> 5.0.0"
 gem "groupdate", "~> 4.0.0"
 gem "pg"

data/gemfiles/activerecord51.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest"
+gem "minitest-reporters"
 gem "activerecord", "~> 5.1.0"
 gem "groupdate", "~> 5.0.0"
 gem "pg"

data/gemfiles/activerecord52.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest"
+gem "minitest-reporters"
 gem "activerecord", "~> 5.2.0"
 gem "groupdate", "~> 5.0.0"
 gem "pg"

data/gemfiles/activerecord60.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest"
+gem "minitest-reporters"
 gem "activerecord", "~> 6.0.0"
 gem "groupdate", "~> 5.0.0"
 gem "pg"

data/gemfiles/activerecord61.gemfile

@@ -4,6 +4,7 @@ gemspec path: ".."
 
 gem "rake"
 gem "minitest"
+gem "minitest-reporters"
 gem "activerecord", "~> 6.1.0"
 gem "groupdate", "~> 5.0.0"
 gem "pg"

data/gemfiles/activerecord70.gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rake"
+gem "minitest"
+gem "minitest-reporters"
+gem "activerecord", "~> 7.0.0"
+gem "groupdate", "~> 5.2.0"
+gem "pg"
+gem "mysql2"
+gem "sqlite3", "~> 1.4"

data/lib/calculate-all/version.rb

@@ -1,3 +1,3 @@
 module CalculateAll
-  VERSION = "0.2.2"
+  VERSION = "0.3.1"
 end

data/lib/calculate-all.rb

@@ -3,54 +3,55 @@ require "calculate-all/version"
 
 module CalculateAll
   # Calculates multiple aggregate values on a scope in one request, similarly to #calculate
-  def calculate_all(*function_aliases, **functions, &block)
-    # If only one aggregate is given without explicit naming,
+  def calculate_all(*expression_shortcuts, **named_expressions, &block)
+    # If only one aggregate is given as a string or Arel.sql without explicit naming,
     # return row(s) directly without wrapping in Hash
-    if function_aliases.size == 1 && functions.size == 0
+    if expression_shortcuts.size == 1 && expression_shortcuts.first.is_a?(String) &&
+        named_expressions.size == 0
       return_plain_values = true
     end
 
-    # Convert the function_aliases to actual SQL
-    functions.merge!(CalculateAll::Helpers.decode_function_aliases(function_aliases))
+    named_expressions = expression_shortcuts.map { |name| [name, name] }.to_h.merge(named_expressions)
 
-    # Check if any functions are given
-    if functions == {}
-      raise ArgumentError, "provide at least one function to calculate"
+    named_expressions.transform_values! do |shortcut|
+      Helpers.decode_expression_shortcut(shortcut, group_values)
     end
 
-    columns = (group_values.map(&:to_s) + functions.values).map { |sql| Arel.sql(sql) }
+    raise ArgumentError, "provide at least one expression to calculate" if named_expressions.empty?
+
+    # Some older active_record versions do not allow for repeating expressions in pluck list,
+    # and named expressions could contain group values.
+    columns = (group_values + named_expressions.values).uniq
+    value_mapping = named_expressions.transform_values { |column| columns.index(column) }
+    columns.map! { |column| column.is_a?(String) ? Arel.sql(column) : column }
+
     results = {}
     pluck(*columns).each do |row|
-      # If pluck called without any groups and with a single argument,
-      # it will return an array of simple results instead of array of arrays
-      if functions.size == 1 && group_values.size == 0
-        row = [row]
-      end
+      # If pluck called with a single argument
+      # it will return an array of scalars instead of array of arrays
+      row = [row] if columns.size == 1
 
       key = if group_values.size == 0
         :ALL
       elsif group_values.size == 1
         # If only one group is provided, the resulting key is just a scalar value
-        row.shift
+        row.first
       else
         # if multiple groups, the key will be an array.
-        row.shift(group_values.size)
+        row.first(group_values.size)
       end
 
-      value = if return_plain_values
-        row.last
-      else
-        # it is possible to have more actual group values returned than group_values.size
-        functions.keys.zip(row.last(functions.size)).to_h
-      end
+      value = value_mapping.transform_values { |index| row[index] }
+
+      value = value.values.last if return_plain_values
 
       results[key] = value
     end
 
     # Additional groupdate magic of filling empty periods with defaults
     if defined?(Groupdate.process_result)
-      # Since that hash is the same instance for every backfilled raw, at least
-      # freeze it to prevent surprize modifications in calling code.
+      # Since that hash is the same instance for every backfilled row, at least
+      # freeze it to prevent surprise modifications across multiple rows in the calling code.
       default_value = return_plain_values ? nil : {}.freeze
       results = Groupdate.process_result(self, results, default_value: default_value)
     end
@@ -68,12 +69,48 @@ module CalculateAll
       results
     end
   end
+
+  # module just to not pollute namespace
+  module Helpers
+    module_function
+
+    # Convert shortcuts like :count_distinct_id to SQL aggregate functions like 'COUNT(DISTINCT ID)'
+    # If shortcut is actually one of the grouping expressions, just return it as-is.
+    def decode_expression_shortcut(shortcut, group_values = [])
+      case shortcut
+      when String
+        shortcut
+      when *group_values
+        shortcut
+      when :count
+        "COUNT(*)"
+      when /^(\w+)_distinct_count$/, /^count_distinct_(\w+)$/
+        "COUNT(DISTINCT #{$1})"
+      when /^(\w+)_(count|sum|max|min|avg)$/
+        "#{$2.upcase}(#{$1})"
+      when /^(count|sum|max|min|avg)_(\w+)$/
+        "#{$1.upcase}(#{$2})"
+      when /^(\w+)_average$/, /^average_(\w+)$/
+        "AVG(#{$1})"
+      when /^(\w+)_maximum$/, /^maximum_(\w+)$/
+        "MAX(#{$1})"
+      when /^(\w+)_minimum$/, /^minimum_(\w+)$/
+        "MIN(#{$1})"
+      else
+        raise ArgumentError, "Can't recognize expression shortcut #{shortcut}"
+      end
+    end
+  end
+
+  module Querying
+    # @see CalculateAll#calculate_all
+    def calculate_all(*args, **kwargs, &block)
+      all.calculate_all(*args, **kwargs, &block)
+    end
+  end
 end
 
 ActiveSupport.on_load(:active_record) do
-  require "calculate-all/helpers"
-  require "calculate-all/querying"
-
   # Make the calculate_all method available for all ActiveRecord::Relations instances
   ActiveRecord::Relation.include CalculateAll
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: calculate-all
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Alexey Trofimenko
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 2025-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
 description: 'Extends Active Record with #calculate_all method'
 email:
 - aronaxis@gmail.com
@@ -47,15 +46,13 @@ files:
 - gemfiles/activerecord52.gemfile
 - gemfiles/activerecord60.gemfile
 - gemfiles/activerecord61.gemfile
+- gemfiles/activerecord70.gemfile
 - lib/calculate-all.rb
-- lib/calculate-all/helpers.rb
-- lib/calculate-all/querying.rb
 - lib/calculate-all/version.rb
 homepage: http://github.com/codesnik/calculate-all
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -63,15 +60,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Fetch from database results of several aggregate functions at once
 test_files: []

data/lib/calculate-all/helpers.rb

@@ -1,33 +0,0 @@
-module CalculateAll
-  module Helpers
-    module_function
-
-    # Convert aliases like :count to SQL aggregate functions like 'COUNT(*)'
-    def decode_function_aliases(aliases)
-      aliases.map do |key|
-        function =
-          case key
-          when String
-            key
-          when :count
-            "COUNT(*)"
-          when /^(.*)_distinct_count$/, /^count_distinct_(.*)$/
-            "COUNT(DISTINCT #{$1})"
-          when /^(.*)_(count|sum|max|min|avg)$/
-            "#{$2.upcase}(#{$1})"
-          when /^(count|sum|max|min|avg)_(.*)$$/
-            "#{$1.upcase}(#{$2})"
-          when /^(.*)_average$/, /^average_(.*)$/
-            "AVG(#{$1})"
-          when /^(.*)_maximum$/, /^maximum_(.*)$/
-            "MAX(#{$1})"
-          when /^(.*)_minimum$/, /^minimum_(.*)$/
-            "MIN(#{$1})"
-          else
-            raise ArgumentError, "Can't recognize function alias #{key}"
-          end
-        [key, function]
-      end.to_h
-    end
-  end
-end

data/lib/calculate-all/querying.rb

@@ -1,8 +0,0 @@
-module CalculateAll
-  module Querying
-    # @see CalculateAll#calculate_all
-    def calculate_all(*args, **kwargs, &block)
-      all.calculate_all(*args, **kwargs, &block)
-    end
-  end
-end