rgeo 2.4.0 → 3.0.0

data/lib/rgeo/impl_helper/validity_check.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RGeo
+  module ImplHelper
+    # This helper enforces valid geometry computation, avoiding results such
+    # as a 0 area for a bowtie shaped polygon. Implementations that are part
+    # of RGeo core should all include this.
+    #
+    # You can play around validity checks if needed:
+    #
+    # - {check_validity!} is the method that will raise if your geometry is
+    #   not valid. Its message will be the same as {invalid_reason}.
+    # - {make_valid} is the method you can call to get a valid copy of the
+    #   current geometry.
+    # - finally, you can bypass any checked method by prepending `unsafe_` to
+    #   it. At your own risk.
+    module ValidityCheck
+      # Every method that should not be overriden by the validity check.
+      # Those methods are either accessors or very basic methods not related
+      # to validity checks, or are used to check validity, in which case the
+      # `true/false` gives a correct information, no need to raise).
+      UNCHECKED_METHODS = [
+        # Basic methods
+        :factory, :geometry_type, :as_text, :as_binary, :srid,
+        :dimension, :coordinate_dimension, :spatial_dimension,
+        # Tests
+        :simple?, :closed?, :empty?, :is_3d?, :measured?,
+        # Accessors
+        :exterior_ring, :interior_rings, :[], :num_geometries, :num_interior_rings,
+        :geometry_n, :each, :points, :point_n, :start_point, :end_point, :x, :y, :z, :m,
+        # Trivial methods
+        :num_points, :locate_along, :locate_between,
+        # Comparison
+        :equals?, :rep_equals?, :eql?, :==, :"!="
+      ].freeze
+      private_constant :UNCHECKED_METHODS
+
+      # Since methods have their unsafe_ counter part, it means that the `+`
+      # method would lead to having an `unsafe_+` method that is not simply
+      # callable. Here's a simple fallback:
+      SYMBOL2NAME = {
+        :+ => "add",
+        :- => "remove",
+        :* => "multiply"
+      }.tap { |h| h.default_proc = ->(_, key) { key.to_s } }.freeze
+      private_constant :SYMBOL2NAME
+
+      class << self
+        # Note for contributors: this should be called after all methods
+        # are loaded for a given feature classe. No worries though, this
+        # is tested.
+        def override_classes # :nodoc:
+          # Using pop here to be thread safe.
+          while (klass = classes.pop)
+            override(klass)
+          end
+        end
+
+        def included(klass) # :nodoc:
+          classes << klass
+        end
+
+        private
+
+        def classes
+          @classes ||= []
+        end
+
+        def override(klass)
+          methods_to_check = feature_methods(klass)
+
+          klass.class_eval do
+            methods_to_check.each do |method_sym|
+              copy = "unsafe_#{SYMBOL2NAME[method_sym]}".to_sym
+              alias_method copy, method_sym
+              undef_method method_sym
+              define_method(method_sym) do |*args|
+                check_validity!
+                args.each do |arg|
+                  arg.check_validity! if RGeo::Feature::Geometry.check_type(arg)
+                end
+                method(copy).call(*args)
+              end
+            end
+          end
+        end
+
+        def feature_methods(klass)
+          feature_defs = Set.new
+          klass
+            .ancestors
+            .select { |ancestor| ancestor <= RGeo::Feature::Geometry }
+            .each { |ancestor| feature_defs.merge(ancestor.instance_methods(false)) }
+          feature_defs & klass.instance_methods - UNCHECKED_METHODS
+        end
+      end
+
+      # Raises {invalid_reason} if the polygon is not valid, does nothing
+      # otherwise.
+      def check_validity!
+        # This method will use a cached invalid_reason for performance purposes.
+        # DO NOT MUTATE GEOMETRIES.
+        return unless invalid_reason_memo
+
+        raise Error::InvalidGeometry, invalid_reason_memo
+      end
+
+      # Tell why the geometry is not valid, `nil` means it is valid.
+      def invalid_reason
+        if defined?(super) == "super"
+          raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
+                                  "definition of #{self.class}##{__method__}."
+        end
+
+        raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."
+      end
+
+      # Try and make the geometry valid, this may change its shape.
+      # Returns a valid copy of the geometry.
+      def make_valid
+        if defined?(super) == "super"
+          raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
+                                  "definition of #{self.class}##{__method__}."
+        end
+
+        raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."
+      end
+
+      private
+
+      def invalid_reason_memo
+        # `defined?` is a bit faster than `instance_variable_defined?`.
+        return @invalid_reason_memo if defined?(@invalid_reason_memo)
+
+        @invalid_reason_memo = invalid_reason
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper.rb

@@ -7,3 +7,4 @@ require_relative "impl_helper/basic_geometry_collection_methods"
 require_relative "impl_helper/basic_point_methods"
 require_relative "impl_helper/basic_line_string_methods"
 require_relative "impl_helper/basic_polygon_methods"
+require_relative "impl_helper/valid_op"

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "2.4.0"
+  VERSION = "3.0.0"
 end

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -39,7 +39,6 @@ module RGeo
     # [<tt>:little_endian</tt>]
     #   If true, output little endian (NDR) byte order. If false, output
     #   big endian (XDR), or network byte order. Default is false.
-
     class WKBGenerator
       # :stopdoc:
       TYPE_CODES = {
@@ -100,103 +99,114 @@ module RGeo
       def generate(obj)
         factory = obj.factory
         if @type_format == :ewkb || @type_format == :wkb12
-          @cur_has_z = factory.property(:has_z_coordinate)
-          @cur_has_m = factory.property(:has_m_coordinate)
+          has_z = factory.property(:has_z_coordinate)
+          has_m = factory.property(:has_m_coordinate)
         else
-          @cur_has_z = nil
-          @cur_has_m = nil
+          has_z = false
+          has_m = false
         end
-        @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
-        start_emitter
-        generate_feature(obj, true)
-        finish_emitter
+        result = Result.new(has_z, has_m)
+        generate_feature(obj, result, toplevel: true)
+        result.emit(@hex_format)
       end
 
       private
 
-      def emit_byte(value)
-        @cur_array << [value].pack("C")
+      class Result
+        def initialize(has_z, has_m)
+          @buffer = []
+          @has_z = has_z
+          @has_m = has_m
+        end
+
+        def <<(data)
+          @buffer << data
+        end
+
+        def emit(hex_format)
+          str = @buffer.join
+          hex_format ? str.unpack1("H*") : str
+        end
+
+        def z?
+          @has_z
+        end
+
+        def m?
+          @has_m
+        end
+      end
+      private_constant :Result
+
+      def emit_byte(value, rval)
+        rval << [value].pack("C")
       end
 
-      def emit_integer(value)
-        @cur_array << [value].pack(@little_endian ? "V" : "N")
+      def emit_integer(value, rval)
+        rval << [value].pack(@little_endian ? "V" : "N")
       end
 
-      def emit_doubles(array)
-        @cur_array << array.pack(@little_endian ? "E*" : "G*")
+      def emit_doubles(array, rval)
+        rval << array.pack(@little_endian ? "E*" : "G*")
       end
 
-      def emit_line_string_coords(obj)
+      def emit_line_string_coords(obj, rval)
         array = []
-        obj.points.each { |p| point_coords(p, array) }
-        emit_integer(obj.num_points)
-        emit_doubles(array)
+        obj.points.each { |pt| point_coords(pt, rval, array) }
+        emit_integer(obj.num_points, rval)
+        emit_doubles(array, rval)
       end
 
-      def point_coords(obj, array = [])
+      def point_coords(obj, rval, array = [])
         array << obj.x
         array << obj.y
-        array << obj.z if @cur_has_z
-        array << obj.m if @cur_has_m
+        array << obj.z if rval.z?
+        array << obj.m if rval.m?
         array
       end
 
-      def start_emitter
-        @cur_array = []
-      end
-
-      def finish_emitter
-        str = @cur_array.join
-        @cur_array = nil
-        @hex_format ? str.unpack("H*")[0] : str
-      end
-
-      def generate_feature(obj, toplevel = false)
-        emit_byte(@little_endian ? 1 : 0)
+      def generate_feature(obj, rval, toplevel: false)
+        emit_byte(@little_endian ? 1 : 0, rval)
         type = obj.geometry_type
         type_code = TYPE_CODES[type]
-        unless type_code
-          raise Error::ParseError, "Unrecognized Geometry Type: #{type}"
-        end
+        raise Error::ParseError, "Unrecognized Geometry Type: #{type}" unless type_code
         emit_srid = false
-        if @type_format == :ewkb
-          type_code |= 0x80000000 if @cur_has_z
-          type_code |= 0x40000000 if @cur_has_m
+        case @type_format
+        when :ewkb
+          type_code |= 0x80000000 if rval.z?
+          type_code |= 0x40000000 if rval.m?
           if @emit_ewkb_srid && toplevel
             type_code |= 0x20000000
             emit_srid = true
           end
-        elsif @type_format == :wkb12
-          type_code += 1000 if @cur_has_z
-          type_code += 2000 if @cur_has_m
+        when :wkb12
+          type_code += 1000 if rval.z?
+          type_code += 2000 if rval.m?
         end
-        emit_integer(type_code)
-        emit_integer(obj.srid) if emit_srid
+        emit_integer(type_code, rval)
+        emit_integer(obj.srid, rval) if emit_srid
+        type_is_collection = [
+          Feature::GeometryCollection,
+          Feature::MultiPoint,
+          Feature::MultiLineString,
+          Feature::MultiPolygon
+        ].include?(type)
         if type == Feature::Point
-          emit_doubles(point_coords(obj))
+          emit_doubles(point_coords(obj, rval), rval)
         elsif type.subtype_of?(Feature::LineString)
-          emit_line_string_coords(obj)
+          emit_line_string_coords(obj, rval)
         elsif type == Feature::Polygon
           exterior_ring = obj.exterior_ring
           if exterior_ring.empty?
-            emit_integer(0)
+            emit_integer(0, rval)
           else
-            emit_integer(1 + obj.num_interior_rings)
-            emit_line_string_coords(exterior_ring)
-            obj.interior_rings.each { |r| emit_line_string_coords(r) }
+            emit_integer(1 + obj.num_interior_rings, rval)
+            emit_line_string_coords(exterior_ring, rval)
+            obj.interior_rings.each { |r| emit_line_string_coords(r, rval) }
           end
-        elsif type == Feature::GeometryCollection
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
-        elsif type == Feature::MultiPoint
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
-        elsif type == Feature::MultiLineString
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
-        elsif type == Feature::MultiPolygon
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
+        elsif type_is_collection
+          emit_integer(obj.num_geometries, rval)
+          obj.each { |g| generate_feature(g, rval) }
         end
       end
     end

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -42,7 +42,6 @@ module RGeo
     # [<tt>:default_srid</tt>]
     #   A SRID to pass to the factory generator if no SRID is present in
     #   the input. Defaults to nil (i.e. don't specify a SRID).
-
     class WKBParser
       # Create and configure a WKB parser. See the WKBParser
       # documentation for the options that can be passed.
@@ -62,6 +61,7 @@ module RGeo
         @support_wkb12 = opts[:support_wkb12] ? true : false
         @ignore_extra_bytes = opts[:ignore_extra_bytes] ? true : false
         @default_srid = opts[:default_srid]
+        @mutex = Mutex.new
       end
 
       # Returns the factory generator. See WKBParser for details.
@@ -105,32 +105,32 @@ module RGeo
       # reasons but deprecated. Use #parse instead.
 
       def parse(data)
-        data = [data].pack("H*") if data[0, 1] =~ /[0-9a-fA-F]/
-        @cur_has_z = nil
-        @cur_has_m = nil
-        @cur_srid = nil
-        @cur_dims = 2
-        @cur_factory = nil
-        begin
-          start_scanner(data)
-          obj = parse_object(false)
-          unless @ignore_extra_bytes
-            bytes = bytes_remaining
-            if bytes > 0
-              raise Error::ParseError, "Found #{bytes} extra bytes at the end of the stream."
+        @mutex.synchronize do
+          data = [data].pack("H*") if data[0, 1] =~ /[0-9a-fA-F]/
+          @cur_has_z = nil
+          @cur_has_m = nil
+          @cur_srid = nil
+          @cur_dims = 2
+          @cur_factory = nil
+          begin
+            start_scanner(data)
+            obj = parse_object(false)
+            unless @ignore_extra_bytes
+              bytes = bytes_remaining
+              raise Error::ParseError, "Found #{bytes} extra bytes at the end of the stream." if bytes > 0
             end
+          ensure
+            @data = nil
           end
-        ensure
-          @data = nil
+          obj
         end
-        obj
       end
       alias parse_hex parse
 
       private
 
       def parse_object(contained)
-        endian_value = get_byte
+        endian_value = byte
         case endian_value
         when 0
           little_endian = false
@@ -158,14 +158,20 @@ module RGeo
           if contained != true && contained != type_code
             raise Error::ParseError, "Enclosed type=#{type_code} is different from container constraint #{contained}"
           end
+
           if has_z != @cur_has_z
             raise Error::ParseError, "Enclosed hasZ=#{has_z} is different from toplevel hasZ=#{@cur_has_z}"
           end
+
           if has_m != @cur_has_m
             raise Error::ParseError, "Enclosed hasM=#{has_m} is different from toplevel hasM=#{@cur_has_m}"
           end
+
           if srid && srid != @cur_srid
-            raise Error::ParseError, "Enclosed SRID #{srid} is different from toplevel srid #{@cur_srid || '(unspecified)'}"
+            raise(
+              Error::ParseError,
+              "Enclosed SRID #{srid} is different from toplevel srid #{@cur_srid || '(unspecified)'}"
+            )
           end
         else
           @cur_has_z = has_z
@@ -173,9 +179,11 @@ module RGeo
           @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
           @cur_srid = srid
           @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: has_z, has_m_coordinate: has_m)
+
           if @cur_has_z && !@cur_factory.property(:has_z_coordinate)
             raise Error::ParseError, "Data has Z coordinates but the factory doesn't have Z coordinates"
           end
+
           if @cur_has_m && !@cur_factory.property(:has_m_coordinate)
             raise Error::ParseError, "Data has M coordinates but the factory doesn't have M coordinates"
           end
@@ -219,29 +227,23 @@ module RGeo
         @len - @pos
       end
 
-      def get_byte
-        if @pos + 1 > @len
-          raise Error::ParseError, "Not enough bytes left to fulfill 1 byte"
-        end
+      def byte
+        raise Error::ParseError, "Not enough bytes left to fulfill 1 byte" if @pos + 1 > @len
         str = @data[@pos, 1]
         @pos += 1
-        str.unpack("C").first
+        str.unpack1("C")
       end
 
       def get_integer(little_endian)
-        if @pos + 4 > @len
-          raise Error::ParseError, "Not enough bytes left to fulfill 1 integer"
-        end
+        raise Error::ParseError, "Not enough bytes left to fulfill 1 integer" if @pos + 4 > @len
         str = @data[@pos, 4]
         @pos += 4
-        str.unpack(little_endian ? "V" : "N").first
+        str.unpack1(little_endian ? "V" : "N")
       end
 
       def get_doubles(little_endian, count)
         len = 8 * count
-        if @pos + len > @len
-          raise Error::ParseError, "Not enough bytes left to fulfill #{count} doubles"
-        end
+        raise Error::ParseError, "Not enough bytes left to fulfill #{count} doubles" if @pos + len > @len
         str = @data[@pos, len]
         @pos += len
         str.unpack("#{little_endian ? 'E' : 'G'}*")

data/lib/rgeo/wkrep/wkt_generator.rb

@@ -45,15 +45,16 @@ module RGeo
     #   letters to lower case; or nil, indicating no case changes from
     #   the default (which is not specified exactly, but is chosen by the
     #   generator to emphasize readability.) Default is nil.
-
     class WKTGenerator
       # Create and configure a WKT generator. See the WKTGenerator
       # documentation for the options that can be passed.
 
       def initialize(opts = {})
         @tag_format = opts[:tag_format] || opts[:type_format] || :wkt11
-        @emit_ewkt_srid = @tag_format == :ewkt ?
-          (opts[:emit_ewkt_srid] ? true : false) : nil
+        @emit_ewkt_srid =
+          if @tag_format == :ewkt
+            (opts[:emit_ewkt_srid] ? true : false)
+          end
         @square_brackets = opts[:square_brackets] ? true : false
         @convert_case = opts[:convert_case]
       end
@@ -93,16 +94,17 @@ module RGeo
         @end_bracket = @square_brackets ? "]" : ")"
         factory = obj.factory
         if @tag_format == :wkt11_strict
-          @cur_support_z = nil
-          @cur_support_m = nil
+          support_z = false
+          support_m = false
         else
-          @cur_support_z = factory.property(:has_z_coordinate)
-          @cur_support_m = factory.property(:has_m_coordinate)
+          support_z = factory.property(:has_z_coordinate)
+          support_m = factory.property(:has_m_coordinate)
         end
-        str = generate_feature(obj, true)
-        if @convert_case == :upper
+        str = generate_feature(obj, support_z, support_m, toplevel: true)
+        case @convert_case
+        when :upper
           str.upcase
-        elsif @convert_case == :lower
+        when :lower
           str.downcase
         else
           str
@@ -111,99 +113,104 @@ module RGeo
 
       private
 
-      def generate_feature(obj, toplevel = false)
+      def generate_feature(obj, support_z, support_m, toplevel: false)
         type = obj.geometry_type
         type = Feature::LineString if type.subtype_of?(Feature::LineString)
         tag = type.type_name.dup
-        if @tag_format == :ewkt
-          tag << "M" if @cur_support_m && !@cur_support_z
+        case @tag_format
+        when :ewkt
+          tag << "M" if support_m && !support_z
           tag = "SRID=#{obj.srid};#{tag}" if toplevel && @emit_ewkt_srid
-        elsif @tag_format == :wkt12
-          if @cur_support_z
-            if @cur_support_m
-              tag << " ZM"
-            else
-              tag << " Z"
-            end
-          elsif @cur_support_m
+        when :wkt12
+          if support_z
+            tag <<
+              if support_m
+                " ZM"
+              else
+                " Z"
+              end
+          elsif support_m
             tag << " M"
           end
         end
         if type == Feature::Point
-          "#{tag} #{generate_point(obj)}"
+          "#{tag} #{generate_point(obj, support_z, support_m)}"
         elsif type == Feature::LineString
-          "#{tag} #{generate_line_string(obj)}"
+          "#{tag} #{generate_line_string(obj, support_z, support_m)}"
         elsif type == Feature::Polygon
-          "#{tag} #{generate_polygon(obj)}"
+          "#{tag} #{generate_polygon(obj, support_z, support_m)}"
         elsif type == Feature::GeometryCollection
-          "#{tag} #{generate_geometry_collection(obj)}"
+          "#{tag} #{generate_geometry_collection(obj, support_z, support_m)}"
         elsif type == Feature::MultiPoint
-          "#{tag} #{generate_multi_point(obj)}"
+          "#{tag} #{generate_multi_point(obj, support_z, support_m)}"
         elsif type == Feature::MultiLineString
-          "#{tag} #{generate_multi_line_string(obj)}"
+          "#{tag} #{generate_multi_line_string(obj, support_z, support_m)}"
         elsif type == Feature::MultiPolygon
-          "#{tag} #{generate_multi_polygon(obj)}"
+          "#{tag} #{generate_multi_polygon(obj, support_z, support_m)}"
         else
           raise Error::ParseError, "Unrecognized geometry type: #{type}"
         end
       end
 
-      def generate_coords(obj)
+      def generate_coords(obj, support_z, support_m)
         str = +"#{obj.x} #{obj.y}"
-        str << " #{obj.z}" if @cur_support_z
-        str << " #{obj.m}" if @cur_support_m
+        str << " #{obj.z}" if support_z
+        str << " #{obj.m}" if support_m
         str
       end
 
-      def generate_point(obj)
-        "#{@begin_bracket}#{generate_coords(obj)}#{@end_bracket}"
+      def generate_point(obj, support_z, support_m)
+        "#{@begin_bracket}#{generate_coords(obj, support_z, support_m)}#{@end_bracket}"
       end
 
-      def generate_line_string(obj)
+      def generate_line_string(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{obj.points.map { |p| generate_coords(p) }.join(', ')}#{@end_bracket}"
+          points = obj.points.map { |p| generate_coords(p, support_z, support_m) }
+          "#{@begin_bracket}#{points.join(', ')}#{@end_bracket}"
         end
       end
 
-      def generate_polygon(obj)
+      def generate_polygon(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{([generate_line_string(obj.exterior_ring)] + obj.interior_rings.map { |r| generate_line_string(r) }).join(', ')}#{@end_bracket}"
+          lines = [generate_line_string(obj.exterior_ring, support_z, support_m)]
+          lines += obj.interior_rings.map { |r| generate_line_string(r, support_z, support_m) }
+          "#{@begin_bracket}#{lines.join(', ')}#{@end_bracket}"
         end
       end
 
-      def generate_geometry_collection(obj)
+      def generate_geometry_collection(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{obj.map { |f| generate_feature(f) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj.map { |f| generate_feature(f, support_z, support_m) }.join(', ')}#{@end_bracket}"
         end
       end
 
-      def generate_multi_point(obj)
+      def generate_multi_point(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{obj.map { |f| generate_point(f) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj.map { |f| generate_point(f, support_z, support_m) }.join(', ')}#{@end_bracket}"
         end
       end
 
-      def generate_multi_line_string(obj)
+      def generate_multi_line_string(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{obj.map { |f| generate_line_string(f) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj.map { |f| generate_line_string(f, support_z, support_m) }.join(', ')}#{@end_bracket}"
         end
       end
 
-      def generate_multi_polygon(obj)
+      def generate_multi_polygon(obj, support_z, support_m)
         if obj.empty?
           "EMPTY"
         else
-          "#{@begin_bracket}#{obj.map { |f| generate_polygon(f) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj.map { |f| generate_polygon(f, support_z, support_m) }.join(', ')}#{@end_bracket}"
         end
       end
     end