calculate-all 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35426c107c947f1f28da7166c703bade37858910
-  data.tar.gz: 810c8b1b9020a9ec4aef2886b6a6fc523f44340e
+SHA256:
+  metadata.gz: 0ccade1f3bc4b62c2842ef335e27d0c7a11a90fa18e90f3b1260bb572243a4b6
+  data.tar.gz: 9d8dd96e03c6155f828d5fb586a652e9f0d94a5cbb21cfb41fc3c5022772501c
 SHA512:
-  metadata.gz: d90936efd4b9a78893e534b347c92934becc305281a7e2b2e9582644eaf3e063da8311c30a8da2b48ca0fa893024a6800e008af964d21a7f3eb64b4c2789a4d9
-  data.tar.gz: ac2dcf69499e33939e28f5b9bc7cd9582e1796b628910edf1ac20173ce6c373f903d8b958eb94f4840927acfd2ead5b22d3b15be4dbec13f17d31a0debe604a4
+  metadata.gz: df3d5a6c997473a188f824f865951c05ed8d054758906c6647d4c868a55a37cb55cc0c5981b0bbe4106214d386a03c11fcb41211498c58b7f022a779b265d192
+  data.tar.gz: ca3c3d75e899ff84f85886aeb649f86cc81f0612476297102036a7d991ed872819381c9505f7ed34b3713aed508960f71d8377ac986d92599f9bf585fe493d78

data/.github/workflows/build.yml

@@ -0,0 +1,41 @@
+name: build
+on: [push, pull_request]
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - ruby: "3.4"
+          gemfile: Gemfile
+        - ruby: "3.1"
+          gemfile: gemfiles/activerecord70.gemfile
+        - ruby: "3.0"
+          gemfile: gemfiles/activerecord61.gemfile
+        - ruby: "2.7"
+          gemfile: gemfiles/activerecord60.gemfile
+        - ruby: "2.6"
+          gemfile: gemfiles/activerecord52.gemfile
+        - ruby: "2.6"
+          gemfile: gemfiles/activerecord51.gemfile
+        - ruby: "2.6"
+          gemfile: gemfiles/activerecord50.gemfile
+        - ruby: "2.3"
+          gemfile: gemfiles/activerecord42.gemfile
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - uses: ankane/setup-postgres@v1
+      with:
+        database: calculate_all_test
+    - uses: ankane/setup-mysql@v1
+      with:
+        database: calculate_all_test
+    - run: mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
+    - run: bundle exec rake test

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.lock

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 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>)
+* Tested with sqlite3, ruby 3.1, Rails 7
+
+## 0.2.1
+
+* Silence deprecation warnings (Forrest Ye <fye@mutan.io>)
+
+## 0.2.0
+
+* Rails 5 compatibility (Stef Schenkelaars <stef.schenkelaars@gmail.com>)
+
 ## 0.1.1
 
 * groupdate compatibility

data/Gemfile

@@ -1,7 +1,16 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in calculate-all.gemspec
 gemspec
 
-gem 'activerecord'
-gem 'pry'
+gem "rake"
+gem "minitest"
+gem "minitest-reporters"
+gem "activerecord", "~> 8.0.0"
+gem "groupdate", "~> 6"
+gem "pg"
+gem "mysql2"
+gem "sqlite3", ">= 2.1"
+
+gem "ostruct"
+
+gem "standardrb", require: false

data/README.md

@@ -1,36 +1,48 @@
 # CalculateAll
 
-Provides `#calculate_all` method on your Active Record models, scopes and relations.
-It's a little addition to Active Record's `#count`, `#maximum`, `#minimum`, `#average` and `#sum`.
-It allows to fetch all of the above and any other aggregate functions results in one request, with respect to grouping.
+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`, `#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.
 
-Tested only with Postgres and MySQL only right now. It relies on automatic values type-casting of underlying driver.
+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: #<BigDecimal:7ff5932ff3d8,'0.3E3',9(27)>,
-#     price_median: #<BigDecimal:7ff5932ff3c2,'0.4E3',9(27)>
+#     price_avg: 0.3e3,
+#     total_users: 5,
+#     price_median: 0.4e3,
+#     plan_ids: [4, 7, 12],
+#     earnings: 2340
 #   },
-#   [1, "card"] => {
+#   [1, "cash"] => {
 #     ...
 #   }
 # }
@@ -38,39 +50,37 @@ stats = Order.group(:department_id).group(:payment_method).calculate_all(
 
 ## Rationale
 
-Active Record allows to use most common DB aggregate functions, COUNT(), MAX(), MIN(), AVG(), SUM() really easy.
-But there's a whole world of wonderful other functions in
-[Postgres](http://www.postgresql.org/docs/9.5/static/functions-aggregate.html) which I can't recommend enough
-if you going to have any work with statistics and BI on your data, though MySQL has something
-[too](http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html).
+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 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 several metrics at once, and database often has to perform a full scan on
-the table for each metric, but it as well can calculate them all in one scan and one request.
+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.
 
 `#calculate_all` to the rescue!
 
 ## Arguments
 
-`#calculate_all` accepts a list of expression aliases and/or expression mapping.
-It could be either one 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)'
+  )
 ```
-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 `caculate(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
 |------------------------------------------------------------------------|------------
@@ -82,28 +92,30 @@ 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.
+
 ## Result
 
 `#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 useless example
-# but you can have 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 one group, it will return hash of results, with simple keys.
+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},
 #   ...
 # }
 ```
@@ -111,31 +123,42 @@ 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 just one argument to `#calculate_all`, its calculated value will be returned as is.
-Otherwise results would 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},
 #   ...
 # }
 ```
 
-You can pass block to calculate_all. Rows will be passed to it and returned value will be used instead of
-row in result hash (or returned as is if there's no grouping)
+You can pass a block to `calculate_all`. Rows will be passed to it, and returned value will be used instead of
+the row in the result hash (or returned as-is if there's no grouping).
 
 ```ruby
 Order.group(:country_id).calculate_all(:count, :avg_price) { |count:, avg_price:|
@@ -146,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
@@ -154,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_price800>
+# }
 ```
 
 ## groupdate compatibility
@@ -161,16 +195,18 @@ Order.calculate_all(:count, :max_price, &OpenStruct.method(:new))
 calculate-all should work with [groupdate](https://github.com/ankane/groupdate) too:
 
 ```ruby
-Order.group_by_year(:created_at, last: 5, default_value: {}).calculate_all(:price_min, :price_max)
-=> {
-  Sun, 01 Jan 2012 => {},
-  Tue, 01 Jan 2013 => {},
-  Wed, 01 Jan 2014 => {},
-  Thu, 01 Jan 2015 => {},
-  Fri, 01 Jan 2016 => {:price_min=>100, :price_max=>500}
-}
+Order.group_by_year(:created_at, last: 5).calculate_all(:price_min, :price_max)
+# => {
+#   Sun, 01 Jan 2012 => {},
+#   Tue, 01 Jan 2013 => {},
+#   Wed, 01 Jan 2014 => {},
+#   Thu, 01 Jan 2015 => {},
+#   Fri, 01 Jan 2016 => {:price_min=>100, :price_max=>500}
+# }
 ```
 
+It works even with groupdate < 4, though you'd have to explicitly provide `default_value: {}` for blank periods.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -189,9 +225,19 @@ Or install it yourself as:
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+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 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'
+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
 
-task :default => :test
+desc "Run all adapter tests"
+task test: ADAPTERS.map { |adapter| "test:#{adapter}" }
+
+task default: :test

data/bin/setup

@@ -2,6 +2,9 @@
 set -euo pipefail
 IFS=$'\n\t'
 
+echo "Installing gems..."
 bundle install
-
-# Do any other automated setup that you need to do here
+echo "Creating postgres database..."
+createdb calculate_all_test || echo "...failed"
+echo "Creating mysql database..."
+mysqladmin -u root create calculate_all_test || echo "...failed"

data/calculate-all.gemspec

@@ -1,30 +1,24 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'calculate-all/version'
+require "calculate-all/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "calculate-all"
-  spec.version       = CalculateAll::VERSION
-  spec.authors       = ["codesnik"]
-  spec.email         = ["aronaxis@gmail.com"]
+  spec.name = "calculate-all"
+  spec.version = CalculateAll::VERSION
+  spec.authors = ["Alexey Trofimenko"]
+  spec.email = ["aronaxis@gmail.com"]
 
-  spec.summary       = %q{Fetch from database results of several aggregate functions at once}
-  spec.description   = %q{Extends Active Record with #calculate_all method}
-  spec.homepage      = "http://github.com/codesnik/calculate-all"
-  spec.license       = "MIT"
+  spec.summary = "Fetch from database results of several aggregate functions at once"
+  spec.description = "Extends Active Record with #calculate_all method"
+  spec.homepage = "http://github.com/codesnik/calculate-all"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord"
+  spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "pg"
-  spec.add_development_dependency "mysql2"
-  spec.add_development_dependency "groupdate"
+  spec.add_dependency "activesupport", ">= 4.0.0"
 end

data/gemfiles/activerecord42.gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+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"
+gem "mysql2"
+gem "sqlite3", "~> 1.3.0"

data/gemfiles/activerecord50.gemfile

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

data/gemfiles/activerecord51.gemfile

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

data/gemfiles/activerecord52.gemfile

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

data/gemfiles/activerecord60.gemfile

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

data/gemfiles/activerecord61.gemfile

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

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.1'
+  VERSION = "0.3.0"
 end

data/lib/calculate-all.rb

@@ -1,89 +1,125 @@
-require 'calculate-all/version'
-require 'calculate-all/helpers'
-require 'calculate-all/querying'
+require "active_support"
+require "calculate-all/version"
 
 module CalculateAll
-  # Method to aggregate function results in one request
-  def calculate_all(*function_aliases, **functions, &block)
-
-    # If only one function_alias is given, the result can be just a single value
-    # So return [{ cash: 3 }] instead of [{ cash: { count: 3 }}]
-    if function_aliases.size == 1 && functions == {}
+  # Calculates multiple aggregate values on a scope in one request, similarly to #calculate
+  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 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
 
-    # If function is called without a group, the pluck method will still return
-    # an array but it is an array with the final results instead of each group
-    # The plain_rows boolean states how the results should be used
-    if functions.size == 1 && group_values.size == 0
-      plain_rows = true
-    end
+    raise ArgumentError, "provide at least one expression to calculate" if named_expressions.empty?
 
-    # Final output hash
-    results = {}
+    # 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 }
 
-    # Fetch all the requested calculations from the database
-    # Note the map(&:to_s). It is required since groupdate returns a
-    # Groupdate::OrderHack instead of a string for the group_values which is not
-    # accepted by ActiveRecord's pluck method.
-    sql_snippets = group_values.map(&:to_s) + functions.values
-    # Fix DEPRECATION WARNING:
-    # Dangerous query method, will be disallowed in Rails 6.0
-    # using Arel.sql() to silence the warning
-    # https://github.com/rails/rails/commit/310c3a8f2d043f3d00d3f703052a1e160430a2c2
-    pluck(*sql_snippets.map { |sql| Arel.sql(sql) }).each do |row|
-
-      # If no grouping, make sure it is still a results array
-      row = [row] if plain_rows
-
-      # If only one value, return a single value, else return a hash
-      if return_plain_values
-        value = row.last
+    results = {}
+    pluck(*columns).each do |row|
+      # If pluck called with with a single argument
+      # it will return an array of sclars 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.first
       else
-        value = functions.keys.zip(row.last(functions.size)).to_h
+        # if multiple groups, the key will be an array.
+        row.first(group_values.size)
       end
 
-      # Call the block for each group
-      value = block.call(value) if block
+      value = value_mapping.transform_values { |index| row[index] }
 
-      # Return unwrapped hash directly for scope without any .group()
-      return value if group_values.empty?
+      value = value.values.last if return_plain_values
 
-      # If only one group is provided, the resulting key is just the group name
-      # if multiple group methods are provided, the key will be an array.
-      if group_values.size == 1
-        key = row.first
-      else
-        key = row.first(group_values.size)
+      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 row, at least
+      # freeze it to prevent surprize 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
+
+    if block
+      results.transform_values! do |value|
+        return_plain_values ? block.call(value) : block.call(**value)
       end
+    end
 
-      # Set the value in the output array
-      results[key] = value
+    # Return unwrapped hash directly for scope without any .group()
+    if group_values.empty?
+      results[:ALL]
+    else
+      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 #{key}"
+      end
     end
+  end
 
-    # Return the output array
-    results
+  module Querying
+    # @see CalculateAll#calculate_all
+    def calculate_all(*args, **kwargs, &block)
+      all.calculate_all(*args, **kwargs, &block)
+    end
   end
 end
 
-# Make the calculate_all method available for all ActiveRecord::Relations instances
-ActiveRecord::Relation.include CalculateAll
+ActiveSupport.on_load(:active_record) do
+  # Make the calculate_all method available for all ActiveRecord::Relations instances
+  ActiveRecord::Relation.include CalculateAll
 
-# Make the calculate_all method available for all ActiveRecord::Base classes
-# You can for example call Orders.calculate_all(:count, :sum_cents)
-ActiveRecord::Base.extend CalculateAll::Querying
+  # Make the calculate_all method available for all ActiveRecord::Base classes
+  # You can for example call Orders.calculate_all(:count, :sum_cents)
+  ActiveRecord::Base.extend CalculateAll::Querying
 
-# A hack for groupdate since it checks if the calculate_all method is defined
-# on the ActiveRecord::Calculations module. It is never called but it is just
-# needed for the check.
-ActiveRecord::Calculations.include CalculateAll::Querying
+  # A hack for groupdate 3.0 since it checks if the calculate_all method is defined
+  # on the ActiveRecord::Calculations module. It is never called but it is just
+  # needed for the check.
+  ActiveRecord::Calculations.include CalculateAll::Querying
+end

metadata

@@ -1,113 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: calculate-all
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
-- codesnik
-autorequire: 
+- Alexey Trofimenko
 bindir: exe
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2025-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     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'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: groupdate
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  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
@@ -115,26 +30,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/build.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - _config.yml
-- bin/console
 - bin/setup
 - calculate-all.gemspec
+- gemfiles/activerecord42.gemfile
+- gemfiles/activerecord50.gemfile
+- gemfiles/activerecord51.gemfile
+- 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
@@ -142,16 +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: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Fetch from database results of several aggregate functions at once
 test_files: []

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.0
-before_install: gem install bundler -v 1.10.6

data/bin/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'calculate-all'
-
-require './test/test_helper'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new(STDERR)
-require 'pry'
-Pry.start

data/lib/calculate-all/helpers.rb

@@ -1,32 +0,0 @@
-module CalculateAll
-  module Helpers
-    module_function
-    # Method to convert function aliases like :count to SQL commands 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,5 +0,0 @@
-module CalculateAll
-  module Querying
-    delegate :calculate_all, to: :all
-  end
-end