rgeo 1.1.2 → 2.0.0

data/lib/rgeo/feature/geometry_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # GeometryCollection feature interface
@@ -31,7 +33,7 @@ module RGeo
       include Geometry
       extend Type
 
-      include ::Enumerable
+      include Enumerable
 
       # === SFS 1.1 Description
       #
@@ -56,7 +58,7 @@ module RGeo
       # Also note that this method is different from GeometryCollection#[]
       # in that it does not support negative indexes.
 
-      def geometry_n(_n_)
+      def geometry_n(n)
         raise Error::UnsupportedOperation, "Method GeometryCollection#geometry_n not defined."
       end
 
@@ -76,7 +78,7 @@ module RGeo
       # the same way Ruby's array indexing works. Hence, geometry_n(-1)
       # returns nil, where [-1] returns the last element of the collection.
 
-      def [](_n_)
+      def [](n)
         raise Error::UnsupportedOperation, "Method GeometryCollection#[] not defined."
       end
 
@@ -93,7 +95,7 @@ module RGeo
       # Note that all GeometryCollection implementations must also
       # include the Enumerable mixin.
 
-      def each(&_block_)
+      def each(&block)
         raise Error::UnsupportedOperation, "Method GeometryCollection#each not defined."
       end
     end

data/lib/rgeo/feature/line.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Line feature interface

data/lib/rgeo/feature/line_string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # LineString feature interface
@@ -45,7 +47,7 @@ module RGeo
       # if the given N is out of range. N is zero-based.
       # Does not support negative indexes.
 
-      def point_n(_n_)
+      def point_n(n)
         raise Error::UnsupportedOperation, "Method LineString#point_n not defined."
       end
 

data/lib/rgeo/feature/linear_ring.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # LinearRing feature interface

data/lib/rgeo/feature/multi_curve.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # MultiCurve feature interface

data/lib/rgeo/feature/multi_line_string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # MultiLineString feature interface

data/lib/rgeo/feature/multi_point.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # MultiPoint feature interface

data/lib/rgeo/feature/multi_polygon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # MultiPolygon feature interface

data/lib/rgeo/feature/multi_surface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # MultiSurface feature interface

data/lib/rgeo/feature/point.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Point feature interface

data/lib/rgeo/feature/polygon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Polygon feature interface
@@ -82,7 +84,7 @@ module RGeo
       # if the given N is out of range. N is zero-based.
       # Does not support negative indexes.
 
-      def interior_ring_n(_n_)
+      def interior_ring_n(n)
         raise Error::UnsupportedOperation, "Method Polygon#interior_ring_n not defined."
       end
 

data/lib/rgeo/feature/surface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Surface feature interface

data/lib/rgeo/feature/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Feature type management and casting
@@ -56,17 +58,17 @@ module RGeo
       # Note that feature objects need not actually include this module.
       # Therefore, the is_a? method will generally not work.
 
-      def check_type(rhs_)
-        rhs_ = rhs_.geometry_type if rhs_.is_a?(Feature::Instance)
-        rhs_.is_a?(Type) && (rhs_ == self || rhs_.include?(self))
+      def check_type(rhs)
+        rhs = rhs.geometry_type if rhs.is_a?(Feature::Instance)
+        rhs.is_a?(Type) && (rhs == self || rhs.include?(self))
       end
       alias === check_type
 
       # Returns true if this type is the same type or a subtype of the
       # given type.
 
-      def subtype_of?(type_)
-        self == type_ || self.include?(type_)
+      def subtype_of?(type)
+        self == type || include?(type)
       end
 
       # Returns the supertype of this type. The supertype of Geometry
@@ -78,8 +80,8 @@ module RGeo
 
       # Iterates over the known immediate subtypes of this type.
 
-      def each_immediate_subtype(&block_)
-        @subtypes.each(&block_) if defined?(@subtypes) && @subtypes
+      def each_immediate_subtype(&block)
+        @subtypes&.each(&block)
       end
 
       # Returns the OpenGIS type name of this type. For example:
@@ -91,14 +93,14 @@ module RGeo
       end
       alias to_s type_name
 
-      def _add_subtype(type_) # :nodoc:
-        (@subtypes ||= []) << type_
+      def add_subtype(type) # :nodoc:
+        (@subtypes ||= []) << type
       end
 
-      def self.extended(type_) # :nodoc:
-        supertype_ = type_.included_modules.find { |m_| m_.is_a?(self) }
-        type_.instance_variable_set(:@supertype, supertype_)
-        supertype_._add_subtype(type_) if supertype_
+      def self.extended(type) # :nodoc:
+        supertype = type.included_modules.find { |m| m.is_a?(self) }
+        type.instance_variable_set(:@supertype, supertype)
+        supertype&.add_subtype(type)
       end
     end
 
@@ -155,124 +157,126 @@ module RGeo
       # casting behavior by defining the override_cast method. See
       # RGeo::Feature::Factory#override_cast for more details.
 
-      def cast(obj_, *params_)
+      def cast(obj, *params)
         # Interpret params
-        factory_ = obj_.factory
-        type_ = obj_.geometry_type
-        opts_ = {}
-        params_.each do |param_|
-          case param_
+        factory = obj.factory
+        type = obj.geometry_type
+        opts = {}
+        params.each do |param|
+          case param
           when Factory::Instance
-            opts_[:factory] = param_
+            opts[:factory] = param
           when Type
-            opts_[:type] = param_
-          when ::Symbol
-            opts_[param_] = true
-          when ::Hash
-            opts_.merge!(param_)
+            opts[:type] = param
+          when Symbol
+            opts[param] = true
+          when Hash
+            opts.merge!(param)
           end
         end
-        force_new_ = opts_[:force_new]
-        keep_subtype_ = opts_[:keep_subtype]
-        project_ = opts_[:project]
-        nfactory_ = opts_.delete(:factory) || factory_
-        ntype_ = opts_.delete(:type) || type_
+        force_new = opts[:force_new]
+        keep_subtype = opts[:keep_subtype]
+        project = opts[:project]
+        nfactory = opts.delete(:factory) || factory
+        ntype = opts.delete(:type) || type
 
         # Let the factory override
-        if nfactory_.respond_to?(:override_cast)
-          override_ = nfactory_.override_cast(obj_, ntype_, opts_)
-          return override_ unless override_ == false
+        if nfactory.respond_to?(:override_cast)
+          override = nfactory.override_cast(obj, ntype, opts)
+          return override unless override == false
         end
 
         # Default algorithm
-        ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
-        if ntype_ == type_
+        ntype = type if keep_subtype && type.include?(ntype)
+        if ntype == type
           # Types are the same
-          if nfactory_ == factory_
-            force_new_ ? obj_.dup : obj_
+          if nfactory == factory
+            force_new ? obj.dup : obj
           else
-            if type_ == Point
-              proj_ = nproj_ = nil
-              if project_
-                proj_ = factory_.proj4
-                nproj_ = nfactory_.proj4
+            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
+              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_
+                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_) })
+              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
           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_)
+          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
-            nil
-          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_))
+          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_) })
+          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_) })
+          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_) })
+          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_) })
+          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_) })
+          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_) })
+          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_)])
+              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.rb

@@ -1,33 +1,23 @@
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
+
+# The Geographic module includes a suite of
+# implementations with one common feature: they represent geographic
+# latitude/longitude coordinates measured in degrees. The "x"
+# coordinate corresponds to longitude, and the "y" coordinate to
+# latitude. Thus, coordinates are often expressed in reverse
+# (i.e. long-lat) order. e.g.
 #
-# Geographic data for RGeo
+#  location = geographic_factory.point(long, lat)
 #
-# -----------------------------------------------------------------------------
-
-module RGeo
-  # The Geographic implementation actually comprises a suite of
-  # implementations with one common feature: they represent geographic
-  # latitude/longitude coordinates measured in degrees. The "x"
-  # coordinate corresponds to longitude, and the "y" coordinate to
-  # latitude. Thus, coordinates are often expressed in reverse
-  # (i.e. long-lat) order. e.g.
-  #
-  #  location = geographic_factory.point(long, lat)
-  #
-  # Some geographic implementations include a secondary factory that
-  # represents a projection. For these implementations, you can quickly
-  # transform data between lat/long coordinates and the projected
-  # coordinate system, and most calculations are done in the projected
-  # coordinate system. For implementations that do not include this
-  # secondary projection factory, calculations are done on the sphereoid.
-  # See the various class methods of Geographic for more information on
-  # the behaviors of the factories they generate.
-
-  module Geographic
-  end
-end
+# Some geographic implementations include a secondary factory that
+# represents a projection. For these implementations, you can quickly
+# transform data between lat/long coordinates and the projected
+# coordinate system, and most calculations are done in the projected
+# coordinate system. For implementations that do not include this
+# secondary projection factory, calculations are done on the sphereoid.
+# See the various class methods of Geographic for more information on
+# the behaviors of the factories they generate.
 
-# Implementation files.
 require "rgeo/geographic/factory"
 require "rgeo/geographic/projected_window"
 require "rgeo/geographic/interface"