georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/ewk/ewkt_parser.rb

@@ -0,0 +1,321 @@
+require 'strscan'
+
+module GeoRuby
+  module SimpleFeatures
+    # 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
+          fail EWKTFormatError.new('SRID not allowed at this position') unless srid_allowed
+          if @tokenizer_structure.get_next_token != '='
+            fail EWKTFormatError.new('Invalid SRID expression')
+          else
+            @srid = @tokenizer_structure.get_next_token.to_i
+            fail 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.key?(geom_type)
+          @parse_options[geom_type].call
+        else
+          fail EWKTFormatError.new("Urecognized geometry type: #{geom_type}")
+        end
+      end
+
+      def parse_geometry_collection
+        if @tokenizer_structure.get_next_token != '('
+          fail 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?
+            fail 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 != '('
+          fail EWKTFormatError.new('Invalid MultiLineString')
+        end
+
+        @factory.begin_geometry(MultiPolygon, @srid)
+        token = ''
+        while token != ')'
+          parse_polygon
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            fail 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 != '('
+          fail 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?
+            fail 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 != '('
+          fail 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?
+            fail 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 != '('
+          fail 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?
+              fail 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 != '('
+          fail EWKTFormatError.new('Invalid Linear ring')
+        end
+
+        parse_point_list(LinearRing)
+      end
+
+      def parse_line_string
+        if @tokenizer_structure.get_next_token != '('
+          fail 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?
+            fail 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 != '('
+          fail EWKTFormatError.new('Invalid Point')
+        end
+
+        @factory.begin_geometry(Point, @srid)
+
+        token = parse_coords
+
+        if token != ')'
+          fail EWKTFormatError.new('EWKT string not correctly terminated')
+        end
+
+        @factory.end_geometry(@with_z, @with_m)
+      end
+
+      def parse_coords
+        coords = []
+        x = @tokenizer_structure.get_next_token
+        y = @tokenizer_structure.get_next_token
+
+        if x.nil? || y.nil?
+          fail EWKTFormatError.new('Bad Point format')
+        end
+
+        if @is_3dm
+          m = @tokenizer_structure.get_next_token
+
+          if m.nil? || m == ',' || m == ')'
+            fail 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?
+            fail EWKTFormatError.new('EWKT string not correctly terminated')
+          end
+
+          if z == ',' || 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?
+              fail EWKTFormatError.new('EWKT string not correctly terminated')
+            end
+
+            if m == ',' || 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

data/lib/geo_ruby/geojson.rb

@@ -8,13 +8,12 @@ rescue LoadError
 end
 
 module GeoRuby
-
-  #Raised when an error in the GeoJSON string is detected
-  class GeojsonFormatError < StandardError
+  # Raised when an error in the GeoJSON string is detected
+  class GeoJSONFormatError < StandardError
   end
 
   # Class added to support geojson 'Feature' objects
-  class GeojsonFeature
+  class GeoJSONFeature
     attr_accessor :geometry, :properties, :id
 
     def initialize(geometry, properties = {}, id = nil)
@@ -27,11 +26,13 @@ module GeoRuby
       if (self.class != other.class)
         false
       else
-        (self.id == other.id) && (self.geometry == other.geometry) && (self.properties == other.properties)
+        (id == other.id) &&
+          (geometry == other.geometry) &&
+          (properties == other.properties)
       end
     end
 
-    def as_json(options={})
+    def to_json(options = {})
       output = {}
       output[:type] = 'Feature'
       output[:geometry] = geometry
@@ -39,15 +40,11 @@ module GeoRuby
       output[:id] = id unless id.nil?
       output.to_json(options)
     end
-
-    def to_json(options = {})
-      as_json(options).to_json
-    end
-    alias :as_geojson :to_json
+    alias_method :as_geojson, :to_json
   end
 
   # Class added to support geojson 'Feature Collection' objects
-  class GeojsonFeatureCollection
+  class GeoJSONFeatureCollection
     attr_accessor :features
 
     def initialize(features)
@@ -59,25 +56,24 @@ module GeoRuby
         return false
       else
         features.each_index do |index|
-          return false if self.features[index] != other.features[index]
+          return false if features[index] != other.features[index]
         end
       end
       true
     end
 
-    def as_json(options = {})
-      {:type => 'FeatureCollection',
-        :features => features}.to_json(options)
+    def to_json(options = {})
+      ({ type: 'FeatureCollection', features: features }).to_json
     end
-    alias :as_geojson :as_json
+    alias_method :as_geojson, :to_json
   end
 
-
-  class GeojsonParser
+  # GeoJSON main parser
+  class GeoJSONParser
     include GeoRuby::SimpleFeatures
     attr_reader :geometry
 
-    def parse(geojson, srid=DEFAULT_SRID)
+    def parse(geojson, srid = DEFAULT_SRID)
       @geometry = nil
       geohash = JSON.parse(geojson)
       parse_geohash(geohash, srid)
@@ -88,14 +84,15 @@ module GeoRuby
     def parse_geohash(geohash, srid)
       srid = srid_from_crs(geohash['crs']) || srid
       case geohash['type']
-      when 'Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'
+      when 'Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon',
+           'MultiPolygon', 'GeometryCollection'
         @geometry = parse_geometry(geohash, srid)
       when 'Feature'
         @geometry = parse_geojson_feature(geohash, srid)
       when 'FeatureCollection'
         @geometry = parse_geojson_feature_collection(geohash, srid)
       else
-        GeojsonFormatError.new('Unknown GeoJSON type')
+        fail GeoJSONFormatError, 'Unknown GeoJSON type'
       end
     end
 
@@ -111,14 +108,14 @@ module GeoRuby
 
     def parse_geometry_collection(geohash, srid)
       srid = srid_from_crs(geohash['crs']) || srid
-      geometries = geohash['geometries'].map{|g| parse_geometry(g,srid)}
-      GeometryCollection.from_geometries(geometries,srid)
+      geometries = geohash['geometries'].map { |g| parse_geometry(g, srid) }
+      GeometryCollection.from_geometries(geometries, srid)
     end
 
     def parse_geojson_feature(geohash, srid)
       srid = srid_from_crs(geohash['crs']) || srid
-      geometry = parse_geometry(geohash['geometry'],srid)
-      GeojsonFeature.new(geometry, geohash['properties'], geohash['id'])
+      geometry = parse_geometry(geohash['geometry'], srid)
+      GeoJSONFeature.new(geometry, geohash['properties'], geohash['id'])
     end
 
     def parse_geojson_feature_collection(geohash, srid)
@@ -127,7 +124,7 @@ module GeoRuby
       geohash['features'].each do |feature|
         features << parse_geojson_feature(feature, srid)
       end
-      GeojsonFeatureCollection.new(features)
+      GeoJSONFeatureCollection.new(features)
     end
 
     def srid_from_crs(crs)
@@ -136,9 +133,7 @@ module GeoRuby
         urn = crs['properties']['urn'].split(':')
         return urn.last if urn[4] == 'EPSG'
       end
-      return nil
+      nil
     end
-
-  end #GeojsonParser
-
-end #GeoRuby
+  end # GeoJSONParser
+end # GeoRuby