ar_pg_array 0.9.13 → 0.10.1

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('activerecord', '>= 2.3.5')
+    gemspec.add_dependency('activerecord', '>= 2.3.5', '<3.0')
     gemspec.rubyforge_project = 'ar-pg-array'
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.9.13
+0.10.0

data/lib/ar_pg_array.rb

@@ -7,9 +7,4 @@ require 'ar_pg_array/schema_cacheable'
 require 'ar_pg_array/querying'
 require 'ar_pg_array/allways_save'
 require 'ar_pg_array/references_by'
-if ActiveRecord::VERSION::MAJOR >= 3
-  require 'ar_pg_array/schema_arel'
-  require 'ar_pg_array/querying_arel'
-else
-  require 'ar_pg_array/schema_fix_will_change'
-end
+require 'ar_pg_array/schema_fix_will_change'

data/lib/ar_pg_array/allways_save.rb

@@ -1,37 +1,21 @@
 module ActiveRecord
-    module CheckArrayBeforeUpdate
-      def mark_arrays_for_update
-        @attributes_cache.each do |name, value|
-          attribute_will_change!(name) if Array === value && _read_attribute(name) != value
-        end
+  module CheckArrayBeforeUpdate
+    def mark_arrays_for_update
+      @attributes_cache.each do |name, value|
+        attribute_will_change!(name) if Array === value && _read_attribute(name) != value
       end
     end
-  if VERSION::MAJOR < 3
-    module CheckArrayBeforeUpdate
-      def self.included(base)
-        base.alias_method_chain :update, :check_array
-        base.send(:alias_method, :_read_attribute, :read_attribute)
-      end
+  end
 
-      def update_with_check_array
-        mark_arrays_for_update
-        update_without_check_array
-      end
+  module CheckArrayBeforeUpdate
+    def self.included(base)
+      base.alias_method_chain :update, :check_array
+      base.send(:alias_method, :_read_attribute, :read_attribute)
     end
-  else
-    module CheckArrayBeforeUpdate
-      include ActiveSupport::Concern
 
-      if VERSION::MAJOR == 3 && VERSION::MINOR >= 2
-        def _read_attribute(attr_name)
-          column_for_attribute(attr_name).type_cast(@attributes[attr_name])
-        end
-      end
-
-      def update(*)
-        mark_arrays_for_update
-        super
-      end
+    def update_with_check_array
+      mark_arrays_for_update
+      update_without_check_array
     end
   end
   Base.__send__ :include, CheckArrayBeforeUpdate

data/lib/ar_pg_array/parser.rb

@@ -0,0 +1,160 @@
+require 'json'
+
+module PgArrayParser
+  CURLY_BRACKETS = '{}'.freeze
+  SQUARE_BRACKETS = '[]'.freeze
+  NULL = 'NULL'.freeze
+  NIL = 'nil'.freeze
+  ESCAPE_HASH={'\\'.freeze=>'\\\\'.freeze, '"'.freeze=>'\\"'.freeze}
+
+  def parse_numeric_pgarray(text)
+    text = text.tr(CURLY_BRACKETS, SQUARE_BRACKETS)
+    text.downcase!
+    JSON.load(text)
+  end
+
+  def parse_safe_pgarray(text, &block)
+    if text =~ /^\{([^\}]*)\}$/
+      $1.split(/,\s*/).map!{|v| v == NULL ? nil : yield(v)}
+    else
+      raise "Mailformed array" unless text =~ /^\{\s*/
+      ar, rest = _parse_safe_pgarray($')
+      ar
+    end
+  end
+
+  def _parse_safe_pgarray(text, &block)
+    values = []
+    return values  if text =~ /^\}\s*/
+    if text =~ /^\{\s*/
+      text = $'
+      while true
+        ar, rest = _parse_safe_pgarray(text, &block)
+        values << ar
+        if rest =~ /^\}\s*/
+          return values, $'
+        elsif rest =~ /^,\s*/
+          rest = $'
+        else
+          raise "Mailformed postgres array"
+        end
+        text = rest
+      end
+    else
+      while true
+        raise 'Mailformed Array' unless text =~ /^([^,\}]*)([,\}])\s*/
+        val, sep, rest = $1, $2, $'
+        values << (val == NULL ? nil : yield(val))
+        if sep == '}'
+          return values, rest
+        end
+        text = rest
+      end
+    end
+  end
+
+  def parse_pgarray(text, &block)
+    raise "Mailformed postgres array" unless text =~ /^\{\s*/
+    ar, rest = _parse_pgarray($', &block)
+    ar
+  end
+
+  def _parse_pgarray(text, &block)
+    values = []
+    return values  if text =~ /^\}\s*/
+    if text =~ /^\{\s*/
+      text = $'
+      while true
+        ar, rest = _parse_pgarray(text, &block)
+        values << ar
+        if rest =~ /^\}\s*/
+          return values, $'
+        elsif rest =~ /^,\s*{\s*/
+          rest = $'
+        else
+          raise "Mailformed postgres array"
+        end
+        text = rest
+      end
+    else
+      while true
+        if text =~ /^"((?:\\.|[^"\\])*)"([,}])\s*/
+          val, sep, rest = $1, $2, $'
+          val.gsub!(/\\(.)/, '\1')
+          val = yield val
+        elsif text =~ /^([^,\}]*)([,}])\s*/
+          val, sep, rest = $1, $2, $'
+          val = val == NULL ? nil : yield(val)
+        else
+          raise "Mailformed postgres array"
+        end
+        values << val
+        if sep == '}'
+          return values, rest
+        end
+        text = rest
+      end
+    end
+  end
+
+  def prepare_pg_integer_array(value)
+    val = value.map{|v| v.nil? ? nil : v.to_i}.inspect
+    val.gsub!(NIL, NULL)
+    val.tr!(SQUARE_BRACKETS, CURLY_BRACKETS)
+    val
+  end
+
+  def prepare_pg_float_array(value)
+    val = value.map{|v| v.nil? ? nil : v.to_f}.inspect
+    val.gsub!(NIL, NULL)
+    val.tr!(SQUARE_BRACKETS, CURLY_BRACKETS)
+    val
+  end
+
+  def prepare_pg_safe_array(value)
+    value = value.map{|val|
+        case val
+        when Array
+          prepare_pg_safe_array(val)
+        when nil
+          NULL
+        else
+          val.to_s
+        end
+    }.join(',')
+    "{#{value}}"
+  end
+
+  def prepare_pg_text_array(value)
+    value = value.map{|val|
+      case val
+      when Array
+        prepare_pg_text_array(val)
+      when nil
+        NULL
+      else
+         "\"#{val.to_s.gsub(/\\|"/){|s| ESCAPE_HASH[s]}}\""
+      end
+    }.join(',')
+    "{#{value}}"
+  end
+
+  def prepare_pg_string_array(value, &block)
+    value = value.map{|val|
+      case val
+      when Array
+        prepare_pg_string_array(val, &block)
+      when nil
+        NULL
+      else
+        val = yield val
+        if val =~ /^'(.*)'$/m
+          "\"#{ $1.gsub(/\\|"/){|s| ESCAPE_HASH[s]} }\""
+        else
+          val
+        end
+      end
+    }.join(',')
+    "{#{value}}"
+  end
+end

data/lib/ar_pg_array/querying.rb

@@ -1,37 +1,25 @@
 module ActiveRecord
   class Base
     class << self
-      if private_method_defined? :attribute_condition
-        def attribute_condition_with_postgresql_arrays(quoted_column_name, argument)
-          if ::PGArrays::PgArray === argument
-            case argument
-              when ::PGArrays::PgAny then      "#{quoted_column_name} && ?"
-              when ::PGArrays::PgAll then      "#{quoted_column_name} @> ?"
-              when ::PGArrays::PgIncludes then "#{quoted_column_name} <@ ?"
-              else "#{quoted_column_name} = ?"
-            end
-          else
-            attribute_condition_without_postgresql_arrays(quoted_column_name, argument)
+      def attribute_condition_with_postgresql_arrays(quoted_column_name, argument)
+        if ::PGArrays::PgArray === argument
+          case argument
+            when ::PGArrays::PgAny then      "#{quoted_column_name} && ?"
+            when ::PGArrays::PgAll then      "#{quoted_column_name} @> ?"
+            when ::PGArrays::PgIncludes then "#{quoted_column_name} <@ ?"
+            else "#{quoted_column_name} = ?"
           end
+        else
+          attribute_condition_without_postgresql_arrays(quoted_column_name, argument)
         end
-        alias_method_chain :attribute_condition, :postgresql_arrays
       end
+      alias_method_chain :attribute_condition, :postgresql_arrays
       
-      if instance_method(:quote_bound_value).arity == 1
-        def quote_bound_value_with_postgresql_arrays(value)
-          if ::PGArrays::PgArray === value
-            connection.quote_array_by_base_type(value, value.base_type)
-          else
-            quote_bound_value_without_postgresql_arrays(value)
-          end
-        end
-      else
-        def quote_bound_value_with_postgresql_arrays(value, c = connection)
-          if ::PGArrays::PgArray === value
-            c.quote_array_by_base_type(value, value.base_type)
-          else
-            quote_bound_value_without_postgresql_arrays(value, c)
-          end
+      def quote_bound_value_with_postgresql_arrays(value)
+        if ::PGArrays::PgArray === value
+          connection.quote_array_by_base_type(value, value.base_type)
+        else
+          quote_bound_value_without_postgresql_arrays(value)
         end
       end
       alias_method_chain :quote_bound_value, :postgresql_arrays

data/lib/ar_pg_array/schema.rb

@@ -1,12 +1,16 @@
+require 'ar_pg_array/parser'
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLColumn < Column #:nodoc:
+      include PgArrayParser
+      extend PgArrayParser
+
       BASE_TYPE_COLUMNS = Hash.new{|h, base_type| 
         base_column= new(nil, nil, base_type.to_s, true)
         h[base_type] = h[base_column.type]= base_column
       }
       attr_reader :base_column
-    
+
       def initialize(name, default, sql_type = nil, null = true)
         if sql_type =~ /^(.+)\[\]$/
           @base_sql_type = $1
@@ -14,7 +18,7 @@ module ActiveRecord
         end
         super(name, self.class.extract_value_from_default(default), sql_type, null)
       end
-      
+
       def simplified_type_with_postgresql_arrays(field_type)
         if field_type=~/^(.+)\[\]$/
           :"#{simplified_type_without_postgresql_arrays($1)}_array"
@@ -36,17 +40,17 @@ module ActiveRecord
         return nil if value.nil?
         case type
           when :integer_array, :float_array 
-            self.class.string_to_num_array(value)
+            string_to_num_array(value)
           when :decimal_array, :date_array, :boolean_array
             safe_string_to_array(value)
           when :timestamp_array, :time_array, :datetime_array, :binary_array
             string_to_array(value)
           when :text_array, :string_array
-            self.class.string_to_text_array(value)
+            string_to_text_array(value)
           else super
         end
       end
-      
+
       def type_cast_code(var_name)
         case type
           when :integer_array, :float_array
@@ -60,70 +64,79 @@ module ActiveRecord
           else super
         end
       end
-      
-      def safe_string_to_array(string)
+
+      def default
+        res = super
+        Array === res ? res.dup : res
+      end
+
+      def self._string_to_array(string)
         return string unless string.is_a? String
         return nil if string.empty?
-        
-        string[1...-1].split(',').map{|v| @base_column.type_cast(v)}
+
+        yield
       end
-      
-      def string_to_array(string)
+
+      def _string_to_array(string)
         return string unless string.is_a? String
         return nil if string.empty?
-        
-        self.class.string_to_text_array(string).map{|v| @base_column.type_cast(v)}
+
+        yield
+      end
+
+      def safe_string_to_array(string)
+        _string_to_array(string) do
+          parse_safe_pgarray(string){|v| @base_column.type_cast(v)}
+        end
       end
-      
+
       def self.safe_string_to_array(string, sql_type)
-        return string unless string.is_a? String
-        return nil if string.empty?
-        
-        base_column = BASE_TYPE_COLUMNS[sql_type]
-        string[1...-1].split(',').map{|v| base_column.type_cast(v)}
+        _string_to_array(string) do
+          base_column = BASE_TYPE_COLUMNS[sql_type]
+          parse_safe_pgarray(string){|v| base_column.type_cast(v)}
+        end
+      end
+
+      def string_to_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| @base_column.type_cast(v)}
+        end
       end
-      
+
       def self.string_to_array(string, sql_type)
-        return string unless string.is_a? String
-        return nil if string.empty?
+        _string_to_array(string) do
+          base_column = BASE_TYPE_COLUMNS[sql_type]
+          parse_pgarray(string){|v| base_column.type_cast(v)}
+        end
+      end
 
-        base_column = BASE_TYPE_COLUMNS[sql_type]
-        string_to_text_array( string ).map{|v| base_column.type_cast(v)}
+      def string_to_num_array(string)
+        _string_to_array(string) do
+          parse_numeric_pgarray(string)
+        end
       end
-      
+
       def self.string_to_num_array(string)
-        return string unless string.is_a? String
-        return nil if string.empty?
-        
-        eval(string.tr('{}','[]'))
+        _string_to_array(string) do
+          parse_numeric_pgarray(string)
+        end
+      end
+
+      def string_to_text_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| v}
+        end
       end
-      
-      SARRAY_QUOTED = /^"((?:\\.|[^\\])*)"$/m
-      SARRAY_PARTIAL = /^".*(\\"|[^"])$/m
-      def self.string_to_text_array(value)
-        return value unless value.is_a? String
-        return nil if value.empty?
-        
-        values = value[1...-1].split(',')
-        partial = false
-        values.inject([]) do |res, s|
-          if partial
-            s = res.pop << ",#{s}"
-          elsif s=~ SARRAY_PARTIAL
-            partial = true
-          end
-          if s =~ SARRAY_QUOTED
-            s = $1.gsub(/\\(.)/,'\1')
-            partial = false
-          elsif s == 'NULL'
-            s = nil
-          end
-          res << s
+
+      def self.string_to_text_array(string)
+        _string_to_array(string) do
+          parse_pgarray(string){|v| v}
         end
       end
     end
-    
+
     class PostgreSQLAdapter #:nodoc:
+      include PgArrayParser
       def quote_with_postgresql_arrays(value, column = nil)
         if Array === value && column && "#{column.type}" =~ /^(.+)_array$/
           quote_array_by_base_type(value, $1, column)
@@ -132,29 +145,19 @@ module ActiveRecord
         end
       end
       alias_method_chain :quote, :postgresql_arrays
-      
+
       def quote_array_by_base_type(value, base_type, column = nil)
         case base_type.to_sym
-        when :integer, :float, :decimal, :boolean, :date, :safe,
-          :string, :text, :other, :datetime, :timestamp, :time
-          quote_array_for_arel_by_base_type( value, base_type )
+        when :integer, :float, :decimal, :boolean, :date, :safe, :datetime, :timestamp, :time
+          "'#{ prepare_array_for_arel_by_base_type(value, base_type) }'"
+        when :string, :text, :other
+          pa = prepare_array_for_arel_by_base_type(value, base_type)
+          "'#{ quote_string( pa ) }'"
         else
           "'#{ prepare_pg_string_array(value, base_type, column) }'"
         end
       end
 
-      def quote_array_for_arel_by_base_type( value, base_type )
-        case base_type.to_sym
-          when :integer, :float, :decimal, :boolean, :date, :safe, :datetime, :timestamp, :time
-            "'#{ prepare_array_for_arel_by_base_type(value, base_type) }'"
-          when :string, :text, :other
-            pa = prepare_array_for_arel_by_base_type(value, base_type)
-            "'#{ quote_string( pa ) }'"
-          else
-            raise "Unsupported array base type #{base_type} for arel"
-        end
-      end
-    
       def prepare_array_for_arel_by_base_type(value, base_type)
         case base_type.to_sym
           when :integer
@@ -166,57 +169,21 @@ module ActiveRecord
           when :datetime, :timestamp, :time
             prepare_pg_string_array(value, base_type)
           when :decimal, :boolean, :date, :safe
-            prepare_pg_string_safe_array(value)
+            prepare_pg_safe_array(value)
           else
             raise "Unsupported array base type #{base_type} for arel"
         end
       end
-      
-      def prepare_pg_integer_array(value)
-        "{#{ value.map{|v| v.nil? ? 'NULL' : v.to_i}.join(',')}}"
-      end
-      
-      def prepare_pg_float_array(value)
-        "{#{ value.map{|v| v.nil? ? 'NULL' : v.to_f}.join(',')}}"
-      end
-      
-      def prepare_pg_string_safe_array(value)
-        "{#{ value.map{|v| v.nil? ? 'NULL' : v.to_s}.join(',')}}"
-      end
-      
-      ESCAPE_HASH={'\\'=>'\\\\', '"'=>'\\"'}
+
       def prepare_pg_string_array(value, base_type, column=nil)
         base_column= if column
                        column.base_column
                      else
                        PostgreSQLColumn::BASE_TYPE_COLUMNS[base_type.to_sym]
                      end
-        value = value.map do|v| 
-            unless v.nil?
-              v = quote_without_postgresql_arrays(v, base_column)
-              if v=~/^'(.+)'$/m then
-                "\"#{$1.gsub(/\\|"/){|s| ESCAPE_HASH[s]}}\""
-              else
-                v
-              end
-            else
-              'NULL'
-            end
-        end
-        "{#{ value.join(',')}}"
+        super(value){|v| quote_without_postgresql_arrays(v, base_column)}
       end
 
-      class CNULL; def inspect; 'NULL'; end; alias to_s inspect end
-      NULL = CNULL.new
-
-      TESCAPE_HASH={'\\'=>'\\\\', '"'=>'\\"'}
-      def prepare_pg_text_array(value)
-        value = value.map{|v|
-             v ? "\"#{v.to_s.gsub(/\\|"/){|s| TESCAPE_HASH[s]}}\"" : NULL
-        }.join(',')
-        "{#{value}}"
-      end
-      
       NATIVE_DATABASE_TYPES.keys.each do |key|
         unless key==:primary_key
           base = NATIVE_DATABASE_TYPES[key].dup
@@ -242,7 +209,7 @@ module ActiveRecord
           EOV
         end
       end
-      
+
       def add_column_with_postgresql_arrays( table, column, type, options = {} )
         if type.to_s =~ /^(.+)_array$/ && options[:default].is_a?(Array)
           options = options.merge(:default => prepare_array_for_arel_by_base_type(options[:default], $1))
@@ -250,7 +217,7 @@ module ActiveRecord
         add_column_without_postgresql_arrays( table, column, type, options )
       end
       alias_method_chain :add_column, :postgresql_arrays
-      
+
       def type_to_sql_with_postgresql_arrays(type, limit = nil, precision = nil, scale = nil)
         if type.to_s =~ /^(.+)_array$/
           type_to_sql_without_postgresql_arrays($1.to_sym, limit, precision, scale)+'[]'
@@ -258,7 +225,7 @@ module ActiveRecord
           type_to_sql_without_postgresql_arrays(type, limit, precision, scale)
         end
       end
-      
+
       alias_method_chain :type_to_sql, :postgresql_arrays
     end
   end

data/lib/ar_pg_array/schema_cacheable.rb

@@ -1,11 +1,6 @@
-adjust_cached_types = lambda do |atcbd|
-  atcbd << /_array$/
-  def atcbd.include?(val)
-    any?{|type| type === val}
-  end
-end
-if ActiveRecord::VERSION::MAJOR < 3
-  adjust_cached_types.call(ActiveRecord::AttributeMethods::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT)
-else
-  adjust_cached_types.call(ActiveRecord::AttributeMethods::Read::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT)
+atcbd = ActiveRecord::AttributeMethods::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+
+atcbd << /_array$/
+def atcbd.include?(val)
+  any?{|type| type === val}
 end

data/spec/fixtures/item.rb

@@ -1,3 +1,4 @@
 class Item < ActiveRecord::Base
   references_by_array :tags, :validate=>true
+  serialize :for_yaml
 end

data/spec/fixtures/schema.rb

@@ -1,22 +1,28 @@
 ActiveRecord::Schema.define do
-	create_table "tags", :force => true do |t|
-	  t.string :name
-	  t.timestamps
-	end
-	
-	create_table "items", :force => true do |t|
-	  t.string :value
-	  t.integer_array :tag_ids,  :default => [1, 2]
-	  t.string_array :tag_names, :default => %w{as so}
-	end
-	
+  create_table "tags", :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table "items", :force => true do |t|
+    t.string :value
+    t.integer_array :tag_ids,  :default => [1, 2]
+    t.string_array :tag_names, :default => %w{as so}
+    t.text :for_yaml
+  end
+
   create_table "bulks", :force => true do |t|
-	  t.string :value, :default => "'"
-	  t.integer_array :ints,  :default => [1, 2]
-	  t.string_array :strings, :default => %w{as so}
-	  t.timestamp_array :times,  :default => %w{2010-01-01 2010-02-01}
-	  t.float_array :floats,     :default => [1.0, 1.2]
-	  t.decimal_array :decimals, :default => [1.0, 1.2]
+    t.string :value, :default => "'"
+    t.integer_array :ints,  :default => [1, 2]
+    t.string_array :strings, :default => %w{as so}
+    t.timestamp_array :times,  :default => %w{2010-01-01 2010-02-01}
+    t.float_array :floats,     :default => [1.0, 1.2]
+    t.decimal_array :decimals, :default => [1.0, 1.2]
     t.text_array :texts, :default => [nil, 'Text', 'NULL', 'Text with nil', 'Text with , nil, !"\\', 'nil']
-	end
+  end
+
+  create_table "unrelateds", :force => true do |t|
+    t.text :for_yaml
+    t.text :for_custom_serialize
+  end
 end

data/spec/fixtures/unrelated.rb

@@ -0,0 +1,21 @@
+require 'base64'
+class Unrelated < ActiveRecord::Base
+  class MySerializer
+    def initialize(val)
+      @val = val
+    end
+
+    def self.dump(obj)
+      Base64.encode64(Marshal.dump(obj))
+    end
+
+    def self.load(str)
+      if str
+        Marshal.load(Base64.decode64(str))
+      end
+    end
+  end
+
+  serialize :for_yaml
+  serialize :for_custom_serialize, MySerializer
+end

data/spec/fixtures/unrelateds.yml

@@ -0,0 +1,3 @@
+item1:
+  id: 1
+  for_yaml: {"a": "b"}

data/spec/pg_array_spec.rb

@@ -83,6 +83,13 @@ describe "PgArray" do
       map_times(bulk.times).should == 
           map_times(parse_times(%w{2010-01-01 2010-02-01}))
     end
+
+    it "should not alter defaults" do
+      bulk = Bulk.new
+      bulk.strings.push :foo
+      bulk = Bulk.new
+      bulk.strings.should == %w{as so}
+    end
     
     it "should save changes" do
       bulk = Bulk.find(3)
@@ -152,6 +159,39 @@ describe "PgArray" do
       bulk.ints.should == new
     end
 
+    it 'should not break yaml serialization on model with array' do
+      item = Item.find(1)
+      item.for_yaml = {:a => :b}
+      item.save.should be_true
+      copy = Item.find(1)
+      copy.for_yaml.should == {:a => :b}
+      copy.for_yaml = ['a', 'b']
+      copy.save.should be_true
+      copy = Item.find(1)
+      copy.for_yaml.should == ['a', 'b']
+    end
+
+    it 'should not break yaml serialization on unrelated model' do
+      item = Unrelated.find(1)
+      item.for_yaml.should == {'a' => 'b'}
+      item.for_yaml = {:a => :b}
+      item.save.should be_true
+      copy = Unrelated.find(1)
+      copy.for_yaml.should == {:a => :b}
+      copy.for_yaml = ['a', 'b']
+      copy.save.should be_true
+      copy = Unrelated.find(1)
+      copy.for_yaml.should == ['a', 'b']
+    end
+
+    it 'should not break custom serialization on model with array' do
+      obj = Unrelated::MySerializer.new(%w{hello world})
+      model = Unrelated.create!(:for_custom_serialize => obj)
+      model.for_custom_serialize.to_yaml.should == obj.to_yaml
+      model2 = Unrelated.find(model.id)
+      model2.for_custom_serialize.to_yaml.should == obj.to_yaml
+    end
+
     def map_times(times)
       times.map{|t| t.strftime("%F %T")}
     end

data/spec/spec_helper.rb

@@ -38,6 +38,7 @@ ActiveRecord::Base.logger = Logger.new(STDOUT) #if $0 == 'irb'
 require 'tag'
 require 'item'
 require 'bulk'
+require 'unrelated'
 ActiveRecord::Base.silence do
   ActiveRecord::Migration.verbose = false
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ar_pg_array
 version: !ruby/object:Gem::Version
-  version: 0.9.13
+  version: 0.10.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,30 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-11 00:00:00.000000000 Z
+date: 2012-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &84224510 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *84224510
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.5
 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.
@@ -38,12 +49,10 @@ files:
 - init.rb
 - lib/ar_pg_array.rb
 - lib/ar_pg_array/allways_save.rb
+- lib/ar_pg_array/parser.rb
 - lib/ar_pg_array/querying.rb
-- lib/ar_pg_array/querying_arel.rb
 - lib/ar_pg_array/references_by.rb
 - lib/ar_pg_array/schema.rb
-- lib/ar_pg_array/schema_arel.rb
-- lib/ar_pg_array/schema_cachable.rb
 - lib/ar_pg_array/schema_cacheable.rb
 - lib/ar_pg_array/schema_fix_will_change.rb
 - spec/fixtures/bulk.rb
@@ -53,6 +62,8 @@ files:
 - spec/fixtures/schema.rb
 - spec/fixtures/tag.rb
 - spec/fixtures/tags.yml
+- spec/fixtures/unrelated.rb
+- spec/fixtures/unrelateds.yml
 - spec/pg_array_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -76,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ar-pg-array
-rubygems_version: 1.8.12
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Use power of PostgreSQL Arrays in ActiveRecord

data/lib/ar_pg_array/querying_arel.rb

@@ -1,234 +0,0 @@
-if Arel::VERSION >= '2.0'
-  module Arel
-    module Nodes
-      class ArrayAny < Arel::Nodes::Binary
-      end
-
-      class ArrayAll < Arel::Nodes::Binary
-      end
-
-      class ArrayIncluded < Arel::Nodes::Binary
-      end
-    end
-
-    module Predications
-      def ar_any other
-        Nodes::ArrayAny.new self, other
-      end
-
-      def ar_all other
-        Nodes::ArrayAll.new self, other
-      end
-
-      def ar_included other
-        Nodes::ArrayIncluded.new self, other
-      end
-    end
-
-    module Visitors
-      class PostgreSQL
-        def visit_Arel_Nodes_ArrayAny o
-          "#{visit o.left} && #{visit o.right}"
-        end
-
-        def visit_Arel_Nodes_ArrayAll o
-          "#{visit o.left} @> #{visit o.right}"
-        end
-
-        def visit_Arel_Nodes_ArrayIncluded o
-          "#{visit o.left} <@ #{visit o.right}"
-        end
-
-        def visit_PGArrays_PgArray o
-          @connection.quote_array_for_arel_by_base_type(o, o.base_type)
-        end
-
-        alias :visit_PGArrays_PgAny :visit_PGArrays_PgArray
-        alias :visit_PGArrays_PgAll :visit_PGArrays_PgArray
-        alias :visit_PGArrays_PgIncluded :visit_PGArrays_PgArray
-      end
-    end
-  end
-else
-  module Arel
-    module Predicates
-      class ArrayAny < Binary
-        def eval(row)
-          !(operand1.eval(row) & operand2.eval(row)).empty?
-        end
-      
-        def predicate_sql
-          "&&"
-        end
-      end
-      
-      class ArrayAll < Binary
-        def eval(row)
-          (operand2.eval(row) - operand1.eval(row)).empty?
-        end
-        
-        def predicate_sql
-          "@>"
-        end
-      end
-      
-      class ArrayIncluded < Binary
-        def eval(row)
-          (operand1.eval(row) - operand2.eval(row)).empty?
-        end
-        
-        def predicate_sql
-          "<@"
-        end
-      end
-    end
-    
-    class Attribute
-      methods = lambda do
-        def ar_any(other)
-          Predicates::ArrayAny.new(self, other)
-        end
-        
-        def ar_all(other)
-          Predicates::ArrayAll.new(self, other)
-        end
-        
-        def ar_included(other)
-          Predicates::ArrayIncluded.new(self, other)
-        end
-      end
-      if defined? PREDICATES
-        PREDICATES.concat [:ar_any, :ar_all, :ar_included]
-        class_exec &methods
-      else
-        Predications.class_exec &methods
-      end
-    end
-  end
-
-  module PGArrays
-    class PgArray
-      def to_sql( formatter = nil )
-        formatter.engine.connection.quote_array_for_arel_by_base_type(self, base_type)
-      end
-      
-      def to_a
-        self
-      end
-    end
-  end
-end
-
-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
-
-        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
-            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
-
-        predicates.flatten
-      end
-    end
-  end
-end

data/lib/ar_pg_array/schema_arel.rb

@@ -1,105 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter
-      def prepare_for_arel( value, column )
-        return value unless value
-        if Array === value && "#{column.type}" =~ /^(.+)_array$/
-          prepare_array_for_arel_by_base_type(value, $1)
-        else
-          super
-        end
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  # I hope ticket 5047 will be included in Rails 3 reliz
-  unless ConnectionAdapters::AbstractAdapter.method_defined? :prepare_for_arel
-    module ConnectionAdapters
-      class AbstractAdapter
-        def prepare_for_arel( value, column )
-          if value && (value.is_a?(Hash) || value.is_a?(Array))
-            value.to_yaml
-          else
-            value
-          end
-        end
-      end
-    end
-  
-    class Base
-      private
-      # Returns a copy of the attributes hash where all the values have been safely quoted for use in
-      # an Arel insert/update method.
-      def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
-        attrs = {}
-        attribute_names.each do |name|
-          if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
-  
-            if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
-              value = read_attribute(name)
-  
-              if value && self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))
-                value = value.to_yaml
-              else
-                value = self.class.connection.prepare_for_arel(value, column)
-              end
-              attrs[self.class.arel_table[name]] = value
-            end
-          end
-        end
-        attrs
-      end    
-    end
-  end
-end
-
-module Arel
-  module Attributes
-    %w{Integer Float Decimal Boolean String Time}.each do |basetype|
-      module_eval <<-"END"
-        class #{basetype}Array < Attribute
-        end
-      END
-    end
-  end
-
-  if Arel::VERSION < '2.0'
-    module Sql
-      module Attributes
-        class << self
-          def for_with_postgresql_arrays(column)
-            if column.type.to_s =~ /^(.+)_array$/
-              ('Arel::Sql::Attributes::' + for_without_postgresql_arrays(column.base_column).name.split('::').last + 'Array').constantize
-            else
-              for_without_postgresql_arrays(column)
-            end
-          end
-          alias_method_chain :for, :postgresql_arrays
-        end
-        
-        %w{Integer Float Decimal Boolean String Time}.each do |basetype|
-          module_eval <<-"END"
-            class #{basetype}Array < Arel::Attributes::#{basetype}Array
-              include Attributes
-            end
-          END
-        end
-      end
-    end
-  else
-    module Attributes
-      class << self
-        def for_with_postgresql_arrays(column)
-          if column.type.to_s =~ /^(.+)_array$/
-            ('Arel::Attributes::' + for_without_postgresql_arrays(column.base_column).name.split('::').last + 'Array').constantize
-          else
-            for_without_postgresql_arrays(column)
-          end
-        end
-        alias_method_chain :for, :postgresql_arrays
-      end
-    end
-  end
-end

data/lib/ar_pg_array/schema_cachable.rb

@@ -1,11 +0,0 @@
-adjust_cached_types = lambda do |atcbd|
-  atcbd << /_array$/
-  def atcbd.include?(val)
-    any?{|type| type === val}
-  end
-end
-if ActiveRecord::VERSION::MAJOR < 3
-  adjust_cached_types.call(ActiveRecord::AttributeMethods::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT)
-else
-  adjust_cached_types.call(ActiveRecord::AttributeMethods::Read::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT)
-end