spatial_adapter 0.2.0

data/lib/spatial_adapter/raw_geom_info.rb

@@ -0,0 +1,23 @@
+module SpatialAdapter
+  class RawGeomInfo < Struct.new(:type,:srid,:dimension,:with_z,:with_m) #:nodoc:
+    def convert!
+      self.type = "geometry" if self.type.nil? #if geometry the geometrytype constraint is not present : need to set the type here then
+    
+      if dimension == 4
+        self.with_m = true
+        self.with_z = true
+      elsif dimension == 3
+        if with_m
+          self.with_z = false
+          self.with_m = true 
+        else
+          self.with_z = true
+          self.with_m = false
+        end
+      else
+        self.with_z = false
+        self.with_m = false
+      end
+    end
+  end
+end

data/lib/spatial_adapter/schema_definitions.rb

@@ -0,0 +1,11 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+ActiveRecord::ConnectionAdapters::IndexDefinition.class_eval do
+  attr_accessor :spatial
+
+  alias_method :initialize_without_spatial, :initialize
+  def initialize(table, name, unique, columns, spatial = false)
+    initialize_without_spatial(table, name, unique, columns)
+    @spatial = spatial
+  end
+end

data/lib/spatial_adapter/schema_dumper.rb

@@ -0,0 +1,135 @@
+ActiveRecord::SchemaDumper.ignore_tables << "spatial_ref_sys" << "geometry_columns"
+
+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]
+  
+  def table(table, stream)
+    columns = @connection.columns(table)
+    begin
+      tbl = StringIO.new
+
+      # first dump primary key column
+      if @connection.respond_to?(:pk_and_sequence_for)
+        pk, pk_seq = @connection.pk_and_sequence_for(table)
+      elsif @connection.respond_to?(:primary_key)
+        pk = @connection.primary_key(table)
+      end
+      
+      tbl.print "  create_table #{table.inspect}"
+      if columns.detect { |c| c.name == pk }
+        if pk != 'id'
+          tbl.print %Q(, :primary_key => "#{pk}")
+        end
+      else
+        tbl.print ", :id => false"
+      end
+      
+      # Added by Spatial Adapter to ensure correct MySQL table engine
+      if @connection.respond_to?(:options_for)
+        res = @connection.options_for(table)
+        tbl.print ", :options=>'#{res}'" if res
+      end
+      
+      tbl.print ", :force => true"
+      tbl.puts " do |t|"
+
+      # then dump all non-primary key columns
+      column_specs = columns.map do |column|
+        raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+        next if column.name == pk
+        spec = column_spec(column)
+        (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+        spec
+      end.compact
+
+      # find all migration keys used in this table
+      keys = VALID_COLUMN_SPEC_KEYS & column_specs.map(&:keys).flatten
+
+      # figure out the lengths for each column based on above keys
+      lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+      # the string we're going to sprintf our values against, with standardized column widths
+      format_string = lengths.map{ |len| "%-#{len}s" }
+
+      # find the max length for the 'type' column, which is special
+      type_length = column_specs.map{ |column| column[:type].length }.max
+
+      # add column type definition to our format string
+      format_string.unshift "    t.%-#{type_length}s "
+
+      format_string *= ''
+
+      column_specs.each do |colspec|
+        values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+        values.unshift colspec[:type]
+        tbl.print((format_string % values).gsub(/,\s*$/, ''))
+        tbl.puts
+      end
+
+      tbl.puts "  end"
+      tbl.puts
+      
+      indexes(table, tbl)
+
+      tbl.rewind
+      stream.print tbl.read
+    rescue => e
+      stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+      stream.puts "#   #{e.message}"
+      stream.puts
+    end
+    
+    stream
+  end
+  
+
+  def indexes(table, stream)
+    if (indexes = @connection.indexes(table)).any?
+      add_index_statements = indexes.map do |index|
+        statment_parts = [ ('add_index ' + index.table.inspect) ]
+        statment_parts << index.columns.inspect
+        statment_parts << (':name => ' + index.name.inspect)
+        statment_parts << ':unique => true' if index.unique
+        # Add spatial option (this is the only change from the original method)
+        statment_parts << ':spatial => true' if index.spatial
+
+        '  ' + statment_parts.join(', ')
+      end
+
+      stream.puts add_index_statements.sort.join("\n")
+      stream.puts
+    end
+  end
+  
+  private
+  
+  # Build specification for a table column
+  def column_spec(column)
+    spec = {}
+    spec[:name]      = column.name.inspect
+    
+    # AR has an optimisation which handles zero-scale decimals as integers.  This
+    # code ensures that the dumper still dumps the column as a decimal.
+    spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+                         'decimal'
+                       else
+                         column.type.to_s
+                       end
+    spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
+    spec[:precision] = column.precision.inspect if !column.precision.nil?
+    spec[:scale]     = column.scale.inspect if !column.scale.nil?
+    spec[:null]      = 'false' if !column.null
+    spec[:default]   = default_string(column.default) if column.has_default?
+    
+    # Additions for spatial columns
+    if column.is_a?(SpatialColumn)
+      # Override with specific geometry type
+      spec[:type]    = column.geometry_type.to_s
+      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
+    end
+    spec
+  end
+end

data/lib/spatial_adapter/spatial_column.rb

@@ -0,0 +1,68 @@
+module SpatialAdapter
+  module SpatialColumn
+    attr_reader  :spatial, :geometry_type, :srid, :with_z, :with_m
+
+    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
+      @with_z = with_z
+      @with_m = with_m
+    end
+  
+    # Redefines type_cast to add support for geometries
+    # alias_method :type_cast_without_spatial, :type_cast
+    def type_cast(value)
+      return nil if value.nil?
+      case type
+      when :geometry then self.class.string_to_geometry(value)
+      else super
+      end
+    end
+
+    #Redefines type_cast_code to add support for geometries. 
+    #
+    #WARNING : Since ActiveRecord keeps only the string values directly returned from the database, it translates from these to the correct types everytime an attribute is read (using the code returned by this method), which is probably ok for simple types, but might be less than efficient for geometries. Also you cannot modify the geometry object returned directly or your change will not be saved. 
+    # alias_method :type_cast_code_without_spatial, :type_cast_code
+    def type_cast_code(var_name)
+      case type
+      when :geometry then "#{self.class.name}.string_to_geometry(#{var_name})"
+      else super
+      end
+    end
+
+
+    #Redefines klass to add support for geometries
+    # alias_method :klass_without_spatial, :klass
+    def klass
+      case type
+      when :geometry then GeoRuby::SimpleFeatures::Geometry
+      else super
+      end
+    end
+
+    private
+
+    #Redefines the simplified_type method to add behabiour for when a column is of type geometry
+    def simplified_type(field_type)
+      case field_type
+      when /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
+      when /^point$/i then :point
+      when /^linestring$/i then :line_string
+      when /^polygon$/i then :polygon
+      when /^geometry$/i then :geometry
+      when /multipoint/i then :multi_point
+      when /multilinestring/i then :multi_line_string
+      when /multipolygon/i then :multi_polygon
+      when /geometrycollection/i then :geometry_collection
+      end
+    end
+  end
+end

data/lib/spatial_adapter/table_definition.rb

@@ -0,0 +1,14 @@
+include SpatialAdapter
+
+ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
+  SpatialAdapter.geometry_data_types.keys.each do |column_type|
+    class_eval <<-EOV
+      def #{column_type}(*args)
+        options = args.extract_options!
+        column_names = args
+      
+        column_names.each { |name| column(name, '#{column_type}', options) }
+      end
+    EOV
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'spatial_adapter'

data/spec/README.txt

@@ -0,0 +1,16 @@
+= Running Tests
+
+You will need to set up empty databases for each adapter you want to test.
+
+== PostgreSQL
+
+Create an empty database "spatial_adapter" and ensure that the PostGIS extensions are loaded.  
+
+run "rake spec:postgis" to run the specs
+
+== MySQL
+
+Create an empty database "spatial_adapter" - the spatial extensions are already available.
+
+run "rake spec:mysql" to run the specs
+

data/spec/db/mysql_raw.rb

@@ -0,0 +1,69 @@
+mysql_connection
+
+ActiveRecord::Schema.define() do
+  execute "drop table if exists point_models"
+  execute "create table point_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom  point not null
+    ) ENGINE=MyISAM"
+  execute "create spatial index index_point_models_on_geom on point_models (geom)"
+  execute "create index index_point_models_on_extra on point_models (extra)"
+    
+  execute "drop table if exists line_string_models"
+  execute "create table line_string_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom linestring
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists polygon_models"
+  execute "create table polygon_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom polygon
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists multi_point_models"
+  execute "create table multi_point_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom multipoint
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists multi_line_string_models"
+  execute "create table multi_line_string_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom multilinestring
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists multi_polygon_models"
+  execute "create table multi_polygon_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom multipolygon
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists geometry_collection_models"
+  execute "create table geometry_collection_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom geometrycollection
+    ) ENGINE=MyISAM"
+    
+  execute "drop table if exists geometry_models"
+  execute "create table geometry_models
+    (
+    	id int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+    	extra varchar(255),
+    	geom geometry
+    ) ENGINE=MyISAM"
+end

data/spec/db/postgis_raw.rb

@@ -0,0 +1,95 @@
+postgis_connection
+
+ActiveRecord::Schema.define() do
+  execute <<-SQL
+    drop table if exists point_models;
+    create table point_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('point_models', 'geom', 4326, 'POINT', 2);
+    create index index_point_models_on_geom on point_models using gist (geom);
+    create index index_point_models_on_extra on point_models (extra);
+    
+    drop table if exists line_string_models;
+    create table line_string_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('line_string_models', 'geom', 4326, 'LINESTRING', 2);
+
+    drop table if exists polygon_models;
+    create table polygon_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('polygon_models', 'geom', 4326, 'POLYGON', 2);
+
+    drop table if exists multi_point_models;
+    create table multi_point_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_point_models', 'geom', 4326, 'MULTIPOINT', 2);
+
+    drop table if exists multi_line_string_models;
+    create table multi_line_string_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_line_string_models', 'geom', 4326, 'MULTILINESTRING', 2);
+
+    drop table if exists multi_polygon_models;
+    create table multi_polygon_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_polygon_models', 'geom', 4326, 'MULTIPOLYGON', 2);
+
+    drop table if exists geometry_collection_models;
+    create table geometry_collection_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('geometry_collection_models', 'geom', 4326, 'GEOMETRYCOLLECTION', 2);
+
+    drop table if exists geometry_models;
+    create table geometry_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('geometry_models', 'geom', 4326, 'GEOMETRY', 2);
+    
+    drop table if exists pointz_models;
+    create table pointz_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('pointz_models', 'geom', 4326, 'POINT', 3);
+    
+    drop table if exists pointm_models;
+    create table pointm_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('pointm_models', 'geom', 4326, 'POINTM', 3);
+
+    drop table if exists point4_models;
+    create table point4_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('point4_models', 'geom', 4326, 'POINT', 4);
+  SQL
+end

data/spec/models/common.rb

@@ -0,0 +1,32 @@
+class PointModel < ActiveRecord::Base
+end
+
+class LineStringModel < ActiveRecord::Base
+end
+
+class PolygonModel < ActiveRecord::Base
+end
+
+class MultiPointModel < ActiveRecord::Base
+end
+
+class MultiLineStringModel < ActiveRecord::Base
+end
+
+class MultiPolygonModel < ActiveRecord::Base
+end
+
+class GeometryCollectionModel < ActiveRecord::Base
+end
+
+class GeometryModel < ActiveRecord::Base
+end
+
+class PointzModel < ActiveRecord::Base
+end
+
+class PointmModel < ActiveRecord::Base
+end
+
+class Point4Model < ActiveRecord::Base
+end