postgres_ext 2.4.0.beta.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45761b40db17573204e88b48c6eb91c135968fde
-  data.tar.gz: d774a33f235ac5f450df26f6f517575ba1360bed
+  metadata.gz: c3246d3eb02a37797d39a1e4c9eb7ef17e010b2b
+  data.tar.gz: 569c3f94c31b6b7979eb95da5d5ab2dcb5f376cb
 SHA512:
-  metadata.gz: c2b883ca3787352f2d6394d45116485565b4c0631b3f84e17405949cbd63049201c087860e470d88b3cad19e849f841b32d3537d5dfef29162d3e153bfb40538
-  data.tar.gz: 7f0224e503f2d0883aae7974b94de5366d612cba43ad4e243e1bf7d16bbffc5d3e2562eae66ad60e55af76915c5c7b1d45907d3652e607471f9e803d77994128
+  metadata.gz: 5ab51fcf131d599a871238d2fd1738b43fc316df96f2810a9045bf513d515e29bfa13008077cf7cccf4349bd7cfbf569812156b9cd62c764d0a830328810dd9d
+  data.tar.gz: ba34c9e19290e4691dc28c337dc7aaa13b121b0fff51499a4720e16f816609e140115508f02c0a959971e74597ad46202822a7fabbb360d3b2d9c402ac533709

data/.travis.yml

@@ -1,6 +1,10 @@
+sudo: false
+language: ruby
+cache: bundler
 rvm:
 - 2.0.0
 - 2.1.2
+- 2.2.0
 
 gemfile:
   - gemfiles/Gemfile.activerecord-4.0.x

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.4.0
+
+ * Fixes missing CTEProxy delegate - eidge
+ * Fixes where chain on joins - edpaget
+ * ActiveRecord 4.2 support added - edpaget
+
 ## 2.3.0
 
  * Fixes an issue with `where(table: { column: [] })` was not properly

data/gemfiles/Gemfile.activerecord-4.2.x

@@ -2,7 +2,8 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~> 4.2.0.beta2"
+gem "activerecord", "~> 4.2.0"
+gem "pg", "~> 0.15"
 
 unless ENV['CI'] || RUBY_PLATFORM =~ /java/
   gem 'byebug'

data/lib/postgres_ext/active_record.rb

@@ -1,3 +1,4 @@
+require 'active_record'
 require 'postgres_ext/active_record/relation'
 require 'postgres_ext/active_record/cte_proxy'
 require 'postgres_ext/active_record/querying'

data/lib/postgres_ext/active_record/cte_proxy.rb

@@ -23,8 +23,8 @@ class CTEProxy
   end
 
   delegate :column_names, :columns_hash, :model_name, :primary_key, :attribute_alias?,
-    :aggregate_reflections, :instantiate, :type_for_attribute, to: :@model
-  
+    :aggregate_reflections, :instantiate, :type_for_attribute, :relation_delegate_class, to: :@model
+
   private
 
   def reflections

data/lib/postgres_ext/active_record/querying.rb

@@ -1,5 +1,3 @@
-require 'active_record/querying'
-
 module ActiveRecord::Querying
   delegate :with, :ranked, to: :all
 

data/lib/postgres_ext/active_record/relation.rb

@@ -1,2 +1,12 @@
+## TODO: Change to ~> 4.2.0 on gem release
+
+gdep = Gem::Dependency.new('activerecord', '~> 4.2.0.beta4')
+ar_version_cutoff = gdep.matching_specs.sort_by(&:version).last
+
 require 'postgres_ext/active_record/relation/query_methods'
-require 'postgres_ext/active_record/relation/predicate_builder'
+if ar_version_cutoff
+  require 'postgres_ext/active_record/relation/predicate_builder/array_handler'
+else
+  require 'postgres_ext/active_record/relation/predicate_builder'
+end
+

data/lib/postgres_ext/active_record/relation/predicate_builder.rb

@@ -1,5 +1,3 @@
-require 'active_record/relation/predicate_builder'
-
 module ActiveRecord
   class PredicateBuilder # :nodoc:
     private

data/lib/postgres_ext/active_record/relation/predicate_builder/array_handler.rb

@@ -0,0 +1,32 @@
+require 'active_record/relation/predicate_builder'
+require 'active_record/relation/predicate_builder/array_handler'
+
+require 'active_support/concern'
+
+module ActiveRecord
+  class PredicateBuilder
+    module ArrayHandlerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        def call_with_feature(attribute, value)
+          engine = attribute.relation.engine
+          column = engine.connection.schema_cache.columns(attribute.relation.name).detect{ |col| col.name.to_s == attribute.name.to_s }
+          if column.array
+            attribute.eq(value)
+          else
+            call_without_feature(attribute, value)
+          end
+        end
+
+        alias_method_chain(:call, :feature)
+      end
+
+      module ClassMethods
+
+      end
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder::ArrayHandler.send(:include, ActiveRecord::PredicateBuilder::ArrayHandlerPatch)

data/lib/postgres_ext/active_record/relation/query_methods.rb

@@ -1,72 +1,117 @@
-require 'active_record/relation/query_methods'
-
 module ActiveRecord
   module QueryMethods
     class WhereChain
-      def overlap(opts)
-        opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].overlap(value))
-        end
-        @scope
+      def overlap(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Overlap, 'overlap')
       end
 
-      def contained_within(opts)
-        opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].contained_within(value))
-        end
+      def contained_within(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithin, 'contained_within')
+      end
 
-        @scope
+      def contained_within_or_equals(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithinEquals, 'contained_within_or_equals')
       end
 
-      def contained_within_or_equals(opts)
-        opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].contained_within_or_equals(value))
+      def contains(opts, *rest)
+        build_where_chain(opts, rest) do |rel|
+          case rel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            column = left_column(rel) || column_from_association(rel)
+            equality_for_hstore(rel) if column.type == :hstore
+            
+            if column.type == :hstore
+              Arel::Nodes::ContainsHStore.new(rel.left, rel.right)
+            elsif column.respond_to?(:array) && column.array
+              Arel::Nodes::ContainsArray.new(rel.left, rel.right)
+            else
+              Arel::Nodes::ContainsINet.new(rel.left, rel.right)
+            end
+          else
+            raise ArgumentError, "Invalid argument for .where.overlap(), got #{rel.class}"
+          end
         end
+      end
 
-        @scope
+      def contains_or_equals(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::ContainsEquals, 'contains_or_equals')
       end
 
-      def contains(opts)
-        opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].contains(value))
-        end
+      def any(opts, *rest)
+        equality_to_function('ANY', opts, rest)
+      end
 
-        @scope
+      def all(opts, *rest)
+        equality_to_function('ALL', opts, rest)
       end
 
-      def contains_or_equals(opts)
-        opts.each do |key, value|
-          @scope = @scope.where(arel_table[key].contains_or_equals(value))
-        end
+      private
 
-        @scope
+      def find_column(col, rel)
+        col.name == rel.left.name.to_s || col.name == rel.left.relation.name.to_s
       end
 
-      def any(opts)
-        equality_to_function('ANY', opts)
+      def left_column(rel)
+        rel.left.relation.engine.columns.find { |col| find_column(col, rel) }
       end
 
-      def all(opts)
-        equality_to_function('ALL', opts)
+      def column_from_association(rel)
+        if assoc = assoc_from_related_table(rel)
+          column = assoc.klass.columns.find { |col| find_column(col, rel) }
+        end
       end
 
-      private
+      def equality_for_hstore(rel)
+        new_right_name = rel.left.name.to_s
+        if rel.right.respond_to?(:val)
+          return if rel.right.val.is_a?(Hash)
+          rel.right = Arel::Nodes.build_quoted({new_right_name => rel.right.val},
+                                               rel.left)
+        else
+          return if rel.right.is_a?(Hash)
+          rel.right = {new_right_name => rel.right }
+        end
+        
+        rel.left.name = rel.left.relation.name.to_sym
+        rel.left.relation.name = rel.left.relation.engine.table_name
+      end
 
-      def arel_table
-        @arel_table ||= @scope.engine.arel_table
+      def assoc_from_related_table(rel)
+        engine = rel.left.relation.engine
+        engine.reflect_on_association(rel.left.relation.name.to_sym) ||
+          engine.reflect_on_association(rel.left.relation.name.singularize.to_sym)
       end
 
-      def equality_to_function(function_name, opts)
-        opts.each do |key, value|
-          any_function = Arel::Nodes::NamedFunction.new(function_name, [arel_table[key]])
-          predicate = Arel::Nodes::Equality.new(value, any_function)
-          @scope = @scope.where(predicate)
+      def build_where_chain(opts, rest, &block)
+        where_value = @scope.send(:build_where, opts, rest).map(&block)
+        @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
+        @scope.where_values += where_value
+        @scope
+      end
+
+      def substitute_comparisons(opts, rest, arel_node_class, method)
+        build_where_chain(opts, rest) do |rel|
+          case rel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            arel_node_class.new(rel.left, rel.right)
+          else
+            raise ArgumentError, "Invalid argument for .where.#{method}(), got #{rel.class}"
+          end
         end
+      end
 
-        @scope
+      def equality_to_function(function_name, opts, rest)
+        build_where_chain(opts, rest) do |rel|
+          case rel
+          when Arel::Nodes::Equality
+            Arel::Nodes::Equality.new(rel.right, Arel::Nodes::NamedFunction.new(function_name, [rel.left]))
+          else
+            raise ArgumentError, "Invalid argument for .where.#{funciton_name.downcase}(), got #{rel.class}"
+          end
+        end
       end
     end
-
+    
     # WithChain objects act as placeholder for queries in which #with does not have any parameter.
     # In this case, #with must be chained with #recursive to return a new relation.
     class WithChain
@@ -175,15 +220,15 @@ module ActiveRecord
     def build_rank(arel, rank_window_options)
       unless arel.projections.count == 1 && Arel::Nodes::Count === arel.projections.first
         rank_window = case rank_window_options
-          when :order
-            arel.orders
-          when Symbol
-            table[rank_window_options].asc
-          when Hash
-            rank_window_options.map { |field, dir| table[field].send(dir) }
-          else
-            Arel::Nodes::SqlLiteral.new "(#{rank_window_options})"
-          end
+                      when :order
+                        arel.orders
+                      when Symbol
+                        table[rank_window_options].asc
+                      when Hash
+                        rank_window_options.map { |field, dir| table[field].send(dir) }
+                      else
+                        Arel::Nodes::SqlLiteral.new "(#{rank_window_options})"
+                      end
 
         unless rank_window.blank?
           rank_node = Arel::Nodes::SqlLiteral.new 'rank()'

data/lib/postgres_ext/arel.rb

@@ -1,6 +1,5 @@
-## TODO: Change to ~> 4.2.0 on gem release
 
-gdep = Gem::Dependency.new('activerecord', '~> 4.2.0.beta2')
+gdep = Gem::Dependency.new('activerecord', '~> 4.2.0')
 ar_version_cutoff = gdep.matching_specs.sort_by(&:version).last
 
 require 'postgres_ext/arel/nodes'

data/lib/postgres_ext/arel/4.1/visitors.rb

@@ -1 +1,2 @@
+require 'postgres_ext/arel/4.1/visitors/depth_first'
 require 'postgres_ext/arel/4.1/visitors/postgresql'

data/lib/postgres_ext/arel/4.1/visitors/depth_first.rb

@@ -0,0 +1,9 @@
+require 'arel/visitors/depth_first'
+
+module Arel
+  module Visitors
+    class DepthFirst
+      alias :visit_IPAddr :terminal
+    end
+  end
+end

data/lib/postgres_ext/arel/4.1/visitors/postgresql.rb

@@ -4,7 +4,7 @@ module Arel
   module Visitors
     class PostgreSQL
       private
-      
+
       def visit_Array o, a
         column = a.relation.engine.connection.schema_cache.columns(a.relation.name).find { |col| col.name == a.name.to_s } if a
         if column && column.respond_to?(:array) && column.array
@@ -13,6 +13,16 @@ module Arel
           o.empty? ? 'NULL' : o.map { |x| visit x }.join(', ')
         end
       end
+
+      def visit_Arel_Nodes_Contains o, a = nil
+        left_column = o.left.relation.engine.columns.find { |col| col.name == o.left.name.to_s }
+        
+        if left_column && (left_column.type == :hstore || (left_column.respond_to?(:array) && left_column.array))
+          "#{visit o.left, a} @> #{visit o.right, o.left}"
+        else
+          "#{visit o.left, a} >> #{visit o.right, o.left}"
+        end
+      end
       
       def visit_Arel_Nodes_ContainedWithin o, a = nil
         "#{visit o.left, a} << #{visit o.right, o.left}"
@@ -22,14 +32,16 @@ module Arel
         "#{visit o.left, a} <<= #{visit o.right, o.left}"
       end
 
-      def visit_Arel_Nodes_Contains o, a = nil
-        left_column = o.left.relation.engine.columns.find { |col| col.name == o.left.name.to_s }
+      def visit_Arel_Nodes_ContainsArray o, a = nil
+        "#{visit o.left, a} @> #{visit o.right, o.left}"
+      end
 
-        if left_column && (left_column.type == :hstore || (left_column.respond_to?(:array) && left_column.array))
-          "#{visit o.left, a} @> #{visit o.right, o.left}"
-        else
-          "#{visit o.left, a} >> #{visit o.right, o.left}"
-        end
+      def visit_Arel_Nodes_ContainsHStore o, a = nil
+        "#{visit o.left, a} @> #{visit o.right, o.left}"
+      end
+
+      def visit_Arel_Nodes_ContainsINet o, a = nil
+        "#{visit o.left, a} >> #{visit o.right, o.left}"
       end
 
       def visit_Arel_Nodes_ContainsEquals o, a = nil

data/lib/postgres_ext/arel/4.2/visitors/postgresql.rb

@@ -4,7 +4,7 @@ module Arel
   module Visitors
     class PostgreSQL
       private
-     
+      
       def visit_Arel_Nodes_ContainedWithin o, collector
         infix_value o, collector, " << " 
       end
@@ -14,15 +14,29 @@ module Arel
       end
 
       def visit_Arel_Nodes_Contains o, collector
-        left_column = o.left.relation.engine.columns.find { |col| col.name == o.left.name.to_s }
+        left_column = o.left.relation.engine.columns.find do |col|
+          col.name == o.left.name.to_s || col.name == o.left.relation.name.to_s
+        end
 
         if left_column && (left_column.type == :hstore || (left_column.respond_to?(:array) && left_column.array))
-          infix_value o, collector, " @> " 
+          infix_value o, collector, " @> "
         else
           infix_value o, collector, " >> " 
         end
       end
 
+      def visit_Arel_Nodes_ContainsINet o, collector
+        infix_value o, collector, " >> " 
+      end
+
+      def visit_Arel_Nodes_ContainsHStore o, collector
+        infix_value o, collector, " @> "
+      end
+      
+      def visit_Arel_Nodes_ContainsArray o, collector
+        infix_value o, collector, " @> "
+      end
+      
       def visit_Arel_Nodes_ContainsEquals o, collector
         infix_value o, collector, " >>= " 
       end

data/lib/postgres_ext/arel/nodes/contained_within.rb

@@ -6,15 +6,27 @@ module Arel
     end
 
     class ContainedWithinEquals < Arel::Nodes::Binary
-      def operator; '<<='.to_sym end
+      def operator; :"<<=" end
     end
 
     class Contains < Arel::Nodes::Binary
       def operator; :>> end
     end
+    
+    class ContainsINet < Arel::Nodes::Binary
+      def operator; :>> end
+    end
 
+    class ContainsHStore < Arel::Nodes::Binary
+      def operator; :"@>" end
+    end
+    
+    class ContainsArray < Arel::Nodes::Binary
+      def operator; :"@>" end
+    end
+    
     class ContainsEquals < Arel::Nodes::Binary
-      def operator; '>>='.to_sym end
+      def operator; :">>=" end
     end
   end
 end

data/lib/postgres_ext/version.rb

@@ -1,3 +1,3 @@
 module PostgresExt
-  VERSION = '2.4.0.beta.1'
+  VERSION = '2.4.0'
 end

data/postgres_ext.gemspec

@@ -29,6 +29,6 @@ Gem::Specification.new do |gem|
   if RUBY_PLATFORM =~ /java/
       gem.add_development_dependency 'activerecord-jdbcpostgresql-adapter', '1.3.0.beta2'
   else
-      gem.add_development_dependency 'pg', '~> 0.13.2'
+      gem.add_development_dependency 'pg', '~> 0.13'
   end
 end

data/test/queries/array_queries_test.rb

@@ -15,9 +15,8 @@ describe 'Array queries' do
 
   describe '.where(joins: { array_column: [] })' do
     it 'returns an array string instead of IN ()' do
-      skip
       query = Person.joins(:hm_tags).where(tags: { categories: ['working'] }).to_sql
-      query.must_match equality_regex
+      query.must_match %r{\"tags\"\.\"categories\" = '\{"?working"?\}'}
     end
   end
 
@@ -33,6 +32,11 @@ describe 'Array queries' do
       query.must_match overlap_regex
       query.must_match equality_regex
     end
+
+    it 'works on joins' do
+      query = Person.joins(:hm_tags).where.overlap(tags: { categories: ['working'] }).to_sql
+      query.must_match %r{\"tags\"\.\"categories\" && '\{"?working"?\}'}
+    end
   end
 
 

data/test/queries/contains_test.rb

@@ -41,16 +41,27 @@ describe 'Contains queries' do
       query.to_sql.must_match contains_array_regex
     end
 
-    it 'generates the appropriate where clause for array columns' do
+    it 'generates the appropriate where clause for hstore columns' do
       query = Person.where.contains(data: { nickname: 'Dan' })
       query.to_sql.must_match contains_hstore_regex
     end
 
+    it 'generates the appropriate where clause for hstore columns on joins' do
+      query = Tag.joins(:person).where.contains(people: { data: { nickname: 'Dan' } })
+      query.to_sql.must_match contains_hstore_regex
+    end
+    
     it 'allows chaining' do
       query = Person.where.contains(:tag_ids => [1,2]).where(:tags => ['working']).to_sql
 
       query.must_match contains_array_regex
       query.must_match equality_regex
     end
+
+    it 'generates the appropriate where clause for array columns on joins' do
+      query = Tag.joins(:person).where.contains(people: { tag_ids: [1,2] }).to_sql
+
+      query.must_match contains_array_regex
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postgres_ext
 version: !ruby/object:Gem::Version
-  version: 2.4.0.beta.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Dan McClain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-13 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.2
+        version: '0.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.2
+        version: '0.13'
 description: Adds missing native PostgreSQL data types to ActiveRecord and convenient
   querying extensions for ActiveRecord and Arel
 email:
@@ -175,10 +175,12 @@ files:
 - lib/postgres_ext/active_record/querying.rb
 - lib/postgres_ext/active_record/relation.rb
 - lib/postgres_ext/active_record/relation/predicate_builder.rb
+- lib/postgres_ext/active_record/relation/predicate_builder/array_handler.rb
 - lib/postgres_ext/active_record/relation/query_methods.rb
 - lib/postgres_ext/arel.rb
 - lib/postgres_ext/arel/4.1/predications.rb
 - lib/postgres_ext/arel/4.1/visitors.rb
+- lib/postgres_ext/arel/4.1/visitors/depth_first.rb
 - lib/postgres_ext/arel/4.1/visitors/postgresql.rb
 - lib/postgres_ext/arel/4.2/predications.rb
 - lib/postgres_ext/arel/4.2/visitors.rb
@@ -211,12 +213,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Extends ActiveRecord to handle native PostgreSQL data types