ar_pg_array 0.8.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Sokolov Yura aka funny_falcon
+
+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

@@ -0,0 +1,39 @@
+PostgresArrays
+==============
+
+This library adds ability to use PostgreSQL array types with ActiveRecord.
+
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg])
+      SELECT * FROM "users" WHERE ('arr' @> E'{"1", "2", "3"}')
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg(:integer)])
+      SELECT * FROM "users" WHERE (arr @> '{1,2,3}')
+    > User.find(:all, :conditions=>['arr @> ?', [1,2,3].pg(:float)])
+      SELECT * FROM "users" WHERE (arr @> '{1.0,2.0,3.0}')
+    > u = User.find(1)
+      SELECT * FROM "users" WHERE ("users"."id" = 1)
+      => #<User id: 1, ..., arr: [1,2]>
+    > u.arr = [3,4]
+    > u.save
+      UPDATE "users" SET "db_ar" = '{3.0,4.0}' WHERE "id" = 19
+    > User.find(:all, :conditions=>{:arr=>[3,4].pg})
+      SELECT * FROM "users" WHERE ("users"."arr" = E'{"3", "4"}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_any(:float)})
+      SELECT * FROM "users" WHERE ("users"."arr" && '{3.0,4.0}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_all(:integer)})
+      SELECT * FROM "users" WHERE ("users"."arr" @> '{3,4}')
+    > User.find(:all, :conditions=>{:arr=>[3,4].search_subarray(:safe)})
+      SELECT * FROM "users" WHERE ("users"."arr" <@ '{3,4}')
+      
+      class U < ActiveRecord::Migration
+        def self.up
+          create_table :users do |t|
+            t.integer_array :int_ar
+          end
+          add_column :users, :fl_ar, :float_array
+        end
+      end
+      
+Plugin worked with rails 2.3.x. integer_array works in ActiveRecord 3 at the moment.
+
+
+Copyright (c) 2010 Sokolov Yura aka funny_falcon, released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the postgres_arrays plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the postgres_arrays plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PostgresArrays'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "ar_pg_array"
+    gemspec.summary = "Use power of PostgreSQL Arrays in ActiveRecord"
+    gemspec.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."
+    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.rubyforge_project = 'ar_pg_array'
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+

data/init.rb

@@ -0,0 +1,3 @@
+# Include hook code here
+require 'ar_pg_array'
+

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/ar_pg_array/querying.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  class Base
+    class << self
+      if 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)
+          end
+        end
+        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)
+        end
+      end                                              
+      alias_method_chain :quote_bound_value, :postgresql_arrays
+    end
+  end
+end
+
+module PGArrays
+  class PgArray < Array
+    attr_reader :base_type
+    
+    def initialize(array, type=nil)
+      super(array)
+      @base_type = type if type
+    end
+    
+    def base_type
+      @base_type || :other
+    end
+  end
+  
+  class PgAny < PgArray; end
+  class PgAll < PgArray; end
+  class PgIncludes < PgArray; end
+  
+  if defined? CanCan::Ability
+    class PgAny
+      def include?(v)
+        Array === v && !( v & self ).empty?
+      end
+    end
+  
+    class PgAll
+      def include?
+        Array === v && (self - v).empty?
+      end
+    end
+
+    class PgIncludes < PgArray
+      def include?
+        Array === v && (v - self).empty?
+      end
+    end
+  end
+end
+
+class Array
+  
+  def pg(type=nil)
+    ::PGArrays::PgArray.new(self, type)
+  end
+  
+  def search_any(type=nil)
+    ::PGArrays::PgAny.new(self, type)
+  end
+  
+  def search_all(type=nil)
+    ::PGArrays::PgAll.new(self, type)
+  end
+  
+  def search_subarray(type=nil)
+    ::PGArrays::PgIncludes.new(self, type)
+  end
+end

data/lib/ar_pg_array/querying_arel.rb

@@ -0,0 +1,74 @@
+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
+    module Predications
+      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
+      
+      def in(other)
+        case other
+        when ::PGArrays::PgAny
+          ar_any(other)
+        when ::PGArrays::PgAll
+          ar_all(other)
+        when ::PGArrays::PgIncludes
+          ar_included(other)
+        else
+          Predicates::In.new(self, other)
+        end
+      end
+    end
+  end
+end
+
+module PGArrays
+  class PgArray
+    def to_sql( formatter = nil )
+      formatter.engine.quote_array_for_arel_by_base_type(self, base_type)
+    end
+    
+    def to_a
+      self
+    end
+  end
+end

data/lib/ar_pg_array/references_by.rb

@@ -0,0 +1,71 @@
+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
+
+  	  	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
+  end
+end
+
+ActiveRecord::Base.extend PGArrays::ReferencesBy::ClassMethods
+

data/lib/ar_pg_array/schema.rb

@@ -0,0 +1,237 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLColumn < Column #:nodoc:
+      BASE_TYPE_COLUMNS = Hash.new{|h, base_type| 
+        base_column= new(nil, nil, base_type, 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
+          @base_column = BASE_TYPE_COLUMNS[@base_sql_type]
+        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"
+        else
+          simplified_type_without_postgresql_arrays(field_type)
+        end
+      end
+      alias_method_chain :simplified_type, :postgresql_arrays
+
+      def klass
+        if type.to_s =~ /_array$/
+          Array
+        else
+          super
+        end
+      end
+
+      def type_cast(value)
+        return nil if value.nil?
+        case type
+          when :integer_array, :float_array 
+            self.class.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)
+          else super
+        end
+      end
+      
+      def type_cast_code(var_name)
+        case type
+          when :integer_array, :float_array
+            "#{self.class.name}.string_to_num_array(#{var_name})"
+          when :decimal_array, :date_array, :boolean_array
+            "#{self.class.name}.safe_string_to_array(#{var_name}, #{@base_sql_type.inspect})"
+          when :timestamp_array, :time_array, :datetime_array, :binary_array
+            "#{self.class.name}.string_to_array(#{var_name}, #{@base_sql_type.inspect})"
+          when :text_array, :string_array
+            "#{self.class.name}.string_to_text_array(#{var_name})"
+          else super
+        end
+      end
+      
+      def safe_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)}
+      end
+      
+      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)}
+      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)}
+      end
+      
+      def self.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_to_text_array( string ).map{|v| base_column.type_cast(v)}
+      end
+      
+      def self.string_to_num_array(string)
+        return string unless string.is_a? String
+        return nil if string.empty?
+        
+        eval(string.tr('{}','[]'))
+      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 = eval(s)
+            partial = false
+          elsif s == 'NULL'
+            s = nil
+          end
+          res << s
+        end
+      end
+    end
+    
+    class PostgreSQLAdapter #:nodoc:
+      def quote_with_postgresql_arrays(value, column = nil)
+        if Array === value && column && "#{column.type}" =~ /^(.+)_array$/
+          quote_array_by_base_type(value, $1, column)
+        else
+          quote_without_postgresql_arrays(value, column)
+        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 )
+        else
+          "E'#{ 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)
+            "E'#{ 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
+            prepare_pg_integer_array(value)
+          when :float
+            prepare_pg_float_array(value)
+          when :string, :text, :other
+            prepare_pg_text_array(value)
+          when :datetime, :timestamp, :time
+            prepare_pg_string_array(value, base_type)
+          when :decimal, :boolean, :date, :safe
+            prepare_pg_string_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
+      
+      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| 
+            v = quote_without_postgresql_arrays(v, base_column)
+            if v=~/^E?'(.+)'$/ then v = $1 end
+            "\"#{v.gsub('"','\"')}\""
+        end
+        "{#{ value.join(',')}}"
+      end
+      
+      def prepare_pg_text_array(value)
+        value = value.map{|v|
+             v ? v.to_s.gsub('\\','\\\\\\').gsub('"','\"') : 'NULL'
+          }.inspect
+        value.tr!('[]','{}')
+      end
+
+      
+      NATIVE_DATABASE_TYPES.keys.each do |key|
+        unless key==:primary_key
+          base = NATIVE_DATABASE_TYPES[key].dup
+          base[:name] = base[:name]+'[]'
+          NATIVE_DATABASE_TYPES[:"#{key}_array"]= base
+          TableDefinition.class_eval <<-EOV
+            def #{key}_array(*args)                                             # def string_array(*args)
+              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) }
+            end                                                                 # end
+          EOV
+        end
+      end
+      
+      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)+'[]'
+        else
+          type_to_sql_without_postgresql_arrays(type, limit, precision, scale)
+        end
+      end
+      
+      alias_method_chain :type_to_sql, :postgresql_arrays
+    end
+  end
+end
+

data/lib/ar_pg_array/schema_arel.rb

@@ -0,0 +1,90 @@
+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.acts_like?(:date) || value.acts_like?(:time)) || 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 = 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
+
+  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
+end

data/lib/ar_pg_array.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+require 'ar_pg_array/schema'
+require 'ar_pg_array/querying'
+require 'ar_pg_array/references_by'
+if defined? ::Arel
+  require 'ar_pg_array/schema_arel'
+  require 'ar_pg_array/querying_arel'  
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: ar_pg_array
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Sokolov Yura aka funny_falcon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+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.
+email: funny.falcon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- init.rb
+- install.rb
+- lib/ar_pg_array.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
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/funny-falcon/activerecord-postgresql-arrays
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ar_pg_array
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Use power of PostgreSQL Arrays in ActiveRecord
+test_files: []
+