spatial_adapter 0.2.1 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/spatial_adapter/adapters/mysql.rb

@@ -3,7 +3,7 @@ require 'active_record/connection_adapters/mysql_adapter'
 ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
   include SpatialAdapter
 
-  def supports_geography?
+  def supports_geographic?
     false
   end
   
@@ -28,12 +28,8 @@ ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
     columns = []
     result = execute(sql, name)
     result.each do |field|
-      if field[1] =~ /geometry|point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection/i
-        #to note that the column is spatial
-        columns << ActiveRecord::ConnectionAdapters::SpatialMysqlColumn.new(field[0], field[4], field[1], field[2] == "YES")
-      else
-        columns << ActiveRecord::ConnectionAdapters::MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES")
-      end
+      klass = field[1] =~ /geometry|point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection/i ? ActiveRecord::ConnectionAdapters::SpatialMysqlColumn : ActiveRecord::ConnectionAdapters::MysqlColumn
+      columns << klass.new(field[0], field[4], field[1], field[2] == "YES")
     end
     result.free
     columns

data/lib/spatial_adapter/adapters/postgis.rb

@@ -25,7 +25,7 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
     !postgis_version.nil?
   end
   
-  def supports_geography?
+  def supports_geographic?
     postgis_major_version > 1 || (postgis_major_version == 1 && postgis_minor_version >= 5)
   end
   
@@ -49,9 +49,12 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
     
     column_definitions(table_name).collect do |name, type, default, notnull|
       case type
+      when /geography/i
+        ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn.create_from_geography(name, default, type, notnull == 'f')
       when /geometry/i
         raw_geom_info = raw_geom_infos[name]
         if raw_geom_info.nil?
+          # This column isn't in the geometry_columns table, so we don't know anything else about it
           ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn.create_simplified(name, default, notnull == "f")
         else
           ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn.new(name, default, raw_geom_info.type, notnull == "f", raw_geom_info.srid, raw_geom_info.with_z, raw_geom_info.with_m)
@@ -77,26 +80,28 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
     create_sql << "#{quote_table_name(table_name)} ("
     create_sql << table_definition.to_sql
     create_sql << ") #{options[:options]}"
-    execute create_sql
 
     # This is the additional portion for PostGIS
     unless table_definition.geom_columns.nil?
       table_definition.geom_columns.each do |geom_column|
-        execute geom_column.to_sql(table_name)
+        geom_column.table_name = table_name
+        create_sql << "; " + geom_column.to_sql
       end
     end
+
+    execute create_sql
   end
 
   alias :original_remove_column :remove_column
-  def remove_column(table_name, column_name, options = {})
+  def remove_column(table_name, *column_names)
+    column_names = column_names.flatten
     columns(table_name).each do |col|
-      if col.name == column_name.to_s 
-        #check if the column is geometric
-        unless geometry_data_types[col.type].nil? or
-               (options[:remove_using_dropgeometrycolumn] == false)
-          execute "SELECT DropGeometryColumn('#{table_name}','#{column_name}')"
+      if column_names.include?(col.name.to_sym)
+        # Geometry columns have to be removed using DropGeometryColumn
+        if col.type == :geometry && !col.geographic?
+          execute "SELECT DropGeometryColumn('#{table_name}','#{col.name}')"
         else
-          original_remove_column(table_name, column_name)
+          original_remove_column(table_name, col.name)
         end
       end
     end
@@ -104,9 +109,20 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
   
   alias :original_add_column :add_column
   def add_column(table_name, column_name, type, options = {})
-    unless geometry_data_types[type].nil? or (options[:create_using_addgeometrycolumn] == false)
-      geom_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumnDefinition.new(self, column_name, type, nil, nil, options[:null], options[:srid] || -1 , options[:with_z] || false , options[:with_m] || false)
-      execute geom_column.to_sql(table_name)
+    unless geometry_data_types[type].nil?
+      geom_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumnDefinition.new(self, column_name, type, nil, nil, options[:null], options[:srid] || -1 , options[:with_z] || false , options[:with_m] || false, options[:geographic] || false)
+      if geom_column.geographic
+        default = options[:default]
+        notnull = options[:null] == false
+        
+        execute("ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{geom_column.to_sql}")
+
+        change_column_default(table_name, column_name, default) if options_include_default?(options)
+        change_column_null(table_name, column_name, false, default) if notnull
+      else
+        geom_column.table_name = table_name
+        execute geom_column.to_sql
+      end
     else
       original_add_column(table_name, column_name, type, options)
     end
@@ -228,14 +244,21 @@ module ActiveRecord
         unless (@base.geometry_data_types[type.to_sym].nil? or
                 (options[:create_using_addgeometrycolumn] == false))
 
-          geom_column = PostgreSQLColumnDefinition.new(@base, name, type)
-          geom_column.null = options[:null]
-          geom_column.srid = options[:srid] || -1
-          geom_column.with_z = options[:with_z] || false 
-          geom_column.with_m = options[:with_m] || false
-         
-          @geom_columns ||= []
-          @geom_columns << geom_column          
+          column = self[name] || PostgreSQLColumnDefinition.new(@base, name, type)
+          column.null = options[:null]
+          column.srid = options[:srid] || -1
+          column.with_z = options[:with_z] || false 
+          column.with_m = options[:with_m] || false
+          column.geographic = options[:geographic] || false
+
+          if column.geographic
+            @columns << column unless @columns.include? column
+          else
+            # Hold this column for later
+            @geom_columns ||= []
+            @geom_columns << column
+          end
+          self
         else
           super(name, type, options)
         end
@@ -243,20 +266,37 @@ module ActiveRecord
     end
 
     class PostgreSQLColumnDefinition < ColumnDefinition
-      attr_accessor :srid, :with_z, :with_m
+      attr_accessor :table_name
+      attr_accessor :srid, :with_z, :with_m, :geographic
       attr_reader :spatial
 
-      def initialize(base = nil, name = nil, type=nil, limit=nil, default=nil, null=nil, srid=-1, with_z=false, with_m=false)
-        super(base, name, type, limit, default,null)
+      def initialize(base = nil, name = nil, type=nil, limit=nil, default=nil, null=nil, srid=-1, with_z=false, with_m=false, geographic=false)
+        super(base, name, type, limit, default, null)
+        @table_name = nil
         @spatial = true
         @srid = srid
         @with_z = with_z
         @with_m = with_m
+        @geographic = geographic
       end
       
-      def to_sql(table_name)
-        if @spatial
-          type_sql = type_to_sql(type.to_sym)
+      def sql_type
+        if geographic
+          type_sql = base.geometry_data_types[type.to_sym][:name]
+          type_sql += "Z" if with_z
+          type_sql += "M" if with_m
+          # SRID is not yet supported (defaults to 4326)
+          #type_sql += ", #{srid}" if (srid && srid != -1)
+          type_sql = "geography(#{type_sql})"
+          type_sql
+        else
+          super
+        end
+      end
+      
+      def to_sql
+        if spatial && !geographic
+          type_sql = base.geometry_data_types[type.to_sym][:name]
           type_sql += "M" if with_m and !with_z
           if with_m and with_z
             dimension = 4 
@@ -265,7 +305,7 @@ module ActiveRecord
           else
             dimension = 2
           end
-          
+        
           column_sql = "SELECT AddGeometryColumn('#{table_name}','#{name}',#{srid},'#{type_sql}',#{dimension})"
           column_sql += ";ALTER TABLE #{table_name} ALTER #{name} SET NOT NULL" if null == false
           column_sql
@@ -273,12 +313,6 @@ module ActiveRecord
           super
         end
       end
-  
-      private
-      
-      def type_to_sql(name, limit=nil)
-        base.type_to_sql(name, limit) rescue name
-      end   
     end
   end
 end
@@ -288,14 +322,60 @@ module ActiveRecord
     class SpatialPostgreSQLColumn < PostgreSQLColumn
       include SpatialAdapter::SpatialColumn
 
+      def initialize(name, default, sql_type = nil, null = true, srid=-1, with_z=false, with_m=false, geographic = false)
+        super(name, default, sql_type, null, srid, with_z, with_m)
+        @geographic = geographic
+      end
+
+      def geographic?
+        @geographic
+      end
+      
       #Transforms a string to a geometry. PostGIS returns a HewEWKB string.
       def self.string_to_geometry(string)
         return string unless string.is_a?(String)
         GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(string) rescue nil
       end
 
-      def self.create_simplified(name,default,null = true)
-        new(name,default,"geometry",null,nil,nil,nil)
+      def self.create_simplified(name, default, null = true)
+        new(name, default, "geometry", null)
+      end
+      
+      def self.create_from_geography(name, default, sql_type, null = true)
+        params = extract_geography_params(sql_type)
+        new(name, default, sql_type, null, params[:srid], params[:with_z], params[:with_m], true)
+      end
+      
+      private
+      
+      # Add detection of PostGIS-specific geography columns
+      def geometry_simplified_type(sql_type)
+        case sql_type
+        when /geography\(point/i then :point
+        when /geography\(linestring/i then :line_string
+        when /geography\(polygon/i then :polygon
+        when /geography\(multipoint/i then :multi_point
+        when /geography\(multilinestring/i then :multi_line_string
+        when /geography\(multipolygon/i then :multi_polygon
+        when /geography\(geometrycollection/i then :geometry_collection
+        when /geography/i then :geometry
+        else
+          super
+        end
+      end
+
+      def self.extract_geography_params(sql_type)
+        params = {
+          :srid => 0,
+          :with_z => false,
+          :with_m => false
+        }
+        if sql_type =~ /geography(?:\((?:\w+?)(Z)?(M)?(?:,(\d+))?\))?/i
+          params[:with_z] = $1 == 'Z'
+          params[:with_m] = $2 == 'M'
+          params[:srid]   = $3.to_i
+        end
+        params
       end
     end
   end

data/lib/spatial_adapter/schema_dumper.rb

@@ -2,7 +2,7 @@ ActiveRecord::SchemaDumper.ignore_tables << "spatial_ref_sys" << "geometry_colum
 
 ActiveRecord::SchemaDumper.class_eval do
   # These are the valid options for a column specification (spatial options added)
-  VALID_COLUMN_SPEC_KEYS = [:name, :limit, :precision, :scale, :default, :null, :srid, :with_z, :with_m]
+  VALID_COLUMN_SPEC_KEYS = [:name, :limit, :precision, :scale, :default, :null, :srid, :with_z, :with_m, :geographic]
   
   def table(table, stream)
     columns = @connection.columns(table)
@@ -129,6 +129,7 @@ ActiveRecord::SchemaDumper.class_eval do
       spec[:srid]    = column.srid.inspect if column.srid != -1
       spec[:with_z]  = 'true' if column.with_z
       spec[:with_m]  = 'true' if column.with_m
+      spec[:geographic] = 'true' if column.geographic?
     end
     spec
   end

data/lib/spatial_adapter/spatial_column.rb

@@ -1,8 +1,8 @@
 module SpatialAdapter
   module SpatialColumn
-    attr_reader  :spatial, :geometry_type, :srid, :with_z, :with_m
+    attr_reader  :geometry_type, :srid, :with_z, :with_m
 
-    def initialize(name, default, sql_type = nil, null = true,srid=-1,with_z=false,with_m=false)
+    def initialize(name, default, sql_type = nil, null = true, srid=-1, with_z=false, with_m=false)
       super(name, default, sql_type, null)
       @geometry_type = geometry_simplified_type(@sql_type)
       @srid = srid
@@ -10,6 +10,10 @@ module SpatialAdapter
       @with_m = with_m
     end
   
+    def geographic?
+      false
+    end
+
     # Redefines type_cast to add support for geometries
     # alias_method :type_cast_without_spatial, :type_cast
     def type_cast(value)
@@ -43,17 +47,17 @@ module SpatialAdapter
 
     private
 
-    #Redefines the simplified_type method to add behabiour for when a column is of type geometry
+    #Redefines the simplified_type method to spatial columns
     def simplified_type(field_type)
       case field_type
-      when /geometry|point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection/i then :geometry
+      when /geography|geometry|point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection/i then :geometry
       else super
       end
     end
 
-    #less simlpified geometric type to be use in migrations
-    def geometry_simplified_type(field_type)
-      case field_type
+    # less simlpified geometric type to be use in migrations
+    def geometry_simplified_type(sql_type)
+      case sql_type
       when /^point$/i then :point
       when /^linestring$/i then :line_string
       when /^polygon$/i then :polygon

data/spec/db/postgis_raw.rb

@@ -93,4 +93,98 @@ ActiveRecord::Schema.define() do
     );
     select AddGeometryColumn('point4_models', 'geom', 4326, 'POINT', 4);
   SQL
+  
+  if ActiveRecord::Base.connection.supports_geographic?
+    execute <<-SQL
+      drop table if exists geography_point_models;
+      create table geography_point_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINT)
+      );
+      create index index_geography_point_models_on_geom on geography_point_models using gist (geom);
+      create index index_geography_point_models_on_extra on geography_point_models (extra);
+
+      drop table if exists geography_line_string_models;
+      create table geography_line_string_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(LINESTRING)
+      );
+
+      drop table if exists geography_polygon_models;
+      create table geography_polygon_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POLYGON)
+      );
+
+      drop table if exists geography_multi_point_models;
+      create table geography_multi_point_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTIPOINT)
+      );
+
+      drop table if exists geography_multi_line_string_models;
+      create table geography_multi_line_string_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTILINESTRING)
+      );
+
+      drop table if exists geography_multi_polygon_models;
+      create table geography_multi_polygon_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTIPOLYGON)
+      );
+
+      drop table if exists geography_geometry_collection_models;
+      create table geography_geometry_collection_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(GEOMETRYCOLLECTION)
+      );
+
+      drop table if exists geography_models;
+      create table geography_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography
+      );
+
+      drop table if exists geography_pointz_models;
+      create table geography_pointz_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTZ)
+      );
+
+      drop table if exists geography_pointm_models;
+      create table geography_pointm_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTM)
+      );
+
+      drop table if exists geography_point4_models;
+      create table geography_point4_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTZM)
+      );
+    SQL
+  end
 end

data/spec/models/common.rb

@@ -30,3 +30,36 @@ end
 
 class Point4Model < ActiveRecord::Base
 end
+
+class GeographyPointModel < ActiveRecord::Base
+end
+
+class GeographyLineStringModel < ActiveRecord::Base
+end
+
+class GeographyPolygonModel < ActiveRecord::Base
+end
+
+class GeographyMultiPointModel < ActiveRecord::Base
+end
+
+class GeographyMultiLineStringModel < ActiveRecord::Base
+end
+
+class GeographyMultiPolygonModel < ActiveRecord::Base
+end
+
+class GeographyGeometryCollectionModel < ActiveRecord::Base
+end
+
+class GeographyModel < ActiveRecord::Base
+end
+
+class GeographyPointzModel < ActiveRecord::Base
+end
+
+class GeographyPointmModel < ActiveRecord::Base
+end
+
+class GeographyPoint4Model < ActiveRecord::Base
+end

data/spec/mysql/connection_adapter_spec.rb

@@ -8,9 +8,9 @@ describe "Modified MysqlAdapter" do
     @connection = ActiveRecord::Base.connection
   end
   
-  describe '#supports_geography?' do
+  describe '#supports_geographic?' do
     it "should be false" do
-      @connection.supports_geography?.should == false
+      @connection.supports_geographic?.should == false
     end
   end
 

data/spec/postgis/connection_adapter_spec.rb

@@ -56,27 +56,39 @@ describe "Modified PostgreSQLAdapter" do
     end
   end
   
-  describe '#supports_geography?' do
+  describe '#supports_geographic?' do
     it "should be true for PostGIS version 1.5.0" do
       @connection.stub!(:postgis_version).and_return('1.5.0')
-      @connection.supports_geography?.should == true
+      @connection.supports_geographic?.should == true
     end
     
     it "should be true for PostGIS newer than 1.5.0" do
       @connection.stub!(:postgis_version).and_return('1.5.1')
-      @connection.supports_geography?.should == true
+      @connection.supports_geographic?.should == true
     end
     
     it "should be true for PostGIS older than 1.5.0" do
       @connection.stub!(:postgis_version).and_return('1.4.0')
-      @connection.supports_geography?.should == false
+      @connection.supports_geographic?.should == false
     end
   end
 
   describe "#columns" do
     describe "type" do
-      it "should be SpatialPostgreSQLColumn if column is a spatial data type" do
-        PointModel.columns.select{|c| c.name == 'geom'}.first.should be_a(ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn)
+      it "should be a regular SpatialPostgreSQLColumn if column is a geometry data type" do
+        column = PointModel.columns.select{|c| c.name == 'geom'}.first
+        column.should be_a(ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn)
+        column.type.should == :geometry
+        column.geometry_type.should == :point
+        column.should_not be_geographic
+      end
+      
+      it "should be a geographic SpatialPostgreSQLColumn if column is a geography data type" do
+        column = GeographyPointModel.columns.select{|c| c.name == 'geom'}.first
+        column.should be_a(ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn)
+        column.type.should == :geometry
+        column.geometry_type.should == :point
+        column.should be_geographic
       end
       
       it "should be PostgreSQLColumn if column is not a spatial data type" do
@@ -85,37 +97,69 @@ describe "Modified PostgreSQLAdapter" do
     end
     
     describe "@geometry_type" do
-      it "should be :point for columns restricted to POINT types" do
+      it "should be :point for geometry columns restricted to POINT types" do
         PointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :point
       end
       
-      it "should be :line_string for columns restricted to LINESTRING types" do
+      it "should be :line_string for geometry columns restricted to LINESTRING types" do
         LineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :line_string
       end
 
-      it "should be :polygon for columns restricted to POLYGON types" do
+      it "should be :polygon for geometry columns restricted to POLYGON types" do
         PolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :polygon
       end
 
-      it "should be :multi_point for columns restricted to MULTIPOINT types" do
+      it "should be :multi_point for geometry columns restricted to MULTIPOINT types" do
         MultiPointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_point
       end
 
-      it "should be :multi_line_string for columns restricted to MULTILINESTRING types" do
+      it "should be :multi_line_string for geometry columns restricted to MULTILINESTRING types" do
         MultiLineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_line_string
       end
       
-      it "should be :multi_polygon for columns restricted to MULTIPOLYGON types" do
+      it "should be :multi_polygon for geometry columns restricted to MULTIPOLYGON types" do
         MultiPolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_polygon
       end
       
-      it "should be :geometry_collection for columns restricted to GEOMETRYCOLLECTION types" do
+      it "should be :geometry_collection for geometry columns restricted to GEOMETRYCOLLECTION types" do
         GeometryCollectionModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry_collection
       end
       
-      it "should be :geometry for columns not restricted to a type" do
+      it "should be :geometry for geometry columns not restricted to a type" do
         GeometryModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry
       end
+      
+      it "should be :point for geography columns restricted to POINT types" do
+        GeographyPointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :point
+      end
+      
+      it "should be :line_string for geography columns restricted to LINESTRING types" do
+        GeographyLineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :line_string
+      end
+
+      it "should be :polygon for geography columns restricted to POLYGON types" do
+        GeographyPolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :polygon
+      end
+
+      it "should be :multi_point for geography columns restricted to MULTIPOINT types" do
+        GeographyMultiPointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_point
+      end
+
+      it "should be :multi_line_string for geography columns restricted to MULTILINESTRING types" do
+        GeographyMultiLineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_line_string
+      end
+      
+      it "should be :multi_polygon for geography columns restricted to MULTIPOLYGON types" do
+        GeographyMultiPolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_polygon
+      end
+      
+      it "should be :geometry_collection for geography columns restricted to GEOMETRYCOLLECTION types" do
+        GeographyGeometryCollectionModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry_collection
+      end
+      
+      it "should be :geometry for geography columns not restricted to a type" do
+        GeographyModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry
+      end
     end
   end
   

data/spec/postgis/migration_spec.rb

@@ -22,17 +22,38 @@ describe "Spatially-enabled Migrations" do
             t.send(type, :geom)
           end
         end
-
+      
         geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
         geom_column.should be_a(SpatialAdapter::SpatialColumn)
-        geom_column.geometry_type.should == type
         geom_column.type.should == :geometry
+        geom_column.geometry_type.should == type
+        geom_column.should_not be_geographic
         geom_column.with_z.should == false
         geom_column.with_m.should == false
         geom_column.srid.should == -1
       end
+      
+      it "should create #{type.to_s} geographic columns" do
+        ActiveRecord::Schema.define do
+          create_table :migrated_geometry_models, :force => true do |t|
+            t.integer :extra
+            t.column :geom, type, :geographic => true
+          end
+        end
+      
+        geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+        
+        geom_column.should be_a(SpatialAdapter::SpatialColumn)
+        geom_column.type.should == :geometry
+        geom_column.geometry_type.should == type
+        geom_column.should be_geographic
+        geom_column.with_z.should == false
+        geom_column.with_m.should == false
+        #geom_column.srid.should == 4326 # SRID is currently irrelevant for geography columns
+      end
     end
     
+  
     it "should create 3d (xyz) geometry columns" do
       ActiveRecord::Schema.define do
         create_table :migrated_geometry_models, :force => true do |t|
@@ -84,19 +105,70 @@ describe "Spatially-enabled Migrations" do
       geom_column.srid.should == -1
     end
     
-
-    it "should create GEOMETRY columns with specified SRID" do
+    it "should create 3d (xyz) geographic columns" do
+      ActiveRecord::Schema.define do
+        create_table :migrated_geometry_models, :force => true do |t|
+          t.integer :extra
+          t.point   :geom, :with_z => true, :geographic => true
+        end
+      end
+      
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.should be_geographic
+      geom_column.with_z.should == true
+      geom_column.with_m.should == false
+    end
+    
+    
+    it "should create 3d (xym) geographic columns" do
+      ActiveRecord::Schema.define do
+        create_table :migrated_geometry_models, :force => true do |t|
+          t.integer :extra
+          t.point   :geom, :with_m => true, :geographic => true
+        end
+      end
+      
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.geometry_type.should == :point
+      geom_column.type.should == :geometry
+      geom_column.should be_geographic
+      geom_column.with_z.should == false
+      geom_column.with_m.should == true
+    end
+    
+    
+    it "should create 4d (xyzm) geographic columns" do
+      ActiveRecord::Schema.define do
+        create_table :migrated_geometry_models, :force => true do |t|
+          t.integer :extra
+          t.point   :geom, :with_z => true, :with_m => true, :geographic => true
+        end
+      end
+      
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.geometry_type.should == :point
+      geom_column.should be_geographic
+      geom_column.type.should == :geometry
+      geom_column.with_z.should == true
+      geom_column.with_m.should == true
+    end
+    
+    
+    it "should create geometry columns with specified SRID" do
       ActiveRecord::Schema.define do
         create_table :migrated_geometry_models, :force => true do |t|
           t.integer :extra
           t.geometry :geom, :srid => 4326
         end
       end
-
+    
       geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
       geom_column.should be_a(SpatialAdapter::SpatialColumn)
-      geom_column.geometry_type.should == :geometry
       geom_column.type.should == :geometry
+      geom_column.geometry_type.should == :geometry
       geom_column.with_z.should == false
       geom_column.with_m.should == false
       geom_column.srid.should == 4326
@@ -115,70 +187,116 @@ describe "Spatially-enabled Migrations" do
     after :each do
       @connection.drop_table "migrated_geometry_models"
     end
-
+  
     SpatialAdapter.geometry_data_types.keys.each do |type|
       it "should add #{type.to_s} columns" do
         ActiveRecord::Schema.define do
           add_column :migrated_geometry_models, :geom, type
         end
-
+  
         geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
         geom_column.should be_a(SpatialAdapter::SpatialColumn)
-        geom_column.geometry_type.should == type
         geom_column.type.should == :geometry
+        geom_column.geometry_type.should == type
         geom_column.with_z.should == false
         geom_column.with_m.should == false
         geom_column.srid.should == -1
       end
     end
-
+  
     it "should add 3d (xyz) geometry columns" do
       ActiveRecord::Schema.define do
         add_column :migrated_geometry_models, :geom, :point, :with_z => true
       end
-
+  
       geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
       geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.type.should == :geometry
+      geom_column.geometry_type.should == :point
       geom_column.with_z.should == true
       geom_column.with_m.should == false
       geom_column.srid.should == -1
     end
-
-
+  
+  
     it "should add 3d (xym) geometry columns" do
       ActiveRecord::Schema.define do
         add_column :migrated_geometry_models, :geom, :point, :with_m => true
       end
-
+  
       geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
       geom_column.should be_a(SpatialAdapter::SpatialColumn)
-      geom_column.geometry_type.should == :point
       geom_column.type.should == :geometry
+      geom_column.geometry_type.should == :point
       geom_column.with_z.should == false
       geom_column.with_m.should == true
       geom_column.srid.should == -1
     end
-
-
+  
+  
     it "should add 4d (xyzm) geometry columns" do
       ActiveRecord::Schema.define do
         add_column :migrated_geometry_models, :geom, :point, :with_z => true, :with_m => true
       end
-
+  
       geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
       geom_column.should be_a(SpatialAdapter::SpatialColumn)
-      geom_column.geometry_type.should == :point
       geom_column.type.should == :geometry
+      geom_column.geometry_type.should == :point
       geom_column.with_z.should == true
       geom_column.with_m.should == true
       geom_column.srid.should == -1
     end
+  
+    it "should add 3d (xyz) geography columns" do
+      ActiveRecord::Schema.define do
+        add_column :migrated_geometry_models, :geom, :point, :with_z => true, :geographic => true
+      end
+  
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.type.should == :geometry
+      geom_column.should be_geographic
+      geom_column.geometry_type.should == :point
+      geom_column.with_z.should == true
+      geom_column.with_m.should == false
+    end
+  
+  
+    it "should add 3d (xym) geography columns" do
+      ActiveRecord::Schema.define do
+        add_column :migrated_geometry_models, :geom, :point, :with_m => true, :geographic => true
+      end
+  
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.type.should == :geometry
+      geom_column.should be_geographic
+      geom_column.geometry_type.should == :point
+      geom_column.with_z.should == false
+      geom_column.with_m.should == true
+    end
+  
+  
+    it "should add 4d (xyzm) geography columns" do
+      ActiveRecord::Schema.define do
+        add_column :migrated_geometry_models, :geom, :point, :with_z => true, :with_m => true, :geographic => true
+      end
+  
+      geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+      geom_column.should be_a(SpatialAdapter::SpatialColumn)
+      geom_column.type.should == :geometry
+      geom_column.should be_geographic
+      geom_column.geometry_type.should == :point
+      geom_column.with_z.should == true
+      geom_column.with_m.should == true
+    end
 
     it "should add GEOMETRY columns with specified SRID" do
       ActiveRecord::Schema.define do
         add_column :migrated_geometry_models, :geom, :geometry, :srid => 4326
       end
-
+  
       geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
       geom_column.should be_a(SpatialAdapter::SpatialColumn)
       geom_column.geometry_type.should == :geometry
@@ -190,13 +308,10 @@ describe "Spatially-enabled Migrations" do
   end
   
   describe "removing columns" do
-    before :each do
-    end
-    
     after :each do
       @connection.drop_table "migrated_geometry_models"
     end
-
+  
     SpatialAdapter.geometry_data_types.keys.each do |type|
       it "should remove #{type.to_s} columns using DropGeometryColumn" do
         ActiveRecord::Schema.define do
@@ -205,7 +320,7 @@ describe "Spatially-enabled Migrations" do
             t.send(type, :geom)
           end
         end
-
+  
         @connection.should_receive(:execute).with(/DropGeometryColumn(.*migrated_geometry_models.*geom)/)
         ActiveRecord::Schema.define do
           remove_column :migrated_geometry_models, :geom
@@ -213,6 +328,23 @@ describe "Spatially-enabled Migrations" do
         @connection.should_receive(:execute).with(anything())
       end
     end
+
+
+  SpatialAdapter.geometry_data_types.keys.each do |type|
+    it "should remove #{type.to_s} geography columns using ALTER TABLE DROP COLUMN" do
+      ActiveRecord::Schema.define do
+        create_table :migrated_geometry_models, :force => true do |t|
+          t.integer :extra
+          t.send(type, :geom, :geographic => true)
+        end
+      end
+
+      @connection.should_receive(:execute).with(/alter table.*migrated_geometry_models.*drop.*geom/i)
+      ActiveRecord::Schema.define do
+        remove_column :migrated_geometry_models, :geom
+      end
+      @connection.should_receive(:execute).with(anything())
+    end
+  end
   end
-  
 end

data/spec/postgis/models_spec.rb

@@ -74,6 +74,72 @@ describe "Spatially-enabled Models" do
       @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.point4.as_hex_ewkb))
       model.save.should == true
     end
+
+    it 'should save Point geography objects' do
+      model = GeographyPointModel.new(:extra => 'test', :geom => GeometryFactory.point)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.point.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save LineString geography objects' do
+      model = GeographyLineStringModel.new(:extra => 'test', :geom => GeometryFactory.line_string)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.line_string.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save Polygon geography objects' do
+      model = GeographyPolygonModel.new(:extra => 'test', :geom => GeometryFactory.polygon)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.polygon.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save MultiPoint geography objects' do
+      model = GeographyMultiPointModel.new(:extra => 'test', :geom => GeometryFactory.multi_point)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.multi_point.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save MultiLineString geography objects' do
+      model = GeographyMultiLineStringModel.new(:extra => 'test', :geom => GeometryFactory.multi_line_string)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.multi_line_string.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save MultiPolygon geography objects' do
+      model = GeographyMultiPolygonModel.new(:extra => 'test', :geom => GeometryFactory.multi_polygon)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.multi_polygon.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save GeometryCollection geography objects' do
+      model = GeographyGeometryCollectionModel.new(:extra => 'test', :geom => GeometryFactory.geometry_collection)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.geometry_collection.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save Geography objects' do
+      model = GeographyModel.new(:extra => 'test', :geom => GeometryFactory.point)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.point.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save 3D Point (with Z coord) geography objects' do
+      model = GeographyPointzModel.new(:extra => 'test', :geom => GeometryFactory.pointz)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.pointz.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save 3D Point (with M coord) geography objects' do
+      model = GeographyPointmModel.new(:extra => 'test', :geom => GeometryFactory.pointm)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.pointm.as_hex_ewkb))
+      model.save.should == true
+    end
+  
+    it 'should save 4D Point geography objects' do
+      model = GeographyPoint4Model.new(:extra => 'test', :geom => GeometryFactory.point4)
+      @connection.should_receive(:select_value).with(Regexp.new(GeometryFactory.point4.as_hex_ewkb))
+      model.save.should == true
+    end
   end
 
   describe "finding records" do
@@ -123,13 +189,68 @@ describe "Spatially-enabled Models" do
     end
   
     it 'should retrieve 3D Point (with M coord) objects' do
-      model = PointmModel.create(:extra => 'test', :geom => GeometryFactory.pointm)
-      PointmModel.find(model.id).geom.should == GeometryFactory.pointm
+      model = GeographyPointmModel.create(:extra => 'test', :geom => GeometryFactory.pointm)
+      GeographyPointmModel.find(model.id).geom.should == GeometryFactory.pointm
     end
   
     it 'should retrieve 4D Point objects' do
-      model = Point4Model.create(:extra => 'test', :geom => GeometryFactory.point4)
-      Point4Model.find(model.id).geom.should == GeometryFactory.point4
+      model = GeographyPoint4Model.create(:extra => 'test', :geom => GeometryFactory.point4)
+      GeographyPoint4Model.find(model.id).geom.should == GeometryFactory.point4
+    end
+
+    it 'should retrieve Point geography objects' do
+      model = GeographyPointModel.create(:extra => 'test', :geom => GeometryFactory.point)
+      GeographyPointModel.find(model.id).geom.should == GeometryFactory.point
+    end
+  
+    it 'should retrieve LineString geography objects' do
+      model = GeographyLineStringModel.create(:extra => 'test', :geom => GeometryFactory.line_string)
+      GeographyLineStringModel.find(model.id).geom.should == GeometryFactory.line_string
+    end
+  
+    it 'should retrieve Polygon geography objects' do
+      model = GeographyPolygonModel.create(:extra => 'test', :geom => GeometryFactory.polygon)
+      GeographyPolygonModel.find(model.id).geom.should == GeometryFactory.polygon
+    end
+  
+    it 'should retrieve MultiPoint geography objects' do
+      model = GeographyMultiPointModel.create(:extra => 'test', :geom => GeometryFactory.multi_point)
+      GeographyMultiPointModel.find(model.id).geom.should == GeometryFactory.multi_point
+    end
+  
+    it 'should retrieve MultiLineString geography objects' do
+      model = GeographyMultiLineStringModel.create(:extra => 'test', :geom => GeometryFactory.multi_line_string)
+      GeographyMultiLineStringModel.find(model.id).geom.should == GeometryFactory.multi_line_string
+    end
+  
+    it 'should retrieve MultiPolygon geography objects' do
+      model = GeographyMultiPolygonModel.create(:extra => 'test', :geom => GeometryFactory.multi_polygon)
+      GeographyMultiPolygonModel.find(model.id).geom.should == GeometryFactory.multi_polygon
+    end
+  
+    it 'should retrieve GeometryCollection geography objects' do
+      model = GeographyGeometryCollectionModel.create(:extra => 'test', :geom => GeometryFactory.geometry_collection)
+      GeographyGeometryCollectionModel.find(model.id).geom.should == GeometryFactory.geometry_collection
+    end
+  
+    it 'should retrieve Geometry geography objects' do
+      model = GeographyModel.create(:extra => 'test', :geom => GeometryFactory.point)
+      GeographyModel.find(model.id).geom.should == GeometryFactory.point
+    end
+  
+    it 'should retrieve 3D Point (with Z coord) geography objects' do
+      model = GeographyPointzModel.create(:extra => 'test', :geom => GeometryFactory.pointz)
+      GeographyPointzModel.find(model.id).geom.should == GeometryFactory.pointz
+    end
+  
+    it 'should retrieve 3D Point (with M coord) geography objects' do
+      model = GeographyPointmModel.create(:extra => 'test', :geom => GeometryFactory.pointm)
+      GeographyPointmModel.find(model.id).geom.should == GeometryFactory.pointm
+    end
+  
+    it 'should retrieve 4D Point geography objects' do
+      model = GeographyPoint4Model.create(:extra => 'test', :geom => GeometryFactory.point4)
+      GeographyPoint4Model.find(model.id).geom.should == GeometryFactory.point4
     end
   end
 end

data/spec/postgis/schema_dumper_spec.rb

@@ -12,14 +12,20 @@ describe "Spatially-enabled Schema Dumps" do
         t.point   :geom, :with_m => true, :with_z => true, :srid => 4326
       end
       add_index :migrated_geometry_models, :geom, :spatial => true, :name => 'test_spatial_index'
+
+      create_table :migrated_geography_models, :force => true do |t|
+        t.integer :extra
+        t.point   :geom, :with_m => true, :with_z => true, :geographic => true
+      end
     end
 
     File.open('schema.rb', "w") do |file|
       ActiveRecord::SchemaDumper.dump(@connection, file)
     end
     
-    # Drop the original table
-    @connection.execute "drop table migrated_geometry_models"
+    # Drop the original tables
+    @connection.drop_table "migrated_geometry_models"
+    @connection.drop_table "migrated_geography_models"
     
     # Load the dumped schema
     load('schema.rb')
@@ -29,11 +35,12 @@ describe "Spatially-enabled Schema Dumps" do
     # delete the schema file
     File.delete('schema.rb')
 
-    # Drop the new table
-    @connection.execute "drop table migrated_geometry_models"
+    # Drop the new tables
+    @connection.drop_table "migrated_geometry_models"
+    @connection.drop_table "migrated_geography_models"
   end
   
-  it "should preserve spatial attributes of tables" do
+  it "should preserve spatial attributes of geometry tables" do
     columns = @connection.columns("migrated_geometry_models")
     
     columns.should have(3).items
@@ -46,6 +53,19 @@ describe "Spatially-enabled Schema Dumps" do
     geom_column.srid.should == 4326
   end
   
+  it "should preserve spatial attributes of geography tables" do
+    columns = @connection.columns("migrated_geography_models")
+    
+    columns.should have(3).items
+    geom_column = columns.select{|c| c.name == 'geom'}.first
+    geom_column.should be_a(SpatialAdapter::SpatialColumn)
+    geom_column.geometry_type.should == :point
+    geom_column.type.should == :geometry
+    geom_column.with_z.should == true
+    geom_column.with_m.should == true
+    geom_column.should be_geographic
+  end
+  
   it "should preserve spatial indexes" do
     indexes = @connection.indexes("migrated_geometry_models")
     

data/spec/spec_helper.rb

@@ -43,11 +43,11 @@ class GeometryFactory
     end
     
     def multi_point
-      MultiPoint.from_coordinates([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]], 4326)
+      MultiPoint.from_coordinates([[12.4,-23.3],[-65.1,23.4],[23.55555555,23]], 4326)
     end
     
     def multi_line_string
-      MultiLineString.from_line_strings([LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012]]),LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012],[45.123,123.3]])], 4326)
+      MultiLineString.from_line_strings([LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012]]),LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012],[45.123,23.3]])], 4326)
     end
     
     def multi_polygon

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spatial_adapter
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Pete Deffendol