arel-extensions 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4847138fb20c8ca58e5bf419b595e1cf9e4dc809
+  data.tar.gz: 54565109b15574583361a153a2558bdb5deac376
+SHA512:
+  metadata.gz: d934dc0afa953e09db3837747ebc919ae473901f6da32033a76635261eda113c75504a7ac98c861b48983993c2e0dace2f439f31d18542b62e01ce30b1d66d74
+  data.tar.gz: f568ff754c5f16fca13c73925353ffe9aae53fcd1cdfa8da74dafebabef5110c0308135375241c8c82e7bb2f420229da4ec41bdc3d9b99e055215d387a988ae6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jon Bracy
+
+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,216 @@
+# Arel Extensions
+
+Adds support for missing SQL operators and functions to Arel for ActiveRecord.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'arel-extensions', require: 'arel/extensions'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install arel-extensions
+
+## 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)

data/arel-extensions.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name = 'arel-extensions'
+  gem.version = '1.0.0'
+  
+  gem.authors       = ["Jon Bracy"]
+  gem.email         = ["jonbracy@gmail.com"]
+  gem.summary       = %q{Adds support for missing SQL operators and functions to Arel}
+  gem.homepage      = 'https://github.com/malomalo/arel-extensions'
+  gem.licenses      = ['MIT']
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'arel', '>= 7.0.0'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+end

data/lib/arel/array_predications.rb

@@ -0,0 +1,20 @@
+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)
+    end
+    
+    def contained_by(*values)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      Arel::Nodes::ContainedBy.new(self, values)
+    end
+    
+    def overlaps(*values)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      Arel::Nodes::Overlaps.new(self, values)
+    end
+    
+  end
+end

data/lib/arel/attributes/key.rb

@@ -0,0 +1,13 @@
+module Arel
+  module Attributes
+    class Key < Attribute
+      def able_to_type_cast?
+        false
+      end
+      
+      def table_name
+        nil
+      end
+    end
+  end
+end

data/lib/arel/extensions.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../array_predications', __FILE__)
+require File.expand_path('../nodes/overlaps', __FILE__)
+require File.expand_path('../nodes/contains', __FILE__)
+Arel::Attributes::Attribute.include(Arel::ArrayPredications)
+
+
+require File.expand_path('../attributes/key', __FILE__)
+require File.expand_path('../nodes/has_any_key', __FILE__)
+require File.expand_path('../nodes/has_key', __FILE__)
+require File.expand_path('../nodes/has_keys', __FILE__)
+require File.expand_path('../json_predications', __FILE__)
+Arel::Attributes::Attribute.include(Arel::JSONPredications)
+
+if defined?(Arel::Visitors::PostgreSQL)
+  require File.expand_path('../visitors/postgresql_extensions', __FILE__)
+end

data/lib/arel/json_predications.rb

@@ -0,0 +1,23 @@
+module Arel
+  module JSONPredications
+    
+    def key(key)
+      Arel::Attributes::Key.new(self, key)
+    end
+    alias :[]     :key
+    alias :index  :key
+    
+    def has_key(key)
+      Arel::Nodes::HasKey.new(self, key)
+    end
+    
+    def has_keys(*keys)
+      Arel::Nodes::HasKeys.new(self, keys)
+    end
+    
+    def has_any_key(*keys)
+      Arel::Nodes::HasAnyKeys.new(self, keys)
+    end
+    
+  end
+end

data/lib/arel/nodes/contains.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Contains < Binary
+    end
+  end
+end

data/lib/arel/nodes/has_any_key.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Nodes
+    class HasAnyKeys < Binary
+      # ?|
+    end
+  end
+end

data/lib/arel/nodes/has_key.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Nodes
+    class HasKey < Binary
+      # ?
+    end
+  end
+end

data/lib/arel/nodes/has_keys.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Nodes
+    class HasKeys < Binary
+      # ?&
+    end
+  end
+end

data/lib/arel/nodes/overlaps.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Overlaps < Binary
+    end
+  end
+end

data/lib/arel/visitors/postgresql_extensions.rb

@@ -0,0 +1,45 @@
+module Arel
+  module Visitors
+    class PostgreSQL
+      private
+      
+      def visit_Arel_Nodes_Contains o, collector
+        visit o.left, collector
+        collector << ' @> '
+        collector << quote(o.left.type_cast_for_database(o.right))
+      end
+      
+      def visit_Arel_Nodes_ContainedBy o, collector
+        visit o.left, collector
+        collector << ' <@ '
+        collector << quote(o.left.type_cast_for_database(o.right))
+      end
+
+      def visit_Arel_Nodes_Overlaps o, collector
+        visit o.left, collector
+        collector << ' && '
+        collector << quote(o.left.type_cast_for_database(o.right))
+      end
+      
+      def visit_Arel_Attributes_Key(o, collector, last_key = true)
+        if o.relation.is_a?(Arel::Attributes::Key)
+          visit_Arel_Attributes_Key(o.relation, collector, false)
+          if last_key
+            collector << o.name.to_s
+            collector << "}'"
+          else
+            collector << o.name.to_s
+            collector << "."
+          end
+        else
+          visit(o.relation, collector)
+          collector << "\#>>'{" << o.name.to_s
+          if !last_key
+            collector << "."
+          end
+        end
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: arel-extensions
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jon Bracy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jonbracy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- arel-extensions.gemspec
+- lib/arel/array_predications.rb
+- lib/arel/attributes/key.rb
+- lib/arel/extensions.rb
+- lib/arel/json_predications.rb
+- lib/arel/nodes/contains.rb
+- lib/arel/nodes/has_any_key.rb
+- lib/arel/nodes/has_key.rb
+- lib/arel/nodes/has_keys.rb
+- lib/arel/nodes/overlaps.rb
+- lib/arel/visitors/postgresql_extensions.rb
+homepage: https://github.com/malomalo/arel-extensions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Adds support for missing SQL operators and functions to Arel
+test_files: []