ar_pg_array 0.9.9 → 0.9.12

data/Rakefile

@@ -30,7 +30,7 @@ begin
     gemspec.email = "funny.falcon@gmail.com"
     gemspec.homepage = "http://github.com/funny-falcon/activerecord-postgresql-arrays"
     gemspec.authors = ["Sokolov Yura aka funny_falcon"]
-    gemspec.add_dependency('active_record', '>= 2.3.5', '<3.1')
+    gemspec.add_dependency('activerecord', '>= 2.3.5')
     gemspec.rubyforge_project = 'ar-pg-array'
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.9.9
+0.9.12

data/lib/ar_pg_array/querying_arel.rb

@@ -119,51 +119,116 @@ else
   end
 end
 
-module ActiveRecord
-  class PredicateBuilder
-    def build_from_hash(attributes, default_table)
-      predicates = attributes.map do |column, value|
-        table = default_table
-
-        if value.is_a?(Hash)
-          table = Arel::Table.new(column, :engine => @engine)
-          build_from_hash(value, table)
-        else
-          column = column.to_s
-
-          if column.include?('.')
-            table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, :engine => @engine)
+if ActiveRecord::VERSION::STRING < '3.1'
+  module ActiveRecord
+    class PredicateBuilder
+      def build_from_hash(attributes, default_table)
+        predicates = attributes.map do |column, value|
+          table = default_table
+
+          if value.is_a?(Hash)
+            table = Arel::Table.new(column, :engine => @engine)
+            build_from_hash(value, table)
+          else
+            column = column.to_s
+
+            if column.include?('.')
+              table_name, column = column.split('.', 2)
+              table = Arel::Table.new(table_name, :engine => @engine)
+            end
+
+            attribute = table[column] || Arel::Attribute.new(table, column)
+
+            case value
+            when PGArrays::PgAny
+              attribute.ar_any(value)
+            when PGArrays::PgAll
+              attribute.ar_all(value)
+            when PGArrays::PgIncludes
+              attribute.ar_included(value)
+            when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+              values = value.to_a.map { |x|
+                x.is_a?(ActiveRecord::Base) ? x.id : x
+              }
+              attribute.in(values)
+            when Range, Arel::Relation
+              attribute.in(value)
+            when ActiveRecord::Base
+              attribute.eq(value.id)
+            when Class
+              # FIXME: I think we need to deprecate this behavior
+              attribute.eq(value.name)
+            else
+              attribute.eq(value)
+            end
           end
+        end
 
-          attribute = table[column] || Arel::Attribute.new(table, column)
-
-          case value
-          when PGArrays::PgAny
-            attribute.ar_any(value)
-          when PGArrays::PgAll
-            attribute.ar_all(value)
-          when PGArrays::PgIncludes
-            attribute.ar_included(value)
-          when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
-            values = value.to_a.map { |x|
-              x.is_a?(ActiveRecord::Base) ? x.id : x
-            }
-            attribute.in(values)
-          when Range, Arel::Relation
-            attribute.in(value)
-          when ActiveRecord::Base
-            attribute.eq(value.id)
-          when Class
-            # FIXME: I think we need to deprecate this behavior
-            attribute.eq(value.name)
+        predicates.flatten
+      end
+    end
+  end
+else
+  module ActiveRecord
+    class PredicateBuilder
+      def self.build_from_hash(engine, attributes, default_table)
+        predicates = attributes.map do |column, value|
+          table = default_table
+
+          if value.is_a?(Hash)
+            table = Arel::Table.new(column, engine)
+            build_from_hash(engine, value, table)
           else
-            attribute.eq(value)
+            column = column.to_s
+
+            if column.include?('.')
+              table_name, column = column.split('.', 2)
+              table = Arel::Table.new(table_name, engine)
+            end
+
+            attribute = table[column.to_sym]
+
+            case value
+            when PGArrays::PgAny
+              attribute.ar_any(value)
+            when PGArrays::PgAll
+              attribute.ar_all(value)
+            when PGArrays::PgIncludes
+              attribute.ar_included(value)
+            when ActiveRecord::Relation
+              value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+              attribute.in(value.arel.ast)
+            when Array, ActiveRecord::Associations::CollectionProxy
+              values = value.to_a.map { |x|
+                x.is_a?(ActiveRecord::Base) ? x.id : x
+              }
+
+              if values.include?(nil)
+                values = values.compact
+                if values.empty?
+                  attribute.eq nil
+                else
+                  attribute.in(values.compact).or attribute.eq(nil)
+                end
+              else
+                attribute.in(values)
+              end
+
+            when Range, Arel::Relation
+              attribute.in(value)
+            when ActiveRecord::Base
+              attribute.eq(value.id)
+            when Class
+              # FIXME: I think we need to deprecate this behavior
+              attribute.eq(value.name)
+            else
+              attribute.eq(value)
+            end
           end
         end
-      end
 
-      predicates.flatten
+        predicates.flatten
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -44,6 +44,7 @@ ActiveRecord::Base.silence do
   # load schema
   load File.join('spec/fixtures/schema.rb')
   # load fixtures
+  Fixtures = ActiveRecord::Fixtures  unless defined?(Fixtures)
   Fixtures.create_fixtures("spec/fixtures", ActiveRecord::Base.connection.tables)
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ar_pg_array
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-04 00:00:00.000000000Z
+date: 2011-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: active_record
-  requirement: &83197980 !ruby/object:Gem::Requirement
+  name: activerecord
+  requirement: &84412580 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - <
-      - !ruby/object:Gem::Version
-        version: '3.1'
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *83197980
+  version_requirements: *84412580
 description: ar_pg_array includes support of PostgreSQL's int[], float[], text[],
   timestamptz[] etc. into ActiveRecord. You could define migrations for array columns,
   query on array columns.