rgeo-activerecord 0.3.4 → 0.4.0

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 0.4.0 / 2011-08-15
+
+* Several compatibility fixes for Rails 3.1.
+* Revamped factory setter mechanism with a system that should be more robust.
+* Some general code cleanup.
+
 === 0.3.4 / 2011-05-23
 
 * Uses the mixin feature of RGeo 0.3 to add an as_json method to all geometry objects. This should allow ActiveRecord's JSON serialization to function for models with geometry fields. (Reported by thenetduck and tonyc on github.)

data/README.rdoc

@@ -23,8 +23,9 @@ need to interact directly with this library.
 RGeo::ActiveRecord has the following requirements:
 
 * Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
-* \RGeo 0.3.0 or later.
+* \RGeo 0.3.2 or later.
 * \ActiveRecord 3.0.3 or later. Earlier versions will not work.
+  Appears to be compatible with Rails 3.1rc5.
 * \Arel 2.0.6 or later. Earlier versions will not work.
 
 Generally, \ActiveRecord adapters which depend on this module should be
@@ -58,6 +59,8 @@ Contributions are welcome. Fork the project on Github.
 
 Report bugs on Github issues at http://github.org/dazuma/rgeo-activerecord/issues
 
+Support available on the rgeo-users google group at http://groups.google.com/group/rgeo-users
+
 Contact the author at dazuma at gmail dot com.
 
 === Acknowledgments

data/Version

@@ -1 +1 @@
-0.3.4
+0.4.0

data/lib/rgeo/active_record/adapter_test_helper.rb

@@ -106,7 +106,7 @@ module RGeo
       # cartesian factory) and @geographic_factory (a spherical factory)
       
       def setup
-        @factory = ::RGeo::Cartesian.preferred_factory(:srid => 4326)
+        @factory = ::RGeo::Cartesian.preferred_factory(:srid => 3785)
         @geographic_factory = ::RGeo::Geographic.spherical_factory(:srid => 4326)
         cleanup_tables
       end
@@ -129,6 +129,15 @@ module RGeo
         if klass_.connection.tables.include?('spatial_test')
           klass_.connection.drop_table(:spatial_test)
         end
+        # Clear any RGeo factory settings.
+        klass_.connection_pool.rgeo_factory_settings.clear!
+        # Rails 3.1 does more aggressive caching than 3.0 did; need to
+        # clear those because the next test might assume different data.
+        if klass_.connection_pool.respond_to?(:clear_cache!)
+          klass_.connection_pool.clear_cache!
+          klass_.connection.clear_query_cache
+          klass_.connection.clear_cache!
+        end
       end
       
       

data/lib/rgeo/active_record/ar_factory_settings.rb

@@ -37,41 +37,128 @@
 require 'active_record'
 
 
-module ActiveRecord
+module RGeo
   
-  
-  # RGeo extends ActiveRecord::Base to include the following new class
-  # attributes. These attributes are inherited by subclasses, and can
-  # be overridden in subclasses.
-  # 
-  # === ActiveRecord::Base::rgeo_factory_generator
-  # 
-  # The value of this attribute is a RGeo::Feature::FactoryGenerator
-  # that is used to generate the proper factory when loading geometry
-  # objects from the database. For example, if the data being loaded
-  # has M but not Z coordinates, and an embedded SRID, then this
-  # FactoryGenerator is called with the appropriate configuration to
-  # obtain a factory with those properties. This factory is the one
-  # associated with the actual geometry properties of the ActiveRecord
-  # object. The result of this generator can be overridden by setting
-  # an explicit factory for a given class and column using the
-  # column_rgeo_factory method.
-  
-  class Base
+  module ActiveRecord
+    
     
+    # The default factory generator for ActiveRecord::Base.
     
-    class_attribute :rgeo_factory_generator, :instance_writer => false
-    self.rgeo_factory_generator = nil
+    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config_|
+      if config_.delete(:geographic)
+        ::RGeo::Geographic.spherical_factory(config_)
+      else
+        ::RGeo::Cartesian.preferred_factory(config_)
+      end
+    end
     
     
-    class << self
+    # An object that manages the RGeo factories for a ConnectionPool.
+    
+    class RGeoFactorySettings
+      
+      def initialize  # :nodoc:
+        @factory_generators = {}
+        @column_factories = {}
+      end
+      
+      
+      # Get the default factory generator for the given table
+      
+      def get_factory_generator(table_name_)
+        @factory_generators[table_name_.to_s] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
+      end
+      
+      
+      # Set the default factory generator for the given table
+      
+      def set_factory_generator(table_name_, gen_)
+        @factory_generators[table_name_.to_s] = gen_
+      end
+      
+      
+      # Get the factory or factory generator for the given table name
+      # and column name.
+      
+      def get_column_factory(table_name_, column_name_, params_=nil)
+        table_name_ = table_name_.to_s
+        column_name_ = column_name_.to_s
+        result_ = (@column_factories[table_name_] ||= {})[column_name_] ||
+          @factory_generators[table_name_] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
+        if params_ && !result_.kind_of?(::RGeo::Feature::Factory::Instance)
+          result_ = result_.call(params_)
+        end
+        result_
+      end
+      
+      
+      # Set the factory or factory generator for the given table name
+      # and column name.
+      
+      def set_column_factory(table_name_, column_name_, factory_)
+        (@column_factories[table_name_.to_s] ||= {})[column_name_.to_s] = factory_
+      end
+      
+      
+      # Clear settings for the given table name, or for all tables
+      
+      def clear!(table_name_=nil)
+        if table_name_
+          table_name_ = table_name_.to_s
+          @factory_generators.delete(table_name_)
+          @column_factories.delete(table_name_)
+        else
+          @factory_generators.clear
+          @column_factories.clear
+        end
+      end
+      
+      
+    end
+    
+    
+    # Additional class methods on ::ActiveRecord::Base that provide
+    # a way to control the RGeo factory used for ActiveRecord objects.
+    
+    module ActiveRecordBaseFactorySettings
+      
+      
+      # Return the RGeoFactorySettings object associated with this
+      # class's connection.
+      
+      def rgeo_factory_settings
+        connection_pool.rgeo_factory_settings
+      end
+      
+      
+      # The value of this attribute is a RGeo::Feature::FactoryGenerator
+      # that is used to generate the proper factory when loading geometry
+      # objects from the database. For example, if the data being loaded
+      # has M but not Z coordinates, and an embedded SRID, then this
+      # FactoryGenerator is called with the appropriate configuration to
+      # obtain a factory with those properties. This factory is the one
+      # associated with the actual geometry properties of the ActiveRecord
+      # object. The result of this generator can be overridden by setting
+      # an explicit factory for a given class and column using the
+      # column_rgeo_factory method.
+      
+      def rgeo_factory_generator
+        rgeo_factory_settings.get_factory_generator(table_name)
+      end
+      
+      
+      # Set the rgeo_factory_generator attribute
+      
+      def rgeo_factory_generator=(gen_)
+        rgeo_factory_settings.set_factory_generator(table_name, gen_)
+      end
       
       
       # This is a convenient way to set the rgeo_factory_generator by
       # passing a block.
       
       def to_generate_rgeo_factory(&block_)
-        self.rgeo_factory_generator = block_
+        rgeo_factory_settings.set_factory_generator(table_name, block_)
       end
       
       
@@ -79,9 +166,8 @@ module ActiveRecord
       # column name. This setting, if present, overrides the result of the
       # rgeo_factory_generator.
       
-      def set_rgeo_factory_for_column(column_, factory_)
-        @rgeo_factory_for_column = {} unless defined?(@rgeo_factory_for_column)
-        @rgeo_factory_for_column[column_.to_sym] = factory_
+      def set_rgeo_factory_for_column(column_name_, factory_)
+        rgeo_factory_settings.set_column_factory(table_name, column_name_, factory_)
       end
       
       
@@ -94,18 +180,42 @@ module ActiveRecord
       # rgeo_factory_generator for this class.
       
       def rgeo_factory_for_column(column_, params_=nil)
-        @rgeo_factory_for_column = {} unless defined?(@rgeo_factory_for_column)
-        result_ = @rgeo_factory_for_column[column_.to_sym] || rgeo_factory_generator || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
-        if params_ && !result_.kind_of?(::RGeo::Feature::Factory::Instance)
-          result_ = result_.call(params_)
+        rgeo_factory_settings.get_column_factory(table_name, column_name_, params_)
+      end
+      
+      
+    end
+    
+    ::ActiveRecord::Base.extend(ActiveRecordBaseFactorySettings)
+    
+    
+    # :stopdoc:
+    
+    
+    # Patch for connection pool to track geo factories per table name
+    
+    ::ActiveRecord::ConnectionAdapters::ConnectionPool.class_eval do
+      
+      def rgeo_factory_settings
+        @_rgeo_factory_settings ||= RGeoFactorySettings.new
+      end
+      
+      private
+      alias_method :new_connection_without_rgeo_modification, :new_connection
+      def new_connection
+        result_ = new_connection_without_rgeo_modification
+        if result_.respond_to?(:set_rgeo_factory_settings)
+          result_.set_rgeo_factory_settings(rgeo_factory_settings)
         end
         result_
       end
       
-      
     end
     
+    
+    # :startdoc:
+    
+    
   end
   
-  
 end

data/lib/rgeo/active_record/arel_spatial_queries.rb

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Mysqlgeo adapter for ActiveRecord
+# Various Arel hacks to support spatial queries
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -72,30 +72,6 @@ module RGeo
       end
       
       
-      # Returns a true value if the given node is of spatial type-- that
-      # is, if it is a spatial literal or a reference to a spatial
-      # attribute.
-      
-      def node_has_spatial_type?(node_)
-        case node_
-        when ::Arel::Attribute
-          @connection.instance_variable_set(:@_getting_columns, true)
-          begin
-            col_ = node_.column
-            col_ && col_.respond_to?(:spatial?) && col_.spatial? ? true : false
-          ensure
-            @connection.instance_variable_set(:@_getting_columns, false)
-          end
-        when ::RGeo::ActiveRecord::SpatialNamedFunction
-          node_.spatial_result?
-        when ::RGeo::ActiveRecord::SpatialConstantNode, ::RGeo::Feature::Instance
-          true
-        else
-          false
-        end
-      end
-      
-      
       # Generates SQL for a spatial node.
       # The node must be a string (in which case it is treated as WKT),
       # an RGeo feature, or a spatial attribute.
@@ -112,71 +88,52 @@ module RGeo
       end
       
       
-      def _check_equality_for_rgeo(node_, negate_)  # :nodoc:
-        left_ = node_.left
-        right_ = node_.right
-        if !@connection.instance_variable_get(:@_getting_columns) && !right_.nil? && (node_has_spatial_type?(left_) || node_has_spatial_type?(right_))
-          "#{negate_ ? 'NOT ' : ''}#{st_func('ST_Equals')}(#{visit_in_spatial_context(left_)}, #{visit_in_spatial_context(right_)})"
-        else
-          false
-        end
-      end
-      
-      
-      # Override equality nodes to use the ST_Equals function if at least
-      # one of the operands is a spatial node.
-      
-      def visit_Arel_Nodes_Equality(node_)
-        _check_equality_for_rgeo(node_, false) || super
-      end
-      
-      
-      # Override equality nodes to use the ST_Equals function if at least
-      # one of the operands is a spatial node.
-      
-      def visit_Arel_Nodes_NotEqual(node_)
-        _check_equality_for_rgeo(node_, true) || super
-      end
-      
     end
     
     
-  end
-  
-end
-
-
-# :stopdoc:
-
-
-# This node wraps an RGeo feature and gives it spatial expression
-# constructors.
-
-module RGeo
-  module ActiveRecord
+    # This node wraps an RGeo feature and gives it spatial expression
+    # constructors.
     
     class SpatialConstantNode
       
       include ::RGeo::ActiveRecord::SpatialExpressions
       
+      
+      # The delegate should be the RGeo feature.
+      
       def initialize(delegate_)
         @delegate = delegate_
       end
       
+      
+      # Return the RGeo feature
+      
       attr_reader :delegate
       
+      
     end
     
-  end
-end
-
-
-# Make sure the standard Arel visitors can handle RGeo feature objects
-# by default.
-
-module Arel
-  module Visitors
-    class Visitor
+    
+    # :stopdoc:
+    
+    
+    # Hack Arel Attributes dispatcher to recognize geometry columns.
+    # This is deprecated but necessary to support legacy Arel versions.
+    
+    if ::Arel::Attributes.method_defined?(:for)
+      module ArelAttributesLegacyClassMethods
+        def for(column_)
+          column_.type == :spatial ? Attribute : super
+        end
+      end
+      ::Arel::Attributes.extend(ArelAttributesLegacyClassMethods)
+    end
+    
+    
+    # Make sure the standard Arel visitors can handle RGeo feature objects
+    # by default.
+    
+    ::Arel::Visitors::Visitor.class_eval do
       def visit_RGeo_ActiveRecord_SpatialConstantNode(node_)
         if respond_to?(:visit_in_spatial_context)
           visit_in_spatial_context(node_.delegate)
@@ -185,66 +142,69 @@ module Arel
         end
       end
     end
-    class Dot
+    ::Arel::Visitors::Dot.class_eval do
       alias :visit_RGeo_Feature_Instance :visit_String
     end
-    class DepthFirst
+    ::Arel::Visitors::DepthFirst.class_eval do
       alias :visit_RGeo_Feature_Instance :terminal
     end
-    class ToSql
+    ::Arel::Visitors::ToSql.class_eval do
       alias :visit_RGeo_Feature_Instance :visit_String
     end
-  end
-end
-
-
-# Add tools to build spatial structures in the AST.
-# This stuff requires Arel 2.1 or later.
-
-if defined?(::Arel::Nodes::NamedFunction)
-  
-  # Allow chaining of predications from named functions
-  # (Hack because Arel doesn't do this but should.)
-  ::Arel::Nodes::NamedFunction.class_eval do
-    include ::Arel::Predications unless include?(::Arel::Predications)
-  end
-  
-  # Allow chaining of spatial expressions from attributes
-  ::Arel::Attribute.class_eval do
-    include ::RGeo::ActiveRecord::SpatialExpressions
-  end
-  
-  
-  # A NamedFunction subclass that keeps track of the spatial-ness of
-  # the arguments and return values, so that it can provide context to
-  # visitors that want to interpret syntax differently when dealing with
-  # spatial elements.
-  
-  class ::RGeo::ActiveRecord::SpatialNamedFunction < ::Arel::Nodes::NamedFunction
     
-    include ::RGeo::ActiveRecord::SpatialExpressions
     
-    def initialize(name_, expr_, spatial_flags_=[], aliaz_=nil)
-      super(name_, expr_, aliaz_)
-      @spatial_flags = spatial_flags_
-    end
+    # Add tools to build spatial structures in the AST.
+    # This stuff requires Arel 2.1 or later.
     
-    def spatial_result?
-      @spatial_flags.first
+    if defined?(::Arel::Nodes::NamedFunction)
+      
+      # Allow chaining of predications from named functions
+      # (Some older versions of Arel didn't do this.)
+      ::Arel::Nodes::NamedFunction.class_eval do
+        include ::Arel::Predications unless include?(::Arel::Predications)
+      end
+      
+      # Allow chaining of spatial expressions from attributes
+      ::Arel::Attribute.class_eval do
+        include ::RGeo::ActiveRecord::SpatialExpressions
+      end
+      
+      
+      # A NamedFunction subclass that keeps track of the spatial-ness of
+      # the arguments and return values, so that it can provide context to
+      # visitors that want to interpret syntax differently when dealing with
+      # spatial elements.
+      
+      class SpatialNamedFunction < ::Arel::Nodes::NamedFunction
+        
+        include ::RGeo::ActiveRecord::SpatialExpressions
+        
+        def initialize(name_, expr_, spatial_flags_=[], aliaz_=nil)
+          super(name_, expr_, aliaz_)
+          @spatial_flags = spatial_flags_
+        end
+        
+        def spatial_result?
+          @spatial_flags.first
+        end
+        
+        def spatial_argument?(index_)
+          @spatial_flags[index_+1]
+        end
+        
+      end
+      
+    else
+      
+      # A dummy SpatialNamedFunction for pre-2.1 versions of Arel.
+      class SpatialNamedFunction; end
+      
     end
     
-    def spatial_argument?(index_)
-      @spatial_flags[index_+1]
-    end
+    
+    # :startdoc:
+    
     
   end
   
-else
-  
-  # A dummy SpatialNamedFunction for pre-2.1 versions of Arel.
-  class ::RGeo::ActiveRecord::SpatialNamedFunction; end
-  
 end
-
-
-# :startdoc:

data/lib/rgeo/active_record/common_adapter_elements.rb

@@ -34,6 +34,11 @@
 ;
 
 
+require 'active_record'
+
+::ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+
 module RGeo
   
   module ActiveRecord
@@ -43,29 +48,18 @@ module RGeo
     # databases. Individual adapters may add to or override this list.
     
     DEFAULT_SPATIAL_COLUMN_CONSTRUCTORS = {
-      :spatial => {:type => 'geometry'},
-      :geometry => {},
-      :point => {},
-      :line_string => {},
-      :polygon => {},
-      :geometry_collection => {},
-      :multi_line_string => {},
-      :multi_point => {},
-      :multi_polygon => {},
+      :spatial => {:type => 'geometry'}.freeze,
+      :geometry => {}.freeze,
+      :point => {}.freeze,
+      :line_string => {}.freeze,
+      :polygon => {}.freeze,
+      :geometry_collection => {}.freeze,
+      :multi_line_string => {}.freeze,
+      :multi_point => {}.freeze,
+      :multi_polygon => {}.freeze,
     }.freeze
     
     
-    # The default factory generator for ActiveRecord::Base.
-    
-    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config_|
-      if config_.delete(:geographic)
-        ::RGeo::Geographic.spherical_factory(config_)
-      else
-        ::RGeo::Cartesian.preferred_factory(config_)
-      end
-    end
-    
-    
     # Index definition struct with a spatial flag field.
     
     class SpatialIndexDefinition < ::Struct.new(:table, :name, :unique, :columns, :lengths, :spatial)
@@ -89,46 +83,12 @@ module RGeo
     end
     
     
-  end
-  
-end
-
-
-# :stopdoc:
-
-
-# Make sure a few things are autoloaded before we modify them.
-::Arel::Attributes
-::ActiveRecord::ConnectionAdapters::AbstractAdapter
-::ActiveRecord::ConnectionAdapters::TableDefinition
-::ActiveRecord::ConnectionAdapters::Table
-::ActiveRecord::Base
-::ActiveRecord::SchemaDumper
-
-
-# Hack Arel Attributes dispatcher to recognize geometry columns.
-# This is deprecated but necessary to support legacy Arel versions.
-
-module Arel
-  module Attributes
-    class << self
-      if method_defined?(:for)
-        alias_method :for_without_rgeo_modification, :for
-        def for(column_)
-          column_.type == :spatial ? Attribute : for_without_rgeo_modification(column_)
-        end
-      end
-    end
-  end
-end
-
-
-# Provide methods for each geometric subtype during table definitions.
-
-module ActiveRecord
-  module ConnectionAdapters
-    class TableDefinition
-      
+    # :stopdoc:
+    
+    
+    # Provide methods for each geometric subtype during table definitions.
+    
+    ::ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
       alias_method :method_missing_without_rgeo_modification, :method_missing
       def method_missing(method_name_, *args_, &block_)
         if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
@@ -142,18 +102,12 @@ module ActiveRecord
           method_missing_without_rgeo_modification(method_name_, *args_, &block_)
         end
       end
-      
     end
-  end
-end
-
-
-# Provide methods for each geometric subtype during table changes.
-
-module ActiveRecord
-  module ConnectionAdapters
-    class Table
-      
+    
+    
+    # Provide methods for each geometric subtype during table changes.
+    
+    ::ActiveRecord::ConnectionAdapters::Table.class_eval do
       alias_method :method_missing_without_rgeo_modification, :method_missing
       def method_missing(method_name_, *args_, &block_)
         if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
@@ -167,62 +121,43 @@ module ActiveRecord
           method_missing_without_rgeo_modification(method_name_, *args_, &block_)
         end
       end
-      
     end
-  end
-end
-
-
-# When creating column objects, cause the enclosing ActiveRecord class
-# to be set on any column that recognizes it. This is commonly used by
-# spatial column subclasses.
-
-module ActiveRecord
-  class Base
-    class << self
-      alias_method :columns_without_rgeo_modification, :columns
-      def columns
-        unless defined?(@columns) && @columns
-          columns_without_rgeo_modification.each do |column_|
-            column_.set_ar_class(self) if column_.respond_to?(:set_ar_class)
+    
+    
+    # Hack schema dumper to output spatial index flag
+    
+    ::ActiveRecord::SchemaDumper.class_eval do
+      private
+      def indexes(table_, stream_)
+        if (indexes_ = @connection.indexes(table_)).any?
+          add_index_statements_ = indexes_.map do |index_|
+            statement_parts_ = [
+              ('add_index ' + index_.table.inspect),
+              index_.columns.inspect,
+              (':name => ' + index_.name.inspect),
+            ]
+            statement_parts_ << ':unique => true' if index_.unique
+            statement_parts_ << ':spatial => true' if index_.respond_to?(:spatial) && index_.spatial
+            index_lengths_ = (index_.lengths || []).compact
+            statement_parts_ << (':length => ' + ::Hash[*index_.columns.zip(index_.lengths).flatten].inspect) unless index_lengths_.empty?
+            '  ' + statement_parts_.join(', ')
           end
+          stream_.puts add_index_statements_.sort.join("\n")
+          stream_.puts
         end
-        @columns
-      end
-    end
-  end
-end
-
-
-# Hack schema dumper to output spatial index flag
-
-module ActiveRecord
-  class SchemaDumper
-    private
-    def indexes(table_, stream_)
-      if (indexes_ = @connection.indexes(table_)).any?
-        add_index_statements_ = indexes_.map do |index_|
-          statement_parts_ = [ ('add_index ' + index_.table.inspect) ]
-          statement_parts_ << index_.columns.inspect
-          statement_parts_ << (':name => ' + index_.name.inspect)
-          statement_parts_ << ':unique => true' if index_.unique
-          statement_parts_ << ':spatial => true' if index_.respond_to?(:spatial) && index_.spatial
-          index_lengths_ = index_.lengths.compact if index_.lengths.is_a?(::Array)
-          statement_parts_ << (':length => ' + ::Hash[*index_.columns.zip(index_.lengths).flatten].inspect) if index_lengths_.present?
-          '  ' + statement_parts_.join(', ')
-        end
-        stream_.puts add_index_statements_.sort.join("\n")
-        stream_.puts
       end
     end
+    
+    
+    # Tell ActiveRecord to cache spatial attribute values so they don't get
+    # re-parsed on every access.
+    
+    ::ActiveRecord::Base.attribute_types_cached_by_default << :spatial
+    
+    
+    # :startdoc:
+    
+    
   end
+  
 end
-
-
-# Tell ActiveRecord to cache spatial attribute values so they don't get
-# re-parsed on every access.
-
-::ActiveRecord::Base.attribute_types_cached_by_default << :spatial
-
-
-# :startdoc:

metadata

@@ -2,7 +2,7 @@
 name: rgeo-activerecord
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-23 00:00:00 Z
+date: 2011-08-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rgeo
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.3.0
+        version: 0.3.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: virtuoso
-rubygems_version: 1.8.2
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: An RGeo module providing spatial extensions to ActiveRecord.