GeoRuby 1.3.1 → 1.3.2

data/lib/geo_ruby/shp4r/shp.rb

@@ -444,7 +444,7 @@ module GeoRuby
                   else 
                     data.to_s
                   end
-            @dbf_io << [str].pack("a#{field.length}")
+            @dbf_io << [str].pack("A#{field.length}")
           end
           
           shp_str,min_xp,max_xp,min_yp,max_yp,min_zp,max_zp,min_mp,max_mp = build_shp_geometry(record.geometry)

data/lib/geo_ruby/simple_features/io/ewkb_parser.rb

@@ -0,0 +1,213 @@
+require 'geo_ruby/simple_features/point'
+require 'geo_ruby/simple_features/line_string'
+require 'geo_ruby/simple_features/linear_ring'
+require 'geo_ruby/simple_features/polygon'
+require 'geo_ruby/simple_features/multi_point'
+require 'geo_ruby/simple_features/multi_line_string'
+require 'geo_ruby/simple_features/multi_polygon'
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+  module SimpleFeatures
+    module Io
+      #Raised when an error in the EWKB string is detected
+      class EWKBFormatError < StandardError
+      end
+      
+      #Parses EWKB strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
+      #
+      #=Example
+      # factory = GeometryFactory::new
+      # ewkb_parser = EWKBParser::new(factory)
+      # ewkb_parser.parse(<EWKB String>)
+      # geometry = @factory.geometry
+      #
+      #You can also use directly the static method Geometry.from_ewkb
+      class EWKBParser
+        
+        def initialize(factory)
+          @factory = factory
+          @parse_options ={
+            1 => method(:parse_point),
+            2 => method(:parse_line_string),
+            3 => method(:parse_polygon),
+            4 => method(:parse_multi_point),
+            5 => method(:parse_multi_line_string),
+            6 => method(:parse_multi_polygon),
+            7 => method(:parse_geometry_collection)
+          }
+        end
+        
+        #Parses the ewkb string passed as argument and notifies the factory of events
+        def parse(ewkb)
+          @factory.reset
+          @unpack_structure=UnpackStructure::new(ewkb)
+          @with_z = false
+          @with_m = false
+          parse_geometry
+          @unpack_structure.done
+          @srid=nil
+        end
+        
+        private
+        def parse_geometry
+          @unpack_structure.endianness=@unpack_structure.read_byte
+          @geometry_type = @unpack_structure.read_uint
+          
+          if (@geometry_type & Z_MASK) != 0
+            @with_z=true
+            @geometry_type = @geometry_type & ~Z_MASK
+          end
+          if (@geometry_type & M_MASK) != 0
+            @with_m=true
+            @geometry_type = @geometry_type & ~M_MASK
+          end
+          if (@geometry_type & SRID_MASK) != 0
+            @srid = @unpack_structure.read_uint
+            @geometry_type = @geometry_type & ~SRID_MASK
+          else
+            #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
+            @srid= @srid || DEFAULT_SRID
+          end
+          
+          if @parse_options.has_key? @geometry_type
+            @parse_options[@geometry_type].call
+          else
+            raise EWKBFormatError::new("Unknown geometry type")
+          end
+        end
+        
+        def parse_geometry_collection
+          parse_multi_geometries(GeometryCollection)
+        end
+        
+        def parse_multi_polygon
+          parse_multi_geometries(MultiPolygon)
+        end
+        
+        def parse_multi_line_string
+          parse_multi_geometries(MultiLineString)
+        end
+        
+        def parse_multi_point
+          parse_multi_geometries(MultiPoint)
+        end
+        
+        def parse_multi_geometries(geometry_type)
+          @factory.begin_geometry(geometry_type,@srid)
+          num_geometries = @unpack_structure.read_uint
+          1.upto(num_geometries) { parse_geometry }
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_polygon
+          @factory.begin_geometry(Polygon,@srid)
+          num_linear_rings = @unpack_structure.read_uint
+          1.upto(num_linear_rings) {parse_linear_ring}
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_linear_ring
+          parse_point_list(LinearRing)
+        end
+        
+        def parse_line_string
+          parse_point_list(LineString)
+        end
+        
+        #used to parse line_strings and linear_rings
+        def parse_point_list(geometry_type)
+          @factory.begin_geometry(geometry_type,@srid)
+          num_points = @unpack_structure.read_uint
+          1.upto(num_points) {parse_point}
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_point
+          @factory.begin_geometry(Point,@srid)
+          x = @unpack_structure.read_double
+          y = @unpack_structure.read_double
+          if ! (@with_z or @with_m) #most common case probably
+            @factory.add_point_x_y(x,y)
+          elsif @with_m and @with_z
+            z = @unpack_structure.read_double
+            m = @unpack_structure.read_double
+            @factory.add_point_x_y_z_m(x,y,z,m)
+          elsif @with_z
+            z = @unpack_structure.read_double
+            @factory.add_point_x_y_z(x,y,z)
+          else
+            m = @unpack_structure.read_double
+            @factory.add_point_x_y_m(x,y,m)
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+      end
+      
+      #Parses HexEWKB strings. In reality, it just transforms the HexEWKB string into the equivalent EWKB string and lets the EWKBParser do the actual parsing.
+      class HexEWKBParser < EWKBParser
+        def initialize(factory)
+          super(factory)
+        end
+        #parses an HexEWKB string
+        def parse(hexewkb)
+          super(decode_hex(hexewkb))
+        end
+        #transforms a HexEWKB string into an EWKB string 
+        def decode_hex(hexewkb)
+          temp_hexewkb= hexewkb.clone
+          result=""
+          while c = temp_hexewkb.slice!(0,2) do
+            break if c.length==0
+            result << c.hex
+          end
+          result
+        end
+        
+      end
+      
+      class UnpackStructure #:nodoc:
+        NDR=1
+        XDR=0
+        def initialize(ewkb)
+          @position=0
+          @ewkb=ewkb
+        end
+        def done
+          raise EWKBFormatError::new("Trailing data") if @position != @ewkb.length
+        end
+        def read_double
+          i=@position
+          @position += 8
+          packed_double = @ewkb[i...@position]
+          raise EWKBFormatError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
+          packed_double.unpack(@double_mark)[0]
+        end
+        def read_uint
+          i=@position
+          @position += 4
+          packed_uint = @ewkb[i...@position]
+          raise EWKBFormatError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
+          packed_uint.unpack(@uint_mark)[0]
+        end
+        def read_byte
+          i = @position
+          @position += 1
+          packed_byte = @ewkb[i...@position]
+          raise EWKBFormatError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
+          packed_byte.unpack("C")[0]
+        end
+        def endianness=(byte_order)
+          if(byte_order == NDR)
+            @uint_mark="V"
+            @double_mark="E"
+          elsif(byte_order == XDR)
+            @uint_mark="N"
+            @double_mark="G"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/io/ewkt_parser.rb

@@ -0,0 +1,335 @@
+require 'geo_ruby/simple_features/point'
+require 'geo_ruby/simple_features/line_string'
+require 'geo_ruby/simple_features/linear_ring'
+require 'geo_ruby/simple_features/polygon'
+require 'geo_ruby/simple_features/multi_point'
+require 'geo_ruby/simple_features/multi_line_string'
+require 'geo_ruby/simple_features/multi_polygon'
+require 'geo_ruby/simple_features/geometry_collection'
+
+require 'strscan'
+
+module GeoRuby
+  module SimpleFeatures
+    module Io
+      #Raised when an error in the EWKT string is detected
+      class EWKTFormatError < StandardError
+      end
+      
+      #Parses EWKT strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
+      #
+      #=Example
+      # factory = GeometryFactory::new
+      # ewkt_parser = EWKTParser::new(factory)
+      # ewkt_parser.parse(<EWKT String>)
+      # geometry = @factory.geometry
+      #
+      #You can also use directly the static method Geometry.from_ewkt
+      class EWKTParser
+        
+        def initialize(factory)
+          @factory = factory
+          @parse_options ={
+            "POINT" => method(:parse_point),
+            "LINESTRING" => method(:parse_line_string),
+            "POLYGON" => method(:parse_polygon),
+            "MULTIPOINT" => method(:parse_multi_point),
+            "MULTILINESTRING" => method(:parse_multi_line_string),
+            "MULTIPOLYGON" => method(:parse_multi_polygon),
+            "GEOMETRYCOLLECTION" => method(:parse_geometry_collection)
+          }
+        end
+        
+        #Parses the ewkt string passed as argument and notifies the factory of events
+        def parse(ewkt)
+          @factory.reset
+          @tokenizer_structure = TokenizerStructure.new(ewkt)
+          @with_z=false
+          @with_m=false
+          @is_3dm = false
+          parse_geometry(true)
+          @srid=nil
+        end
+        
+        private
+        def parse_geometry(srid_allowed)
+          
+          token = @tokenizer_structure.get_next_token
+          if token == 'SRID'
+            #SRID present
+            raise  EWKTFormatError.new("SRID not allowed at this position") if(!srid_allowed)
+            if @tokenizer_structure.get_next_token != '='
+              raise EWKTFormatError.new("Invalid SRID expression")
+            else
+              @srid = @tokenizer_structure.get_next_token.to_i
+              raise EWKTFormatError.new("Invalid SRID separator") if @tokenizer_structure.get_next_token != ';'
+              geom_type = @tokenizer_structure.get_next_token
+            end
+            
+          else
+            #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
+            @srid= @srid || DEFAULT_SRID
+            geom_type = token
+          end
+          
+          if geom_type[-1] == ?M
+            @is_3dm=true
+            @with_m=true
+            geom_type.chop! #remove the M
+          end
+          
+          if @parse_options.has_key?(geom_type)
+            @parse_options[geom_type].call
+          else
+            raise EWKTFormatError.new("Urecognized geometry type: #{geom_type}")
+          end
+        end
+        
+        def parse_geometry_collection
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid GeometryCollection')
+          end
+          
+          @factory.begin_geometry(GeometryCollection,@srid)
+          
+          token = ''
+          while token != ')'
+            parse_geometry(false)
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_multi_polygon
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid MultiLineString')
+          end
+          
+          @factory.begin_geometry(MultiPolygon,@srid)
+          token = ''
+          while token != ')'
+            parse_polygon
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_multi_line_string
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid MultiLineString')
+          end
+          
+          @factory.begin_geometry(MultiLineString,@srid)
+          
+          token = ''
+          while token != ')'
+            parse_line_string
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_polygon
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid Polygon')
+          end
+          
+          @factory.begin_geometry(Polygon,@srid)
+          
+          token = ''
+          while token != ')'
+            parse_linear_ring
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        #must support the PostGIS form and the one in the specification
+        def parse_multi_point
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid MultiPoint')
+          end
+          
+          token = @tokenizer_structure.check_next_token
+          if token == '('
+            #specification
+            @factory.begin_geometry(MultiPoint,@srid)
+            
+            token = ''
+            while token != ')'
+              parse_point
+              token = @tokenizer_structure.get_next_token
+              if token.nil?
+                raise EWKTFormatError.new("EWKT string not correctly terminated")
+              end
+            end
+            
+            @factory.end_geometry(@with_z,@with_m)
+          else
+            #postgis
+            parse_point_list(MultiPoint)
+          end
+        end
+        
+        def parse_linear_ring
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid Linear ring')
+          end
+          
+          parse_point_list(LinearRing)
+        end
+        
+        def parse_line_string
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid Line string')
+          end
+          
+          parse_point_list(LineString)
+        end
+        
+        #used to parse line_strings and linear_rings and the PostGIS form of multi_points
+        def parse_point_list(geometry_type)
+          @factory.begin_geometry(geometry_type,@srid)
+          
+          token = ''
+          while token != ')'
+            @factory.begin_geometry(Point,@srid)
+            token = parse_coords
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+            @factory.end_geometry(@with_z,@with_m)
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_point
+          if @tokenizer_structure.get_next_token !='('
+            raise EWKTFormatError.new('Invalid Point')
+          end
+          
+          @factory.begin_geometry(Point,@srid)
+          
+          token = parse_coords
+          
+          if token != ')'
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+          
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        def parse_coords
+          coords = Array.new
+          x = @tokenizer_structure.get_next_token
+          y = @tokenizer_structure.get_next_token
+          
+          if x.nil? or y.nil?
+            raise EWKTFormatError.new("Bad Point format")
+          end
+          
+          if @is_3dm
+            m = @tokenizer_structure.get_next_token
+            
+            if m.nil? or m == ',' or m == ')'
+              raise EWKTFormatError.new("No M dimension found")
+            else
+              @factory.add_point_x_y_m(x.to_f,y.to_f,m.to_f)
+              @tokenizer_structure.get_next_token
+            end
+          else
+            z = @tokenizer_structure.get_next_token
+            
+            if z.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+            
+            if z == ',' or z == ')'
+              #2D : no z no m
+              @factory.add_point_x_y(x.to_f,y.to_f)
+              z
+            else
+              m = @tokenizer_structure.get_next_token
+              if m.nil?
+                raise EWKTFormatError.new("EWKT string not correctly terminated")
+              end
+              
+              if m == ',' or m ==')'
+                #3Dz : no m
+                @with_z = true
+                @factory.add_point_x_y_z(x.to_f,y.to_f,z.to_f)
+                m
+              else
+                #4D
+                @with_z = true
+                @with_m = true
+                @factory.add_point_x_y_z_m(x.to_f,y.to_f,z.to_f,m.to_f)
+                @tokenizer_structure.get_next_token
+              end
+            end
+          end
+        end
+      end
+      
+      class TokenizerStructure
+        
+        def initialize(ewkt)
+          @ewkt = ewkt
+          @scanner = StringScanner.new(ewkt)
+          @regex = /\s*([\w.-]+)s*/
+        end
+        
+        def get_next_token
+          if @scanner.scan(@regex).nil?
+            if @scanner.eos?
+              nil
+            else
+              ch = @scanner.getch
+              while ch == ' '
+                ch = @scanner.getch
+              end
+              ch
+            end
+          else
+            @scanner[1]
+          end
+        end
+        
+        
+        def check_next_token
+          check = @scanner.check(@regex)
+          if check.nil?
+            if @scanner.eos?
+              nil
+            else
+              pos = @scanner.pos
+              while @ewkt[pos].chr == ' '
+                pos+=1
+              end
+              @ewkt[pos].chr
+            end
+          else
+            check
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/io/geometry_factory.rb

@@ -0,0 +1,65 @@
+require 'geo_ruby/simple_features/point'
+require 'geo_ruby/simple_features/line_string'
+require 'geo_ruby/simple_features/linear_ring'
+require 'geo_ruby/simple_features/polygon'
+require 'geo_ruby/simple_features/multi_point'
+require 'geo_ruby/simple_features/multi_line_string'
+require 'geo_ruby/simple_features/multi_polygon'
+require 'geo_ruby/simple_features/geometry_collection'
+
+
+module GeoRuby
+  module SimpleFeatures
+    module Io
+      #Creates a new geometry according to constructions received from a parser, for example EWKBParser.
+      class GeometryFactory
+        #the built geometry
+        attr_reader :geometry
+        
+        def initialize
+          @geometry_stack = []
+        end
+        #resets the factory
+        def reset
+          @geometry_stack = []
+        end
+        #add a 2D point to the current geometry
+        def add_point_x_y(x,y)
+          @geometry_stack.last.set_x_y(x,y)
+        end
+        #add a 3D point to the current geometry
+        def add_point_x_y_z(x,y,z)
+          @geometry_stack.last.set_x_y_z(x,y,z)
+        end
+        #add a 2D point with M to the current geometry
+        def add_point_x_y_m(x,y,m)
+          @geometry_stack.last.set_x_y(x,y)
+          @geometry_stack.last.m=m
+        end
+        #add a 3D point with M to the current geometry
+        def add_point_x_y_z_m(x,y,z,m)
+          @geometry_stack.last.set_x_y_z(x,y,z)
+          @geometry_stack.last.m=m
+        end
+        #begin a geometry of type +geometry_type+
+        def begin_geometry(geometry_type,srid=DEFAULT_SRID)
+          geometry= geometry_type::new(srid)
+          @geometry= geometry if @geometry.nil?
+          @geometry_stack << geometry
+        end
+        #terminates the current geometry
+        def end_geometry(with_z=false,with_m=false)
+          @geometry=@geometry_stack.pop
+          @geometry.with_z=with_z
+          @geometry.with_m=with_m
+          #add the newly defined geometry to its parent if there is one
+          @geometry_stack.last << geometry if !@geometry_stack.empty?
+        end
+        #abort a geometry
+        def abort_geometry
+          reset
+        end
+      end
+    end
+  end
+end

data/rakefile.rb

@@ -24,7 +24,7 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'GeoRuby'
-  s.version = "1.3.1"
+  s.version = "1.3.2"
   s.summary = "Ruby data holder for OGC Simple Features"
   s.description = <<EOF
 GeoRuby is intended as a holder for data returned from PostGIS and MySQL Spatial queries. The data model roughly follows the OGC "Simple Features for SQL" specification (see www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections)

data/tools/lib/spatial_adapter/README

@@ -29,7 +29,7 @@ Here is an example of code for the creation of a table with a geometric column i
 
 Here is a related statement valid for MySql version <= 5.0.16 :
 	ActiveRecord::Schema.define do
-	  create_table "table_points", :options=>"ENGINE=MyISAM", :force => true do |t|
+	  create_table "table_points", ;options=>"ENGINE=MyISAM", :force => true do |t|
     	    t.column "data", :string
     	    t.column "geom", :point, :null=>false
   	  end
@@ -63,11 +63,11 @@ For MySQL, it is slightly different since it does not support Z dimension or SRI
 
 ==== Fixtures
 
-If you use fixtures for your unit tests, at some point, you will want to input a geometry. You could transform your geometries to a form suitable for YAML yourself everytime but the spatial adapter provides a method to do it for you: +to_fixture_format+. It works for both MySQL and PostGIS (although the string returned is different for each database). You would use it like this, if the geometric column is a point:
+If you use fixtures for your unit tests, at some point, you will want to input a geometry. You could transform your geometries to a form suitable for YAML yourself everytime but the spatial adapter provides a method to do it for you: +to_yaml+. It works for both MySQL and PostGIS (although the string returned is different for each database). You would use it like this, if the geometric column is a point:
 	fixture:
 	 id: 1
 	 data: HELLO
-	 geom: <%= Point.from_x_y(123.5,321.9).to_fixture_format %>
+	 geom: <%= Point.from_x_y(123.5,321.9).to_yaml %>
 
 ==== Find_by
 
@@ -103,7 +103,7 @@ Ruby geometric datatypes are currently made available only through the GeoRuby l
 - Support of M dimensions in migrations. The <tt>:dimension</tt> key in the column definition has disappeared and has been replaced by <tt>:with_z</tt> and <tt>:with_m</tt>.
 - Addition of unit tests. At the plugin root, Run <tt>rake test:mysql</tt> to run the mysql tests and <tt>rake test:postgis</tt> for the postgis ones. You will need to configure your connection in <tt>test/db/database_mysql.yml</tt> and <tt>test/db/database_postgis.yml</tt>. If you get errors on your platform, please report to mailto:guilhem.vellut+georuby@gmail.com.
 - Addition of a find_by methods with a special behaviour for geometries
-- Addition of a to_fixture_format method to use inside a YAML fixture
+- Addition of a to_yaml method to use inside a YAML fixture
 
 ===TODO
 - Support of other geometric datatype libraries in addition to GeoRuby

data/tools/lib/spatial_adapter/lib/common_spatial_adapter.rb

@@ -88,6 +88,8 @@ ActiveRecord::SchemaDumper.class_eval do
 end
 
 
+
+
 module SpatialAdapter
   #Translation of geometric data types
   def geometry_data_types

data/tools/lib/spatial_adapter/lib/mysql_spatial_adapter.rb

@@ -4,34 +4,66 @@ require 'common_spatial_adapter'
 
 include GeoRuby::SimpleFeatures
 
-
-#add a method to_fixture_format 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)
+#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
     "!binary | #{[(255.chr * 4) + as_wkb].pack('m')}"
   end
 end
 
-
 ActiveRecord::Base.class_eval do
-  #Redefinition of the method to do something special when a geometric column is encountered
-  def self.construct_conditions_from_arguments(attribute_names, arguments)
-    conditions = []
-    attribute_names.each_with_index do |name, idx| 
-      if columns_hash[name].is_a?(SpatialColumn)
-        #when the discriminating column is spatial, always use the MBRIntersects (bounding box intersection check) operator : the user can pass either a geometric object (which will be transformed to a string using the quote method of the database adapter) or an array with the corner points of a bounding box
-        if arguments[idx].is_a?(Array)
-          conditions << "MBRIntersects(?, #{table_name}.#{connection.quote_column_name(name)}) "
-          #using some georuby utility : The multipoint has a bbox whose corners are the 2 points passed as parameters : [ pt1, pt2]
-          arguments[idx]= MultiPoint.from_coordinates(arguments[idx])
-        else
+  require 'active_record/version'
+
+  #For Rails < 1.2
+  if ActiveRecord::VERSION::STRING < "1.15.1"
+    def self.construct_conditions_from_arguments(attribute_names, arguments)
+      conditions = []
+      attribute_names.each_with_index do |name, idx| 
+        if columns_hash[name].is_a?(SpatialColumn)
+          #when the discriminating column is spatial, always use the MBRIntersects (bounding box intersection check) operator : the user can pass either a geometric object (which will be transformed to a string using the quote method of the database adapter) or an array with the corner points of a bounding box
+          if arguments[idx].is_a?(Array)
+            #using some georuby utility : The multipoint has a bbox whose corners are the 2 points passed as parameters : [ pt1, pt2]
+            arguments[idx]= MultiPoint.from_coordinates(arguments[idx])
+          elsif arguments[idx].is_a?(Envelope)
+            arguments[idx]= MultiPoint.from_points([arguments[idx].lower_corner,arguments[idx].upper_corner])
+          end
           conditions << "MBRIntersects(?, #{table_name}.#{connection.quote_column_name(name)}) " 
+        else
+          conditions << "#{table_name}.#{connection.quote_column_name(name)} #{attribute_condition(arguments[idx])} " 
         end
-      else
-        conditions << "#{table_name}.#{connection.quote_column_name(name)} #{attribute_condition(arguments[idx])} " 
+      end
+      [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
+    end
+
+  else
+    def self.get_conditions(attrs)
+      attrs.map do |attr, value|
+        if columns_hash[attr].is_a?(SpatialColumn)
+          if value.is_a?(Array)
+            #using some georuby utility : The multipoint has a bbox whose corners are the 2 points passed as parameters : [ pt1, pt2]
+            attrs[attr]= MultiPoint.from_coordinates(value)
+          elsif value.is_a?(Envelope)
+            attrs[attr]= MultiPoint.from_points([value.lower_corner,value.upper_corner])
+          end
+          "MBRIntersects(?, #{table_name}.#{connection.quote_column_name(attr)}) " 
+        else
+          #original stuff
+          "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+        end
+      end.join(' AND ')
+    end
+    if ActiveRecord::VERSION::STRING == "1.15.1"
+      def self.sanitize_sql_hash(attrs)
+        conditions = get_conditions(attrs)
+        replace_bind_variables(conditions, attrs.values)
+      end
+    else
+      #For Rails >= 1.2
+      def self.sanitize_sql_hash(attrs)
+        conditions = get_conditions(attrs)
+        replace_bind_variables(conditions, expand_range_bind_variables(attrs.values))
       end
     end
-    [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
   end
 end
 
@@ -76,18 +108,10 @@ ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
   #Redefines add_index to support the case where the index is spatial
   #If the :spatial key in the options table is true, then the sql string for a spatial index is created
   def add_index(table_name,column_name,options = {})
-    index_name = options[:name] || "#{table_name}_#{Array(column_name).first}_index"
+    index_name = options[:name] || index_name(table_name,:column => Array(column_name))
     
     if options[:spatial]
-      if column_name.is_a?(Array) and column_name.length > 1
-        #one by one or error : Should raise exception instead? ; use default name even if name passed as argument
-        Array(column_name).each do |col|
-          execute "CREATE SPATIAL INDEX #{table_name}_#{col}_index ON #{table_name} (#{col})"
-        end
-      else
-        col = Array(column_name)[0]
-        execute "CREATE SPATIAL INDEX #{index_name} ON #{table_name} (#{col})"
-      end
+      execute "CREATE SPATIAL INDEX #{index_name} ON #{table_name} (#{Array(column_name).join(", ")})"
     else
       index_type = options[:unique] ? "UNIQUE" : ""
       #all together

data/tools/lib/spatial_adapter/lib/post_gis_adapter.rb

@@ -8,7 +8,7 @@ include GeoRuby::SimpleFeatures
 ActiveRecord::SchemaDumper.ignore_tables << "spatial_ref_sys" << "geometry_columns"
 
 
-#add a method to_fixture_format 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)
+#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
     as_hex_ewkb
@@ -17,24 +17,58 @@ end
 
 
 ActiveRecord::Base.class_eval do
-  def self.construct_conditions_from_arguments(attribute_names, arguments)
-    conditions = []
-    attribute_names.each_with_index do |name, idx| 
-      if columns_hash[name].is_a?(SpatialColumn)
-        #when the discriminating column is spatial, always use the && (bounding box intersection check) operator : the user can pass either a geometric object (which will be transformed to a string using the quote method of the database adapter) or an array representing 2 opposite corners of a bounding box
-        if arguments[idx].is_a?(Array)
-          bbox = arguments[idx]
-          conditions << "#{table_name}.#{connection.quote_column_name(name)} && SetSRID(?::box3d, #{bbox[2] || -1} ) " 
-          #Could do without the ? and replace directly with the quoted BBOX3D but like this, the flow is the same everytime
-          arguments[idx]= "BOX3D(" + bbox[0].join(" ") + "," + bbox[1].join(" ") + ")"
+  require 'active_record/version'
+
+  #For Rails < 1.2
+  if ActiveRecord::VERSION::STRING < "1.15.1"
+    def self.construct_conditions_from_arguments(attribute_names, arguments)
+      conditions = []
+      attribute_names.each_with_index do |name, idx| 
+        if columns_hash[name].is_a?(SpatialColumn)
+          #when the discriminating column is spatial, always use the && (bounding box intersection check) operator : the user can pass either a geometric object (which will be transformed to a string using the quote method of the database adapter) or an array representing 2 opposite corners of a bounding box
+          if arguments[idx].is_a?(Array)
+            bbox = arguments[idx]
+            conditions << "#{table_name}.#{connection.quote_column_name(name)} && SetSRID(?::box3d, #{bbox[2] || DEFAULT_SRID} ) " 
+            #Could do without the ? and replace directly with the quoted BBOX3D but like this, the flow is the same everytime
+            arguments[idx]= "BOX3D(" + bbox[0].join(" ") + "," + bbox[1].join(" ") + ")"
+          else
+            conditions << "#{table_name}.#{connection.quote_column_name(name)} && ? " 
+          end
         else
-          conditions << "#{table_name}.#{connection.quote_column_name(name)} && ? " 
+          conditions << "#{table_name}.#{connection.quote_column_name(name)} #{attribute_condition(arguments[idx])} " 
         end
-      else
-        conditions << "#{table_name}.#{connection.quote_column_name(name)} #{attribute_condition(arguments[idx])} " 
+      end
+      [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
+    end
+  else
+    def self.get_conditions(attrs)
+      attrs.map do |attr, value|
+        if columns_hash[attr].is_a?(SpatialColumn)
+          if value.is_a?(Array)
+            attrs[attr]= "BOX3D(" + value[0].join(" ") + "," + value[1].join(" ") + ")"
+            "#{table_name}.#{connection.quote_column_name(attr)} && SetSRID(?::box3d, #{value[2] || DEFAULT_SRID} ) " 
+          elsif value.is_a?(Envelope)
+            attrs[attr]= "BOX3D(" + value.lower_corner.text_representation + "," + value.upper_corner.text_representation + ")"
+            "#{table_name}.#{connection.quote_column_name(attr)} && SetSRID(?::box3d, #{value.srid} ) " 
+          else
+            "#{table_name}.#{connection.quote_column_name(attr)} && ? " 
+          end
+        else
+          "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+        end
+      end.join(' AND ')
+    end
+    if ActiveRecord::VERSION::STRING == "1.15.1"
+      def self.sanitize_sql_hash(attrs)
+        conditions = get_conditions(attrs)
+        replace_bind_variables(conditions, attrs.values)
+      end
+    else
+      def self.sanitize_sql_hash(attrs)
+        conditions = get_conditions(attrs)
+        replace_bind_variables(conditions, expand_range_bind_variables(attrs.values))
       end
     end
-    [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
   end
 end
 
@@ -84,7 +118,7 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
   alias :original_remove_column :remove_column
   def remove_column(table_name,column_name)
     columns(table_name).each do |col|
-      if col.name.to_s == column_name.to_s
+      if col.name == column_name.to_s 
         #check if the column is geometric
         unless geometry_data_types[col.type].nil?
           execute "SELECT DropGeometryColumn('#{table_name}','#{column_name}')"
@@ -109,17 +143,9 @@ ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
   
   #Adds a GIST spatial index to a column. Its name will be <table_name>_<column_name>_spatial_index unless the key :name is present in the options hash, in which case its value is taken as the name of the index.
   def add_index(table_name,column_name,options = {})
-    index_name = options[:name] ||"#{table_name}_#{Array(column_name).first}_index"
+    index_name = options[:name] || index_name(table_name,:column => Array(column_name))
     if options[:spatial]
-      if column_name.is_a?(Array) and column_name.length > 1
-        #one by one or error : Should raise exception instead? ; use default name even if name passed as argument
-        Array(column_name).each do |col|
-          execute "CREATE INDEX #{table_name}_#{col}_index ON #{table_name} USING GIST (#{col} GIST_GEOMETRY_OPS)"
-        end
-      else
-        col = Array(column_name)[0]
-        execute "CREATE INDEX #{index_name} ON #{table_name} USING GIST (#{col} GIST_GEOMETRY_OPS)"
-      end
+      execute "CREATE INDEX #{index_name} ON #{table_name} USING GIST (#{Array(column_name).join(", ")} GIST_GEOMETRY_OPS)"
     else
       index_type = options[:unique] ? "UNIQUE" : ""
       #all together

data/tools/lib/spatial_adapter/rakefile.rb

@@ -11,7 +11,7 @@ namespace :test do
 
   Rake::TestTask::new(:postgis => "db:postgis" ) do |t|
     t.test_files = FileList['test/*_postgis_test.rb']
-    t.verbose = true
+    t.verbose = true 
   end
 end
 

data/tools/lib/spatial_adapter/test/access_mysql_test.rb

@@ -11,7 +11,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     pt = TablePoint.new(:data => "Test", :geom => Point.from_x_y(1.2,4.5))
     assert(pt.save)
     
-    pt = TablePoint.find_first
+    pt = TablePoint.find(:first)
     assert(pt)
     assert_equal("Test",pt.data)
     assert_equal(Point.from_x_y(1.2,4.5),pt.geom)
@@ -22,7 +22,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     ls = TableLineString.new(:value => 3, :geom => LineString.from_coordinates([[1.4,2.5],[1.5,6.7]]))
     assert(ls.save)
     
-    ls = TableLineString.find_first
+    ls = TableLineString.find(:first)
     assert(ls)
     assert_equal(3,ls.value)
     assert_equal(LineString.from_coordinates([[1.4,2.5],[1.5,6.7]]),ls.geom)
@@ -33,7 +33,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     pg = TablePolygon.new(:geom => Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]]))
     assert(pg.save)
 
-    pg = TablePolygon.find_first
+    pg = TablePolygon.find(:first)
     assert(pg)
     assert_equal(Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]]),pg.geom)
   end
@@ -42,7 +42,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     mp = TableMultiPoint.new(:geom => MultiPoint.from_coordinates([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]]))
     assert(mp.save)
 
-    mp = TableMultiPoint.find_first
+    mp = TableMultiPoint.find(:first)
     assert(mp)
     assert_equal(MultiPoint.from_coordinates([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]]),mp.geom)
   end
@@ -51,7 +51,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     ml = TableMultiLineString.new(:geom => 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]])]))
     assert(ml.save)
 
-    ml = TableMultiLineString.find_first
+    ml = TableMultiLineString.find(:first)
     assert(ml)
     assert_equal(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]])]),ml.geom)
   end
@@ -60,7 +60,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     mp = TableMultiPolygon.new( :geom => MultiPolygon.from_polygons([Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]]),Polygon.from_coordinates([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]])]))
     assert(mp.save)
 
-    mp = TableMultiPolygon.find_first
+    mp = TableMultiPolygon.find(:first)
     assert(mp)
     assert_equal(MultiPolygon.from_polygons([Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]]),Polygon.from_coordinates([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]])]),mp.geom)
   end
@@ -69,7 +69,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     gm = TableGeometry.new(:geom => LineString.from_coordinates([[12.4,-45.3],[45.4,41.6],[4.456,1.0698]]))
     assert(gm.save)
 
-    gm = TableGeometry.find_first
+    gm = TableGeometry.find(:first)
     assert(gm)
     assert_equal(LineString.from_coordinates([[12.4,-45.3],[45.4,41.6],[4.456,1.0698]]),gm.geom)
   end
@@ -78,7 +78,7 @@ class AccessMysqlTest < Test::Unit::TestCase
     gc = TableGeometryCollection.new(:geom => GeometryCollection.from_geometries([Point.from_x_y(4.67,45.4),LineString.from_coordinates([[5.7,12.45],[67.55,54]])]))
     assert(gc.save)
 
-    gc = TableGeometryCollection.find_first
+    gc = TableGeometryCollection.find(:first)
     assert(gc)
     assert_equal(GeometryCollection.from_geometries([Point.from_x_y(4.67,45.4),LineString.from_coordinates([[5.7,12.45],[67.55,54]])]),gc.geom)
   end

data/tools/lib/spatial_adapter/test/migration_mysql_test.rb

@@ -71,16 +71,15 @@ class MigrationMysqlTest < Test::Unit::TestCase
     assert_equal(0,connection.indexes("parks").length) #index on id does not count
     
     ActiveRecord::Schema.define() do      
-      add_index "parks","geom",:spatial=>true,:name => "example_spatial_index"
+      add_index "parks","geom",:spatial=>true
     end
     
     #TEST
     assert_equal(1,connection.indexes("parks").length)
     assert(connection.indexes("parks")[0].spatial)
-    assert_equal("example_spatial_index",connection.indexes("parks")[0].name)
-
+   
     ActiveRecord::Schema.define() do
-      remove_index "parks",:name=> "example_spatial_index"
+      remove_index "parks","geom"
     end
     
     #TEST

data/tools/lib/spatial_adapter/test/migration_postgis_test.rb

@@ -77,21 +77,39 @@ class MigrationPostgisTest < Test::Unit::TestCase
     assert_equal(0,connection.indexes("parks").length) #index on id does not count
     
     ActiveRecord::Schema.define do      
-      add_index "parks","geom",:spatial=>true,:name => "example_spatial_index"
+      add_index "parks","geom",:spatial=>true
     end
     
     #TEST
     assert_equal(1,connection.indexes("parks").length)
     assert(connection.indexes("parks")[0].spatial)
-    assert_equal("example_spatial_index",connection.indexes("parks")[0].name)
-
+    
     ActiveRecord::Schema.define do
-      remove_index "parks",:name=> "example_spatial_index"
+      remove_index "parks", "geom"
     end
     
     #TEST
     assert_equal(0,connection.indexes("parks").length)
     
+    ActiveRecord::Schema.define do
+      remove_column "parks","geom2"
+    end
+    
+    #testing with point
+    ActiveRecord::Schema.define do
+      add_column "parks","geom2", :point
+    end
+    
+    ActiveRecord::Schema.define do      
+      add_index "parks","geom2",:spatial=>true,:name => "example_spatial_index"
+    end
+    
+    #TEST
+    assert_equal(1,connection.indexes("parks").length)
+    assert(connection.indexes("parks")[0].spatial)
+    assert_equal("example_spatial_index",connection.indexes("parks")[0].name)
+    
+
   end
 
   def test_keyword_column_name

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.2
 specification_version: 1
 name: GeoRuby
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
-date: 2007-08-28 00:00:00 +02:00
+  version: 1.3.2
+date: 2007-09-14 00:00:00 +02:00
 summary: Ruby data holder for OGC Simple Features
 require_paths: 
 - lib
@@ -29,7 +29,6 @@ post_install_message:
 authors: 
 - Guilhem Vellut
 files: 
-- lib/geo_ruby.rb
 - lib/geo_ruby/shp4r/dbf.rb
 - lib/geo_ruby/shp4r/shp.rb
 - lib/geo_ruby/simple_features/envelope.rb
@@ -40,6 +39,9 @@ files:
 - lib/geo_ruby/simple_features/geometry_factory.rb
 - lib/geo_ruby/simple_features/georss_parser.rb
 - lib/geo_ruby/simple_features/helper.rb
+- lib/geo_ruby/simple_features/io/ewkb_parser.rb
+- lib/geo_ruby/simple_features/io/ewkt_parser.rb
+- lib/geo_ruby/simple_features/io/geometry_factory.rb
 - lib/geo_ruby/simple_features/linear_ring.rb
 - lib/geo_ruby/simple_features/line_string.rb
 - lib/geo_ruby/simple_features/multi_line_string.rb
@@ -47,6 +49,7 @@ files:
 - lib/geo_ruby/simple_features/multi_polygon.rb
 - lib/geo_ruby/simple_features/point.rb
 - lib/geo_ruby/simple_features/polygon.rb
+- lib/geo_ruby.rb
 - test/test_ewkb_parser.rb
 - test/test_ewkt_parser.rb
 - test/test_georss_kml.rb
@@ -60,38 +63,35 @@ files:
 - test/data/point.shp
 - test/data/polygon.shp
 - test/data/polyline.shp
-- test/data/polyline2.shp
 - test/data/multipoint.dbf
 - test/data/point.dbf
 - test/data/polygon.dbf
 - test/data/polyline.dbf
-- test/data/polyline2.dbf
 - test/data/multipoint.shx
 - test/data/point.shx
 - test/data/polygon.shx
 - test/data/polyline.shx
-- test/data/polyline2.shx
 - tools/db.yml
 - tools/lib/spatial_adapter/test/db/database_mysql.yml
 - tools/lib/spatial_adapter/test/db/database_postgis.yml
-- tools/shp2sql.rb
 - tools/lib/spatial_adapter/init.rb
-- tools/lib/spatial_adapter/rakefile.rb
 - tools/lib/spatial_adapter/lib/common_spatial_adapter.rb
 - tools/lib/spatial_adapter/lib/mysql_spatial_adapter.rb
 - tools/lib/spatial_adapter/lib/post_gis_adapter.rb
+- tools/lib/spatial_adapter/rakefile.rb
 - tools/lib/spatial_adapter/test/access_mysql_test.rb
 - tools/lib/spatial_adapter/test/access_postgis_test.rb
+- tools/lib/spatial_adapter/test/common/common_mysql.rb
+- tools/lib/spatial_adapter/test/common/common_postgis.rb
 - tools/lib/spatial_adapter/test/find_mysql_test.rb
 - tools/lib/spatial_adapter/test/find_postgis_test.rb
 - tools/lib/spatial_adapter/test/migration_mysql_test.rb
 - tools/lib/spatial_adapter/test/migration_postgis_test.rb
-- tools/lib/spatial_adapter/test/common/common_mysql.rb
-- tools/lib/spatial_adapter/test/common/common_postgis.rb
 - tools/lib/spatial_adapter/test/models/models_mysql.rb
 - tools/lib/spatial_adapter/test/models/models_postgis.rb
 - tools/lib/spatial_adapter/test/schema/schema_mysql.rb
 - tools/lib/spatial_adapter/test/schema/schema_postgis.rb
+- tools/shp2sql.rb
 - tools/lib/spatial_adapter
 - tools/lib/spatial_adapter/lib
 - tools/lib/spatial_adapter/MIT-LICENSE