rgeo 3.0.0.pre.rc.2 → 3.0.0.pre.rc.3

data/lib/rgeo/geos/zm_factory.rb

@@ -41,7 +41,6 @@ module RGeo
       end
 
       def initialize(opts = {}) # :nodoc:
-        proj4 = opts[:proj4]
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
         srid ||= coord_sys.authority_code if coord_sys
@@ -49,7 +48,7 @@ module RGeo
           buffer_resolution: opts[:buffer_resolution], auto_prepare: opts[:auto_prepare],
           wkt_generator: opts[:wkt_generator], wkt_parser: opts[:wkt_parser],
           wkb_generator: opts[:wkb_generator], wkb_parser: opts[:wkb_parser],
-          srid: srid.to_i, proj4: proj4, coord_sys: coord_sys
+          srid: srid.to_i, coord_sys: coord_sys
         }
         native_interface = opts[:native_interface] || Geos.preferred_native_interface
         if native_interface == :ffi
@@ -103,22 +102,14 @@ module RGeo
           "apre" => @zfactory.property(:auto_prepare) == :simple,
           "nffi" => @zfactory.is_a?(FFIFactory)
         }
-        proj4 = @zfactory.proj4
         coord_sys = @zfactory.coord_sys
-        hash["proj4"] = proj4.marshal_dump if proj4
         hash["cs"] = coord_sys.to_wkt if coord_sys
         hash
       end
 
       def marshal_load(data) # :nodoc:
-        if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
-          proj4 = CoordSys::Proj4.allocate
-          proj4.marshal_load(proj4_data)
-        else
-          proj4 = nil
-        end
         if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
         else
           coord_sys = nil
         end
@@ -133,7 +124,6 @@ module RGeo
           wkt_parser: symbolize_hash(data["wktp"]),
           wkb_parser: symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -149,28 +139,14 @@ module RGeo
         coder["wkb_parser"] = @wkb_parser.properties
         coder["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
         coder["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
-        if (proj4 = @zfactory.proj4)
-          str = proj4.original_str || proj4.canonical_str
-          coder["proj4"] = proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
         if (coord_sys = @zfactory.coord_sys)
           coder["coord_sys"] = coord_sys.to_wkt
         end
       end
 
       def init_with(coder) # :nodoc:
-        if (proj4_data = coder["proj4"])
-          CoordSys.check!(:proj4)
-          if proj4_data.is_a?(Hash)
-            proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
-          else
-            proj4 = CoordSys::Proj4.create(proj4_data.to_s)
-          end
-        else
-          proj4 = nil
-        end
         if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data.to_s)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
         else
           coord_sys = nil
         end
@@ -185,7 +161,6 @@ module RGeo
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
           auto_prepare: coder["auto_prepare"] == "disabled" ? :disabled : :simple,
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -303,12 +278,6 @@ module RGeo
         create_feature(ZMMultiPolygonImpl, @zfactory.multi_polygon(elems), @mfactory.multi_polygon(elems))
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        @zfactory.proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
@@ -328,7 +297,7 @@ module RGeo
           # Optimization if we're just changing factories, but to
           # another ZM factory.
           if original.factory != self && ntype == type &&
-              (!project || original.factory.proj4 == @proj4)
+              (!project || original.factory.coord_sys == @coord_sys)
             zresult = original.z_geometry.dup
             zresult.factory = @zfactory
             mresult = original.m_geometry.dup
@@ -337,7 +306,7 @@ module RGeo
           end
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
-              (!project || original.factory.proj4 == @proj4) &&
+              (!project || original.factory.coord_sys == @coord_sys) &&
               type.subtypeof?(Feature::LineString) && ntype.subtypeof?(Feature::LineString)
             klass = Factory::IMPL_CLASSES[ntype]
             zresult = klass._copy_from(@zfactory, original.z_geometry)

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -26,7 +26,7 @@ module RGeo
       end
 
       def hash
-        @factory.hash ^ @zgeometry.hash ^ @mgeometry.hash
+        [@factory, @zgeometry, @mgeometry].hash
       end
 
       def factory
@@ -77,20 +77,10 @@ module RGeo
         @zgeometry.empty?
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def simple?
         @zgeometry.simple?
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
-      end
-
       def is_3d?
         true
       end
@@ -252,20 +242,10 @@ module RGeo
         @zgeometry.closed?
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def ring?
         @zgeometry.ring?
       end
 
-      def is_ring?
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      end
-
       def num_points
         @zgeometry.num_points
       end
@@ -363,11 +343,6 @@ module RGeo
         @zgeometry.closed?
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def coordinates
         each.map(&:coordinates)
       end

data/lib/rgeo/geos.rb

@@ -45,12 +45,9 @@ module RGeo
       raise "Problem loading FFI" unless ::FFI::AutoPointer
       FFI_SUPPORTED = true
       FFI_SUPPORT_EXCEPTION = nil
-    rescue LoadError => ex
+    rescue LoadError, StandardError => e
       FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex
-    rescue StandardError => ex
-      FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex
+      FFI_SUPPORT_EXCEPTION = e
     end
 
     if FFI_SUPPORTED

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -55,11 +55,6 @@ module RGeo
         @elements.size == 0
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def rep_equals?(rhs)
         if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @elements.size == rhs.num_geometries
           rhs.each_with_index { |p, i| return false unless @elements[i].rep_equals?(p) }
@@ -69,10 +64,7 @@ module RGeo
       end
 
       def hash
-        @hash ||= begin
-          hash = [factory, geometry_type].hash
-          @elements.inject(hash) { |h, g| (1_664_525 * h + g.hash).hash }
-        end
+        @hash ||= [factory, geometry_type, *@elements].hash
       end
 
       private
@@ -102,11 +94,6 @@ module RGeo
         all?(&:closed?)
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def length
         @elements.inject(0.0) { |sum, obj| sum + obj.length }
       end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -49,11 +49,6 @@ module RGeo
         @points.size == 0
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def boundary
         array = []
         array << @points.first << @points.last if !empty? && !closed?
@@ -75,20 +70,10 @@ module RGeo
         @closed
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def ring?
         closed? && simple?
       end
 
-      def is_ring?
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      end
-
       def rep_equals?(rhs)
         if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @points.size == rhs.num_points
           rhs.points.each_with_index { |p, i| return false unless @points[i].rep_equals?(p) }
@@ -98,10 +83,7 @@ module RGeo
       end
 
       def hash
-        @hash ||= begin
-          hash = [factory, geometry_type].hash
-          @points.inject(hash) { |h, p| (1_664_525 * h + p.hash).hash }
-        end
+        @hash ||= [factory, geometry_type, *@points].hash
       end
 
       def coordinates

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -49,20 +49,10 @@ module RGeo
         false
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def simple?
         true
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
-      end
-
       def envelope
         self
       end

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -53,11 +53,6 @@ module RGeo
         @exterior_ring.empty?
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def boundary
         array = []
         array << @exterior_ring unless @exterior_ring.empty?
@@ -74,10 +69,7 @@ module RGeo
       end
 
       def hash
-        @hash ||= begin
-          hash = [geometry_type, @exterior_ring].hash
-          @interior_rings.inject(hash) { |h, r| (1_664_525 * h + r.hash).hash }
-        end
+        @hash ||= [geometry_type, @exterior_ring, *@interior_rings].hash
       end
 
       def coordinates

data/lib/rgeo/impl_helper/utils.rb

@@ -9,6 +9,33 @@
 module RGeo
   module ImplHelper # :nodoc:
     module Utils # :nodoc:
+      # Helper function to create coord_sys from
+      # common options in most factories. Returns
+      # a hash with finalized coord sys info after processing.
+      #
+      # The reason we return the data as a hash instead of assigning
+      # instance variables is because some classes need to do this
+      # multiple times with different values and others pass the data
+      # to a CAPI or FFI.
+      def self.setup_coord_sys(srid, coord_sys, coord_sys_class)
+        unless coord_sys_class.is_a?(Class)
+          coord_sys_class = CoordSys::CONFIG.default_coord_sys_class
+        end
+
+        if coord_sys.is_a?(String)
+          coord_sys = coord_sys_class.create_from_wkt(coord_sys)
+        end
+
+        srid ||= coord_sys.authority_code if coord_sys
+        srid = srid.to_i
+        # Create a coord sys based on the SRID if one was not given
+        if coord_sys.nil? && srid != 0
+          coord_sys = coord_sys_class.create(srid)
+        end
+
+        { coord_sys: coord_sys, srid: srid }
+      end
+
       private
 
       def symbolize_hash(hash)

data/lib/rgeo/impl_helper/validity_check.rb

@@ -31,7 +31,7 @@ module RGeo
         # Trivial methods
         :num_points, :locate_along, :locate_between,
         # Comparison
-        :equals?, :rep_equals?, :eql?, :==, :'!='
+        :equals?, :rep_equals?, :eql?, :==, :"!="
       ].freeze
       private_constant :UNCHECKED_METHODS
 
@@ -109,7 +109,7 @@ module RGeo
       def invalid_reason
         if defined?(super) == "super"
           raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
-            "definition of #{self.class}##{__method__}."
+                                  "definition of #{self.class}##{__method__}."
         end
 
         raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."
@@ -120,7 +120,7 @@ module RGeo
       def make_valid
         if defined?(super) == "super"
           raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
-            "definition of #{self.class}##{__method__}."
+                                  "definition of #{self.class}##{__method__}."
         end
 
         raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "3.0.0-rc.2"
+  VERSION = "3.0.0-rc.3"
 end

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -100,59 +100,74 @@ 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, 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.unpack("H*")[0] : str
+        end
+
+        def z?
+          @has_z
+        end
+
+        def m?
+          @has_m
+        end
+      end
+      private_constant :Result
+
+      def emit_byte(value, rv)
+        rv << [value].pack("C")
       end
 
-      def emit_integer(value)
-        @cur_array << [value].pack(@little_endian ? "V" : "N")
+      def emit_integer(value, rv)
+        rv << [value].pack(@little_endian ? "V" : "N")
       end
 
-      def emit_doubles(array)
-        @cur_array << array.pack(@little_endian ? "E*" : "G*")
+      def emit_doubles(array, rv)
+        rv << array.pack(@little_endian ? "E*" : "G*")
       end
 
-      def emit_line_string_coords(obj)
+      def emit_line_string_coords(obj, rv)
         array = []
-        obj.points.each { |p| point_coords(p, array) }
-        emit_integer(obj.num_points)
-        emit_doubles(array)
+        obj.points.each { |pt| point_coords(pt, rv, array) }
+        emit_integer(obj.num_points, rv)
+        emit_doubles(array, rv)
       end
 
-      def point_coords(obj, array = [])
+      def point_coords(obj, rv, 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 rv.z?
+        array << obj.m if rv.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, rv, toplevel = false)
+        emit_byte(@little_endian ? 1 : 0, rv)
         type = obj.geometry_type
         type_code = TYPE_CODES[type]
         unless type_code
@@ -160,43 +175,43 @@ module RGeo
         end
         emit_srid = false
         if @type_format == :ewkb
-          type_code |= 0x80000000 if @cur_has_z
-          type_code |= 0x40000000 if @cur_has_m
+          type_code |= 0x80000000 if rv.z?
+          type_code |= 0x40000000 if rv.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
+          type_code += 1000 if rv.z?
+          type_code += 2000 if rv.m?
         end
-        emit_integer(type_code)
-        emit_integer(obj.srid) if emit_srid
+        emit_integer(type_code, rv)
+        emit_integer(obj.srid, rv) if emit_srid
         if type == Feature::Point
-          emit_doubles(point_coords(obj))
+          emit_doubles(point_coords(obj, rv), rv)
         elsif type.subtype_of?(Feature::LineString)
-          emit_line_string_coords(obj)
+          emit_line_string_coords(obj, rv)
         elsif type == Feature::Polygon
           exterior_ring = obj.exterior_ring
           if exterior_ring.empty?
-            emit_integer(0)
+            emit_integer(0, rv)
           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, rv)
+            emit_line_string_coords(exterior_ring, rv)
+            obj.interior_rings.each { |r| emit_line_string_coords(r, rv) }
           end
         elsif type == Feature::GeometryCollection
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
+          emit_integer(obj.num_geometries, rv)
+          obj.each { |g| generate_feature(g, rv) }
         elsif type == Feature::MultiPoint
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
+          emit_integer(obj.num_geometries, rv)
+          obj.each { |g| generate_feature(g, rv) }
         elsif type == Feature::MultiLineString
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
+          emit_integer(obj.num_geometries, rv)
+          obj.each { |g| generate_feature(g, rv) }
         elsif type == Feature::MultiPolygon
-          emit_integer(obj.num_geometries)
-          obj.each { |g| generate_feature(g) }
+          emit_integer(obj.num_geometries, rv)
+          obj.each { |g| generate_feature(g, rv) }
         end
       end
     end

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -62,6 +62,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,25 +106,27 @@ 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
+              if bytes > 0
+                raise Error::ParseError, "Found #{bytes} extra bytes at the end of the stream."
+              end
             end
+          ensure
+            @data = nil
           end
-        ensure
-          @data = nil
+          obj
         end
-        obj
       end
       alias parse_hex parse