rollups 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac85a23af0477ab8ce7abed983995b06a935f82c2836fc0a63ff1fe4b150b9d7
+  data.tar.gz: bb60e3c7c87e22e68a4ba94652e011031292ce879d60824f745d7f808055684c
+SHA512:
+  metadata.gz: abee36f374c42202b8a13919ff863aef511af7c28258eb5f657b0b00de4d8f9d329d53d1f58768377372eae428c09b7f223fbcdeb2b7a43a87339fbe3d9f3e9e
+  data.tar.gz: 452951f5d6a8fda80288650b7061e0e17ab9bfd76a2638a7f529b4919ec2933fb725b07e6f85392665fd4e44b69790eed1d69b88341122aa8338640e4b45c868

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2020-09-07)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Andrew Kane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,386 @@
+# Rollup
+
+:fire: Rollup time-series data in Rails
+
+Works great with [Ahoy](https://github.com/ankane/ahoy) and [Searchjoy](https://github.com/ankane/searchjoy)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'rollups'
+```
+
+For Rails < 6, also add:
+
+```ruby
+gem 'activerecord-import'
+```
+
+And run:
+
+```sh
+bundle install
+rails generate rollups
+rails db:migrate
+```
+
+## Contents
+
+- [Getting Started](#getting-started)
+- [Creating Rollups](#creating-rollups)
+- [Querying Rollups](#querying-rollups)
+- [Other Topics](#other-topics)
+- [Examples](#examples)
+
+## Getting Started
+
+Store the number of users created by day in the `rollups` table
+
+```ruby
+User.rollup("New users")
+```
+
+Get the series
+
+```ruby
+Rollup.series("New users")
+# {
+#   Sat, 24 May 2020 => 50,
+#   Sun, 25 May 2020 => 100,
+#   Mon, 26 May 2020 => 34
+# }
+```
+
+Use a rake task or background job to create rollups on a regular basis. Don’t worry too much about naming - you can [rename](#naming) later if needed.
+
+## Creating Rollups
+
+### Time Column
+
+Specify the time column - `created_at` by default
+
+```ruby
+User.rollup("New users", column: :joined_at)
+```
+
+Change the default column for a model
+
+```ruby
+class User < ApplicationRecord
+  self.rollup_column = :joined_at
+end
+```
+
+### Time Intervals
+
+Specify the interval - `day` by default
+
+```ruby
+User.rollup("New users", interval: "week")
+```
+
+And when querying
+
+```ruby
+Rollup.series("New users", interval: "week")
+```
+
+Supported intervals are:
+
+- hour
+- day
+- week
+- month
+- quarter
+- year
+
+Or any number of minutes or seconds:
+
+- 1m, 5m, 15m
+- 1s, 30s, 90s
+
+Weeks start on Sunday by default. Change this with:
+
+```ruby
+Rollup.week_start = :monday
+```
+
+### Time Zones
+
+The default time zone is `Time.zone`. Change this with:
+
+```ruby
+Rollup.time_zone = "Pacific Time (US & Canada)"
+```
+
+or
+
+```ruby
+User.rollup("New users", time_zone: "Pacific Time (US & Canada)")
+```
+
+Time zone objects also work. To see a list of available time zones in Rails, run `rake time:zones:all`.
+
+See [date storage](#date-storage) for how dates are stored.
+
+### Calculations
+
+Rollups use `count` by default. For other calculations, use:
+
+```ruby
+Order.rollup("Revenue") { |r| r.sum(:revenue) }
+```
+
+Works with `count`, `sum`, `minimum`, `maximum`, and `average`. For `median` and `percentile`, check out [ActiveMedian](https://github.com/ankane/active_median).
+
+### Dimensions
+
+*PostgreSQL only*
+
+Create rollups with dimensions
+
+```ruby
+Order.group(:platform).rollup("Orders by platform")
+```
+
+Works with multiple groups as well
+
+```ruby
+Order.group(:platform, :channel).rollup("Orders by platform and channel")
+```
+
+Dimension names are determined by the `group` clause. To set manually, use:
+
+```ruby
+Order.group(:channel).rollup("Orders by source", dimension_names: ["source"])
+```
+
+See how to [query dimensions](#multiple-series).
+
+### Updating Data
+
+When you run a rollup for the first time, the entire series is calculated. When you run it again, newer data is added.
+
+By default, the latest interval stored for a series is recalculated, since it was likely calculated before the interval completed. Earlier intervals aren’t recalculated since the source rows may have been deleted (this also improves performance).
+
+To recalculate the last few intervals, use:
+
+```ruby
+User.rollup("New users", last: 3)
+```
+
+To only store data for completed intervals, use:
+
+```ruby
+User.rollup("New users", current: false)
+```
+
+To clear and recalculate the entire series, use:
+
+```ruby
+User.rollup("New users", clear: true)
+```
+
+To delete a series, use:
+
+```ruby
+Rollup.where(name: "New users", interval: "day").delete_all
+```
+
+## Querying Rollups
+
+### Single Series
+
+Get a series
+
+```ruby
+Rollup.series("New users")
+```
+
+Specify the interval if it’s not day
+
+```ruby
+Rollup.series("New users", interval: "week")
+```
+
+If a series has dimensions, they must match exactly as well
+
+```ruby
+Rollup.series("Orders by platform and channel", dimensions: {platform: "Web", channel: "Search"})
+```
+
+### Multiple Series
+
+*PostgreSQL only*
+
+Get multiple series grouped by dimensions
+
+```ruby
+Rollup.multi_series("Orders by platform")
+```
+
+Specify the interval if it’s not day
+
+```ruby
+Rollup.multi_series("Orders by platform", interval: "week")
+```
+
+Filter by dimensions
+
+```ruby
+Rollup.where_dimensions(platform: "Web").multi_series("Orders by platform and channel")
+```
+
+### Raw Data
+
+Uses the `Rollup` model to query the data directly
+
+```ruby
+Rollup.where(name: "New users", interval: "day")
+```
+
+### List
+
+List names and intervals
+
+```ruby
+Rollup.list
+```
+
+### Charts
+
+Rollup works great with [Chartkick](https://github.com/ankane/chartkick)
+
+```erb
+<%= line_chart Rollup.series("New users") %>
+```
+
+For multiple series, set a `name` for each series before charting
+
+```ruby
+series = Rollup.multi_series("Orders by platform")
+series.each do |s|
+  s[:name] = s[:dimensions]["platform"]
+end
+```
+
+## Other Topics
+
+### Naming
+
+Use any naming convention you prefer. Some ideas are:
+
+- Human - `New users`
+- Underscore - `new_users`
+- Dots - `new_users.count`
+
+Rename with:
+
+```ruby
+Rollup.rename("Old name", "New name")
+```
+
+### Date Storage
+
+Rollup stores both dates and times in the `time` column depending on the interval. For date intervals (day, week, etc), it stores `00:00:00` for the time part. Cast the `time` column to a date when querying in SQL to get the correct value.
+
+- PostgreSQL: `time::date`
+- MySQL: `CAST(time AS date)`
+- SQLite: `date(time)`
+
+## Examples
+
+- [Ahoy](#ahoy)
+- [Searchjoy](#searchjoy)
+
+### Ahoy
+
+Set the default rollup column for your models
+
+```ruby
+class Ahoy::Visit < ApplicationRecord
+  self.rollup_column = :started_at
+end
+```
+
+and
+
+```ruby
+class Ahoy::Event < ApplicationRecord
+  self.rollup_column = :time
+end
+```
+
+Hourly visits
+
+```ruby
+Ahoy::Visit.rollup("Visits", interval: "hour")
+```
+
+Visits by browser
+
+```ruby
+Ahoy::Visit.group(:browser).rollup("Visits by browser")
+```
+
+Unique homepage views
+
+```ruby
+Ahoy::Event.where(name: "Viewed homepage").joins(:visit).rollup("Homepage views") { |r| r.distinct.count(:visitor_token) }
+```
+
+Product views
+
+```ruby
+Ahoy::Event.where(name: "Viewed product").group_prop(:product_id).rollup("Product views")
+```
+
+### Searchjoy
+
+Daily searches
+
+```ruby
+Searchjoy::Search.rollup("Searches")
+```
+
+Searches by query
+
+```ruby
+Searchjoy::Search.group(:normalized_query).rollup("Searches by query", dimension_names: ["query"])
+```
+
+Conversion rate
+
+```ruby
+Searchjoy::Search.rollup("Search conversion rate") { |r| r.average("(converted_at IS NOT NULL)::int") }
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/rollup/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/rollup/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/rollup/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/rollup.git
+cd rollup
+bundle install
+
+# create databases
+createdb rollup_test
+mysqladmin create rollup_test
+
+# run tests
+bundle exec rake test
+```

data/lib/generators/rollups_generator.rb

@@ -0,0 +1,26 @@
+require "rails/generators/active_record"
+
+# use rollups instead of rollup:install to avoid
+# class Rollup < ActiveRecord::Base
+# also works out nicely since it's the gem name
+class RollupsGenerator < Rails::Generators::Base
+  include ActiveRecord::Generators::Migration
+  source_root File.join(__dir__, "templates")
+
+  def copy_templates
+    migration_template migration_source, "db/migrate/create_rollups.rb", migration_version: migration_version
+  end
+
+  def migration_source
+    case ActiveRecord::Base.connection_config[:adapter].to_s
+    when /postg/i
+      "dimensions.rb"
+    else
+      "standard.rb"
+    end
+  end
+
+  def migration_version
+    "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+  end
+end

data/lib/generators/templates/dimensions.rb.tt

@@ -0,0 +1,12 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :rollups do |t|
+      t.string :name, null: false
+      t.string :interval, null: false
+      t.datetime :time, null: false
+      t.jsonb :dimensions, null: false, default: {}
+      t.float :value
+    end
+    add_index :rollups, [:name, :interval, :time, :dimensions], unique: true
+  end
+end

data/lib/generators/templates/standard.rb.tt

@@ -0,0 +1,11 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :rollups do |t|
+      t.string :name, null: false
+      t.string :interval, null: false
+      t.datetime :time, null: false
+      t.float :value
+    end
+    add_index :rollups, [:name, :interval, :time], unique: true
+  end
+end

data/lib/rollup.rb

@@ -0,0 +1,98 @@
+class Rollup < ActiveRecord::Base
+  validates :name, presence: true
+  validates :interval, presence: true
+  validates :time, presence: true
+
+  class << self
+    attr_accessor :week_start
+    attr_writer :time_zone
+  end
+  self.week_start = :sunday
+
+  class << self
+    # do not memoize so Time.zone can change
+    def time_zone
+      (defined?(@time_zone) && @time_zone) || Time.zone || "Etc/UTC"
+    end
+
+    def series(name, interval: "day", dimensions: {})
+      Utils.check_dimensions if dimensions.any?
+
+      relation = where(name: name, interval: interval)
+      relation = relation.where(dimensions: dimensions) if Utils.dimensions_supported?
+
+      # use select_all due to incorrect casting with pluck
+      sql = relation.order(:time).select(Utils.time_sql(interval), :value).to_sql
+      result = connection.select_all(sql).rows
+
+      Utils.make_series(result, interval)
+    end
+
+    def multi_series(name, interval: "day")
+      Utils.check_dimensions
+
+      relation = where(name: name, interval: interval)
+
+      # use select_all to reduce allocations
+      sql = relation.order(:time).select(Utils.time_sql(interval), :value, :dimensions).to_sql
+      result = connection.select_all(sql).rows
+
+      result.group_by { |r| JSON.parse(r[2]) }.map do |dimensions, rollups|
+        {dimensions: dimensions, data: Utils.make_series(rollups, interval)}
+      end
+    end
+
+    def where_dimensions(dimensions)
+      Utils.check_dimensions
+
+      relation = self
+      dimensions.each do |k, v|
+        k = k.to_s
+        relation =
+          if v.nil?
+            relation.where("dimensions ->> ? IS NULL", k)
+          elsif v.is_a?(Array)
+            relation.where("dimensions ->> ? IN (?)", k, v.map { |vi| vi.as_json.to_s })
+          else
+            relation.where("dimensions ->> ? = ?", k, v.as_json.to_s)
+          end
+      end
+      relation
+    end
+
+    def list
+      select(:name, :interval).distinct.order(:name, :interval).map do |r|
+        {name: r.name, interval: r.interval}
+      end
+    end
+
+    # TODO maybe use in_batches
+    def rename(old_name, new_name)
+      where(name: old_name).update_all(name: new_name)
+    end
+  end
+
+  # feels cleaner than overriding _read_attribute
+  def inspect
+    if Utils.date_interval?(interval)
+      previous_time = time_before_type_cast
+      previous_time = previous_time.to_s(:db) if previous_time.is_a?(Time)
+      previous_time = previous_time + " 00:00:00" if previous_time.length == 10
+      super.sub("time: \"#{previous_time}\"", "time: \"#{time.to_s(:db)}\"")
+    else
+      super
+    end
+  end
+
+  def time
+    if Utils.date_interval?(interval) && !time_before_type_cast.nil?
+      if time_before_type_cast.is_a?(Time)
+        time_before_type_cast.utc.to_date
+      else
+        Date.parse(time_before_type_cast.to_s)
+      end
+    else
+      super
+    end
+  end
+end

data/lib/rollup/aggregator.rb

@@ -0,0 +1,178 @@
+class Rollup
+  class Aggregator
+    def initialize(klass)
+      @klass = klass # or relation
+    end
+
+    def rollup(name, column: nil, interval: "day", dimension_names: nil, time_zone: nil, current: true, last: nil, clear: false, &block)
+      raise "Name can't be blank" if name.blank?
+
+      column ||= @klass.rollup_column || :created_at
+      validate_column(column)
+
+      relation = perform_group(name, column: column, interval: interval, time_zone: time_zone, current: current, last: last, clear: clear)
+      result = perform_calculation(relation, &block)
+
+      dimension_names = set_dimension_names(dimension_names, relation)
+      records = prepare_result(result, name, dimension_names, interval)
+
+      maybe_clear(clear, name, interval) do
+        save_records(records) if records.any?
+      end
+    end
+
+    # basic version of Active Record disallow_raw_sql!
+    # symbol = column (safe), Arel node = SQL (safe), other = untrusted
+    # no need to quote/resolve column here, as Groupdate handles it
+    # TODO remove this method when gem depends on Groupdate 6+
+    def validate_column(column)
+      # matches table.column and column
+      unless column.is_a?(Symbol) || column.is_a?(Arel::Nodes::SqlLiteral) || /\A\w+(\.\w+)?\z/i.match(column.to_s)
+        raise "Non-attribute argument: #{column}. Use Arel.sql() for known-safe values"
+      end
+    end
+
+    def perform_group(name, column:, interval:, time_zone:, current:, last:, clear:)
+      raise ArgumentError, "Cannot use last and clear together" if last && clear
+
+      gd_options = {
+        current: current
+      }
+
+      # make sure Groupdate global options aren't applied
+      gd_options[:time_zone] = time_zone || Rollup.time_zone
+      gd_options[:week_start] = Rollup.week_start if interval.to_s == "week"
+      gd_options[:day_start] = 0 if Utils.date_interval?(interval)
+
+      if last
+        gd_options[:last] = last
+      elsif !clear
+        # if no rollups, compute all intervals
+        # if rollups, recompute last interval
+        max_time = Rollup.where(name: name, interval: interval).maximum(Utils.time_sql(interval))
+        if max_time
+          # aligns perfectly if time zone doesn't change
+          # if time zone does change, there are other problems besides this
+          gd_options[:range] = max_time..
+        end
+      end
+
+      # intervals are stored as given
+      # we don't normalize intervals (i.e. change 60s -> 1m)
+      case interval.to_s
+      when "hour", "day", "week", "month", "quarter", "year"
+        @klass.group_by_period(interval, column, **gd_options)
+      when /\A\d+s\z/
+        @klass.group_by_second(column, n: interval.to_i, **gd_options)
+      when /\A\d+m\z/
+        @klass.group_by_minute(column, n: interval.to_i, **gd_options)
+      else
+        raise ArgumentError, "Invalid interval: #{interval}"
+      end
+    end
+
+    def set_dimension_names(dimension_names, relation)
+      groups = relation.group_values[0..-2]
+
+      if dimension_names
+        Utils.check_dimensions
+        if dimension_names.size != groups.size
+          raise ArgumentError, "Expected dimension_names to be size #{groups.size}, not #{dimension_names.size}"
+        end
+        dimension_names
+      else
+        Utils.check_dimensions if groups.any?
+        groups.map { |group| determine_dimension_name(group) }
+      end
+    end
+
+    def determine_dimension_name(group)
+      # split by ., ->>, and -> and remove whitespace
+      value = group.to_s.split(/\s*((\.)|(->>)|(->))\s*/).last
+
+      # removing starting and ending quotes
+      # for simplicity, they don't need to be the same
+      value = value[1..-2] if value.match(/\A["'`].+["'`]\z/)
+
+      unless value.match(/\A\w+\z/)
+        raise "Cannot determine dimension name: #{group}. Use the dimension_names option"
+      end
+
+      value
+    end
+
+    # calculation can mutate relation, but that's fine
+    def perform_calculation(relation, &block)
+      if block_given?
+        yield(relation)
+      else
+        relation.count
+      end
+    end
+
+    def prepare_result(result, name, dimension_names, interval)
+      raise "Expected calculation to return Hash, not #{result.class.name}" unless result.is_a?(Hash)
+
+      time_class = Utils.date_interval?(interval) ? Date : Time
+      dimensions_supported = Utils.dimensions_supported?
+      expected_key_size = dimension_names.size + 1
+
+      result.map do |key, value|
+        dimensions = {}
+        if dimensions_supported && dimension_names.any?
+          unless key.is_a?(Array) && key.size == expected_key_size
+            raise "Expected result key to be Array with size #{expected_key_size}"
+          end
+          time = key[-1]
+          # may be able to support dimensions in SQLite by sorting dimension names
+          dimension_names.each_with_index do |dn, i|
+            dimensions[dn] = key[i]
+          end
+        else
+          time = key
+        end
+
+        raise "Expected time to be #{time_class.name}, not #{time.class.name}" unless time.is_a?(time_class)
+        raise "Expected value to be Numeric or nil, not #{value.class.name}" unless value.is_a?(Numeric) || value.nil?
+
+        record = {
+          name: name,
+          interval: interval,
+          time: time,
+          value: value
+        }
+        record[:dimensions] = dimensions if dimensions_supported
+        record
+      end
+    end
+
+    def maybe_clear(clear, name, interval)
+      if clear
+        Rollup.transaction do
+          Rollup.where(name: name, interval: interval).delete_all
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def save_records(records)
+      # order must match unique index
+      # consider using index name instead
+      conflict_target = [:name, :interval, :time]
+      conflict_target << :dimensions if Utils.dimensions_supported?
+
+      if ActiveRecord::VERSION::MAJOR >= 6
+        options = Utils.mysql? ? {} : {unique_by: conflict_target}
+        Rollup.upsert_all(records, **options)
+      else
+        update = Utils.mysql? ? [:value] : {columns: [:value], conflict_target: conflict_target}
+        Rollup.import(records,
+          on_duplicate_key_update: update,
+          validate: false
+        )
+      end
+    end
+  end
+end

data/lib/rollup/model.rb

@@ -0,0 +1,10 @@
+class Rollup
+  module Model
+    attr_accessor :rollup_column
+
+    def rollup(*args, **options, &block)
+      Aggregator.new(self).rollup(*args, **options, &block)
+      nil
+    end
+  end
+end

data/lib/rollup/utils.rb

@@ -0,0 +1,75 @@
+class Rollup
+  module Utils
+    DATE_INTERVALS = %w(day week month quarter year)
+
+    class << self
+      def time_sql(interval)
+        if date_interval?(interval)
+          if postgresql?
+            "rollups.time::date"
+          elsif sqlite?
+            "date(rollups.time)"
+          else
+            "CAST(rollups.time AS date)"
+          end
+        else
+          :time
+        end
+      end
+
+      def date_interval?(interval)
+        DATE_INTERVALS.include?(interval.to_s)
+      end
+
+      def dimensions_supported?
+        unless defined?(@dimensions_supported)
+          @dimensions_supported = postgresql? && Rollup.column_names.include?("dimensions")
+        end
+        @dimensions_supported
+      end
+
+      def check_dimensions
+        raise "Dimensions not supported" unless dimensions_supported?
+      end
+
+      def adapter_name
+        Rollup.connection.adapter_name
+      end
+
+      def postgresql?
+        adapter_name =~ /postg/i
+      end
+
+      def mysql?
+        adapter_name =~ /mysql/i
+      end
+
+      def sqlite?
+        adapter_name =~ /sqlite/i
+      end
+
+      def make_series(result, interval)
+        series = {}
+        if Utils.date_interval?(interval)
+          result.each do |row|
+            series[row[0].to_date] = row[1]
+          end
+        else
+          time_zone = Rollup.time_zone
+          if result.any? && result[0][0].is_a?(Time)
+            result.each do |row|
+              series[row[0].in_time_zone(time_zone)] = row[1]
+            end
+          else
+            utc = ActiveSupport::TimeZone["Etc/UTC"]
+            result.each do |row|
+              # row can be time or string
+              series[utc.parse(row[0]).in_time_zone(time_zone)] = row[1]
+            end
+          end
+        end
+        series
+      end
+    end
+  end
+end

data/lib/rollup/version.rb

@@ -0,0 +1,5 @@
+class Rollup
+  # not used in gemspec to avoid superclass mismatch
+  # be sure to update there as well
+  VERSION = "0.1.0"
+end

data/lib/rollups.rb

@@ -0,0 +1,16 @@
+# dependencies
+require "active_support"
+require "groupdate"
+
+ActiveSupport.on_load(:active_record) do
+  # must come first
+  require "rollup"
+
+  require "rollup/model"
+  extend Rollup::Model
+
+  # modules
+  require "rollup/aggregator"
+  require "rollup/utils"
+  require "rollup/version"
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: rollups
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: groupdate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: sqlite3
+  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'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/generators/rollups_generator.rb
+- lib/generators/templates/dimensions.rb.tt
+- lib/generators/templates/standard.rb.tt
+- lib/rollup.rb
+- lib/rollup/aggregator.rb
+- lib/rollup/model.rb
+- lib/rollup/utils.rb
+- lib/rollup/version.rb
+- lib/rollups.rb
+homepage: https://github.com/ankane/rollup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Rollup time-series data in Rails
+test_files: []