arel-extensions 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c79633129067dda19ceaeaf6f0241b23d57c804
-  data.tar.gz: 7f401572e73ed1e40cde5f094360d427bd7539c1
+  metadata.gz: ea6bb2f32dc1602cd546c28188fe5ed2be2a0f09
+  data.tar.gz: e11ccebf5147a7d83f7e081c17bda2e387aa6b41
 SHA512:
-  metadata.gz: d306bc36f6b25224da947efc251686455e7353f67bc9af65ba7f81df704838ff640c0fe5f6d030f5a33cfffbc5e5f51885caba4c715231072463d24582b7a602
-  data.tar.gz: d802003762477a56fde5f2e7f7b08c4dbbdab73cc0f448d5915a953cdfe8ce5562bb1e7aa785876f8069eda3b1e8487461a8c3aa8488e16293c36cd9487cbd0f
+  metadata.gz: dd5bb4101f987f0143643d01437550e141b2867ff5447e9e15164cb0359e44445f15a188bcf72d12ac729602e9f5093dfcaf618c6646dbbc68ca11002e8e6274
+  data.tar.gz: 39827c24bc7ed46ee7d2578db388f30d38c00ef489acf98d49929401e5476c33f05aaff91363125dcf420917f643393b68e351675b6bfe6d8df2bd10f567c541

data/README.md

@@ -19,198 +19,4 @@ Or install it yourself as:
 ## Usage
 
 Just `require 'arel-extensions'` and use Arel/ActiveRecord as you normally would!
-arel-extensions extends ActiveRecord's query methods in both Arel and ActiveRecord.
-
- * [Querying PostgreSQL datatypes](docs/querying.md)
- 
- ## Arrays
-
-   * [@> - Array Contains operator](#---array-contains-operator)
-   * [<@ - Array Contained By operator](#---array-contined-by-operator)
-   * [&& - Array Overlap operator](#---array-overlap-operator)
-
- ### && - Array Overlap operator
-
- PostgreSQL implements the `&&` operator, known as the overlap operator,
- for arrays. The overlap operator returns `t` (true) when two arrays have
- one or more elements in common.
-
- ```sql
- ARRAY[1,2,3] && ARRAY[4,5,6]
- -- f
-
- ARRAY[1,2,3] && ARRAY[3,5,6]
- -- t
- ```
-
- Postgres\_ext extends the `ActiveRecord::Relation.where` method similar
- to the Rails 4.0 not clause. The easiest way to make a overlap query
- would be:
-
- ```ruby
- User.where.overlap(:nick_names => ['Bob', 'Fred'])
- ``` 
-
- Postgres\_ext defines `overlap`, an [Arel](https://github.com/rails/arel)
- predicate for the `&&` operator. This is utilized by the `where.overlap`
- call above.
-
- ```ruby
- user_arel = User.arel_table
-
- # Execute the query
- User.where(user_arel[:tags].overlap(['one','two']))
- # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"tags\" && '{one,two}'
- ```
-
- ### @> - Array Contains operator
-
- PostgreSQL has a contains (`@>`) operator for querying whether all the
- elements of an array are within another.
-
- ```sql
- ARRAY[1,2,3] @> ARRAY[3,4]
- -- f
-
- ARRAY[1,2,3] @> ARRAY[2,3]
- -- t
- ```
-
- Postgres\_ext extends the `ActiveRecord::Relation.where` method by
- adding a `contains` method. To make a contains query, you can do:
-
- ```ruby
- User.where.contains(:nick_names => ['Bob', 'Fred'])
- ```
-
- Postgres\_ext overrides `contains`, an [Arel](https://github.com/rails/arel)
- predicate, to use the `@>` operator for arrays. This is utilized by the
- `where.contains` call above.
-
- ```ruby
- user_arel = User.arel_table
-
- # Execute the query
- User.where(user_arel[:tags].contains(['one','two']))
- # => SELECT "users".* FROM "users" WHERE "users"."tags" @> '{"one","two"}'
- ```
-
- ### ANY or ALL functions
-
- When querying array columns, you have the ability to see if a predicate
- apply's to either *any* element in the array, or *all* elements of the
- array. The syntax for these predicates are slightly different then the
- normal `where` syntax in PostgreSQL. To see if an array contains the
- string `'test'` in any location, you would write the following in SQL
-
- ```sql
- SELECT *
- FROM users
- WHERE 'test' = ANY(users.tags)
- ```
-
- Notice that the column is on the right hand side of the predicate,
- instead of the left, because we have to call the `ANY` function on that
- column.
-
- Postgres\_ext provides a `ActiveRecord::Relation.where.any()` method. The
- easiest way to make a ANY query would be:
-
- ```ruby
- User.where.any(:nick_names => 'Bob')
- ``` 
-
- There is also an `ActiveRecord::Relation.where.all()` call as well. This
- method utilizes the following code to create the query:
-
- We can generate the above query using [Arel](https://github.com/rails/arel)
- and generating the Node manually. We would use the following to
- accompish this:
-
- ```ruby
- user_arel = User.arel_table
-
- # Execute the query
- User.where(user_arel[:tags].any('test'))
- #=> SELECT \"users\".* FROM \"users\" WHERE 'test' = ANY(\"users\".\"tags\")
- ```
-
- The ALL version of this same predicate can be generated by swapping
- `#any()` for `#all()`.
-
- ## INET/CIDR Queries
-
- PostgreSQL defines the `<<`, or contained within operator for INET and
- CIDR datatypes. The `<<` operator returns `t` (true) if a INET or CIDR
- address is contained within the given subnet. 
-
- ```sql
- inet '192.168.1.6' << inet '10.0.0.0/24'
- -- f
-
- inet '192.168.1.6' << inet '192.168.1.0/24'
- -- t
- ```
-
- In addition to contained within, there is also:
-
-  * `<<=` - Contained within or equals
-  * `>>` - Contains
-  * `>>=` - Contains or equals
-
- Postgres\_ext extends the `ActiveRecord::Relation.where` method similar
- to the Rails 4.0 not clause. The easiest way to make a overlap query
- would be:
-
- ```ruby
- User.where.contained_within(:ip => '192.168.1.1/24')
- User.where.contained_within_or_equals(:ip => '192.168.1.1/24')
- User.where.contains(:ip => '192.168.1.14')
- User.where.contains_or_equals(:ip => '192.168.1.14')
- ``` 
-
- Postgres\_ext defines `contained_within`, an [Arel](https://github.com/rails/arel)
- predicate for the `<<` operator.  This is utilized by the
- methods above.
-
- ```ruby
- user_arel = User.arel_table
-
- # Execute the query
- User.where(user_arel[:ip_address].contained_within('127.0.0.1/24'))
- # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip_address\" << '127.0.0.1/24'
- User.where(user_arel[:ip_address].contained_within_or_equals('127.0.0.1/24'))
- # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip_address\" <<= '127.0.0.1/24'
- User.where(user_arel[:ip_address].contains('127.0.0.1'))
- # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip_address\" >> '127.0.0.1'
- User.where(user_arel[:ip_address].contains_or_equals('127.0.0.1'))
- # => SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip_address\" >>= '127.0.0.1'
- ```
-
-## Developing
-
-To work on postgres\_ext locally, follow these steps:
-
- 1. Run `bundle install`, this will install (almost) all the development
-    dependencies
- 2. Run `gem install byebug` (not a declared dependency to not break CI)
- 3. Run `bundle exec rake db:setup`, this will set up the `.env` file necessary to run
-    the tests and set up the database
- 4. Run `bundle exec rake db:create`, this will create the test database
- 5. Run `bundle exec rake db:migrate`, this will set up the database tables required
-    by the test
- 6. Run `BUNDLE_GEMFILE='gemfiles/Gemfile.activerecord-4.0.x' bundle install --quiet` to create the Gemfile.lock for 4.0.
- 7. Run `BUNDLE_GEMFILE='gemfiles/Gemfile.activerecord-4.1.x' bundle install --quiet` to create the Gemfile.lock for 4.1.
- 8. Run `bundle exec rake test:all` to run tests against all supported versions of Active Record
-
-## Authors
-
-Dan McClain [twitter](http://twitter.com/_danmcclain) [github](http://github.com/danmcclain)
-
-
-
-
-
-Change.arel_table[:diff].has_key?(:in_review)
-Change.arel_table[:diff].has_keys?(:in_review, :cached_at)
-Change.arel_table[:diff].has_any_key?(:in_review, :nokey)
+arel-extensions extends ActiveRecord's query methods in both Arel and ActiveRecord.

data/arel-extensions.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name = 'arel-extensions'
-  gem.version = '1.1.0'
+  gem.version = '1.2.0'
   
   gem.authors       = ["Jon Bracy"]
   gem.email         = ["jonbracy@gmail.com"]

data/lib/active_record/query_methods.rb

@@ -0,0 +1,37 @@
+require 'active_record'
+require 'active_record/relation'
+require 'active_record/querying'
+require 'active_record/relation/query_methods'
+
+module ActiveRecord::QueryMethods
+  def distinct_on_values
+    @values["distinct_on_values"] || []
+  end
+
+  def distinct_on_values=(value)
+    @values["distinct_on_values"] = value
+  end
+
+  def distinct_on(*fields)
+    spawn.distinct_on!(*fields)
+  end
+  alias uniq_on distinct_on
+
+  def distinct_on!(*fields)
+    fields.flatten!
+    self.distinct_on_values = fields.map { |x| x.is_a?(Arel::Attributes::Attribute) ? x : klass.arel_table[x] }
+    self
+  end
+  alias uniq_on! distinct_on!
+
+  def build_arel_with_distinct_on
+    arel = build_arel_without_distinct_on
+    arel.distinct_on(self.distinct_on_values) if !self.distinct_on_values.empty?
+    arel
+  end
+  alias_method :build_arel_without_distinct_on, :build_arel
+  alias_method :build_arel, :build_arel_with_distinct_on
+end
+
+ActiveRecord::Querying.delegate :distinct_on, to: :all
+ActiveRecord::Querying.delegate :distinct_on!, to: :all

data/lib/arel/array_predications.rb

@@ -1,14 +1,14 @@
 module Arel
   module ArrayPredications
     
-    def contains(*values)
-      values = values[0] if values.size == 1 && values[0].is_a?(Array)
-      Arel::Nodes::Contains.new(self, values)
+    # Used by both JSON and ARRAY so it doesn't try to cast to array
+    def contains(value)
+      Arel::Nodes::Contains.new(self, value)
     end
     
-    def contained_by(*values)
-      values = values[0] if values.size == 1 && values[0].is_a?(Array)
-      Arel::Nodes::ContainedBy.new(self, values)
+    # Used by both JSON and ARRAY so it doesn't try to cast to array
+    def contained_by(value)
+      Arel::Nodes::ContainedBy.new(self, value)
     end
     
     def overlaps(*values)

data/lib/arel/extensions.rb

@@ -18,6 +18,8 @@ require File.expand_path('../nodes/ts_match', __FILE__)
 require File.expand_path('../ts_predications', __FILE__)
 Arel::Attributes::Attribute.include(Arel::TSPredications)
 
+require File.expand_path('../../active_record/query_methods', __FILE__)
+
 if defined?(Arel::Visitors::PostgreSQL)
   require File.expand_path('../visitors/postgresql_extensions', __FILE__)
 end

data/lib/arel/visitors/postgresql_extensions.rb

@@ -41,7 +41,7 @@ module Arel
           end
         else
           visit(o.relation, collector)
-          collector << "\#>>'{" << o.name.to_s
+          collector << "\#>'{" << o.name.to_s
           collector << (last_key ? "}'" : ",")
         end
         collector
@@ -94,4 +94,4 @@ module Arel
 
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arel-extensions
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-06 00:00:00.000000000 Z
+date: 2017-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel
@@ -62,6 +62,7 @@ files:
 - LICENSE
 - README.md
 - arel-extensions.gemspec
+- lib/active_record/query_methods.rb
 - lib/arel/array_predications.rb
 - lib/arel/attributes/cast.rb
 - lib/arel/attributes/key.rb
@@ -98,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Adds support for missing SQL operators and functions to Arel