ar_pg_array 0.10.2 → 0.11.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/Rakefile

@@ -1,15 +1,15 @@
 require 'rake'
-require 'rdoc/task'
+require 'rake/testtask'
+require 'rake/rdoctask'
 
-desc 'Test the postgres_arrays plugin.'
-task :test do
-  Dir.chdir(File.dirname(__FILE__)) do
-    Process.wait2 spawn('rspec spec')
-  end
-end
+desc 'Default: run unit tests.'
+task :default => :test
 
-task :default do
-  # nothing
+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.'
@@ -20,3 +20,24 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   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', '>= 3.0.6', '<4.0')
+    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/VERSION

@@ -0,0 +1 @@
+0.11.0

data/lib/ar_pg_array.rb

@@ -7,4 +7,5 @@ require 'ar_pg_array/schema_cacheable'
 require 'ar_pg_array/querying'
 require 'ar_pg_array/allways_save'
 require 'ar_pg_array/references_by'
-require 'ar_pg_array/schema_fix_will_change'
+require 'ar_pg_array/schema_arel'
+require 'ar_pg_array/querying_arel'

data/lib/ar_pg_array/allways_save.rb

@@ -1,21 +1,37 @@
 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
+    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
     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
 
-  module CheckArrayBeforeUpdate
-    def self.included(base)
-      base.alias_method_chain :update, :check_array
-      base.send(:alias_method, :_read_attribute, :read_attribute)
+      def update_with_check_array
+        mark_arrays_for_update
+        update_without_check_array
+      end
     end
+  else
+    module CheckArrayBeforeUpdate
+      include ActiveSupport::Concern
 
-    def update_with_check_array
-      mark_arrays_for_update
-      update_without_check_array
+      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
     end
   end
   Base.__send__ :include, CheckArrayBeforeUpdate

data/lib/ar_pg_array/parser.rb

@@ -69,7 +69,7 @@ module PgArrayParser
         values << ar
         if rest =~ /^\}\s*/
           return values, $'
-        elsif rest =~ /^,\s*\{\s*/
+        elsif rest =~ /^,\s*{\s*/
           rest = $'
         else
           raise "Mailformed postgres array"
@@ -97,28 +97,15 @@ module PgArrayParser
     end
   end
 
-  def _remap_array(array, &block)
-    array.map{|v|
-      case v
-      when Array
-        _remap_array(v, &block)
-      when nil
-        nil
-      else
-        yield v
-      end
-    }
-  end
-
   def prepare_pg_integer_array(value)
-    val = _remap_array(value){|v| v.to_i}.inspect
+    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 = _remap_array(value){|v| v.to_f}.inspect
+    val = value.map{|v| v.nil? ? nil : v.to_f}.inspect
     val.gsub!(NIL, NULL)
     val.tr!(SQUARE_BRACKETS, CURLY_BRACKETS)
     val
@@ -152,11 +139,11 @@ module PgArrayParser
     "{#{value}}"
   end
 
-  def _prepare_pg_string_array(value, &block)
+  def prepare_pg_string_array(value, &block)
     value = value.map{|val|
       case val
       when Array
-        _prepare_pg_string_array(val, &block)
+        prepare_pg_string_array(val, &block)
       when nil
         NULL
       else
@@ -170,5 +157,4 @@ module PgArrayParser
     }.join(',')
     "{#{value}}"
   end
-  alias prepare_pg_string_array _prepare_pg_string_array
 end

data/lib/ar_pg_array/querying.rb

@@ -1,25 +1,11 @@
 module ActiveRecord
   class Base
     class << self
-      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
-      
-      def quote_bound_value_with_postgresql_arrays(value)
+      def quote_bound_value_with_postgresql_arrays(value, c = connection)
         if ::PGArrays::PgArray === value
-          connection.quote_array_by_base_type(value, value.base_type)
+          c.quote_array_by_base_type(value, value.base_type)
         else
-          quote_bound_value_without_postgresql_arrays(value)
+          quote_bound_value_without_postgresql_arrays(value, c)
         end
       end
       alias_method_chain :quote_bound_value, :postgresql_arrays

data/lib/ar_pg_array/querying_arel.rb

@@ -0,0 +1,168 @@
+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_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
+
+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
+              }
+
+              ranges, values = values.partition{|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+              predicates = ranges.map{|range| attribute.in(range)}
+
+              predicates << 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
+
+              predicates.inject{|composite, predicate| composite.or(predicate)}
+            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.rb

@@ -181,7 +181,7 @@ module ActiveRecord
                      else
                        PostgreSQLColumn::BASE_TYPE_COLUMNS[base_type.to_sym]
                      end
-        _prepare_pg_string_array(value){|v| quote_without_postgresql_arrays(v, base_column)}
+        super(value){|v| quote_without_postgresql_arrays(v, base_column)}
       end
 
       NATIVE_DATABASE_TYPES.keys.each do |key|

data/lib/ar_pg_array/schema_arel.rb

@@ -0,0 +1,47 @@
+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 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
+
+module ActiveRecord
+  class << Base
+    if method_defined?(:column_defaults)
+      alias column_defaults_without_extradup column_defaults
+      def column_defaults_with_extradup
+        res = {}
+        column_defaults_without_extradup.each{|k, v|
+          res[k] = Array === v ? v.dup : v
+        }
+        res
+      end
+      def column_defaults
+        defaults = column_defaults_without_extradup
+        if defaults.values.grep(Array).empty?
+          alias column_defaults column_defaults_without_extradup
+        else
+          alias column_defaults column_defaults_with_extradup
+        end
+        column_defaults
+      end
+    end
+  end
+end

data/lib/ar_pg_array/schema_cacheable.rb

@@ -1,4 +1,4 @@
-atcbd = ActiveRecord::AttributeMethods::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+atcbd = ActiveRecord::AttributeMethods::Read::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
 
 atcbd << /_array$/
 def atcbd.include?(val)

data/spec/fixtures/bulk.rb

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

data/spec/fixtures/bulks.yml

@@ -28,7 +28,6 @@ fourth:
   decimals: [ ]
 fifth:
   id: 5
-  type: "Bulk1"
   ints: [ 10 ]
   strings: [ "#{1+1}", "\\#{1+1}\"'\\z\x01", "\t\n" ]
   times: [ ]

data/spec/fixtures/schema.rb

@@ -12,7 +12,6 @@ ActiveRecord::Schema.define do
   end
 
   create_table "bulks", :force => true do |t|
-    t.string :type, :default => "Bulk"
     t.string :value, :default => "'"
     t.integer_array :ints,  :default => [1, 2]
     t.string_array :strings, :default => %w{as so}
@@ -20,7 +19,6 @@ ActiveRecord::Schema.define do
     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']
-    t.integer_array :empty_def, :default => []
   end
 
   create_table "unrelateds", :force => true do |t|

data/spec/pg_array_spec.rb

@@ -72,7 +72,7 @@ describe "PgArray" do
       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]
@@ -82,22 +82,6 @@ describe "PgArray" do
       bulk.texts.should == [nil, 'Text', 'NULL', 'Text with nil', 'Text with , nil, !"\\', 'nil']
       map_times(bulk.times).should == 
           map_times(parse_times(%w{2010-01-01 2010-02-01}))
-      bulk.empty_def.should == []
-    end
-
-    it "should be able to insert" do
-      bulki = Bulk.new
-      bulki.save
-      bulk = Bulk.find(bulki.id)
-      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]
-      bulk.texts.should == [nil, 'Text', 'NULL', 'Text with nil', 'Text with , nil, !"\\', 'nil']
-      map_times(bulk.times).should ==
-          map_times(parse_times(%w{2010-01-01 2010-02-01}))
-      bulk.empty_def.should == []
-      bulk.destroy
     end
 
     it "should not alter defaults" do
@@ -123,40 +107,11 @@ describe "PgArray" do
     
     it "should save right text" do
       bulk = Bulk.find(5)
-      bulk.texts = ['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\n\\\'\""]
+      bulk.texts = ['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\\\'\""]
       bulk.save!
       bulk.texts = []
       bulk = Bulk.find(:first, :conditions=>'5 = id')
-      bulk.texts.should == ['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\n\\\'\""]
-    end
-
-    it "should save nested arrays" do
-      Bulk.transaction do
-        bulk = Bulk.find(3)
-        bulk.ints = [[1,2],[3,4]]
-        bulk.floats = [[1.0, 2.3e34],[3.43,6.21]]
-        bulk.times = [parse_times(%w{2010-04-01 2011-04-01}), parse_times(%w{2011-05-01 2010-05-01})]
-        bulk.save!
-        bulk = Bulk.find(:first, :conditions=>'3 = id')
-        bulk.ints.should == [[1,2],[3,4]]
-        bulk.floats.should == [[1.0, 2.3e34],[3.43,6.21]]
-        bulk.times.map{|ts| map_times(ts)}.should == [
-          map_times(parse_times(%w{2010-04-01 2011-04-01})),
-          map_times(parse_times(%w{2011-05-01 2010-05-01}))]
-        raise ActiveRecord::Rollback
-      end
-    end
-
-    it "should save right nested text" do
-      Bulk.transaction do
-        bulk = Bulk.find(5)
-        bulk.texts = [['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\n\\\'\""], ['asdf', 'fdsa']]
-        bulk.save!
-        bulk.texts = []
-        bulk = Bulk.find(:first, :conditions=>'5 = id')
-        bulk.texts.should == [['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\n\\\'\""], ['asdf', 'fdsa']]
-        raise ActiveRecord::Rollback
-      end
+      bulk.texts.should == ['Text with , nil, !\x01\\\'"',"Text with , nil, !\x01\\\'\""]
     end
 
     it "should be safe for eval" do
@@ -237,19 +192,6 @@ describe "PgArray" do
       model2.for_custom_serialize.to_yaml.should == obj.to_yaml
     end
 
-    it 'should be workable with sti' do
-      obj = Bulk1.where(:ints => [10].pg).first
-      obj.should be_instance_of Bulk1
-      obj.floats = [1.1, 2.2]
-      obj.save
-      obj1 = Bulk.find(obj.id)
-      obj1.should be_instance_of Bulk1
-      obj1.floats.should == [1.1, 2.2]
-      obj2 = Bulk1.new
-      obj2.save
-      obj2.destroy
-    end
-
     def map_times(times)
       times.map{|t| t.strftime("%F %T")}
     end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: ar_pg_array
 version: !ruby/object:Gem::Version
+  version: 0.11.0
   prerelease: 
-  version: 0.10.2
 platform: ruby
 authors:
 - Sokolov Yura aka funny_falcon
@@ -12,7 +12,7 @@ cert_chain: []
 date: 2012-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  type: :runtime
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -22,6 +22,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.6
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -32,7 +33,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.6
-  name: activerecord
 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.
@@ -42,31 +42,33 @@ extensions: []
 extra_rdoc_files:
 - README
 files:
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- init.rb
 - lib/ar_pg_array.rb
-- lib/ar_pg_array/schema_cacheable.rb
-- lib/ar_pg_array/references_by.rb
-- lib/ar_pg_array/querying.rb
 - lib/ar_pg_array/allways_save.rb
-- lib/ar_pg_array/schema_fix_will_change.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
-- spec/spec_helper.rb
-- spec/spec.opts
+- lib/ar_pg_array/schema_arel.rb
+- lib/ar_pg_array/schema_cacheable.rb
+- lib/ar_pg_array/schema_fix_will_change.rb
+- spec/fixtures/bulk.rb
 - spec/fixtures/bulks.yml
-- spec/fixtures/tags.yml
-- spec/fixtures/unrelateds.yml
-- spec/fixtures/tag.rb
-- spec/fixtures/items.yml
 - spec/fixtures/item.rb
+- spec/fixtures/items.yml
 - spec/fixtures/schema.rb
-- spec/fixtures/bulk.rb
+- spec/fixtures/tag.rb
+- spec/fixtures/tags.yml
 - spec/fixtures/unrelated.rb
+- spec/fixtures/unrelateds.yml
 - spec/pg_array_spec.rb
-- Gemfile
-- init.rb
-- README
-- Rakefile
-- ar_pg_array.gemspec
+- spec/spec.opts
+- spec/spec_helper.rb
 homepage: http://github.com/funny-falcon/activerecord-postgresql-arrays
 licenses: []
 post_install_message: 

data/Gemfile

@@ -1,9 +0,0 @@
-source "http://rubygems.org"
-
-gem "activerecord", ">= 2.3.5", "< 3.0"
-group :development, :test do
-  gem "fake_arel"
-  gem "cancan"
-  gem "pg"
-  gem "rspec"
-end

data/ar_pg_array.gemspec

@@ -1,34 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "ar_pg_array"
-  s.version = "0.10.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Sokolov Yura aka funny_falcon"]
-  s.date = "2012-06-03"
-  s.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."
-  s.email = "funny.falcon@gmail.com"
-  s.extra_rdoc_files = [ "README" ]
-  s.files = (Dir['lib/**/*']+Dir['spec/**/*']+%w{Gemfile init.rb MIT_LICENSE README Rakefile ar_pg_array.gemspec}).find_all{|f| File.file?(f)}
-  s.homepage = "http://github.com/funny-falcon/activerecord-postgresql-arrays"
-  s.require_paths = ["lib"]
-  s.rubyforge_project = "ar-pg-array"
-  s.summary = "Use power of PostgreSQL Arrays in ActiveRecord"
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, ["< 4.0", ">= 3.0.6"])
-    else
-      s.add_dependency(%q<activerecord>, ["< 4.0", ">= 3.0.6"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, ["< 4.0", ">= 3.0.6"])
-  end
-end
-