activerecord-postgis-adapter 0.3.2 → 0.3.3

data/History.rdoc

@@ -1,6 +1,12 @@
+=== 0.3.3 / 2011-02-28
+
+* INCOMPATIBLE CHANGE: the default SRID for non-geography columns is now -1, rather than 4326. (Geography columns still default to 4326.)
+* It is now possible to create a spatial column without a corresponding entry in the geometry_columns table, and the adapter now handles this case properly. (Reported by Pirmin Kalberer)
+* Now requires rgeo-activerecord 0.3.1 (which brings a critical fix involving declaring multiple spatial columns in a migration).
+
 === 0.3.2 / 2011-02-11
 
-* You can now specify a separate "database creation" superuser so your normal postgres user doesn't need superuser privileges when running database creation tasks.
+* You can now specify a separate "database creation" superuser role so your normal PostgreSQL login role doesn't need superuser privileges when running database creation tasks.
 * Database creation tasks automatically create all schemas listed in the schema search path.
 
 === 0.3.1 / 2011-02-01

data/README.rdoc

@@ -14,8 +14,20 @@ the pg gem.
 First, this adapter extends the migration syntax to support creating 
 spatial columns and indexes. To create a spatial column, use the
 <tt>:geometry</tt> type, or any of the OGC spatial types such as
-<tt>:point</tt> or <tt>:line_string</tt>. To create a geography column,
-set the <tt>:geographic</tt> option to true when creating the column.
+<tt>:point</tt> or <tt>:line_string</tt> to set a geometry type
+constraint. You may also provide any of the following options:
+
+* <tt>:geographic</tt> -- If set to true, create a PostGIS geography
+  column; otherwise create a geometry column. Default is false.
+* <tt>:srid</tt> -- Set a SRID constraint for the column. Default is 4326
+  for a geography column, or -1 for a geometry column. Note that PostGIS
+  currently (as of version 1.5.2) requires geography columns to have SRID
+  4326, so this constraint is of limited use for geography columns.
+* <tt>:has_z</tt> -- Specify that objects in this column include a Z
+  coordinate. Default is false.
+* <tt>:has_m</tt> -- Specify that objects in this column include an M
+  coordinate. Default is false.
+
 To create a spatial index, set the <tt>:spatial</tt> option to true when
 creating the index.
 
@@ -40,7 +52,7 @@ format, which the adapter will automatically convert to geometry objects.
 Spatial objects in RGeo are tied to a factory that specifies the
 coordinate system as well as other behaviors of the object. You must
 therefore specify a factory for each spatial column (attribute) in your
-ActiveRecord class. You can either set an explicit factory for a specific
+\ActiveRecord class. You can either set an explicit factory for a specific
 column, or provide a factory generator that will yield the appropriate
 factory for the table's spatial columns based on their types. For the
 former, call the <tt>set_rgeo_factory_for_column</tt> class method on your
@@ -100,10 +112,10 @@ This adapter has the following requirements:
 
 * Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
 * PostGIS 1.5 or later.
+* pg gem 0.10 or later.
 * \ActiveRecord 3.0.3 or later. Earlier versions will not work.
 * rgeo gem 0.2.4 or later.
-* rgeo-activerecord gem 0.3.0 or later.
-* pg gem 0.10 or later.
+* rgeo-activerecord gem 0.3.1 or later.
 
 Install this adapter as a gem:
 
@@ -151,13 +163,13 @@ Generally, therefore, this parameter is required at least for the test
 database, which is usually automatically created by the rake tasks.
 
 The <i>su_username</i> and <i>su_password</i> parameters are provided as
-optional parameters. If present, they specify an auxiliary Postgres role
-that will be used for two functions:
+optional parameters. If present, they specify an auxiliary PostgreSQL role
+that must have superuser privileges, and will be used for two functions:
 
 * Creation of the database. This is so the main database user that you
   specify doesn't need superuser or createdb privileges.
 * Installation of the PostGIS definitions, if requested by the presence
-  of <i>script_dir</i>. This process normally requires a Postgres role
+  of <i>script_dir</i>. This process normally requires a PostgreSQL role
   with superuser privileges, so again if you don't want your main database
   user to have superuser, you can perform this one-time procedure using
   this alternate user.
@@ -198,11 +210,11 @@ To deal with these issues, we recommend the following technique:
   The PostGIS Adapter responds to this special name by sandboxing the
   PostGIS definitions into it when rake db:create is run, and it omits
   this schema when running SQL structure dumps.
-* Provide a separate <i>su_username</i> and <i>su_password</i> user for
-  your database, and make sure that Postgres user has SUPERUSER
-  privilege. This will cause the PostGIS Adapter to log in as that user
+* Provide a separate <i>su_username</i> and <i>su_password</i> role for
+  your database, and make sure that separate role has the SUPERUSER
+  privilege. This will cause the PostGIS Adapter to log in as that role
   when creating the database, since the PostGIS definition installation
-  requires SUPERUSER. Alternately, you can give the normal database user
+  requires SUPERUSER. Alternately, you can give the normal database role
   SUPERUSER privilege, which may be okay for a private development
   database. These are used only by <tt>rake db:create</tt> so you can
   remove them from your database.yml for your staging or production

data/Version

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/active_record/connection_adapters/postgis_adapter/main_adapter.rb

@@ -108,7 +108,7 @@ module ActiveRecord
           
           # Get index type by joining with pg_am.
           result_ = query(<<-SQL, name_)
-            SELECT distinct i.relname, d.indisunique, d.indkey, t.oid, am.amname
+            SELECT DISTINCT i.relname, d.indisunique, d.indkey, t.oid, am.amname
               FROM pg_class t, pg_class i, pg_index d, pg_am am
             WHERE i.relkind = 'i'
               AND d.indexrelid = i.oid
@@ -129,10 +129,10 @@ module ActiveRecord
             
             columns_ = query(<<-SQL, "Columns for index #{row_[0]} on #{table_name_}").inject({}){ |h_, r_| h_[r_[0]] = [r_[1], r_[2]]; h_ }
               SELECT a.attnum, a.attname, t.typname
-              FROM pg_attribute a, pg_type t
+                FROM pg_attribute a, pg_type t
               WHERE a.attrelid = #{oid_}
-              AND a.attnum IN (#{indkey_.join(",")})
-              AND a.atttypid = t.oid
+                AND a.attnum IN (#{indkey_.join(",")})
+                AND a.atttypid = t.oid
             SQL
             
             spatial_ = indtype_ == 'gist' && columns_.size == 1 && (columns_.values.first[1] == 'geometry' || columns_.values.first[1] == 'geography')
@@ -180,23 +180,30 @@ module ActiveRecord
           table_name_ = table_name_.to_s
           if (info_ = spatial_column_constructor(type_.to_sym))
             limit_ = options_[:limit]
-            options_.merge!(limit_) if limit_.is_a?(::Hash)
-            type_ = (options_[:type] || info_[:type] || type_).to_s.gsub('_', '').upcase
-            has_z_ = options_[:has_z]
-            has_m_ = options_[:has_m]
-            srid_ = (options_[:srid] || 4326).to_i
-            if options_[:geographic]
-              type_ << 'Z' if has_z_
-              type_ << 'M' if has_m_
-              execute("ALTER TABLE #{quote_table_name(table_name_)} ADD COLUMN #{quote_column_name(column_name_)} GEOGRAPHY(#{type_},#{srid_})")
-              change_column_default(table_name_, column_name_, options_[:default]) if options_include_default?(options_)
-              change_column_null(table_name_, column_name_, false, options_[:default]) if options_[:null] == false
+            if type_.to_s == 'geometry' &&
+              (options_[:no_constraints] || limit_.is_a?(::Hash) && limit_[:no_constraints])
+            then
+              options_.delete(:limit)
+              super
             else
-              type_ = "#{type_}M" if has_m_ && !has_z_
-              dimensions_ = 2
-              dimensions_ += 1 if has_z_
-              dimensions_ += 1 if has_m_
-              execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(column_name_.to_s)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
+              options_.merge!(limit_) if limit_.is_a?(::Hash)
+              type_ = (options_[:type] || info_[:type] || type_).to_s.gsub('_', '').upcase
+              has_z_ = options_[:has_z]
+              has_m_ = options_[:has_m]
+              srid_ = (options_[:srid] || -1).to_i
+              if options_[:geographic]
+                type_ << 'Z' if has_z_
+                type_ << 'M' if has_m_
+                execute("ALTER TABLE #{quote_table_name(table_name_)} ADD COLUMN #{quote_column_name(column_name_)} GEOGRAPHY(#{type_},#{srid_})")
+                change_column_default(table_name_, column_name_, options_[:default]) if options_include_default?(options_)
+                change_column_null(table_name_, column_name_, false, options_[:default]) if options_[:null] == false
+              else
+                type_ = "#{type_}M" if has_m_ && !has_z_
+                dimensions_ = 2
+                dimensions_ += 1 if has_z_
+                dimensions_ += 1 if has_m_
+                execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(column_name_.to_s)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
+              end
             end
           else
             super

data/lib/active_record/connection_adapters/postgis_adapter/spatial_column.rb

@@ -50,11 +50,14 @@ module ActiveRecord
           super(name_, default_, sql_type_, null_)
           @geographic = sql_type_ =~ /geography/i ? true : false
           if opts_
-            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type])
+            # This case comes from an entry in the geometry_columns table
+            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type]) ||
+              ::RGeo::Feature::Geometry
             @srid = opts_[:srid].to_i
-            @has_z = opts_[:has_z]
-            @has_m = opts_[:has_m]
+            @has_z = opts_[:has_z] ? true : false
+            @has_m = opts_[:has_m] ? true : false
           elsif @geographic
+            # Geographic type information is embedded in the SQL type
             @geometric_type = ::RGeo::Feature::Geometry
             @srid = 4326
             @has_z = @has_m = false
@@ -71,15 +74,23 @@ module ActiveRecord
                 end
               end
             end
+          elsif type == :spatial
+            # Just in case there is a geometry column with no geometry_columns entry.
+            @geometric_type = ::RGeo::Feature::Geometry
+            @srid = @has_z = @has_m = nil
           else
-            @geometric_type = @has_z = @has_m = nil
-            @srid = 0
+            # Non-spatial column
+            @geometric_type = @has_z = @has_m = @srid = nil
           end
           if type == :spatial
-            @limit = {:srid => @srid, :type => @geometric_type.type_name.underscore}
-            @limit[:has_z] = true if @has_z
-            @limit[:has_m] = true if @has_m
-            @limit[:geographic] = true if @geographic
+            if @srid
+              @limit = {:srid => @srid, :type => @geometric_type.type_name.underscore}
+              @limit[:has_z] = true if @has_z
+              @limit[:has_m] = true if @has_m
+              @limit[:geographic] = true if @geographic
+            else
+              @limit = {:no_constraints => true}
+            end
           end
           @ar_class = ::ActiveRecord::Base
         end
@@ -106,18 +117,34 @@ module ActiveRecord
         end
         
         
+        def has_spatial_constraints?
+          !@srid.nil?
+        end
+        
+        
         def klass
           type == :spatial ? ::RGeo::Feature::Geometry : super
         end
         
         
         def type_cast(value_)
-          type == :spatial ? SpatialColumn.convert_to_geometry(value_, @ar_class, name, @geographic, @srid, @has_z, @has_m) : super
+          if type == :spatial
+            SpatialColumn.convert_to_geometry(value_, @ar_class, name, @geographic,
+              @srid, @has_z, @has_m)
+          else
+            super
+          end
         end
         
         
         def type_cast_code(var_name_)
-          type == :spatial ? "::ActiveRecord::ConnectionAdapters::PostGISAdapter::SpatialColumn.convert_to_geometry(#{var_name_}, self.class, #{name.inspect}, #{@geographic ? 'true' : 'false'}, #{@srid.inspect}, #{@has_z ? 'true' : 'false'}, #{@has_m ? 'true' : 'false'})" : super
+          if type == :spatial
+            "::ActiveRecord::ConnectionAdapters::PostGISAdapter::SpatialColumn.convert_to_geometry("+
+              "#{var_name_}, self.class, #{name.inspect}, #{@geographic ? 'true' : 'false'}, "+
+              "#{@srid.inspect}, #{@has_z ? 'true' : 'false'}, #{@has_m ? 'true' : 'false'})"
+          else
+            super
+          end
         end
         
         
@@ -130,15 +157,21 @@ module ActiveRecord
         
         
         def self.convert_to_geometry(input_, ar_class_, column_, geographic_, srid_, has_z_, has_m_)
+          if srid_
+            constraints_ = {:geographic => geographic_, :has_z_coordinate => has_z_,
+              :has_m_coordinate => has_m_, :srid => srid_}
+          else
+            constraints_ = nil
+          end
           case input_
           when ::RGeo::Feature::Geometry
-            factory_ = ar_class_.rgeo_factory_for_column(column_, :srid => srid_, :has_z_coordinate => has_z_, :has_m_coordinate => has_m_, :geographic => geographic_)
+            factory_ = ar_class_.rgeo_factory_for_column(column_, constraints_)
             ::RGeo::Feature.cast(input_, factory_)
           when ::String
             if input_.length == 0
               nil
             else
-              factory_ = ar_class_.rgeo_factory_for_column(column_, :srid => srid_, :has_z_coordinate => has_z_, :has_m_coordinate => has_m_, :geographic => geographic_)
+              factory_ = ar_class_.rgeo_factory_for_column(column_, constraints_)
               marker_ = input_[0,1]
               if marker_ == "\x00" || marker_ == "\x01"
                 ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse(input_) rescue nil

data/lib/active_record/connection_adapters/postgis_adapter/spatial_table_definition.rb

@@ -47,8 +47,16 @@ module ActiveRecord
         
         def column(name_, type_, options_={})
           if (info_ = @base.spatial_column_constructor(type_.to_sym))
-            options_[:type] ||= info_[:type] || type_
-            type_ = :spatial
+            type_ = options_[:type] || info_[:type] || type_
+            if type_.to_s == 'geometry' &&
+              (options_[:no_constraints] ||
+               options_[:limit].is_a?(::Hash) && options_[:limit][:no_constraints])
+            then
+              options_.delete(:limit)
+            else
+              options_[:type] = type_
+              type_ = :spatial
+            end
           end
           super(name_, type_, options_)
           if type_ == :spatial
@@ -57,7 +65,7 @@ module ActiveRecord
             options_.merge!(col_.limit) if col_.limit.is_a?(::Hash)
             col_.set_spatial_type(options_[:type])
             col_.set_geographic(options_[:geographic])
-            col_.set_srid((options_[:srid] || 4326).to_i)
+            col_.set_srid(options_[:srid])
             col_.set_has_z(options_[:has_z])
             col_.set_has_m(options_[:has_m])
           end
@@ -78,23 +86,23 @@ module ActiveRecord
       module SpatialColumnDefinitionMethods
         
         def spatial_type
-          defined?(@spatial_type) && @spatial_type
+          @spatial_type
         end
         
         def geographic?
-          defined?(@geographic) && @geographic
+          @geographic
         end
         
         def srid
-          defined?(@srid) ? @srid : 4326
+          @srid ? @srid.to_i : (geographic? ? 4326 : -1)
         end
         
         def has_z?
-          defined?(@has_z) && @has_z
+          @has_z
         end
         
         def has_m?
-          defined?(@has_m) && @has_m
+          @has_m
         end
         
         def set_geographic(value_)

data/test/tc_basic.rb

@@ -61,6 +61,10 @@ module RGeo
                 klass_.connection.create_table(:spatial_test) do |t_|
                   t_.column 'latlon', :point, :srid => 4326, :geographic => true
                 end
+              when :no_constraints
+                klass_.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'geo', :geometry, :no_constraints => true
+                end
               end
               klass_
             end
@@ -159,6 +163,25 @@ module RGeo
             end
             
             
+            def test_save_and_load_no_constraints
+              klass_ = populate_ar_class(:no_constraints)
+              factory1_ = ::RGeo::Cartesian.preferred_factory(:srid => 3785)
+              factory2_ = ::RGeo::Cartesian.preferred_factory(:srid => 2000)
+              obj_ = klass_.new
+              obj_.geo = factory1_.point(1, 2)
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(factory1_.point(1, 2), obj2_.geo)
+              assert_equal(3785, obj2_.geo.srid)
+              obj2_.geo = factory2_.point(3, 4)
+              obj2_.save!
+              obj3_ = klass_.find(id_)
+              assert_equal(factory2_.point(3,4), obj3_.geo)
+              assert_equal(2000, obj3_.geo.srid)
+            end
+            
+            
           end
           
         end

data/test/tc_ddl.rb

@@ -58,14 +58,32 @@ module RGeo
               assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
               col_ = klass_.columns.last
               assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(true, col_.has_spatial_constraints?)
               assert_equal(false, col_.geographic?)
-              assert_equal(4326, col_.srid)
+              assert_equal(-1, col_.srid)
               assert(klass_.cached_attributes.include?('latlon'))
               klass_.connection.drop_table(:spatial_test)
               assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
             end
             
             
+            def test_create_no_constraints_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'geom', :geometry, :limit => {:no_constraints => true}
+              end
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_equal(false, col_.has_spatial_constraints?)
+              assert_nil(col_.srid)
+              assert(klass_.cached_attributes.include?('geom'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
             def test_create_simple_geography
               klass_ = create_ar_class
               klass_.connection.create_table(:spatial_test) do |t_|
@@ -73,6 +91,7 @@ module RGeo
               end
               col_ = klass_.columns.last
               assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(true, col_.has_spatial_constraints?)
               assert_equal(true, col_.geographic?)
               assert_equal(4326, col_.srid)
               assert(klass_.cached_attributes.include?('latlon'))
@@ -114,11 +133,37 @@ module RGeo
               assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
               cols_ = klass_.columns
               assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(4326, cols_[-3].srid)
+              assert_equal(-1, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
               assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
               assert_equal(4326, cols_[-2].srid)
               assert_equal(false, cols_[-2].geographic?)
+              assert_equal(true, cols_[-2].has_spatial_constraints?)
+              assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
+            end
+            
+            
+            def test_add_no_constraints_geometry_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.column('geom2', :geometry, :no_constraints => true)
+                t_.column('name', :string)
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
+              assert_equal(-1, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
+              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
+              assert_nil(cols_[-2].srid)
+              assert_equal(false, cols_[-2].geographic?)
+              assert_equal(false, cols_[-2].has_spatial_constraints?)
               assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
             end
             
             
@@ -134,11 +179,14 @@ module RGeo
               assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
               cols_ = klass_.columns
               assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(4326, cols_[-3].srid)
+              assert_equal(-1, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
               assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
               assert_equal(4326, cols_[-2].srid)
               assert_equal(true, cols_[-2].geographic?)
+              assert_equal(true, cols_[-2].has_spatial_constraints?)
               assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
             end
             
             
@@ -155,7 +203,7 @@ module RGeo
               cols_ = klass_.columns
               assert_equal(::RGeo::Feature::Geometry, cols_[-1].geometric_type)
               assert_equal('latlon', cols_[-1].name)
-              assert_equal(4326, cols_[-1].srid)
+              assert_equal(-1, cols_[-1].srid)
               assert_equal(false, cols_[-1].geographic?)
             end
             
@@ -190,13 +238,29 @@ module RGeo
               col_ = klass_.columns.last
               assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
               assert_equal(false, col_.geographic?)
-              assert_equal(4326, col_.srid)
+              assert_equal(-1, col_.srid)
               assert(klass_.cached_attributes.include?('latlon'))
               klass_.connection.drop_table(:spatial_test)
               assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
             end
             
             
+            def test_create_no_constraints_geometry_using_shortcut
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.spatial 'geom', :no_constraints => true
+              end
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_nil(col_.srid)
+              assert(klass_.cached_attributes.include?('geom'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
             def test_create_simple_geography_using_shortcut
               klass_ = create_ar_class
               klass_.connection.create_table(:spatial_test) do |t_|

metadata

@@ -2,7 +2,7 @@
 name: activerecord-postgis-adapter
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-10 00:00:00 -08:00
+date: 2011-02-28 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.3.0
+        version: 0.3.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -84,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: virtuoso
-rubygems_version: 1.5.2
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: An ActiveRecord adapter for PostGIS, based on RGeo.