activerecord-postgis-adapter 0.2.0

data/History.rdoc

@@ -0,0 +1,6 @@
+=== 0.2.0 / 2010-12-07
+
+* Initial public alpha release. Spun activerecord-postgis-adapter off from the core rgeo gem.
+* You can now set the factory for a specific column by name.
+
+For earlier history, see the History file for the rgeo gem.

data/README.rdoc

@@ -0,0 +1,152 @@
+== PostGIS \ActiveRecord Adapter
+
+The PostGIS \ActiveRecord Adapter is an \ActiveRecord connection adapter
+based on the standard postgresql adapter. It extends the standard adapter
+to provide support for the spatial extensions provided by PostGIS, using
+the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial
+data in Ruby. Like the standard postgresql adapter, this adapter requires
+the pg gem.
+
+=== Usage
+
+To use this adapter, add this gem, "activerecord-postgis-adapter", to
+your Gemfile, and then request the adapter name "postgis" in your
+database connection configuration (which, for a Rails application, is in
+the config/database.yml file). The other database connection configuration
+parameters are the same as for the stock postgresql adapter.
+
+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.
+To create a spatial index, set the <tt>:spatial</tt> option to true when
+creating the index.
+
+Examples:
+
+ create_table :spatial_table do |t|
+   t.column :shape, :geometry  # or t.geometry :shape
+   t.line_string :path
+   t.column :latlon, :point, :geographic => true
+ end
+ change_table :spatial_table do |t|
+   t.index :latlon, :spatial => true
+ end
+
+When this adapter is in use, spatial attributes in your \ActiveRecord
+objects will have RGeo geometry values. You can set spatial attributes
+either to RGeo geometry objects, or to strings in WKT (well-known text)
+format, which the adapter will automatically convert to geometry objects.
+
+To specify the RGeo geometry factory, you can either set an explicit
+factory for a 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 set_rgeo_factory_for_column class method on your
+\ActiveRecord class. For the latter, set the rgeo_factory_generator class
+attribute. This generator should understand the usual <tt>:srid</tt>,
+<tt>:has_z_coordinate</tt>, and <tt>:has_m_coordinate</tt> options. It
+will also be passed a <tt>:geographic</tt> option indicating whether the
+column is a geography column. The set_rgeo_factory_for_column and 
+rgeo_factory_generator methods are actually implemented and documented in
+the "rgeo-activerecord" gem.
+
+Examples, given the spatial table defined above:
+
+ class SpatialTable < ActiveRecord::Base
+   
+   # By default, use the GEOS implementation for spatial columns.
+   self.rgeo_factory_generator = RGeo::Geos.method(:factory)
+   
+   # But use a geographic implementation for the :latlon column.
+   set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
+   
+ end
+
+Now you can interact with the data using the RGeo types:
+
+ rec = SpatialTable.new
+ rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
+ loc = rec.latlon                # Accessing always returns a feature object, in
+                                 # this case, a geographic that understands latitude.
+ loc.latitude                    # => 47
+ rec.shape = loc                 # the factory for the :shape column is GEOS, so the
+                                 # value will be cast from geographic to GEOS.
+ RGeo::Geos.is_geos?(rec.shape)  # => true
+
+=== Installation
+
+This adapter has the following requirements:
+
+* Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
+* PostGIS 1.5 or later.
+* \ActiveRecord 3.0.3 or later. Earlier versions will not work.
+* rgeo gem 0.2.0 or later.
+* rgeo-activerecord gem 0.2.0 or later.
+* pg gem 0.10 or later.
+
+Install this adapter as a gem:
+
+ gem install activerecord-postgis-adapter
+
+See the README for the "rgeo" gem, a required dependency, for further
+installation information.
+
+=== Known bugs and limitations
+
+A few minor holes still exist in this adapter. Notably, using \ActiveRecord
+to list indexes doesn't properly identify GiST (spatial) indexes as such.
+This adapter is also not yet well tested.
+
+=== Development and support
+
+Documentation is available at http://virtuoso.rubyforge.org/activerecord-postgis-adapter/README_rdoc.html
+
+Source code is hosted on Github at http://github.com/dazuma/activerecord-postgis-adapter
+
+Contributions are welcome. Fork the project on Github.
+
+Report bugs on Github issues at http://github.org/dazuma/activerecord-postgis-adapter/issues
+
+Contact the author at dazuma at gmail dot com.
+
+=== Acknowledgments
+
+RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+
+Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com).
+
+This adapter implementation owes some debt to the spatial_adapter plugin
+(http://github.com/fragility/spatial_adapter). Although we made some
+different design decisions for this adapter, studying the spatial_adapter
+source gave us a head start on the implementation.
+
+=== License
+
+Copyright 2010 Daniel Azuma
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the copyright holder, nor the names of any other
+  contributors to this software, may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/Version

@@ -0,0 +1 @@
+0.2.0

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -0,0 +1,444 @@
+# -----------------------------------------------------------------------------
+# 
+# PostGIS adapter for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'rgeo/active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+
+# :stopdoc:
+
+module Arel
+  module Visitors
+    VISITORS['postgis'] = ::Arel::Visitors::PostgreSQL
+  end
+end
+
+# :startdoc:
+
+
+# The activerecord-postgis-adapter gem installs the *postgis*
+# connection adapter into ActiveRecord.
+
+module ActiveRecord
+  
+  
+  # ActiveRecord looks for the postgis_connection factory method in
+  # this class.
+  
+  class Base
+    
+    
+    # Create a postgis connection adapter.
+    
+    def self.postgis_connection(config_)
+      require 'pg'
+      
+      config_ = config_.symbolize_keys
+      host_ = config_[:host]
+      port_ = config_[:port] || 5432
+      username_ = config_[:username].to_s if config_[:username]
+      password_ = config_[:password].to_s if config_[:password]
+      if config_.has_key?(:database)
+        database_ = config_[:database]
+      else
+        raise ::ArgumentError, "No database specified. Missing argument: database."
+      end
+      
+      # The postgres drivers don't allow the creation of an unconnected PGconn object,
+      # so just pass a nil connection object for the time being.
+      ConnectionAdapters::PostGisAdapter.new(nil, logger, [host_, port_, nil, nil, database_, username_, password_], config_)
+    end
+    
+    
+  end
+  
+  
+  module ConnectionAdapters  # :nodoc:
+    
+    
+    class PostGisAdapter < PostgreSQLAdapter  # :nodoc:
+      
+      
+      ADAPTER_NAME = 'PostGIS'.freeze
+      
+      @@native_database_types = nil
+      
+      
+      def native_database_types
+        @@native_database_types ||= super.merge(:geometry => {:name => "geometry"}, :point => {:name => "point"}, :line_string => {:name => "linestring"}, :polygon => {:name => "polygon"}, :geometry_collection => {:name => "geometrycollection"}, :multi_point => {:name => "multipoint"}, :multi_line_string => {:name => "multilinestring"}, :multi_polygon => {:name => "multipolygon"})
+      end
+      
+      
+      def adapter_name
+        ADAPTER_NAME
+      end
+      
+      
+      def postgis_lib_version
+        unless defined?(@postgis_lib_version)
+          @postgis_lib_version = select_value("SELECT PostGIS_Lib_Version()") rescue nil
+        end
+        @postgis_lib_version
+      end
+      
+      
+      def quote(value_, column_=nil)
+        if ::RGeo::Feature::Geometry.check_type(value_)
+          "'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value_)}'"
+        else
+          super
+        end
+      end
+      
+      
+      def columns(table_name_, name_=nil)  #:nodoc:
+        table_name_ = table_name_.to_s
+        spatial_info_ = spatial_column_info(table_name_)
+        column_definitions(table_name_).collect do |name_, type_, default_, notnull_|
+          SpatialColumn.new(name_, default_, type_, notnull_ == 'f', type_ =~ /geometry/i ? spatial_info_[name_] : nil)
+        end
+      end
+      
+      
+      def create_table(table_name_, options_={})
+        table_name_ = table_name_.to_s
+        table_definition_ = SpatialTableDefinition.new(self)
+        table_definition_.primary_key(options_[:primary_key] || ::ActiveRecord::Base.get_primary_key(table_name_.singularize)) unless options_[:id] == false
+        yield table_definition_ if block_given?
+        if options_[:force] && table_exists?(table_name_)
+          drop_table(table_name_, options_)
+        end
+        
+        create_sql_ = "CREATE#{' TEMPORARY' if options_[:temporary]} TABLE "
+        create_sql_ << "#{quote_table_name(table_name_)} ("
+        create_sql_ << table_definition_.to_sql
+        create_sql_ << ") #{options_[:options]}"
+        execute create_sql_
+        
+        table_definition_.non_geographic_spatial_columns.each do |col_|
+          type_ = col_.type.to_s.gsub('_', '').upcase
+          has_z_ = col_.has_z?
+          has_m_ = col_.has_m?
+          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(col_.name)}', #{col_.srid}, '#{quote_string(type_)}', #{dimensions_})")
+        end
+      end
+      
+      
+      def drop_table(table_name_, options_={})
+        execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
+        super
+      end
+      
+      
+      def add_column(table_name_, column_name_, type_, options_={})
+        table_name_ = table_name_.to_s
+        if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(type_.to_sym)
+          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
+          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
+        else
+          super
+        end
+      end
+      
+      
+      def remove_column(table_name_, *column_names_)
+        column_names_ = column_names_.flatten.map{ |n_| n_.to_s }
+        spatial_info_ = spatial_column_info(table_name_)
+        remaining_column_names_ = []
+        column_names_.each do |name_|
+          if spatial_info_.include?(name_)
+            execute("SELECT DropGeometryColumn('#{quote_string(table_name_.to_s)}','#{quote_string(name_)}')")
+          else
+            remaining_column_names_ << name_.to_sym
+          end
+        end
+        if remaining_column_names_.size > 0
+          super(table_name_, *remaining_column_names_)
+        end
+      end
+      
+      
+      def add_index(table_name_, column_name_, options_={})
+        table_name_ = table_name_.to_s
+        column_names_ = ::Array.wrap(column_name_)
+        index_name_ = index_name(table_name_, :column => column_names_)
+        gist_clause_ = ''
+        index_type_ = ''
+        if ::Hash === options_  # legacy support, since this param was a string
+          index_type_ = 'UNIQUE' if options_[:unique]
+          index_name_ = options_[:name].to_s if options_.key?(:name)
+          gist_clause_ = 'USING GIST' if options_[:spatial]
+        else
+          index_type_ = options_
+        end
+        if index_name_.length > index_name_length
+          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' is too long; the limit is #{index_name_length} characters"
+        end
+        if index_name_exists?(table_name_, index_name_, false)
+          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' already exists"
+        end
+        quoted_column_names_ = quoted_columns_for_index(column_names_, options_).join(", ")
+        execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)} #{gist_clause_} (#{quoted_column_names_})"
+      end
+      
+      
+      def spatial_column_info(table_name_)
+        info_ = query("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
+        result_ = {}
+        info_.each do |row_|
+          name_ = row_[3]
+          type_ = row_[6]
+          dimension_ = row_[4].to_i
+          has_m_ = type_ =~ /m$/i ? true : false
+          type_.sub!(/m$/, '')
+          has_z_ = dimension_ > 3 || dimension_ == 3 && !has_m_
+          result_[name_] = {
+            :name => name_,
+            :type => type_,
+            :dimension => dimension_,
+            :srid => row_[5].to_i,
+            :has_z => has_z_,
+            :has_m => has_m_,
+          }
+        end
+        result_
+      end
+      
+      
+      class SpatialTableDefinition < ConnectionAdapters::TableDefinition  # :nodoc:
+        
+        attr_reader :spatial_columns
+        
+        def initialize(base_)
+          super
+        end
+        
+        def column(name_, type_, options_={})
+          super
+          col_ = self[name_]
+          if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(col_.type.to_sym)
+            col_.extend(GeometricColumnDefinitionMethods) unless col_.respond_to?(:geographic?)
+            col_.set_geographic(options_[:geographic])
+            col_.set_srid((options_[:srid] || 4326).to_i)
+            col_.set_has_z(options_[:has_z])
+            col_.set_has_m(options_[:has_m])
+          end
+          self
+        end
+        
+        def to_sql
+          @columns.find_all{ |c_| !c_.respond_to?(:geographic?) || c_.geographic? }.map{ |c_| c_.to_sql } * ', '
+        end
+        
+        def non_geographic_spatial_columns
+          @columns.find_all{ |c_| c_.respond_to?(:geographic?) && !c_.geographic? }
+        end
+        
+      end
+      
+      
+      module GeometricColumnDefinitionMethods  # :nodoc:
+        
+        def geographic?
+          defined?(@geographic) && @geographic
+        end
+        
+        def srid
+          defined?(@srid) ? @srid : 4326
+        end
+        
+        def has_z?
+          defined?(@has_z) && @has_z
+        end
+        
+        def has_m?
+          defined?(@has_m) && @has_m
+        end
+        
+        def set_geographic(value_)
+          @geographic = value_ ? true : false
+        end
+        
+        def set_srid(value_)
+          @srid = value_
+        end
+        
+        def set_has_z(value_)
+          @has_z = value_ ? true : false
+        end
+        
+        def set_has_m(value_)
+          @has_m = value_ ? true : false
+        end
+        
+        def sql_type
+          type_ = type.to_s.upcase.gsub('_', '')
+          type_ << 'Z' if has_z?
+          type_ << 'M' if has_m?
+          "GEOGRAPHY(#{type_},#{srid})"
+        end
+        
+      end
+      
+      
+      class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
+        
+        
+        def initialize(name_, default_, sql_type_=nil, null_=true, opts_=nil)
+          super(name_, default_, sql_type_, null_)
+          @geographic = sql_type_ =~ /^geography/ ? true : false
+          if opts_
+            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type])
+            @srid = opts_[:srid].to_i
+            @has_z = opts_[:has_z]
+            @has_m = opts_[:has_m]
+          elsif @geographic
+            if sql_type_ =~ /geography\((\w+[^,zm])(z?)(m?),(\d+)\)/i
+              @has_z = $2.length > 0
+              @has_m = $3.length > 0
+              @srid = $4.to_i
+              @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name($1)
+            else
+              @geometric_type = ::RGeo::Feature::Geometry
+              @srid = 4326
+              @has_z = @has_m = false
+            end
+          else
+            @geometric_type = @has_z = @has_m = nil
+            @srid = 0
+          end
+          @ar_class = ::ActiveRecord::Base
+        end
+        
+        
+        def set_ar_class(val_)
+          @ar_class = val_
+        end
+        
+        
+        attr_reader :srid
+        attr_reader :geometric_type
+        attr_reader :has_z
+        attr_reader :has_m
+        
+        
+        def spatial?
+          type == :geometry
+        end
+        
+        
+        def geographic?
+          @geographic
+        end
+        
+        
+        def klass
+          type == :geometry ? ::RGeo::Feature::Geometry : super
+        end
+        
+        
+        def type_cast(value_)
+          type == :geometry ? SpatialColumn.convert_to_geometry(value_, @ar_class, name, @geographic, @srid, @has_z, @has_m) : super
+        end
+        
+        
+        def type_cast_code(var_name_)
+          type == :geometry ? "::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
+        end
+        
+        
+        private
+        
+        
+        def simplified_type(sql_type_)
+          sql_type_ =~ /geography|geometry|point|linestring|polygon/i ? :geometry : super
+        end
+        
+        
+        def self.convert_to_geometry(input_, ar_class_, column_, geographic_, srid_, has_z_, has_m_)
+          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_)
+            ::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_)
+              marker_ = input_[0,1]
+              if marker_ == "\x00" || marker_ == "\x01"
+                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse(input_) rescue nil
+              elsif input_[0,4] =~ /[0-9a-fA-F]{4}/
+                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse_hex(input_) rescue nil
+              else
+                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_) rescue nil
+              end
+            end
+          else
+            nil
+          end
+        end
+        
+        
+      end
+      
+      
+    end
+    
+    
+  end
+  
+  
+end

data/test/tc_basic.rb

@@ -0,0 +1,271 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the PostGIS ActiveRecord adapter
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+require 'test/unit'
+require 'rgeo/active_record/adapter_test_helper'
+
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      module Tests  # :nodoc:
+        
+        class TestBasic < ::Test::Unit::TestCase  # :nodoc:
+          
+          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
+          include AdapterTestHelper
+          
+          define_test_methods do
+            
+            
+            def populate_ar_class(content_)
+              klass_ = create_ar_class
+              case content_
+              when :latlon_point
+                klass_.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'latlon', :point, :srid => 4326
+                end
+              when :latlon_point_geographic
+                klass_.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'latlon', :point, :srid => 4326, :geographic => true
+                end
+              end
+              klass_
+            end
+            
+            
+            def test_postgis_available
+              connection_ = create_ar_class.connection
+              assert_equal('PostGIS', connection_.adapter_name)
+              assert_not_nil(connection_.postgis_lib_version)
+            end
+            
+            
+            def test_create_simple_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry
+              end
+              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(false, col_.geographic?)
+              assert_equal(4326, 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_simple_geography
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry, :geographic => true
+              end
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(true, col_.geographic?)
+              assert_equal(4326, col_.srid)
+              assert(klass_.cached_attributes.include?('latlon'))
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_point_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :point
+              end
+              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
+              assert(klass_.cached_attributes.include?('latlon'))
+            end
+            
+            
+            def test_create_geometry_with_index
+              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_.index([:latlon], :spatial => true)
+              end
+            end
+            
+            
+            def test_set_and_get_point
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              assert_nil(obj_.latlon)
+              obj_.latlon = @factory.point(1, 2)
+              assert_equal(@factory.point(1, 2), obj_.latlon)
+              assert_equal(4326, obj_.latlon.srid)
+            end
+            
+            
+            def test_set_and_get_point_from_wkt
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              assert_nil(obj_.latlon)
+              obj_.latlon = 'POINT(1 2)'
+              assert_equal(@factory.point(1, 2), obj_.latlon)
+              assert_equal(4326, obj_.latlon.srid)
+            end
+            
+            
+            def test_save_and_load_point
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              obj_.latlon = @factory.point(1, 2)
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(@factory.point(1, 2), obj2_.latlon)
+              assert_equal(4326, obj2_.latlon.srid)
+              assert_equal(true, ::RGeo::Geos.is_geos?(obj2_.latlon))
+            end
+            
+            
+            def test_save_and_load_geographic_point
+              klass_ = populate_ar_class(:latlon_point_geographic)
+              obj_ = klass_.new
+              obj_.latlon = @factory.point(1, 2)
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(@geographic_factory.point(1, 2), obj2_.latlon)
+              assert_equal(4326, obj2_.latlon.srid)
+              assert_equal(false, ::RGeo::Geos.is_geos?(obj2_.latlon))
+            end
+            
+            
+            def test_save_and_load_point_from_wkt
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              obj_.latlon = 'POINT(1 2)'
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(@factory.point(1, 2), obj2_.latlon)
+              assert_equal(4326, obj2_.latlon.srid)
+            end
+            
+            
+            def test_add_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', :point, :srid => 4326)
+                t_.column('name', :string)
+              end
+              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(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(false, cols_[-2].geographic?)
+              assert_nil(cols_[-1].geometric_type)
+            end
+            
+            
+            def test_add_geography_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', :point, :srid => 4326, :geographic => 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(4326, cols_[-3].srid)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(true, cols_[-2].geographic?)
+              assert_nil(cols_[-1].geometric_type)
+            end
+            
+            
+            def test_drop_geometry_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+                t_.column('geom2', :point, :srid => 4326)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.remove('geom2')
+              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_[-1].geometric_type)
+              assert_equal('latlon', cols_[-1].name)
+              assert_equal(4326, cols_[-1].srid)
+              assert_equal(false, cols_[-1].geographic?)
+            end
+            
+            
+            def test_drop_geography_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+                t_.column('geom2', :point, :srid => 4326, :geographic => true)
+                t_.column('geom3', :point, :srid => 4326)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.remove('geom2')
+              end
+              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::Point, cols_[-1].geometric_type)
+              assert_equal('geom3', cols_[-1].name)
+              assert_equal(false, cols_[-1].geographic?)
+              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
+              assert_equal('latlon', cols_[-2].name)
+              assert_equal(false, cols_[-2].geographic?)
+            end
+            
+            
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-postgis-adapter
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Daniel Azuma
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rgeo-activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :runtime
+  version_requirements: *id002
+description: This is an ActiveRecord connection adapter for PostGIS. It is based on the stock PostgreSQL adapter, but provides built-in support for the spatial extensions provided by PostGIS. It uses the RGeo library to represent spatial data in Ruby.
+email: dazuma@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.rdoc
+- README.rdoc
+files: 
+- lib/active_record/connection_adapters/postgis_adapter.rb
+- History.rdoc
+- README.rdoc
+- test/tc_basic.rb
+- Version
+has_rdoc: true
+homepage: http://virtuoso.rubyforge.org/activerecord-postgis-adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: virtuoso
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord adapter for PostGIS, based on RGeo.
+test_files: 
+- test/tc_basic.rb