nofxx-postgis_adapter 0.1.8 → 0.2.1

data/Manifest.txt

@@ -12,24 +12,20 @@ lib/postgis_functions.rb
 lib/postgis_functions/bbox.rb
 lib/postgis_functions/class.rb
 lib/postgis_functions/common.rb
-lib/postgis_functions/linestring.rb
-lib/postgis_functions/point.rb
-lib/postgis_functions/polygon.rb
 postgis_adapter.gemspec
 rails/init.rb
 script/console
 script/destroy
 script/generate
-spec/acts_as_geom_spec.rb
-spec/common_spatial_adapter_spec.rb
 spec/db/database_postgis.yml
 spec/db/models_postgis.rb
 spec/db/schema_postgis.rb
+spec/postgis_adapter/acts_as_geom_spec.rb
+spec/postgis_adapter/common_spatial_adapter_spec.rb
 spec/postgis_adapter_spec.rb
 spec/postgis_functions/bbox_spec.rb
-spec/postgis_functions/linestring_spec.rb
-spec/postgis_functions/point_spec.rb
-spec/postgis_functions/polygon_spec.rb
+spec/postgis_functions/class_spec.rb
+spec/postgis_functions/common_spec.rb
 spec/postgis_functions_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/README.rdoc

@@ -247,6 +247,13 @@ the geometric column is a point:
   	  geom: <%= Point.from_x_y(123.5,321.9).to_yaml %>
 
 
+=== Annotate
+
+If you are using annotate_models, check out this fork which adds geometrical annotations for PostgisAdapter and SpatialAdapter:
+
+http://github.com/nofxx/annotate_models
+
+
 == Geometric data types
 
 Ruby geometric datatypes are currently made available only through
@@ -256,11 +263,6 @@ of a future release of the Spatial Adapter to support additional
 geometric datatype libraries, such as Ruby/GEOS, as long as they
 can support reading and writing of EWKB.
 
-== Annotate
-
-If you are using annotate_models, check out this fork which adds geometrical annotations for PostgisAdapter and SpatialAdapter:
-
-http://github.com/nofxx/annotate_models
 
 
 === Warning

data/lib/postgis_adapter/acts_as_geom.rb

@@ -14,7 +14,6 @@ module PostgisFunctions
     # acts_as_geom :geom
     def acts_as_geom(*columns)
       cattr_accessor :postgis_geoms
-
       geoms = columns.map do |g|
         geom_type = get_geom_type(g)
         case geom_type
@@ -25,13 +24,15 @@ module PostgisFunctions
         when :line_string
           send :include, LineStringFunctions
         end
-        {g => geom_type}
+        g
       end
-      self.postgis_geoms = {:geoms => geoms}#, :opts => options}
+      self.postgis_geoms = {:columns => geoms}#, :opts => options}
     end
 
     def get_geom_type(column)
       self.columns.select { |c| c.name == column.to_s}.first.geometry_type
+    rescue ActiveRecord::StatementInvalid => e
+      nil
     end
   end
 end

data/lib/postgis_adapter.rb

@@ -10,9 +10,6 @@ require 'postgis_adapter/common_spatial_adapter'
 require 'postgis_functions'
 require 'postgis_functions/common'
 require 'postgis_functions/class'
-require 'postgis_functions/point'
-require 'postgis_functions/linestring'
-require 'postgis_functions/polygon'
 require 'postgis_functions/bbox'
 require 'postgis_adapter/acts_as_geom'
 
@@ -20,13 +17,12 @@ include GeoRuby::SimpleFeatures
 include SpatialAdapter
 
 module PostgisAdapter
-  VERSION = '0.1.8'
+  VERSION = '0.2.1'
 end
 
 #tables to ignore in migration : relative to PostGIS management of geometric columns
 ActiveRecord::SchemaDumper.ignore_tables << "spatial_ref_sys" << "geometry_columns"
 
-
 #add a method to_yaml to the Geometry class which will transform a geometry in a form suitable to be used in a YAML file (such as in a fixture)
 GeoRuby::SimpleFeatures::Geometry.class_eval do
   def to_fixture_format
@@ -34,7 +30,6 @@ GeoRuby::SimpleFeatures::Geometry.class_eval do
   end
 end
 
-
 ActiveRecord::Base.class_eval do
   require 'active_record/version'
 

data/lib/postgis_functions/common.rb

@@ -234,7 +234,7 @@ module PostgisFunctions
   
   def simplify!(tolerance=0.1)
     #FIXME: not good..
-    self.geom = simplify
+    self.update_attribute(get_column_name, simplify)
   end
 
   #
@@ -424,6 +424,357 @@ module PostgisFunctions
     m = "'#{m}'" if m
     postgis_calculate("Relate", [self, other], m)
   end  
+
+  # 
+  # Transform the geometry into a different spatial reference system.
+  #
+  # Return geometry ST_Transform(geometry g1, integer srid);
+  # Returns a new geometry with its coordinates transformed to spatial reference system referenced by the SRID integer parameter. The destination SRID must exist in the SPATIAL_REF_SYS table.
+  # ST_Transform is often confused with ST_SetSRID(). ST_Transform actually changes the coordinates of a geometry from one spatial reference system to another, while ST_SetSRID() simply changes the SRID identifier of the geometry
+  # Requires PostGIS be compiled with Proj support. Use PostGIS_Full_Version to confirm you have proj support compiled in.
+  #	
+  # If using more than one transformation, it is useful to have a functional index on the commonly used transformations to take advantage of index usage.
+  #
+  # Prior to 1.3.4, this function crashes if used with geometries that contain CURVES. This is fixed in 1.3.4+
+  # This method implements the OpenGIS Simple Features Implementation Specification for SQL.
+  # This method supports Circular Strings and Curves
+  #
+  def transform(new_srid)
+    postgis_calculate("Transform", self, new_srid)
+  end
+  
+  #
+  # LINESTRING
+  #
+  #
+  #
+  module LineStringFunctions
+    
+    #
+    # Returns the 2D length of the geometry if it is a linestring, multilinestring,
+    # ST_Curve, ST_MultiCurve. 0 is returned for areal geometries. For areal geometries
+    # use 'perimeter'. Measurements are in the units of the spatial reference system
+    # of the geometry.
+    #
+    # Returns Float
+    #
+    def length
+      dis = postgis_calculate(:length, self).to_f
+    end
+
+    #
+    # Returns the 3-dimensional or 2-dimensional length of the geometry if it is
+    # a linestring or multi-linestring. For 2-d lines it will just return the 2-d
+    # length (same as 'length')
+    #
+    # Returns Float
+    #
+    def length_3d
+      dis = postgis_calculate(:length3d, self).to_f
+    end
+
+    #
+    # Calculates the length of a geometry on an ellipsoid. This is useful if the
+    # coordinates of the geometry are in longitude/latitude and a length is
+    # desired without reprojection. The ellipsoid is a separate database type and
+    # can be constructed as follows:
+    #
+    # SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
+    #
+    # Example:
+    #   SPHEROID["GRS_1980",6378137,298.257222101]
+    #
+    # Defaults to:
+    #
+    #   SPHEROID["IERS_2003",6378136.6,298.25642]
+    #
+    # Returns Float length_spheroid(geometry linestring, spheroid);
+    #
+    def length_spheroid(spheroid = EARTH_SPHEROID)
+      dis = postgis_calculate(:length_spheroid, self, spheroid).to_f
+    end
+
+    #
+    # Return the number of points of the geometry.
+    # PostGis ST_NumPoints does not work as nov/08
+    #
+    # Returns Integer ST_NPoints(geometry g1);
+    #
+    def num_points
+      postgis_calculate(:npoints, self).to_i
+    end
+
+    #
+    # Returns geometry start point.
+    #
+    def start_point
+      postgis_calculate(:startpoint, self)
+    end
+
+    #
+    # Returns geometry end point.
+    #
+    def end_point
+      postgis_calculate(:endpoint, self)
+    end
+
+    #
+    # Takes two geometry objects and returns TRUE if their intersection
+    # "spatially cross", that is, the geometries have some, but not all interior
+    # points in common. The intersection of the interiors of the geometries must
+    # not be the empty set and must have a dimensionality less than the the
+    # maximum dimension of the two input geometries. Additionally, the
+    # intersection of the two geometries must not equal either of the source
+    # geometries. Otherwise, it returns FALSE.
+    #
+    #
+    # Returns Boolean ST_Crosses(geometry g1, geometry g2);
+    #
+    def crosses? other
+      postgis_calculate(:crosses, [self, other])
+    end
+
+    #
+    # Returns a float between 0 and 1 representing the location of the closest point
+    # on LineString to the given Point, as a fraction of total 2d line length.
+    #
+    # You can use the returned location to extract a Point (ST_Line_Interpolate_Point)
+    # or a substring (ST_Line_Substring).
+    #
+    # This is useful for approximating numbers of addresses.
+    #
+    # Returns float (0 to 1) ST_Line_Locate_Point(geometry a_linestring, geometry a_point);
+    #
+    def locate_point point
+      postgis_calculate(:line_locate_point, [self, point]).to_f
+    end
+    
+    #
+    # Return a derived geometry collection value with elements that match the 
+    # specified measure. Polygonal elements are not supported.
+    #
+    # Semantic is specified by: ISO/IEC CD 13249-3:200x(E) - Text for 
+    # Continuation CD Editing Meeting
+    #
+    # Returns geometry ST_Locate_Along_Measure(geometry ageom_with_measure, float a_measure);
+    #
+    def locate_along_measure(measure)
+      postgis_calculate(:locate_along_measure, self, measure)
+    end
+    
+    #
+    # Return a derived geometry collection value with elements that match the 
+    # specified range of measures inclusively. Polygonal elements are not supported.
+    #
+    # Semantic is specified by: ISO/IEC CD 13249-3:200x(E) - Text for Continuation CD Editing Meeting
+    #
+    # Returns geometry ST_Locate_Between_Measures(geometry geomA, float measure_start, float measure_end);
+    #
+    def locate_between_measures(a, b)
+      postgis_calculate(:locate_between_measures, self, [a,b])
+    end
+    
+    #
+    # Returns a point interpolated along a line. First argument must be a LINESTRING.
+    # Second argument is a float8 between 0 and 1 representing fraction of total
+    # linestring length the point has to be located.
+    #
+    # See ST_Line_Locate_Point for computing the line location nearest to a Point.
+    #
+    # Returns geometry ST_Line_Interpolate_Point(geometry a_linestring, float a_fraction);
+    #
+    def interpolate_point(fraction)
+      postgis_calculate(:line_interpolate_point, self, fraction)
+    end
+
+    #
+    # Return a linestring being a substring of the input one starting and ending
+    # at the given fractions of total 2d length. Second and third arguments are
+    # float8 values between 0 and 1. This only works with LINESTRINGs. To use
+    # with contiguous MULTILINESTRINGs use in conjunction with ST_LineMerge.
+    #
+    # If 'start' and 'end' have the same value this is equivalent to 'interpolate_point'.
+    #
+    # See 'locate_point' for computing the line location nearest to a Point.
+    #
+    # Returns geometry ST_Line_Substring(geometry a_linestring, float startfraction, float endfraction);
+    #
+    def line_substring(s,e)
+      postgis_calculate(:line_substring, self, [s, e])
+    end
+
+    ###  
+    #Not implemented in postgis yet
+    # ST_max_distance Returns the largest distance between two line strings.
+    #def max_distance other
+    # #float ST_Max_Distance(geometry g1, geometry g2);
+    #  postgis_calculate(:max_distance, [self, other])
+    #end
+  end
+
+
+  ####
+  ###
+  ##
+  #
+  # POINT
+  #
+  #
+  module PointFunctions
+
+    #
+    # Returns a float between 0 and 1 representing the location of the closest point
+    # on LineString to the given Point, as a fraction of total 2d line length.
+    #
+    # You can use the returned location to extract a Point (ST_Line_Interpolate_Point)
+    # or a substring (ST_Line_Substring).
+    #
+    # This is useful for approximating numbers of addresses.
+    #
+    # Returns float (0 to 1) ST_Line_Locate_Point(geometry a_linestring, geometry a_point);
+    #
+    def where_on_line line
+      postgis_calculate(:line_locate_point, [line, self]).to_f
+    end
+
+    #
+    # Linear distance in meters between two lon/lat points.
+    # Uses a spherical earth and radius of 6370986 meters.
+    # Faster than 'distance_spheroid', but less accurate.
+    #
+    # Only implemented for points.
+    #
+    # Returns Float ST_Distance_Sphere(geometry pointlonlatA, geometry pointlonlatB);
+    #
+    def distance_sphere_to(other)
+      dis = postgis_calculate(:distance_sphere, [self, other]).to_f
+    end
+
+    #
+    # Calculates the distance on an ellipsoid. This is useful if the
+    # coordinates of the geometry are in longitude/latitude and a length is
+    # desired without reprojection. The ellipsoid is a separate database type and
+    # can be constructed as follows:
+    #
+    # This is slower then 'distance_sphere_to', but more precise.
+    #
+    # SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
+    #
+    # Example:
+    #   SPHEROID["GRS_1980",6378137,298.257222101]
+    #
+    # Defaults to:
+    #
+    #   SPHEROID["IERS_2003",6378136.6,298.25642]
+    #
+    # Returns ST_Distance_Spheroid(geometry geomA, geometry geomB, spheroid);
+    #
+    def distance_spheroid_to(other, spheroid = EARTH_SPHEROID)
+      postgis_calculate(:distance_spheroid, [self, other], spheroid).to_f
+    end
+
+    #
+    # The azimuth of the segment defined by the given Point geometries,
+    # or NULL if the two points are coincident. Return value is in radians.
+    #
+    # The Azimuth is mathematical concept defined as the angle, in this case
+    # measured in radian, between a reference plane and a point.
+    #
+    # Returns Float ST_Azimuth(geometry pointA, geometry pointB);
+    #
+    def azimuth other
+      #TODO: return if not point/point
+      postgis_calculate(:azimuth, [self, other]).to_f
+      rescue
+        ActiveRecord::StatementInvalid
+    end
+
+    #
+    # True if the geometry is a point and is inside the circle.
+    #
+    # Returns Boolean ST_point_inside_circle(geometry, float, float, float)
+    #
+    def inside_circle?(x,y,r)
+      postgis_calculate(:point_inside_circle, self, [x,y,r])
+    end
+
+  end
+  
+  ###
+  ##
+  #
+  # Polygon
+  #
+  #
+  module PolygonFunctions
+
+    #
+    # The area of the geometry if it is a polygon or multi-polygon.
+    # Return the area measurement of an ST_Surface or ST_MultiSurface value.
+    # Area is in the units of the spatial reference system.
+    #
+    # Returns Float ST_Area(geometry g1);
+    #
+    def area
+      postgis_calculate(:area, self).to_f
+    end
+
+    #
+    # Returns the 2D perimeter of the geometry if it is a ST_Surface, ST_MultiSurface
+    # (Polygon, Multipolygon). 0 is returned for non-areal geometries. For linestrings
+    # use 'length'. Measurements are in the units of the spatial reference system of
+    # the geometry.
+    #
+    # Returns Float ST_Perimeter(geometry g1);
+    #
+    def perimeter
+      postgis_calculate(:perimeter, self).to_f
+    end
+
+    #
+    # Returns the 3-dimensional perimeter of the geometry, if it is a polygon or multi-polygon.
+    # If the geometry is 2-dimensional, then the 2-dimensional perimeter is returned.
+    #
+    # Returns Float ST_Perimeter3D(geometry geomA);
+    #
+    def perimeter3d
+      postgis_calculate(:perimeter3d, self).to_f
+    end
+
+    #
+    # True if the LineString's start and end points are coincident.
+    #
+    # This method implements the OpenGIS Simple Features Implementation
+    # Specification for SQL.
+    #
+    # SQL-MM defines the result of ST_IsClosed(NULL) to be 0, while PostGIS returns NULL.
+    #
+    # Returns boolean ST_IsClosed(geometry g);
+    #
+    def closed?
+      postgis_calculate(:isclosed, self)
+    end
+    alias_method "is_closed?", "closed?"
+
+    #
+    # True if no point in Geometry B is outside Geometry A
+    #
+    # This function call will automatically include a bounding box comparison
+    # that will make use of any indexes that are available on the geometries.
+    # To avoid index use, use the function _ST_Covers.
+    #
+    # Do not call with a GEOMETRYCOLLECTION as an argument
+    # Do not use this function with invalid geometries. You will get unexpected results.
+    #
+    # Performed by the GEOS module.
+    #
+    # Returns Boolean ST_Covers(geometry geomA, geometry geomB);
+    #
+    def covers? other
+      postgis_calculate(:covers, [self, other])
+    end
+
+  end
   
 end
 
@@ -435,4 +786,4 @@ end
 
 
 #x ST_SnapToGrid(geometry, geometry, sizeX, sizeY, sizeZ, sizeM)
-# ST_X , ST_Y, SE_M, SE_Z, SE_IsMeasured has_m?
+# ST_X , ST_Y, SE_M, SE_Z, SE_IsMeasured has_m?

data/lib/postgis_functions.rb

@@ -18,9 +18,8 @@
 #
 #
 module PostgisFunctions
-  # EARTH_SPHEROID = "'SPHEROID[\"GRS-80\",6378137,298.257222101]'"
-
-  EARTH_SPHEROID = "'SPHEROID[\"IERS_2003\",6378136.6,298.25642]'"
+  EARTH_SPHEROID = "'SPHEROID[\"GRS-80\",6378137,298.257222101]'" # SRID => 4326
+  #EARTH_SPHEROID = "'SPHEROID[\"IERS_2003\",6378136.6,298.25642]'" # SRID => 
 
   def postgis_calculate(operation, subjects, options = nil)
     subjects = [subjects] unless subjects.respond_to?(:map)
@@ -29,12 +28,13 @@ module PostgisFunctions
     raise StandardError, "#{e}"
   end
 
-
   private
 
-
+  def get_column_name
+    @geo_column ||= postgis_geoms[:columns].first
+  end
+ 
   # Construct the postgis sql query
-  # TODO: ST_Transform() ?? # Convert between distances. Implement this?
   #
   # Area return in square feet
   # Distance/DWithin/Length/Perimeter —  in projected units.
@@ -49,7 +49,7 @@ module PostgisFunctions
       :id => t[:id] }
     end
 
-    fields      = tables.map { |f| "#{f[:uid]}.geom" }            # W1.geom
+    fields      = tables.map { |f| "#{f[:uid]}.#{get_column_name}" }            # W1.geom
     conditions  = tables.map { |f| "#{f[:uid]}.id = #{f[:id]}" }  # W1.id = 5
     tables.map! { |f| "#{f[:class]} #{f[:uid]}" }    # streets W1
     
@@ -57,17 +57,16 @@ module PostgisFunctions
     # Data =>  SELECT Func(A,B)
     # BBox =>  SELECT (A <=> B)
     # 
-    if type == :bbox
-      opcode = nil
-      s_join = " #{options} "
-    else
+    unless type == :bbox
       opcode = type.to_s
       opcode = "ST_#{opcode}" unless opcode =~ /th3d|pesinter/
-      s_join = ","
       fields << options if options
+      fields = fields.join(",")
+    else
+      fields = fields.join(" #{options} ")
     end
 
-    sql =   "SELECT #{opcode}(#{fields.join(s_join)}) "
+    sql =   "SELECT #{opcode}(#{fields}) "
     sql <<  "FROM #{tables.join(",")} "           if tables
     sql <<  "WHERE #{conditions.join(" AND ")}"   if conditions
     #p sql; sql
@@ -94,7 +93,7 @@ module PostgisFunctions
 
   # Get a unique ID for tables
   def unique_identifier
-    @u_id ||= "W1"
+    @u_id ||= "T1"
     @u_id = @u_id.succ
   end
 

data/postgis_adapter.gemspec

@@ -1,21 +1,23 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
-  s.name = "postgis_adapter"
-  s.version = "0.1.8"
+  s.name = %q{postgis_adapter}
+  s.version = "0.2.1"
+
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Marcos Piccinini"]
-  s.date = "2008-12-16"
-  s.description = "Postgis Adapter for Activer Record"
+  s.date = %q{2009-01-10}
+  s.description = %q{Postgis Adapter for Activer Record}
   s.email = ["x@nofxx.com"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "init.rb", "install.rb", "lib/postgis_adapter.rb", "lib/postgis_adapter/acts_as_geom.rb", "lib/postgis_adapter/common_spatial_adapter.rb", "lib/postgis_functions.rb", "lib/postgis_functions/bbox.rb", "lib/postgis_functions/class.rb", "lib/postgis_functions/common.rb", "lib/postgis_functions/linestring.rb", "lib/postgis_functions/point.rb", "lib/postgis_functions/polygon.rb", "postgis_adapter.gemspec", "rails/init.rb", "script/console", "script/destroy", "script/generate", "uninstall.rb"]
-  s.test_files = ["spec/acts_as_geom_spec.rb", "spec/common_spatial_adapter_spec.rb", "spec/db/database_postgis.yml", "spec/db/models_postgis.rb", "spec/db/schema_postgis.rb", "spec/postgis_adapter_spec.rb", "spec/postgis_functions/bbox_spec.rb", "spec/postgis_functions/linestring_spec.rb", "spec/postgis_functions/point_spec.rb", "spec/postgis_functions/polygon_spec.rb", "spec/postgis_functions_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "init.rb", "install.rb", "lib/postgis_adapter.rb", "lib/postgis_adapter/acts_as_geom.rb", "lib/postgis_adapter/common_spatial_adapter.rb", "lib/postgis_functions.rb", "lib/postgis_functions/bbox.rb", "lib/postgis_functions/class.rb", "lib/postgis_functions/common.rb", "postgis_adapter.gemspec", "rails/init.rb", "script/console", "script/destroy", "script/generate", "spec/db/database_postgis.yml", "spec/db/models_postgis.rb", "spec/db/schema_postgis.rb", "spec/postgis_adapter/acts_as_geom_spec.rb", "spec/postgis_adapter/common_spatial_adapter_spec.rb", "spec/postgis_adapter_spec.rb", "spec/postgis_functions/bbox_spec.rb", "spec/postgis_functions/class_spec.rb", "spec/postgis_functions/common_spec.rb", "spec/postgis_functions_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "uninstall.rb"]
   s.has_rdoc = true
-  s.homepage = "http://github.com/nofxx/postgis_adapter"
+  s.homepage = %q{http://github.com/nofxx/postgis_adapter}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{postgis_adapter}
   s.rubygems_version = %q{1.3.1}
-  s.summary = "Postgis Adapter for Activer Record"
+  s.summary = %q{Postgis Adapter for Activer Record}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
@@ -23,16 +25,16 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activerecord>, [">= 2.0.2"])
-      s.add_development_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
       s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
     else
       s.add_dependency(%q<activerecord>, [">= 2.0.2"])
-      s.add_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_dependency(%q<newgem>, [">= 1.2.3"])
       s.add_dependency(%q<hoe>, [">= 1.8.0"])
     end
   else
     s.add_dependency(%q<activerecord>, [">= 2.0.2"])
-    s.add_dependency(%q<newgem>, [">= 1.1.0"])
+    s.add_dependency(%q<newgem>, [">= 1.2.3"])
     s.add_dependency(%q<hoe>, [">= 1.8.0"])
   end
 end

data/spec/db/database_postgis.yml

@@ -1,4 +1,4 @@
 adapter: postgresql
-database: postgis_plugin_test
+database: postgis_plugin
 username: postgres
 password:

data/spec/db/models_postgis.rb

@@ -53,4 +53,5 @@ class Street < ActiveRecord::Base
 end
 
 class CommonGeo < ActiveRecord::Base
+  acts_as_geom :geom
 end

data/spec/db/schema_postgis.rb

@@ -54,33 +54,30 @@ ActiveRecord::Schema.define() do
     t.point "geom", :null => false, :with_m => true, :with_z => true
   end
 
-   create_table "table_srid_line_strings", :force => true do |t|
-    t.line_string "geom", :null => false , :srid => 123
+  create_table "table_srid_line_strings", :force => true do |t|
+    t.line_string "geom", :null => false , :srid => 4326
   end
 
   create_table "table_srid4d_polygons", :force => true do |t|
-    t.polygon "geom", :with_m => true, :with_z => true, :srid => 123
+    t.polygon "geom", :with_m => true, :with_z => true, :srid => 4326
   end
 
-        create_table :cities do |t|
-          t.string :data, :limit => 100
-          t.integer :value
-          t.polygon  :geom,:null=>false,:srid=>123
-        end
-
-        create_table :positions do |t|
-          t.string :data, :limit => 100
-          t.integer :value
-          t.point  :geom,:null=>false,:srid=>123
-        end
-
-        create_table :streets do |t|
-          t.string :data, :limit => 100
-          t.integer :value
-          t.line_string  :geom,:null=>false,:srid=>123
-        end
-
+  create_table :cities do |t|
+    t.string :data, :limit => 100
+    t.integer :value
+    t.polygon  :geom,:null=>false,:srid=>4326
+  end
 
+  create_table :positions do |t|
+    t.string :data, :limit => 100
+    t.integer :value
+    t.point  :geom,:null=>false,:srid=>4326
+  end
 
+  create_table :streets do |t|
+    t.string :data, :limit => 100
+    t.integer :value
+    t.line_string  :geom,:null=>false,:srid=>4326
+  end
 
 end