eager_group 0.5.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3ddfe7747a2b77e9f26cbbbb0029b41acb03b88b
-  data.tar.gz: 5357c3d44af2542594fc5ea593029cd3e3c5cc7e
+SHA256:
+  metadata.gz: 27ca5cd0d0757f48f272d4349a6dcad1f54992946d960f364bec0086a7646ccf
+  data.tar.gz: 27d7def8639caca795400ba7912789ba7098315578ec954dfb2610fe5a6262af
 SHA512:
-  metadata.gz: 80419fb36e918d83f69487633330ffd607d806abaed2ff0a10ecd28134402968105c336aa31e90d361511dc717f3d3bfa3deb7a8a2892663e2a7efc7348ad862
-  data.tar.gz: ca82b49a3007370aebc5b3f2db9d85d51b3aeda6ee800a16dc20a3bda5a8b136c96bfbcfc7ffeb6523a110ef4083c20859ed0d31abb3cf6df4fe2b450d3d5c04
+  metadata.gz: 464cafc22781b01be11027b832219b1dc551f0b3c300f3b377296690c0b9e7d4e98dde5f87c7e9ad8f4f88792ed4b908e00347ab95042a66412a3ef1d31731b6
+  data.tar.gz: 81aaa99f6d856239dba7e1a06fe4d8e2fb2781e5cb98557d142eac440a658cb4ea2a90c354ea82b33b91dcd2f2fa9452a64cf6f2e0c749282937d682fee62618

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Next Release
 
+## 0.7.2 (10/10/2019)
+
+* Simplify `association_klass` for `first_object` and `last_object`
+
+## 0.7.1 (08/23/2019)
+
+* Set `eager_group_definitions` by `mattr_accessor`
+
+## 0.7.0 (08/22/2019)
+
+* Add `first_object` and `last_object` aggregation
+
+## 0.6.1 (03/05/2018)
+
+* Skip preload when association is empty
+
+## 0.6.0 (12/15/2018)
+
+* Support hash as `eager_group` argument
+* Support rails 5.x
+
 ## 0.5.0 (09/22/2016)
 
 * Add magic method for one record

data/README.md

@@ -1,34 +1,44 @@
 # EagerGroup
 
-[![Build Status](https://secure.travis-ci.org/xinminlabs/eager_group.png)](http://travis-ci.org/xinminlabs/eager_group)
+[![Build Status](https://secure.travis-ci.org/flyerhzm/eager_group.png)](http://travis-ci.org/flyerhzm/eager_group)
+[![AwesomeCode Status for
+flyerhzm/eager_group](https://awesomecode.io/projects/e5386790-9420-4003-831a-c9a8c8a48108/status)](https://awesomecode.io/repos/flyerhzm/eager_group)
 
-[More explaination on our blog](http://blog.xinminlabs.com/2015/06/29/eager_group/)
+[More explaination on our blog](http://blog.flyerhzm.com/2015/06/29/eager_group/)
 
 Fix n+1 aggregate sql functions for rails, like
 
-    SELECT "posts".* FROM "posts";
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 1 AND "comments"."status" = 'approved'
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 2 AND "comments"."status" = 'approved'
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 3 AND "comments"."status" = 'approved'
+```
+SELECT "posts".* FROM "posts";
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 1 AND "comments"."status" = 'approved'
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 2 AND "comments"."status" = 'approved'
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 3 AND "comments"."status" = 'approved'
+```
 
 =>
 
-    SELECT "posts".* FROM "posts";
-    SELECT COUNT(*) AS count_all, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) AND "comments"."status" = 'approved' GROUP BY post_id;
+```
+SELECT "posts".* FROM "posts";
+SELECT COUNT(*) AS count_all, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) AND "comments"."status" = 'approved' GROUP BY post_id;
+```
 
 or
 
-    SELECT "posts".* FROM "posts";
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 1;
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 2;
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 3;
+```
+SELECT "posts".* FROM "posts";
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 1;
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 2;
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 3;
+```
 
 =>
 
-    SELECT "posts".* FROM "posts";
-    SELECT AVG("comments"."rating") AS average_comments_rating, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) GROUP BY post_id;
+```
+SELECT "posts".* FROM "posts";
+SELECT AVG("comments"."rating") AS average_comments_rating, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) GROUP BY post_id;
+```
 
-It only supports Rails 4.x so far.
+It supports Rails 4.x, Rails 5.x and Rails 6.x
 
 ## Installation
 
@@ -40,29 +50,35 @@ gem 'eager_group'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install eager_group
+```
+$ gem install eager_group
+```
 
 ## Usage
 
 First you need to define what aggregate function you want to eager
 load.
 
-    class Post < ActiveRecord::Base
-      has_many :comments
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
 
-      define_eager_group :comments_average_rating, :comments, :average, :rating
-      define_eager_group :approved_comments_count, :comments, :count, :*, -> { approved }
-    end
+  define_eager_group :comments_average_rating, :comments, :average, :rating
+  define_eager_group :approved_comments_count, :comments, :count, :*, -> { approved }
+end
 
-    class Comment < ActiveRecord::Base
-      belongs_to :post
+class Comment < ActiveRecord::Base
+  belongs_to :post
 
-      scope :approved, -> { where(status: 'approved') }
-    end
+  scope :approved, -> { where(status: 'approved') }
+end
+```
 
 The parameters for `define_eager_group` are as follows
 
@@ -71,29 +87,75 @@ method, it also generates a method with the same name to fetch the
 result.
 * `association`, association name you want to aggregate.
 * `aggregate_function`, aggregate sql function, can be one of `average`,
-`count`, `maximum`, `minimum`, `sum`.
+`count`, `maximum`, `minimum`, `sum`, I define 2 additional aggregate
+function `first_object` and `last_object` to eager load first and last
+association objects.
 * `column_name`, aggregate column name, it can be `:*` for `count`
 * `scope`, scope is optional, it's used to filter data for aggregation.
 
 Then you can use `eager_group` to fix n+1 aggregate sql functions
 when querying
 
-    posts = Post.all.eager_group(:comments_average_rating, :approved_comments_count)
-    posts.each do |post|
-      post.comments_average_rating
-      post.approved_comments_count
-    end
+```ruby
+posts = Post.all.eager_group(:comments_average_rating, :approved_comments_count)
+posts.each do |post|
+  post.comments_average_rating
+  post.approved_comments_count
+end
+```
 
 EagerGroup will execute `GROUP BY` sqls for you then set the value of
 attributes.
 
-`define_eager_group` will define a method in model. 
-You can call the `definition_name` directly for convenience, 
+`define_eager_group` will define a method in model.
+You can call the `definition_name` directly for convenience,
 but it would not help you to fix n+1 aggregate sql issue.
 
-    post = Post.first
-    post.commets_average_rating
-    post.approved_comments_count
+```
+post = Post.first
+post.commets_average_rating
+post.approved_comments_count
+```
+
+## Advanced
+
+`eager_group` through association
+
+```ruby
+User.limit(10).includes(:posts).eager_group(posts: [:comments_average_rating, :approved_comments_count])
+```
+
+pass parameter to scope
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  define_eager_group :comments_average_rating_by_author, :comments, :average, :rating, ->(author, ignore) { by_author(author, ignore) }
+end
+
+posts = Post.all.eager_group([:comments_average_rating_by_author, author, true])
+posts.each { |post| post.comments_average_rating_by_author }
+```
+
+`first_object` and `last_object` aggregation to eager load first and
+last association objects.
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  define_eager_group :first_comment, :comments, :first_object, :id
+  define_eager_group :last_comment, :comments, :last_object, :id
+end
+
+posts = Post.all.eager_group(:first_comment, :last_comment)
+posts.each do |post|
+  post.first_comment
+  post.last_comment
+end
+```
+
 
 ## Benchmark
 
@@ -103,6 +165,6 @@ times faster, WOW!
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/xinminlabs/eager_group.
+Bug reports and pull requests are welcome on GitHub at https://github.com/flyerhzm/eager_group.
 
-[1]:  https://github.com/xinminlabs/eager_group/blob/master/benchmark.rb
+[1]:  https://github.com/flyerhzm/eager_group/blob/master/benchmark.rb

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/benchmark.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Calculating -------------------------------------
 #   Without EagerGroup     2.000  i/100ms
 #      With EagerGroup    28.000  i/100ms
@@ -28,22 +30,22 @@ class Comment < ActiveRecord::Base
 end
 
 # create database eager_group_benchmark;
-ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'eager_group_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
+ActiveRecord::Base.establish_connection(
+  adapter: 'mysql2', database: 'eager_group_benchmark', server: '/tmp/mysql.socket', username: 'root'
+)
 
-ActiveRecord::Base.connection.tables.each do |table|
-  ActiveRecord::Base.connection.drop_table(table)
-end
+ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
 
 ActiveRecord::Schema.define do
   self.verbose = false
 
-  create_table :posts, :force => true do |t|
+  create_table :posts, force: true do |t|
     t.string :title
     t.string :body
     t.timestamps null: false
   end
 
-  create_table :comments, :force => true do |t|
+  create_table :comments, force: true do |t|
     t.string :body
     t.string :status
     t.integer :rating
@@ -53,30 +55,31 @@ ActiveRecord::Schema.define do
 end
 
 posts_size = 100
-comments_size = 1000
+comments_size = 1_000
 
 posts = []
-posts_size.times do |i|
-  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}")
-end
+posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}") }
 Post.import posts
 post_ids = Post.all.pluck(:id)
 
 comments = []
 comments_size.times do |i|
-  comments << Comment.new(:body => "Comment #{i}", :post_id => post_ids[i%100], :status => ["approved", "deleted"][i%2], rating: i%5+1)
+  comments <<
+    Comment.new(
+      body: "Comment #{i}", post_id: post_ids[i % 100], status: %w[approved deleted][i % 2], rating: i % 5 + 1
+    )
 end
 Comment.import comments
 
 Benchmark.ips do |x|
-  x.report("Without EagerGroup") do
+  x.report('Without EagerGroup') do
     Post.limit(20).each do |post|
       post.comments.approved.count
       post.comments.approved.average('rating')
     end
   end
 
-  x.report("With EagerGroup") do
+  x.report('With EagerGroup') do
     Post.eager_group(:approved_comments_count, :comments_average_rating).limit(20).each do |post|
       post.approved_comments_count
       post.comments_average_rating

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "eager_group"
+require 'bundler/setup'
+require 'eager_group'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "eager_group"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/eager_group.gemspec

@@ -1,30 +1,32 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'eager_group/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "eager_group"
+  spec.name          = 'eager_group'
   spec.version       = EagerGroup::VERSION
-  spec.authors       = ["Richard Huang"]
-  spec.email         = ["flyerhzm@gmail.com"]
+  spec.authors       = ['Richard Huang']
+  spec.email         = ['flyerhzm@gmail.com']
 
-  spec.summary       = %q{Fix n+1 aggregate sql functions}
-  spec.description   = %q{Fix n+1 aggregate sql functions for rails}
-  spec.homepage      = "https://github.com/xinminlabs/eager_group"
+  spec.summary       = 'Fix n+1 aggregate sql functions'
+  spec.description   = 'Fix n+1 aggregate sql functions for rails'
+  spec.homepage      = 'https://github.com/flyerhzm/eager_group'
 
-  spec.license     = 'MIT'
+  spec.license = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.3"
-  spec.add_development_dependency "sqlite3", "~> 1.3"
-  spec.add_development_dependency "activerecord"
-  spec.add_development_dependency "activerecord-import"
-  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'activerecord-import'
+  spec.add_development_dependency 'activesupport'
+  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'sqlite3'
 end

data/lib/active_record/with_eager_group.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module WithEagerGroup
+    def exec_queries
+      records = super
+      EagerGroup::Preloader.new(klass, records, eager_group_values).run if eager_group_values.present?
+      records
+    end
+
+    def eager_group(*args)
+      check_if_method_has_arguments!('eager_group', args)
+      spawn.eager_group!(*args)
+    end
+
+    def eager_group!(*args)
+      self.eager_group_values += args
+      self
+    end
+
+    def eager_group_values
+      @values[:eager_group] || []
+    end
+
+    def eager_group_values=(values)
+      raise ImmutableRelation if @loaded
+
+      @values[:eager_group] = values
+    end
+  end
+end

data/lib/eager_group.rb

@@ -1,7 +1,7 @@
-require "eager_group/version"
-require 'active_record'
-require 'eager_group/active_record_base'
-require 'eager_group/active_record_relation'
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attribute_accessors'
+require 'eager_group/version'
 
 module EagerGroup
   autoload :Preloader, 'eager_group/preloader'
@@ -12,36 +12,44 @@ module EagerGroup
   end
 
   module ClassMethods
-    attr_reader :eager_group_definations
+    mattr_accessor :eager_group_definitions, default: {}
 
     # class Post
     #   define_eager_group :comments_avergage_rating, :comments, :average, :rating
     #   define_eager_group :approved_comments_count, :comments, :count, :*, -> { approved }
     # end
     def define_eager_group(attr, association, aggregate_function, column_name, scope = nil)
-      self.send :attr_accessor, attr
-      @eager_group_definations ||= {}
-      @eager_group_definations[attr] = Definition.new association, aggregate_function, column_name, scope
-      
-      define_method attr, -> (*args) do
-        query_result_cache = instance_variable_get("@#{attr}")
-        if args.blank? && query_result_cache.present?
-          return query_result_cache
-        end
-        preload_eager_group(attr, *args)
-        instance_variable_get("@#{attr}")
-      end
-      
+      send :attr_accessor, attr
+      eager_group_definitions[attr] = Definition.new(association, aggregate_function, column_name, scope)
+
+      define_method attr,
+                    lambda { |*args|
+                      query_result_cache = instance_variable_get("@#{attr}")
+                      return query_result_cache if args.blank? && query_result_cache.present?
+
+                      preload_eager_group(attr, *args)
+                      instance_variable_get("@#{attr}")
+                    }
+
       define_method "#{attr}=" do |val|
         instance_variable_set("@#{attr}", val)
       end
     end
   end
-  
+
   private
+
   def preload_eager_group(*eager_group_value)
     EagerGroup::Preloader.new(self.class, [self], [eager_group_value]).run
   end
 end
 
-ActiveRecord::Base.send :include, EagerGroup
+require 'active_record'
+ActiveRecord::Base.class_eval do
+  include EagerGroup
+  class << self
+    delegate :eager_group, to: :all
+  end
+end
+require 'active_record/with_eager_group'
+ActiveRecord::Relation.send :prepend, ActiveRecord::WithEagerGroup

data/lib/eager_group/active_record_base.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class ActiveRecord::Base
-  class <<self
+  class << self
     # Post.eager_group(:approved_comments_count, :comments_average_rating)
-    delegate :eager_group, :to => :all
+    delegate :eager_group, to: :all
   end
 end

data/lib/eager_group/active_record_relation.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
 class ActiveRecord::Relation
   # Post.all.eager_group(:approved_comments_count, :comments_average_rating)
 
   def exec_queries_with_eager_group
     records = exec_queries_without_eager_group
-    if eager_group_values.present?
-      EagerGroup::Preloader.new(self.klass, records, eager_group_values).run
-    end
+    EagerGroup::Preloader.new(klass, records, eager_group_values).run if eager_group_values.present?
     records
   end
+
   alias_method_chain :exec_queries, :eager_group
 
   def eager_group(*args)
@@ -26,6 +27,7 @@ class ActiveRecord::Relation
 
   def eager_group_values=(values)
     raise ImmutableRelation if @loaded
+
     @values[:eager_group] = values
   end
 end

data/lib/eager_group/definition.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module EagerGroup
   class Definition
-    attr_reader :association, :aggregate_function, :column_name, :scope
+    attr_reader :association, :column_name, :scope
 
     def initialize(association, aggregate_function, column_name, scope)
       @association = association
@@ -8,5 +10,20 @@ module EagerGroup
       @column_name = column_name
       @scope = scope
     end
+
+    def aggregation_function
+      return :maximum if @aggregate_function.to_sym == :last_object
+      return :minimum if @aggregate_function.to_sym == :first_object
+
+      @aggregate_function
+    end
+
+    def need_load_object
+      %i[first_object last_object].include?(@aggregate_function.to_sym)
+    end
+
+    def default_value
+      %i[first_object last_object].include?(@aggregate_function.to_sym) ? nil : 0
+    end
   end
 end

data/lib/eager_group/preloader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EagerGroup
   class Preloader
     def initialize(klass, records, eager_group_values)
@@ -9,40 +11,52 @@ module EagerGroup
     # Preload aggregate functions
     def run
       primary_key = @klass.primary_key
-      record_ids = @records.map { |record| record.send primary_key }
       @eager_group_values.each do |eager_group_value|
-        defination_key, arguments = eager_group_value.is_a?(Array) ? [eager_group_value.shift, eager_group_value] : [eager_group_value, nil]
-        if definition = @klass.eager_group_definations[defination_key]
-          reflection = @klass.reflect_on_association(definition.association)
-          association_class = reflection.klass
-          association_class = association_class.instance_exec(*arguments, &definition.scope) if definition.scope
-          polymophic_as_condition = lambda {|reflection|
-            if reflection.type
-              ["#{reflection.name}.#{reflection.type} = ?", @klass.base_class.name]
-            else
-              []
-            end
-          }
+        definition_key, arguments =
+          eager_group_value.is_a?(Array) ? [eager_group_value.shift, eager_group_value] : [eager_group_value, nil]
+        if definition_key.is_a?(Hash)
+          association_name, definition_key = *definition_key.first
+          @records = @records.flat_map { |record| record.send(association_name) }
+          next if @records.empty?
+
+          @klass = @records.first.class
+        end
+        record_ids = @records.map { |record| record.send(primary_key) }
+        next unless definition = @klass.eager_group_definitions[definition_key]
 
-          if reflection.through_reflection
-            foreign_key = "#{reflection.through_reflection.name}.#{reflection.through_reflection.foreign_key}"
-            aggregate_hash = association_class.joins(reflection.through_reflection.name)
-                                              .where("#{foreign_key} IN (?)", record_ids)
-                                              .where(polymophic_as_condition.call(reflection.through_reflection))
-                                              .group("#{foreign_key}")
-                                              .send(definition.aggregate_function, definition.column_name)
-          else
-            aggregate_hash = association_class.where(reflection.foreign_key => record_ids)
-                                              .where(polymophic_as_condition.call(reflection))
-                                              .group(reflection.foreign_key)
-                                              .send(definition.aggregate_function, definition.column_name)
-          end
-          @records.each do |record|
-            id = record.send primary_key
-            record.send "#{defination_key}=", aggregate_hash[id] || 0
-          end
+        reflection = @klass.reflect_on_association(definition.association)
+        association_class = reflection.klass
+        association_class = association_class.instance_exec(*arguments, &definition.scope) if definition.scope
+
+        if reflection.through_reflection
+          foreign_key = "#{reflection.through_reflection.name}.#{reflection.through_reflection.foreign_key}"
+          aggregate_hash =
+            association_class.joins(reflection.through_reflection.name).where(foreign_key => record_ids).where(
+              polymophic_as_condition(reflection.through_reflection)
+            )
+              .group(foreign_key)
+              .send(definition.aggregation_function, definition.column_name)
+        else
+          aggregate_hash =
+            association_class.where(reflection.foreign_key => record_ids).where(polymophic_as_condition(reflection))
+              .group(reflection.foreign_key)
+              .send(definition.aggregation_function, definition.column_name)
+        end
+        if definition.need_load_object
+          aggregate_objects = reflection.klass.find(aggregate_hash.values).each_with_object({}) { |o, h| h[o.id] = o }
+          aggregate_hash.keys.each { |key| aggregate_hash[key] = aggregate_objects[aggregate_hash[key]] }
+        end
+        @records.each do |record|
+          id = record.send(primary_key)
+          record.send("#{definition_key}=", aggregate_hash[id] || definition.default_value)
         end
       end
     end
+
+    private
+
+    def polymophic_as_condition(reflection)
+      reflection.type ? { reflection.name => { reflection.type => @klass.base_class.name } } : []
+    end
   end
 end

data/lib/eager_group/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EagerGroup
-  VERSION = "0.5.0"
+  VERSION = '0.7.2'
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: eager_group
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2019-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,49 +25,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: activerecord-import
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,21 +81,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activerecord-import
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: benchmark-ips
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -126,13 +140,14 @@ files:
 - bin/console
 - bin/setup
 - eager_group.gemspec
+- lib/active_record/with_eager_group.rb
 - lib/eager_group.rb
 - lib/eager_group/active_record_base.rb
 - lib/eager_group/active_record_relation.rb
 - lib/eager_group/definition.rb
 - lib/eager_group/preloader.rb
 - lib/eager_group/version.rb
-homepage: https://github.com/xinminlabs/eager_group
+homepage: https://github.com/flyerhzm/eager_group
 licenses:
 - MIT
 metadata: {}
@@ -151,8 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Fix n+1 aggregate sql functions