rgeo 2.3.1 → 3.0.1

data/lib/rgeo/feature/surface.rb

@@ -34,7 +34,6 @@ module RGeo
     # class method (or === operator) defined in the Type module.
     #
     # Some implementations may support higher dimensional points.
-
     module Surface
       include Geometry
       extend Type
@@ -49,7 +48,7 @@ module RGeo
       # Returns a floating-point scalar value.
 
       def area
-        raise Error::UnsupportedOperation, "Method Surface#area not defined."
+        raise Error::UnsupportedOperation, "Method #{self.class.name}#area not defined."
       end
 
       # === SFS 1.1 Description
@@ -62,7 +61,7 @@ module RGeo
       # Returns an object that supports the Point interface.
 
       def centroid
-        raise Error::UnsupportedOperation, "Method Surface#centroid not defined."
+        raise Error::UnsupportedOperation, "Method #{self.class.name}#centroid not defined."
       end
 
       # === SFS 1.1 Description
@@ -74,7 +73,7 @@ module RGeo
       # Returns an object that supports the Point interface.
 
       def point_on_surface
-        raise Error::UnsupportedOperation, "Method Surface#point_on_surface not defined."
+        raise Error::UnsupportedOperation, "Method #{self.class.name}#point_on_surface not defined."
       end
     end
   end

data/lib/rgeo/feature/types.rb

@@ -11,7 +11,6 @@ module RGeo
     # All geometry implementations MUST include this submodule.
     # This serves as a marker that may be used to test an object for
     # feature-ness.
-
     module Instance
     end
 
@@ -49,7 +48,6 @@ module RGeo
     # a particular object is a feature type:
     #
     #   RGeo::Feature::Type === object.geometry_type  # true
-
     module Type
       # Returns true if the given object is this type or a subtype
       # thereof, or if it is a feature object whose geometry_type is
@@ -192,92 +190,78 @@ module RGeo
           # Types are the same
           if nfactory == factory
             force_new ? obj.dup : obj
-          else
-            if type == Point
-              proj = nproj = nil
-              if project
-                proj = factory.proj4
-                nproj = nfactory.proj4
-              end
-              hasz = factory.property(:has_z_coordinate)
-              nhasz = nfactory.property(:has_z_coordinate)
-              if proj && nproj && CoordSys.check!(:proj4)
-                coords = CoordSys::Proj4.transform_coords(proj, nproj, obj.x, obj.y, hasz ? obj.z : nil)
-                coords << (hasz ? obj.z : 0.0) if nhasz && coords.size < 3
-              else
-                coords = [obj.x, obj.y]
-                coords << (hasz ? obj.z : 0.0) if nhasz
-              end
-              coords << (factory.property(:has_m_coordinate) ? obj.m : 0.0) if nfactory.property(:has_m_coordinate)
-              nfactory.point(*coords)
-            elsif type == Line
-              nfactory.line(cast(obj.start_point, nfactory, opts), cast(obj.end_point, nfactory, opts))
-            elsif type == LinearRing
-              nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
-            elsif type == LineString
-              nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
-            elsif type == Polygon
-              nfactory.polygon(cast(obj.exterior_ring, nfactory, opts),
-                                obj.interior_rings.map { |r| cast(r, nfactory, opts) })
-            elsif type == MultiPoint
-              nfactory.multi_point(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == MultiLineString
-              nfactory.multi_line_string(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == MultiPolygon
-              nfactory.multi_polygon(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == GeometryCollection
-              nfactory.collection(obj.map { |g| cast(g, nfactory, opts) })
-            end
+          elsif type == Point
+            z = factory.property(:has_z_coordinate) ? obj.z : nil
+            coords = if project && (cs = factory.coord_sys) && (ncs = nfactory.coord_sys)
+                       cs.transform_coords(ncs, obj.x, obj.y, z)
+                     else
+                       [obj.x, obj.y]
+                     end
+            coords << (z || 0.0) if nfactory.property(:has_z_coordinate) && coords.size < 3
+            m = factory.property(:has_m_coordinate) ? obj.m : nil
+            coords << (m || 0.0) if nfactory.property(:has_m_coordinate)
+            nfactory.point(*coords)
+          elsif type == Line
+            nfactory.line(cast(obj.start_point, nfactory, opts), cast(obj.end_point, nfactory, opts))
+          elsif type == LinearRing
+            nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
+          elsif type == LineString
+            nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
+          elsif type == Polygon
+            nfactory.polygon(
+              cast(obj.exterior_ring, nfactory, opts),
+              obj.interior_rings.map { |r| cast(r, nfactory, opts) }
+            )
+          elsif type == MultiPoint
+            nfactory.multi_point(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == MultiLineString
+            nfactory.multi_line_string(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == MultiPolygon
+            nfactory.multi_polygon(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == GeometryCollection
+            nfactory.collection(obj.map { |g| cast(g, nfactory, opts) })
           end
-        else
-          # Types are different
-          if ntype == Point && (type == MultiPoint || type == GeometryCollection) ||
-              (ntype == Line || ntype == LineString || ntype == LinearRing) && (type == MultiLineString || type == GeometryCollection) ||
-              ntype == Polygon && (type == MultiPolygon || type == GeometryCollection)
-            if obj.num_geometries == 1
-              cast(obj.geometry_n(0), nfactory, ntype, opts)
-            end
-          elsif ntype == Point
-            raise(Error::InvalidGeometry, "Cannot cast to Point")
-          elsif ntype == Line
-            if type == LineString && obj.num_points == 2
-              nfactory.line(cast(obj.point_n(0), nfactory, opts), cast(obj.point_n(1), nfactory, opts))
-            end
-          elsif ntype == LinearRing
-            if type == LineString
-              nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == LineString
-            if type == Line || type == LinearRing
-              nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiPoint
-            if type == Point
-              nfactory.multi_point([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_point(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiLineString
-            if type == Line || type == LinearRing || type == LineString
-              nfactory.multi_line_string([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_line_string(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiPolygon
-            if type == Polygon
-              nfactory.multi_polygon([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_polygon(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == GeometryCollection
-            if type == MultiPoint || type == MultiLineString || type == MultiPolygon
-              nfactory.collection(obj.map { |p| cast(p, nfactory, opts) })
-            else
-              nfactory.collection([cast(obj, nfactory, opts)])
-            end
+        # Types are different
+        elsif ntype == Point && [MultiPoint, GeometryCollection].include?(type) ||
+            [Line, LineString, LinearRing].include?(ntype) && [MultiLineString, GeometryCollection].include?(type) ||
+            ntype == Polygon && [MultiPolygon, GeometryCollection].include?(type)
+          cast(obj.geometry_n(0), nfactory, ntype, opts) if obj.num_geometries == 1
+        elsif ntype == Point
+          raise(Error::InvalidGeometry, "Cannot cast to Point")
+        elsif ntype == Line
+          if type == LineString && obj.num_points == 2
+            nfactory.line(cast(obj.point_n(0), nfactory, opts), cast(obj.point_n(1), nfactory, opts))
+          end
+        elsif ntype == LinearRing
+          nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) }) if type == LineString
+        elsif ntype == LineString
+          nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) }) if [Line, LinearRing].include?(type)
+        elsif ntype == MultiPoint
+          if type == Point
+            nfactory.multi_point([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_point(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == MultiLineString
+          if [Line, LinearRing, LineString].include?(type)
+            nfactory.multi_line_string([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_line_string(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == MultiPolygon
+          if type == Polygon
+            nfactory.multi_polygon([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_polygon(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == GeometryCollection
+          if [MultiPoint, MultiLineString, MultiPolygon].include?(type)
+            nfactory.collection(obj.map { |p| cast(p, nfactory, opts) })
           else
-            raise(RGeo::Error::InvalidGeometry, "Undefined type cast from #{type.name} to #{ntype.name}")
+            nfactory.collection([cast(obj, nfactory, opts)])
           end
+        else
+          raise(RGeo::Error::InvalidGeometry, "Undefined type cast from #{type.name} to #{ntype.name}")
         end
       end
     end

data/lib/rgeo/geographic/factory.rb

@@ -11,13 +11,20 @@ module RGeo
     # This class implements the various factories for geography features.
     # See methods of the RGeo::Geographic module for the API for creating
     # geography factories.
-
     class Factory
       include Feature::Factory::Instance
       include ImplHelper::Utils
 
       attr_writer :projector
 
+      attr_reader :coordinate_dimension, :spatial_dimension
+
+      # Returns the srid reported by this factory.
+      attr_reader :srid
+
+      # See RGeo::Feature::Factory#coord_sys
+      attr_reader :coord_sys
+
       def initialize(impl_prefix, opts = {}) # :nodoc:
         @impl_prefix = impl_prefix
         @point_class = Geographic.const_get("#{impl_prefix}PointImpl")
@@ -31,67 +38,69 @@ module RGeo
         @multi_polygon_class = Geographic.const_get("#{impl_prefix}MultiPolygonImpl")
         @support_z = opts[:has_z_coordinate] ? true : false
         @support_m = opts[:has_m_coordinate] ? true : false
-        @srid = (opts[:srid] || 4326).to_i
-        @proj4 = opts[:proj4]
-        if @proj4 && CoordSys.check!(:proj4)
-          if @proj4.is_a?(String) || @proj4.is_a?(Hash)
-            @proj4 = CoordSys::Proj4.create(@proj4)
-          end
-        end
-        @coord_sys = opts[:coord_sys]
-        if @coord_sys.is_a?(String)
-          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
-        end
-        @lenient_assertions = opts[:uses_lenient_assertions] ? true : false
+        @coordinate_dimension = 2
+        @coordinate_dimension += 1 if @support_z
+        @coordinate_dimension += 1 if @support_m
+        @spatial_dimension = @support_z ? 3 : 2
+
+        srid = opts.fetch(:srid, 4326).to_i
+        coord_sys_info = ImplHelper::Utils.setup_coord_sys(srid, opts[:coord_sys], opts[:coord_sys_class])
+        @coord_sys = coord_sys_info[:coord_sys]
+        @srid = coord_sys_info[:srid]
+
         @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
 
         wkt_generator = opts[:wkt_generator]
-        case wkt_generator
-        when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
-        else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-        end
+        @wkt_generator =
+          case wkt_generator
+          when Hash
+            WKRep::WKTGenerator.new(wkt_generator)
+          else
+            WKRep::WKTGenerator.new(convert_case: :upper)
+          end
         wkb_generator = opts[:wkb_generator]
-        case wkb_generator
-        when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
-        else
-          @wkb_generator = WKRep::WKBGenerator.new
-        end
+        @wkb_generator =
+          case wkb_generator
+          when Hash
+            WKRep::WKBGenerator.new(wkb_generator)
+          else
+            WKRep::WKBGenerator.new
+          end
         wkt_parser = opts[:wkt_parser]
-        case wkt_parser
-        when Hash
-          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
-        else
-          @wkt_parser = WKRep::WKTParser.new(self)
-        end
+        @wkt_parser =
+          case wkt_parser
+          when Hash
+            WKRep::WKTParser.new(self, wkt_parser)
+          else
+            WKRep::WKTParser.new(self)
+          end
         wkb_parser = opts[:wkb_parser]
-        case wkb_parser
-        when Hash
-          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
-        else
-          @wkb_parser = WKRep::WKBParser.new(self)
-        end
+        @wkb_parser =
+          case wkb_parser
+          when Hash
+            WKRep::WKBParser.new(self, wkb_parser)
+          else
+            WKRep::WKBParser.new(self)
+          end
         @projector = nil
       end
 
       # Equivalence test.
 
-      def eql?(rhs_)
-        rhs_.is_a?(Geographic::Factory) &&
-          @impl_prefix == rhs_.instance_variable_get(:@impl_prefix) &&
-          @support_z == rhs_.instance_variable_get(:@support_z) &&
-          @support_m == rhs_.instance_variable_get(:@support_m) &&
-          @proj4 == rhs_.instance_variable_get(:@proj4)
+      def eql?(other)
+        other.is_a?(Geographic::Factory) &&
+          @impl_prefix == other.instance_variable_get(:@impl_prefix) &&
+          @support_z == other.instance_variable_get(:@support_z) &&
+          @support_m == other.instance_variable_get(:@support_m) &&
+          @coord_sys == other.instance_variable_get(:@coord_sys)
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [@impl_prefix, @support_z, @support_m, @proj4].hash
+        @hash ||= [@impl_prefix, @support_z, @support_m, @coord_sys].hash
       end
 
       # Marshal support
@@ -106,10 +115,8 @@ module RGeo
           "wkbg" => @wkb_generator.properties,
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
-          "lena" => @lenient_assertions,
           "bufr" => @buffer_resolution
         }
-        hash_["proj4"] = @proj4.marshal_dump if @proj4
         hash_["cs"] = @coord_sys.to_wkt if @coord_sys
         if @projector
           hash_["prjc"] = @projector.class.name.sub(/.*::/, "")
@@ -119,18 +126,11 @@ module RGeo
       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)
-        else
-          coord_sys = nil
-        end
-        initialize(data_["pref"],
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = data_["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
+        initialize(
+          data_["pref"],
           has_z_coordinate: data_["hasz"],
           has_m_coordinate: data_["hasm"],
           srid: data_["srid"],
@@ -138,19 +138,21 @@ module RGeo
           wkb_generator: symbolize_hash(data_["wkbg"]),
           wkt_parser: symbolize_hash(data_["wktp"]),
           wkb_parser: symbolize_hash(data_["wkbp"]),
-          uses_lenient_assertions: data_["lena"],
           buffer_resolution: data_["bufr"],
-          proj4: proj4,
           coord_sys: coord_sys
         )
-        if (proj_klass = data_["prjc"]) && (proj_factory = data_["prjf"])
-          klass_ = RGeo::Geographic.const_get(proj_klass)
-          if klass_
-            projector = klass_.allocate
-            projector.set_factories(self, proj_factory)
-            @projector = projector
-          end
-        end
+        proj_klass = data_["prjc"]
+        proj_factory = data_["prjf"]
+
+        return unless proj_klass && proj_factory
+
+        klass_ = RGeo::Geographic.const_get(proj_klass)
+
+        return unless klass_
+
+        projector = klass_.allocate
+        projector.set_factories(self, proj_factory)
+        @projector = projector
       end
 
       # Psych support
@@ -164,36 +166,21 @@ module RGeo
         coder["wkb_generator"] = @wkb_generator.properties
         coder["wkt_parser"] = @wkt_parser.properties
         coder["wkb_parser"] = @wkb_parser.properties
-        coder["lenient_assertions"] = @lenient_assertions
         coder["buffer_resolution"] = @buffer_resolution
-        if @proj4
-          str = @proj4.original_str || @proj4.canonical_str
-          coder["proj4"] = @proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
         coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
-        if @projector
-          coder["projectorclass"] = @projector.class.name.sub(/.*::/, "")
-          coder["projection_factory"] = @projector.projection_factory
-        end
+
+        return unless @projector
+
+        coder["projectorclass"] = @projector.class.name.sub(/.*::/, "")
+        coder["projection_factory"] = @projector.projection_factory
       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)
-        else
-          coord_sys = nil
-        end
-        initialize(coder["impl_prefix"],
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = coder["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
+        initialize(
+          coder["impl_prefix"],
           has_z_coordinate: coder["has_z_coordinate"],
           has_m_coordinate: coder["has_m_coordinate"],
           srid: coder["srid"],
@@ -201,24 +188,22 @@ module RGeo
           wkb_generator: symbolize_hash(coder["wkb_generator"]),
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
-          uses_lenient_assertions: coder["lenient_assertions"],
           buffer_resolution: coder["buffer_resolution"],
-          proj4: proj4,
           coord_sys: coord_sys
         )
-        if (proj_klass = coder["projectorclass"]) && (proj_factory = coder["projection_factory"])
-          klass_ = RGeo::Geographic.const_get(proj_klass)
-          if klass_
-            projector = klass_.allocate
-            projector.set_factories(self, proj_factory)
-            @projector = projector
-          end
-        end
-      end
+        proj_klass = coder["projectorclass"]
+        proj_factory = coder["projection_factory"]
 
-      # Returns the srid reported by this factory.
+        return unless proj_klass && proj_factory
 
-      attr_reader :srid
+        klass_ = RGeo::Geographic.const_get(proj_klass)
+
+        return unless klass_
+
+        projector = klass_.allocate
+        projector.set_factories(self, proj_factory)
+        @projector = projector
+      end
 
       # Returns true if this factory supports a projection.
 
@@ -241,9 +226,7 @@ module RGeo
 
       def project(geometry)
         return unless @projector && geometry
-        unless geometry.factory == self
-          raise Error::InvalidGeometry, "Wrong geometry type"
-        end
+        raise Error::InvalidGeometry, "Wrong geometry type" unless geometry.factory == self
         @projector.project(geometry)
       end
 
@@ -254,9 +237,11 @@ module RGeo
 
       def unproject(geometry)
         return unless geometry
+
         unless @projector && @projector.projection_factory == geometry.factory
           raise Error::InvalidGeometry, "You can unproject only features that are in the projected coordinate space."
         end
+
         @projector.unproject(geometry)
       end
 
@@ -277,12 +262,10 @@ module RGeo
       # projection limits are not known.
 
       def projection_limits_window
-        if @projector
-          unless defined?(@projection_limits_window)
-            @projection_limits_window = @projector.limits_window
-          end
-          @projection_limits_window
-        end
+        return @projection_limits_window if defined?(@projection_limits_window)
+        return unless @projector
+
+        @projection_limits_window = @projector.limits_window
       end
 
       # See RGeo::Feature::Factory#property
@@ -293,8 +276,6 @@ module RGeo
           @support_z
         when :has_m_coordinate
           @support_m
-        when :uses_lenient_assertions
-          @lenient_assertions
         when :buffer_resolution
           @buffer_resolution
         when :is_geographic
@@ -368,14 +349,6 @@ module RGeo
         @multi_polygon_class.new(self, elems)
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      attr_reader :proj4
-
-      # See RGeo::Feature::Factory#coord_sys
-
-      attr_reader :coord_sys
-
       def generate_wkt(obj)
         @wkt_generator.generate(obj)
       end