edge_rider 0.3.2 → 2.0.0

data/{gemfiles/Gemfile.5.1.mysql2 → Gemfile.5.2.pg}

@@ -1,15 +1,17 @@
 source 'https://rubygems.org'
 
 # Runtime dependencies
-gem 'activerecord', '~>5.1.1'
-gem 'mysql2'
+gem 'activerecord', '~>5.2.3'
+gem 'pg'
+gem 'i18n', '<=1.5.1' # Required to support tests for Ruby 2.2.x
 
 # Development dependencies
 gem 'rake'
 gem 'database_cleaner'
-gem 'rspec'
 gem 'has_defaults' # used by test models
-gem 'gemika'
+gem 'rspec'
+gem 'gemika', '>=0.5.0'
+gem 'pry-byebug'
 
 # Gem under test
-gem 'edge_rider', :path => '..'
+gem 'edge_rider', path: '.'

data/{gemfiles/Gemfile.5.1.pg.lock → Gemfile.5.2.pg.lock}

@@ -1,33 +1,43 @@
 PATH
-  remote: ..
+  remote: .
   specs:
-    edge_rider (0.3.2)
-      activerecord
+    edge_rider (2.0.0)
+      activerecord (>= 3.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.1.1)
-      activesupport (= 5.1.1)
-    activerecord (5.1.1)
-      activemodel (= 5.1.1)
-      activesupport (= 5.1.1)
-      arel (~> 8.0)
-    activesupport (5.1.1)
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
+    activesupport (5.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (8.0.0)
-    concurrent-ruby (1.0.5)
+    arel (9.0.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
     database_cleaner (1.6.1)
     diff-lcs (1.3)
-    gemika (0.3.2)
+    gemika (0.5.0)
     has_defaults (0.4.4)
       activerecord
-    i18n (0.8.1)
-    minitest (5.10.2)
+    i18n (1.5.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.2)
+    minitest (5.11.3)
     pg (0.20.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
     rake (12.0.0)
     rspec (3.6.0)
       rspec-core (~> 3.6.0)
@@ -43,21 +53,23 @@ GEM
       rspec-support (~> 3.6.0)
     rspec-support (3.6.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.3)
+    tzinfo (1.2.5)
       thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  activerecord (~> 5.1.1)
+  activerecord (~> 5.2.3)
   database_cleaner
   edge_rider!
-  gemika
+  gemika (>= 0.5.0)
   has_defaults
+  i18n (<= 1.5.1)
   pg
+  pry-byebug
   rake
   rspec
 
 BUNDLED WITH
-   1.15.0
+   2.2.26

data/{gemfiles/Gemfile.5.1.pg → Gemfile.6.1.pg}

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
 # Runtime dependencies
-gem 'activerecord', '~>5.1.1'
+gem 'activerecord', '~>6.1.3'
 gem 'pg'
 
 # Development dependencies
@@ -9,7 +9,8 @@ gem 'rake'
 gem 'database_cleaner'
 gem 'has_defaults' # used by test models
 gem 'rspec'
-gem 'gemika'
+gem 'gemika', '>=0.5.0'
+gem 'pry-byebug'
 
 # Gem under test
-gem 'edge_rider', :path => '..'
+gem 'edge_rider', path: '.'

data/Gemfile.6.1.pg.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    edge_rider (2.0.0)
+      activerecord (>= 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.3)
+      activesupport (= 6.1.3)
+    activerecord (6.1.3)
+      activemodel (= 6.1.3)
+      activesupport (= 6.1.3)
+    activesupport (6.1.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.8)
+    database_cleaner (2.0.1)
+      database_cleaner-active_record (~> 2.0.0)
+    database_cleaner-active_record (2.0.0)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
+    diff-lcs (1.4.4)
+    gemika (0.5.0)
+    has_defaults (0.4.4)
+      activerecord
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    pg (1.2.3)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 6.1.3)
+  database_cleaner
+  edge_rider!
+  gemika (>= 0.5.0)
+  has_defaults
+  pg
+  pry-byebug
+  rake
+  rspec
+
+BUNDLED WITH
+   2.2.26

data/Gemfile.lock

@@ -0,0 +1 @@
+Gemfile.6.1.pg.lock

data/README.md

@@ -1,8 +1,6 @@
-Edge Rider [![Build Status](https://secure.travis-ci.org/makandra/edge_rider.png?branch=master)](https://travis-ci.org/makandra/edge_rider)
-====================================
+# Edge Rider [![Tests](https://github.com/makandra/edge_rider/workflows/Tests/badge.svg)](https://github.com/makandra/edge_rider/actions)
 
-Power tools for ActiveRecord relations (scopes)
--------------------------------------------------
+## Power tools for ActiveRecord relations (scopes)
 
 In ActiveRecord, relations (or scopes) allow you to construct complex queries piece-by-piece
 and then trigger a query or update at a precisely defined moment. If you write any kind
@@ -14,9 +12,7 @@ Edge Rider was created with two intents:
 2. Provide a stable API for working with relations across multiple versions of Rails (since
 Rails has a tradition of breaking details of its relation API every other release).
 
-
-Usage
------
+## Usage
 
 ### Traversing a relation along an association
 
@@ -25,20 +21,26 @@ returns a new relation by "pivoting" around a named association.
 
 Say we have a `Post` model and each `Post` belongs to an author:
 
-    class Post < ActiveRecord::Base
-      belongs_to :author
-    end
-  
+```ruby
+class Post < ActiveRecord::Base
+  belongs_to :author
+end
+```
+
 To turn a relation of posts into a relation of its authors:
 
-    posts = Post.where(:archived => false)
-    authors = posts.traverse_association(:author)
-    
+```ruby
+posts = Post.where(archived: false)
+authors = posts.traverse_association(:author)
+```
+
 You can traverse multiple associations in a single call.
 E.g. to turn a relation of posts into a relation of all posts of their authors:
 
-    posts = Post.where(:archived => false)
-    posts_by_same_authors = posts.traverse_association(:author, :posts)
+```ruby
+posts = Post.where(archived: false)
+posts_by_same_authors = posts.traverse_association(:author, :posts)
+```
 
 *Implementation note:* The traversal is achieved internally by collecting all foreign keys in the current relation
 and return a new relation with an `IN(...)` query (which is very efficient even for many thousand keys).
@@ -56,10 +58,12 @@ its ID.
 Edge Rider has a better way. Your relations gain a method `#collect_ids` that will
 fetch all IDs in a single query without instantiating a single ActiveRecord object:
 
-    posts = Post.where(:archived => false)
-    post_ids = posts.collect_ids
+```ruby
+posts = Post.where(archived: false)
+post_ids = posts.collect_ids
+```
 
-*Implemenation note:* In Rails 3.2+, `#collect_ids` delegates to [`#pluck`](http://apidock.com/rails/ActiveRecord/Calculations/pluck),
+*Implementation note:* `#collect_ids` delegates to [`#pluck`](https://apidock.com/rails/ActiveRecord/Calculations/pluck),
 which can be used for the same purpose.
 
 
@@ -68,33 +72,39 @@ which can be used for the same purpose.
 When writing a method that filters by record IDs, you can make it more useful by accepting
 any kind of argument that can be turned into a list of IDs:
 
-    Post.by_author(1)
-    Post.by_author([1, 2, 3])
-    Post.by_author(Author.find(1))
-    Post.by_author([Author.find(1), Author.find(2)])
-    Post.by_author(Author.active)
+```ruby
+Post.by_author(1)
+Post.by_author([1, 2, 3])
+Post.by_author(Author.find(1))
+Post.by_author([Author.find(1), Author.find(2)])
+Post.by_author(Author.active)
+```
 
 For this use case Edge Rider defines `#collect_ids` on many different types:
 
-    Post.where(:id => [1, 2]).collect_ids    # => [1, 2, 3]
-    [Post.find(1), Post.find(2)].collect_ids # => [1, 2]
-    Post.find(1).collect_ids                 # => [1]
-    [1, 2, 3].collect_ids                    # => [1, 2, 3]
-    1.collect_ids                            # => [1]
+```ruby
+Post.where(id: [1, 2]).collect_ids    # => [1, 2]
+[Post.find(1), Post.find(2)].collect_ids # => [1, 2]
+Post.find(1).collect_ids                 # => [1]
+[1, 2, 3].collect_ids                    # => [1, 2, 3]
+1.collect_ids                            # => [1]
+```
 
 You can now write `Post.by_author` from the example above without a single `if` or `case`:
 
-    class Post < ActiveRecord::Base
-    
-      belongs_to :author
+```ruby
+class Post < ActiveRecord::Base
+
+  belongs_to :author
+
+  def self.for_author(author_or_authors)
+    where(author_id: author_or_authors.collect_ids)
+  end
+
+end
+```
 
-      def self.for_author(author_or_authors)
-        where(:author_id => author_or_authors.collect_ids)
-      end
 
-    end
-    
-    
 ### Efficiently collect all values in a relation's column
 
 You often want to ask a relation for an array of all values ofin a given column.
@@ -106,42 +116,27 @@ its column value.
 Edge Rider has a better way. Your relations gain a method `#collect_column` that will
 fetch all column values in a single query without instantiating a single ActiveRecord object:
 
-    posts = Post.where(:archived => false)
-    subjects = posts.collect_column(:subject)
+```ruby
+posts = Post.where(archived: false)
+subjects = posts.collect_column(:subject)
+```
 
-*Implementation note:* In Rails 3.2+, `#collect_column` delegates to [`#pluck`](http://apidock.com/rails/ActiveRecord/Calculations/pluck),
+*Implementation note:* `#collect_column` delegates to [`#pluck`](https://apidock.com/rails/ActiveRecord/Calculations/pluck),
 which can be used for the same effect.
 
 #### Collect unique values in a relation's column
 
-If you only care about *unique* values, use the `:distinct => true` option:
+If you only care about *unique* values, use the `distinct: true` option:
 
-    posts = Post.where(:archived => false)
-    distinct_subjects = posts.collect_column(:subject, :distinct => true)
+```ruby
+posts = Post.where(archived: false)
+distinct_subjects = posts.collect_column(:subject, distinct: true)
+```
 
 With this options duplicates are discarded by the database before making their way into Ruby.
 
-*Implementation note:* In Rails 3.2+, the `:distinct` option is implemented with [`#uniq`](http://apidock.com/rails/ActiveRecord/QueryMethods/uniq)
- which can be used for the same effect.
-
-
-### Retrieve the SQL a relation would produce
-
-Sometimes it is useful to ask a relation which SQL query it would trigger,
-if it was evaluated right now. For this, Edge Rider gives your relations a method
-`#to_sql`:
-
-    # Rails 2 scope
-    Post.scoped(:conditions => { :id => [1, 2] }).to_sql 
-    # => "SELECT `posts`.* FROM `posts` WHERE `posts.id` IN (1, 2)"
-
-    # Rails 3 relation
-    Post.where(:id => [1, 2]).to_sql 
-    # => "SELECT `posts`.* FROM `posts` WHERE `posts.id` IN (1, 2)"
-
-*Implementation note*: Rails 3+ implements `#to_sql`. Edge Rider backports this method to Rails 2 so you can use it
-regardless of your Rails version.
-
+*Implementation note:* The `:distinct` option is implemented with [`#uniq`](https://apidock.com/rails/ActiveRecord/QueryMethods/uniq)
+ or [`#distinct`](https://apidock.com/rails/ActiveRecord/QueryMethods/distinct) which can be used for the same effect.
 
 ### Simplify a complex relation for better chainability
 
@@ -155,40 +150,51 @@ mashes together strings that mostly happen to look like a MySQL query in the end
 
 Edge Rider gives your relations a new method `#to_id_query`:
 
-    Site.joins(:user).where(:users => { :name => 'Bruce' }).to_id_query
+```ruby
+Site.joins(user).where(:users: { name: 'Bruce' }).to_id_query
+```
 
 `#to_id_query` will immediately run an SQL query where it collects all the IDs that match your relation:
 
-    SELECT sites.id FROM sites INNER JOIN users WHERE sites.user_id = sites.id AND users.name = 'Bruce'
+```sql
+SELECT sites.id FROM sites INNER JOIN users WHERE sites.user_id = sites.id AND users.name = 'Bruce'
+```
 
 It now uses these IDs to return a new relation that has **no joins** and a single condition on the `id` column:
 
-    SELECT * FROM sites WHERE sites.user_id IN (3, 17, 103)
+```sql
+SELECT * FROM sites WHERE sites.user_id IN (3, 17, 103)
+```
 
 
 ### Preload associations for loaded ActiveRecords
 
 Sometimes you want to fetch associations for records that you already instantiated, e.g. when it has deeply nested associations.
 
-Edge Rider gives your model classes a method `.preload_associations`. The method can be used to preload associations for loaded objects like this:
+Edge Rider gives your model classes and instances a method `preload_associations`. The method can be used to preload associations for loaded objects like this:
 
-    @user = User.find(params[:id])
-    User.preload_associations [@user], { :threads => { :posts => :author }, :messages => :sender }
+```ruby
+@user = User.find(params[:id])
+User.preload_associations [@user], { threads: { posts: :author }, messages: :sender }
+# or
+user.preload_associations { threads: { posts: :author }, messages: :sender }
+```
 
-*Implementation note*: Rails 2.3 and Rails 3.0 already has a method [`.preload_associations`](http://apidock.com/rails/ActiveRecord/AssociationPreload/ClassMethods/preload_associations)
+*Implementation note*: Rails 3.0 already has a method [`.preload_associations`](https://apidock.com/rails/ActiveRecord/AssociationPreload/ClassMethods/preload_associations)
 which Edge Rider merely makes public. Edge Rider ports this method forward to Rails 3.1+.
 
 
-
 ### Retrieve the class a relation is based on
 
 Edge Rider gives your relations a method `#origin_class` that returns the class the relation is based on.
 This is useful e.g. to perform unscoped record look-up.
 
-    Post.recent.origin_class
-    # => Post
+```ruby
+Post.recent.origin_class
+# => Post
+```
 
-Note that `#origin_class` it roughly equivalent to the blockless form of [`unscoped`](http://apidock.com/rails/ActiveRecord/Scoping/Default/ClassMethods/unscoped) from Rails 3.2+,
+Note that `#origin_class` it roughly equivalent to the blockless form of [`unscoped`](https://apidock.com/rails/ActiveRecord/Scoping/Default/ClassMethods/unscoped) from Rails 3.2+,
 but it works consistently across all Rails versions.
 
 
@@ -199,11 +205,13 @@ Edge Rider ports `Model.scoped` forward to Rails 4+ (taken from
 enables you to consistently turn models into scopes or narrow down scopes
 across all versions of Rails.
 
-    User.scoped # just calls User.all in Rails 4
-    User.active.scoped(conditions: { admin: true })
+```ruby
+User.scoped # just calls User.all in Rails 4
+User.active.scoped(conditions: { admin: true })
+```
 
-*Implementation note*: Rails 2 and 3 already have a method
-[`.scoped`](http://apidock.com/rails/ActiveRecord/Scoping/Named/ClassMethods/scoped) which Edge Rider does not touch. Rails 4 has removed this method and
+*Implementation note*: Rails 3 already have a method
+[`.scoped`](https://apidock.com/rails/ActiveRecord/Scoping/Named/ClassMethods/scoped) which Edge Rider does not touch. Rails 4 has removed this method and
 splits its functionality into the query methods known from Rails 3 (`.where`,
 `.order` etc.) and an `.all` method that just returns a scope.
 
@@ -213,24 +221,24 @@ slightly different in all versions of Rails (see
 methods are not modified.
 
 
-Installation
-------------
+## Installation
 
 In your `Gemfile` say:
 
-    gem 'edge_rider'
+```ruby
+gem 'edge_rider'
+```
 
 Now run `bundle install` and restart your server.
 
 
-Development
------------
+## Development
 
 - There are tests in `spec`. We only accept PRs with tests.
-- We currently develop using Ruby 2.2.4 (see `.ruby-version`) since that version works for all versions of ActiveRecord that we support. Travis CI will test additional Ruby versions (2.1.8 and 2.3.1).
+- We currently develop using the Ruby version in `.ruby-version`. It is required to change the Ruby Version to cover all Rails version or just use Travis CI.
 - Put your database credentials into `spec/support/database.yml`. There's a `database.sample.yml` you can use as a template.
 - Create a database `edge_rider_test` in both MySQL and PostgreSQL.
-- There are gem bundles in `gemfiles` for each combination of ActiveRecord version and database type that we support.
+- There are gem bundles in the project root for each combination of ActiveRecord version and database type that we support.
 - You can bundle all test applications by saying `bundle exec rake matrix:install`
 - You can run specs from the project root by saying `bundle exec rake matrix:spec`. This will run all gemfiles compatible with your current Ruby.
 
@@ -241,9 +249,6 @@ If you would like to contribute:
 - Send me a pull request.
 
 
-Credits
--------
+## Credits
 
 Henning Koch from [makandra](http://makandra.com/)
-
-