ar_pg_array 0.8.4 → 0.9.0

data/VERSION

@@ -1 +1 @@
-0.8.4
+0.9.0

data/lib/ar_pg_array/querying.rb

@@ -17,13 +17,23 @@ module ActiveRecord
         alias_method_chain :attribute_condition, :postgresql_arrays
       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)
+      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
         end
-      end                                              
+      end
       alias_method_chain :quote_bound_value, :postgresql_arrays
     end
   end
@@ -55,13 +65,13 @@ module PGArrays
     end
   
     class PgAll
-      def include?
+      def include?(v)
         Array === v && (self - v).empty?
       end
     end
 
     class PgIncludes < PgArray
-      def include?
+      def include?(v)
         Array === v && (v - self).empty?
       end
     end

data/lib/ar_pg_array/querying_arel.rb

@@ -32,7 +32,7 @@ module Arel
   end
   
   class Attribute
-    module Predications
+    methods = lambda do
       def ar_any(other)
         Predicates::ArrayAny.new(self, other)
       end
@@ -58,13 +58,19 @@ module Arel
         end
       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.quote_array_for_arel_by_base_type(self, base_type)
+      formatter.engine.connection.quote_array_for_arel_by_base_type(self, base_type)
     end
     
     def to_a

data/lib/ar_pg_array/references_by.rb

@@ -1,69 +1,153 @@
 module PGArrays
   module ReferencesBy
-  	class RelationHolder < Struct.new(:relation, :field, :klass)
-  	  
-  	  def referenced(obj)
-  	  	ids = obj.read_attribute(field) || []
- 	  	klass.find( ids.sort ).sort_by{|o| ids.index(o.id)}
-  	  end
-  	  
-  	  def set_referenced(obj, value)
-        value = value.map{|v| 
-  	      case v
-  	  	    when ActiveRecord::Base then v.id
-  	  	    when nil then nil
-  	  	    else v.to_i
-  	  	  end
-  	  	}.compact
-  	  	obj.write_attribute( field, value )
-  	  end
-  	  
-  	  def validate(obj)
-  	  	has_ids = klass.find(:all, :select=>'id', :conditions=>{:id=>obj.read_attribute(field)}).map(&:id)
-  	  	unless has_ids.sort == obj.read_attribute(field).sort
-  	  	  obj.errors.add(relation, :wrong_array_reference)
-  	  	end
-  	  end
-  	  
-  	  def for_referenced(obj_klass)
-  	  	condition = lambda do |obj| 
-  	  	  { :conditions=>{field.to_sym => case obj when klass then obj.id else obj.to_i end} } 
-  	  	end
-  	  	obj_klass.send(:named_scope, "#{relation}_include", condition )
-  	  end
-  	  
-  	end
-  	
-  	module ClassMethods
-  	  def references_by_array( relation, options = {} )
-  	  	unless ActiveSupport::Memoizable === self
-  	  	  extend ActiveSupport::Memoizable
-  	  	end
+    if defined? ::Arel
+      HAS_AREL=true
+      NAMED_SCOPE='scope'
+    else
+      NAMED_SCOPE='named_scope'
+      if defined? ::FakeArel
+        HAS_AREL= true
+      else
+        HAS_AREL=false
+      end
+    end
 
-  	  	relation = relation.to_s.pluralize
-  	  	field = "#{relation.singularize}_ids"
-  	  	klass_name = (options[:class_name] || relation).to_s.singularize.camelize
-  	    klass = klass_name.constantize
-  	    holder = RelationHolder.new(relation, field, klass )
-  	    
-  	    define_method(relation) do
-  	      holder.referenced(self)
-  	    end
-  	    memoize relation
-  	    
-  	    define_method("#{relation}=") do |value|
-  	      flush_cache(relation)
-  	      holder.set_referenced(self, value)
-  	    end
-  	    
-  	    if options[:validate]
-  	      validate {|o| holder.validate(o)}
-  	    end
-  	    
-  	    holder.for_referenced(self)
-  	  end
-  	  
-  	end
+    class RelationHolder < Struct.new(:relation, :field, :klass)
+      
+      def referenced(obj)
+        ids = obj[field] || []
+        objs = klass.find_all_by_id( ids.sort )
+        if ids.size < 20
+          objs.sort_by{|o| ids.index(o.id)}
+        else
+          to_ind = ids.each_with_index.inject({}){|h, (v,i)| h[v]=i; h}
+          objs.sort_by{|o| to_ind[o.id]}
+        end
+      end
+      
+      def set_referenced(obj, value)
+        obj[field] = map_to_ids(value)
+      end
+      
+      if HAS_AREL
+        def validate(obj)
+          has_ids = klass.where(:id=>obj.read_attribute(field)).
+                    select('id').all.map(&:id)
+          unless has_ids.sort == obj.read_attribute(field).sort
+            obj.errors.add(relation, :wrong_array_reference)
+          end
+        end
+
+        def for_referenced(obj_klass)
+          myself = self
+          obj_klass.class_exec do
+            puts "named_scope #{NAMED_SCOPE} #{myself.relation}_include"
+            self.send NAMED_SCOPE, "#{myself.relation}_include", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_all)
+            }
+            
+            self.send NAMED_SCOPE, "#{myself.relation}_have_all", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_all)
+            }
+
+            self.send NAMED_SCOPE, "#{myself.relation}_have_any", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_any)
+            }
+            
+            self.send NAMED_SCOPE, "#{myself.relation}_included_into", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              where(myself.field.to_sym => objs.search_subarray)
+            }
+          end
+        end
+      else
+        def validate(obj)
+          has_ids = klass.find(:all, 
+              :select=>'id',
+              :conditions=>{:id=>obj.read_attribute(field)}
+              ).map(&:id)
+          unless has_ids.sort == obj.read_attribute(field).sort
+            obj.errors.add(relation, :wrong_array_reference)
+          end
+        end
+        
+        def for_referenced(obj_klass)
+          myself = self
+          obj_klass.class_exec do
+            named_scope "#{myself.relation}_include", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_all } }
+            }
+            
+            named_scope "#{myself.relation}_have_all", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_all } }
+            }
+            
+            named_scope "#{myself.relation}_have_any", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_any } }
+            }
+            
+            named_scope "#{myself.relation}_included_into", lambda{|*objs|
+              objs = myself.map_to_ids objs.flatten
+              { :conditions=>{ myself.field.to_sym => objs.search_subarray } }
+            }
+          end
+        end
+      end
+      
+      def val_to_id(val)
+        case val
+        when ActiveRecord::Base then val.id
+        when nil then nil
+        else val.to_i
+        end
+      end
+      
+      def map_to_ids(vals)
+        (r = vals.map{|v| val_to_id(v)}).compact!
+        r
+      end
+    end
+    
+    module ClassMethods
+      def references_by_array( relation, options = {} )
+        unless ActiveSupport::Memoizable === self
+          extend ActiveSupport::Memoizable
+        end
+
+        relation = relation.to_s.pluralize
+        field = "#{relation.singularize}_ids"
+        klass_name = (options[:class_name] || relation).to_s.singularize.camelize
+        klass = klass_name.constantize
+        holder = RelationHolder.new(relation, field, klass )
+        
+        meths =  Module.new do
+          define_method(relation) do
+            holder.referenced(self)
+          end
+          
+          define_method("#{relation}=") do |value|
+            flush_cache(relation)
+            holder.set_referenced(self, value)
+          end
+        end
+        include meths
+        
+        memoize relation
+        
+        if options[:validate]
+          validate {|o| holder.validate(o)}
+        end
+        
+        holder.for_referenced(self)
+      end
+      
+    end
   end
 end
 

data/lib/ar_pg_array/schema.rb

@@ -216,7 +216,7 @@ module ActiveRecord
               options = args.extract_options!                                   #   options = args.extract_options!
               column_names = args                                               #   column_names = args
                                                                                 #
-              column_names.each { |name| column(name, '#{key}_array', options) }#   column_names.each { |name| column(name, 'string_array', options) }
+              column_names.each { |name| column(name, :'#{key}_array', options) }#   column_names.each { |name| column(name, 'string_array', options) }
             end                                                                 # end
           EOV
           Table.class_eval <<-EOV
@@ -225,7 +225,7 @@ module ActiveRecord
               column_names = args                                               #   column_names = args
                                                                                 #
               column_names.each { |name|                                        #   column_names.each { |name|
-                @base.add_column(@table_name, name, '#{key}_array', options)    #     @base.add_column(@table_name, name, 'string_array', options) }
+                @base.add_column(@table_name, name, :'#{key}_array', options)    #     @base.add_column(@table_name, name, 'string_array', options) }
               }                                                                 #   }
             end                                                                 # end
           EOV
@@ -234,7 +234,7 @@ module ActiveRecord
       
       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, limit, precision, scale)+'[]'
+          type_to_sql_without_postgresql_arrays($1.to_sym, limit, precision, scale)+'[]'
         else
           type_to_sql_without_postgresql_arrays(type, limit, precision, scale)
         end

data/spec/fixtures/bulk.rb

@@ -0,0 +1,2 @@
+class Bulk < ActiveRecord::Base
+end

data/spec/fixtures/bulks.yml

@@ -0,0 +1,28 @@
+first:
+  id: 1
+  ints: [ 1 ]
+  strings: [ one ]
+  times: [<%= Time.now.at_beginning_of_month.to_s(:db)%>, <%= Time.now.at_beginning_of_day.to_s(:db) %>]
+  floats: [1.0, 2.3]
+  decimals: [1.0, 2.3]
+second:
+  id: 2
+  ints: [ 2 ]
+  strings: [ two ]
+  times: [2010-01-01, 2010-02-01]
+  floats: [2.0, 2.3]
+  decimals: [2.0, 2.3]
+third:
+  id: 3
+  ints: [ 2, 3 ]
+  strings: [ two, three ]
+  times: [2010-03-01, 2010-04-01]
+  floats: [2.0, 2.5]
+  decimals: [2.0, 2.5]
+four:
+  id: 4
+  ints: [ ]
+  strings: [ ]
+  times: [ ]
+  floats: [ ]
+  decimals: [ ]

data/spec/fixtures/item.rb

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

data/spec/fixtures/items.yml

@@ -0,0 +1,22 @@
+i1:
+  id: 1
+  tag_ids: [ 1 ]
+i2:
+  id: 2
+  tag_ids: [ 3 ]
+i3:
+  id: 3
+  tag_ids: [ 1, 3 ]
+i4:
+  id: 4
+  tag_ids: [ 3, 1 ]
+i5:
+  id: 5
+  tag_ids: [ 1, 2 ]
+i6:
+  id: 6
+  tag_ids: [ 1, 2, 3 ]
+i7:
+  id: 7
+  tag_ids: [ ]
+

data/spec/fixtures/schema.rb

@@ -0,0 +1,21 @@
+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 "bulks", :force => true do |t|
+	  t.string :value
+	  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]
+	end
+end

data/spec/fixtures/tag.rb

@@ -0,0 +1,2 @@
+class Tag < ActiveRecord::Base
+end

data/spec/fixtures/tags.yml

@@ -0,0 +1,15 @@
+one:
+  id: 1
+  name: one
+  created_at: <%= Date.today.to_s(:db) %>
+  updated_at: <%= Time.now.to_s(:db) %>
+two:
+  id: 2
+  name: two
+  created_at: <%= Date.today.to_s(:db) %>
+  updated_at: <%= Time.now.to_s(:db) %>
+three:
+  id: 3
+  name: three
+  created_at: <%= Date.today.to_s(:db) %>
+  updated_at: <%= Time.now.to_s(:db) %>

data/spec/pg_array_spec.rb

@@ -0,0 +1,221 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "PgArray" do
+  describe "Array" do
+    before :all do
+      @ability_class = Class.new do
+        include CanCan::Ability
+      end
+      @acheck = Struct.new(:a)
+    end
+    
+    before :each do
+      @ability = @ability_class.new
+    end
+    
+    it "should change type" do
+      [].pg.should be_an_instance_of(PGArrays::PgArray)
+      [].search_any.should be_an_instance_of(PGArrays::PgAny)
+      [].search_all.should be_an_instance_of(PGArrays::PgAll)
+      [].search_subarray.should be_an_instance_of(PGArrays::PgIncludes)
+    end
+    
+    it "should provide search_any for cancan" do
+      ab.can :boom, @acheck, :a => [1, 2].search_any
+      ab.should be_able_to(:boom, the([1]))
+      ab.should be_able_to(:boom, the([1, 3]))
+      ab.should be_able_to(:boom, the([3, 1]))
+      ab.should be_able_to(:boom, the([1, 2]))
+      ab.should be_able_to(:boom, the([1, 2, 3]))
+      ab.should_not be_able_to(:boom, the([3]))
+      ab.should_not be_able_to(:boom, the([]))
+    end
+    
+    it "should provide search_all for cancan" do
+      ab.can :boom, @acheck, :a => [1, 2].search_all
+      ab.should_not be_able_to(:boom, the([1]))
+      ab.should_not be_able_to(:boom, the([1, 3]))
+      ab.should_not be_able_to(:boom, the([3, 1]))
+      ab.should be_able_to(:boom, the([1, 2]))
+      ab.should be_able_to(:boom, the([1, 2, 3]))
+      ab.should_not be_able_to(:boom, the([3]))
+      ab.should_not be_able_to(:boom, the([]))
+    end
+    
+    it "should provide search_subarray for cancan" do
+      ab.can :boom, @acheck, :a => [1, 2].search_subarray
+      ab.should be_able_to(:boom, the([1]))
+      ab.should_not be_able_to(:boom, the([1, 3]))
+      ab.should_not be_able_to(:boom, the([3, 1]))
+      ab.should be_able_to(:boom, the([1, 2]))
+      ab.should_not be_able_to(:boom, the([1, 2, 3]))
+      ab.should_not be_able_to(:boom, the([3]))
+      ab.should be_able_to(:boom, the([]))
+    end
+        
+    def the(ar)
+      @acheck.new(ar)
+    end
+    
+    def ab
+      @ability
+    end
+  end
+  
+  describe "AR" do
+    it "should adequatly insert fixtures" do
+      bulk = Bulk.find(1)
+      bulk.ints.should == [ 1 ]
+      bulk.strings.should == %w{one}
+      bulk.times.should == [Time.now.at_beginning_of_month, Time.now.at_beginning_of_day]
+      bulk.floats.should == [1.0, 2.3]
+      bulk.decimals.should == [1.0, 2.3]
+    end
+    
+    it "should be created with defaults" do
+      bulk = Bulk.new
+      bulk.ints.should == [1, 2]
+      bulk.strings.should == %w{as so}
+      bulk.floats.should == [1.0, 1.2]
+      bulk.decimals.should == [1.0, 1.2]
+      map_times(bulk.times).should == 
+          map_times(parse_times(%w{2010-01-01 2010-02-01}))
+    end
+    
+    it "should save changes" do
+      bulk = Bulk.find(3)
+      for field in %w{ints strings floats decimals times}
+        bulk.send(field+'=', bulk.send(field).reverse)
+      end
+      bulk.save!
+      bulk = Bulk.find(:first, :conditions=>'3 = id')
+      bulk.ints.should == [3, 2]
+      bulk.strings.should == %w{three two}
+      bulk.floats.should == [2.5, 2]
+      bulk.decimals.should == [2.5, 2]
+      map_times(bulk.times).should == map_times(parse_times(%w{2010-04-01 2010-03-01}))
+    end
+    
+    it "should allow to use sql" do
+      bulks_where(['ints && ?', [1,2].pg]).should == bulks_where(:id=>[1,2,3])
+    end
+    
+    it "should allow to use finders" do
+      bulks_where(:ints => [2].search_any).should == bulks_where(:id=>[2,3])
+      bulks_where(:ints => [2,3].search_any).should == bulks_where(:id=>[2,3])
+      bulks_where(:ints => [1,2].search_any).should == bulks_where(:id=>[1,2,3])
+      
+      bulks_where(:ints => [2].search_all).should == bulks_where(:id=>[2,3])
+      bulks_where(:ints => [2,3].search_all).should == bulks_where(:id=>[3])
+      bulks_where(:ints => [1,2].search_all).should == []
+      
+      bulks_where(:ints => [2].search_subarray).should == bulks_where(:id=>[2,4])
+      bulks_where(:ints => [2,3].search_subarray).should == bulks_where(:id=>[2,3,4])
+      bulks_where(:ints => [1,2].search_subarray).should == bulks_where(:id=>[1,2,4])
+    end
+    
+    def map_times(times)
+      times.map{|t| t.strftime("%F %T")}
+    end
+    
+    def parse_times(times)
+      times.map{|t| DateTime.parse(t)}
+    end
+    
+    def bulks_where(cond)
+      Bulk.where(cond).order('id').all
+    end
+  end
+  
+  describe "CanCan" do
+    before :all do
+      @ability_class = Class.new do
+        include CanCan::Ability
+      end
+      @all_items = Item.all
+    end
+    
+    before :each do
+      @ability = @ability_class.new
+    end
+    
+    it "should provide search_any for cancan" do
+      should_match_ids_with_ability [2, 3, 4, 6], :tag_ids => [3].search_any
+      should_match_ids_with_ability [1, 3, 4, 5, 6], :tag_ids => [1, 2].search_any
+    end
+    
+    it "should provide search_all for cancan" do
+      should_match_ids_with_ability [2, 3, 4, 6], :tag_ids => [3].search_all
+      should_match_ids_with_ability [5, 6], :tag_ids => [1, 2].search_all
+    end
+    
+    it "should provide search_subarray for cancan" do
+      should_match_ids_with_ability [2, 7], :tag_ids => [3].search_subarray
+      should_match_ids_with_ability [1, 5, 7], :tag_ids => [1, 2].search_subarray
+    end
+    
+    def should_match_ids_with_ability(ids, ability)
+      act = (ability[:tag_ids].class.name + ids.join('_')).to_sym
+      ab.can act, Item, ability
+      items = accessible_items(act)
+      items.should == items_where(:id=>ids)
+      should_be_able_all        items, act
+      should_not_be_able_except items, act
+    end
+    
+    def ab
+      @ability
+    end
+    
+    def accessible_items(act)
+      Item.accessible_by(ab, act).order('id').all
+    end
+    
+    def items_where(cond)
+      Item.where(cond).order('id').all
+    end
+    
+    def should_be_able_all(items, act)
+      items.each{|item| ab.should be_able_to(act, item)}
+    end
+    
+    def should_not_be_able_except(items, act)
+      (@all_items - items).each{|item| ab.should_not be_able_to(act, items)}
+    end
+  end
+  
+  describe "references_by" do
+    it "should fetch tags in saved order" do
+      Item.find(3).tags.should == [Tag.find(1), Tag.find(3)]
+      Item.find(4).tags.should == [Tag.find(3), Tag.find(1)]
+    end
+    
+    it "should save tags references" do
+      item = Item.find(3)
+      item.tags= [Tag.find(1), '3', 2]
+      item.tags.should == [Tag.find(1), Tag.find(3), Tag.find(2)]
+      item.save!
+      item.reload
+      item.tags.should == [Tag.find(1), Tag.find(3), Tag.find(2)]
+      item.tags= [1,3]
+      item.save!
+      item.reload
+      item.tags.should == [Tag.find(1), Tag.find(3)]
+    end
+    
+    it "should define named scopes for tags" do
+      Item.tags_include(3).order('id').all.should == items_where(:id=>[2,3,4,6])
+      Item.tags_include(1,3).order('id').all.should == items_where(:id=>[3,4,6])
+      Item.tags_have_all(3).order('id').all.should == items_where(:id=>[2,3,4,6])
+      Item.tags_have_all(1,3).order('id').all.should == items_where(:id=>[3,4,6])
+      Item.tags_have_any(3).order('id').all.should == items_where(:id=>[2,3,4,6])
+      Item.tags_have_any(1,3).order('id').all.should == items_where(:id=>[1,2,3,4,5,6])
+      Item.tags_included_into(3).order('id').all.should == items_where(:id=>[2,7])
+      Item.tags_included_into(1,3).order('id').all.should == items_where(:id=>[1,2,3,4,7])
+    end
+    
+    def items_where(cond)
+      Item.where(cond).order('id').all
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+gem 'rspec'
+gem 'activerecord'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__) + '/fixtures')
+
+require 'active_record'
+require 'active_record/fixtures'
+gem 'pg'
+begin
+  gem 'arel'
+rescue Gem::LoadError
+  require 'fake_arel'
+  class ActiveRecord::Base
+    named_scope :joins, lambda {|*join| {:joins => join } if join[0]}
+  end
+end
+require 'cancan'
+require 'cancan/matchers'
+require 'ar_pg_array'
+
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'postgresql',
+  :database => 'postgres',
+  :encoding => 'utf8'
+)
+ActiveRecord::Base.connection.create_database('test_pg_array', :encoding=>'utf8') rescue nil
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'postgresql',
+  :database => 'test_pg_array',
+  :encoding => 'utf8'
+)
+ActiveRecord::Base.logger = Logger.new(STDOUT) #if $0 == 'irb'
+
+require 'tag'
+require 'item'
+require 'bulk'
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  # load schema
+  load File.join('spec/fixtures/schema.rb')
+  # load fixtures
+  Fixtures.create_fixtures("spec/fixtures", ActiveRecord::Base.connection.tables)
+end
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar_pg_array
 version: !ruby/object:Gem::Version 
+  hash: 59
   prerelease: false
   segments: 
   - 0
-  - 8
-  - 4
-  version: 0.8.4
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Sokolov Yura aka funny_falcon
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-19 00:00:00 +04:00
+date: 2010-09-04 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,6 +26,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -50,6 +52,16 @@ files:
 - lib/ar_pg_array/references_by.rb
 - lib/ar_pg_array/schema.rb
 - lib/ar_pg_array/schema_arel.rb
+- spec/fixtures/bulk.rb
+- spec/fixtures/bulks.yml
+- spec/fixtures/item.rb
+- spec/fixtures/items.yml
+- spec/fixtures/schema.rb
+- spec/fixtures/tag.rb
+- spec/fixtures/tags.yml
+- spec/pg_array_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/funny-falcon/activerecord-postgresql-arrays
 licenses: []
@@ -64,6 +76,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -72,6 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -82,5 +96,10 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Use power of PostgreSQL Arrays in ActiveRecord
-test_files: []
-
+test_files: 
+- spec/fixtures/schema.rb
+- spec/fixtures/item.rb
+- spec/fixtures/bulk.rb
+- spec/fixtures/tag.rb
+- spec/pg_array_spec.rb
+- spec/spec_helper.rb