rgeo-dschee 0.5.4

data/lib/rgeo/feature/geometry_collection.rb

@@ -0,0 +1,95 @@
+# -----------------------------------------------------------------------------
+#
+# GeometryCollection feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A GeometryCollection is a geometric object that is a collection of 1
+    # or more geometric objects.
+    #
+    # All the elements in a GeometryCollection shall be in the same Spatial
+    # Reference. This is also the Spatial Reference for the GeometryCollection.
+    #
+    # GeometryCollection places no other constraints on its elements.
+    # Subclasses of GeometryCollection may restrict membership based on
+    # dimension and may also place other constraints on the degree of spatial
+    # overlap between elements.
+    #
+    # == Notes
+    #
+    # GeometryCollection is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module GeometryCollection
+      include Geometry
+      extend Type
+
+      include ::Enumerable
+
+      # === SFS 1.1 Description
+      #
+      # Returns the number of geometries in this GeometryCollection.
+      #
+      # === Notes
+      #
+      # Returns an integer.
+
+      def num_geometries
+        raise Error::UnsupportedOperation, "Method GeometryCollection#num_geometries not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # Returns the Nth geometry in this GeometryCollection.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Geometry interface, or nil
+      # if the given N is out of range. N is zero-based.
+      # Also note that this method is different from GeometryCollection#[]
+      # in that it does not support negative indexes.
+
+      def geometry_n(_n_)
+        raise Error::UnsupportedOperation, "Method GeometryCollection#geometry_n not defined."
+      end
+
+      # Alias of the num_geometries method.
+
+      def size
+        num_geometries
+      end
+
+      # Returns the Nth geometry in this GeometryCollection, or nil if the
+      # given N is out of range. N is zero-based.
+      #
+      # This behaves slightly different from GeometryCollection#geometry_n.
+      # GeometryCollection#geometry_n accepts only nonnegative indexes,
+      # as specified by the SFS. However, GeometryCollection#[] also accepts
+      # negative indexes counting backwards from the end of the collection,
+      # 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_)
+        raise Error::UnsupportedOperation, "Method GeometryCollection#[] not defined."
+      end
+
+      # Iterates over the geometries of this GeometryCollection.
+      #
+      # This is not a standard SFS method, but is provided so that a
+      # GeometryCollection can behave as a Ruby enumerable.
+      # Note that all GeometryCollection implementations must also
+      # include the Enumerable mixin.
+
+      def each(&_block_)
+        raise Error::UnsupportedOperation, "Method GeometryCollection#each not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/line.rb

@@ -0,0 +1,26 @@
+# -----------------------------------------------------------------------------
+#
+# Line feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A Line is a LineString with exactly 2 Points.
+    #
+    # == Notes
+    #
+    # Line is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module Line
+      include LineString
+      extend Type
+    end
+  end
+end

data/lib/rgeo/feature/line_string.rb

@@ -0,0 +1,60 @@
+# -----------------------------------------------------------------------------
+#
+# LineString feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A LineString is a Curve with linear interpolation between Points.
+    # Each consecutive pair of Points defines a Line segment.
+    #
+    # == Notes
+    #
+    # LineString is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module LineString
+      include Curve
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # The number of Points in this LineString.
+      #
+      # === Notes
+      #
+      # Returns an integer.
+
+      def num_points
+        raise Error::UnsupportedOperation, "Method LineString#num_points not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # Returns the specified Point N in this LineString.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Point interface, or nil
+      # if the given N is out of range. N is zero-based.
+      # Does not support negative indexes.
+
+      def point_n(_n_)
+        raise Error::UnsupportedOperation, "Method LineString#point_n not defined."
+      end
+
+      # Returns the constituent points as an array of objects that
+      # support the Point interface.
+
+      def points
+        raise Error::UnsupportedOperation, "Method LineString#points not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/linear_ring.rb

@@ -0,0 +1,26 @@
+# -----------------------------------------------------------------------------
+#
+# LinearRing feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A LinearRing is a LineString that is both closed and simple.
+    #
+    # == Notes
+    #
+    # LinearRing is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module LinearRing
+      include LineString
+      extend Type
+    end
+  end
+end

data/lib/rgeo/feature/mixins.rb

@@ -0,0 +1,143 @@
+# -----------------------------------------------------------------------------
+#
+# Mixin tracker
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # MixinCollection is a mechanism for adding arbitrary methods to
+    # geometry objects.
+    #
+    # Normally, geometry objects respond to the methods defined in the
+    # feature interface for that type of geometry; e.g.
+    # RGeo::Feature::Geometry, RGeo::Feature::Point, etc. Some
+    # implementations include additional methods specific to the
+    # implementation. However, occasionally it is desirable also to
+    # include custom methods allowing objects to function in different
+    # contexts. To do so, provide those methods in a mixin Module, and
+    # add it to an appropriate MixinCollection. A MixinCollection is
+    # simply a collection of mixin Modules, connected to geometry types,
+    # that are included in objects of that type.
+    #
+    # There is a global collection, MixinCollection::GLOBAL, which
+    # manages mixins to be added to all implementations. In addition,
+    # individual implementation factories may provide additional local
+    # MixinCollection objects for mixins specific to objects created
+    # by that factory.
+    #
+    # Each mixin module added to a MixinCollection is connected to a
+    # specific type, which controls to which objects that mixin is added.
+    # For example, a mixin connected to Point is added only to Point
+    # objects. A mixin connected to GeometryCollection is added to
+    # GeometryCollection objects as well as MultiPoint, MultiLineString,
+    # and MultiPolygon, since those are subtypes of GeometryCollection.
+    # To add a mixin to all objects, connect it to the Geometry base type.
+
+    class MixinCollection
+      # An API point controlling a particular type.
+
+      class TypeData
+        def initialize(collection_, type_) # :nodoc:
+          @collection = collection_
+          @type = type_
+          @mixins = []
+          @classes = []
+          @rmixins = []
+          @rclasses = []
+        end
+
+        # The feature type
+        attr_reader :type
+
+        # The MixinCollection owning this data
+        attr_reader :collection
+
+        # Add a mixin to be included in implementations of this type.
+
+        def add(module_)
+          @mixins << module_
+          @classes.each { |k_| k_.class_eval { include(module_) } }
+          _radd(module_)
+        end
+
+        # A class that implements this type should call this method to
+        # get the appropriate mixins.
+        # If include_ancestry_ is set to true, then mixins connected to
+        # subtypes of this type are also added to the class.
+
+        def include_in_class(klass_, include_ancestry_ = false)
+          (include_ancestry_ ? @rmixins : @mixins).each { |m_| klass_.class_eval { include(m_) } }
+          (include_ancestry_ ? @rclasses : @classes) << klass_
+          self
+        end
+
+        # An object that implements this type should call this method to
+        # get the appropriate mixins.
+        # If include_ancestry_ is set to true, then mixins connected to
+        # subtypes of this type are also added to the object.
+
+        def include_in_object(obj_, include_ancestry_ = false)
+          (include_ancestry_ ? @rmixins : @mixins).each { |m_| obj_.extend(m_) }
+          self
+        end
+
+        def _radd(module_) # :nodoc:
+          @rmixins << module_
+          @rclasses.each { |k_| k_.class_eval { include(module_) } }
+          @type.each_immediate_subtype { |t_| @collection.for_type(t_)._radd(module_) }
+          self
+        end
+      end
+
+      # Create a new empty MixinCollection
+
+      def initialize
+        @types = {}
+      end
+
+      # Returns a TypeData for the given type.
+      #
+      # e.g. to add a module for point types, you can call:
+      #  for_type(::RGeo::Feature::Point).add(module)
+
+      def for_type(type_)
+        (@types[type_] ||= TypeData.new(self, type_))
+      end
+
+      # Add a module connected to the given type.
+      #
+      # Shorthand for:
+      #  for_type(type_).add(module_)
+
+      def add(type_, module_)
+        for_type(type_).add(module_)
+      end
+
+      # A class that implements this type should call this method to
+      # get the appropriate mixins.
+      #
+      # Shorthand for:
+      #  for_type(type_).include_in_class(klass_, include_ancestry_)
+
+      def include_in_class(type_, klass_, include_ancestry_ = false)
+        for_type(type_).include_in_class(klass_, include_ancestry_)
+      end
+
+      # An object that implements this type should call this method to
+      # get the appropriate mixins.
+      #
+      # Shorthand for:
+      #  for_type(type_).include_in_object(obj_, include_ancestry_)
+
+      def include_in_object(type_, obj_, include_ancestry_ = false)
+        for_type(type_).include_in_object(obj_, include_ancestry_)
+      end
+
+      # The global MixinCollection. Mixins added to this collection are
+      # added to all geometry objects for all implementations.
+
+      GLOBAL = MixinCollection.new
+    end
+  end
+end

data/lib/rgeo/feature/multi_curve.rb

@@ -0,0 +1,71 @@
+# -----------------------------------------------------------------------------
+#
+# MultiCurve feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A MultiCurve is a 1-dimensional GeometryCollection whose elements are
+    # Curves.
+    #
+    # MultiCurve is a non-instantiable class in this specification; it
+    # defines a set of methods for its subclasses and is included for
+    # reasons of extensibility.
+    #
+    # A MultiCurve is simple if and only if all of its elements are simple
+    # and the only intersections between any two elements occur at Points
+    # that are on the boundaries of both elements.
+    #
+    # The boundary of a MultiCurve is obtained by applying the "mod 2"
+    # union rule: A Point is in the boundary of a MultiCurve if it is in
+    # the boundaries of an odd number of elements of the MultiCurve.
+    #
+    # A MultiCurve is closed if all of its elements are closed. The
+    # boundary of a closed MultiCurve is always empty.
+    #
+    # A MultiCurve is defined as topologically closed.
+    #
+    # == Notes
+    #
+    # MultiCurve is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module MultiCurve
+      include GeometryCollection
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # The Length of this MultiCurve which is equal to the sum of the
+      # lengths of the element Curves.
+      #
+      # === Notes
+      #
+      # Returns a floating-point scalar value.
+
+      def length
+        raise Error::UnsupportedOperation, "Method MultiCurve#length not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # Returns true if this MultiCurve is closed [StartPoint() = EndPoint()
+      # for each Curve in this MultiCurve].
+      #
+      # === Notes
+      #
+      # Returns a boolean value. Note that this is different from the SFS
+      # specification, which stipulates an integer return value.
+
+      def is_closed?
+        raise Error::UnsupportedOperation, "Method MultiCurve#is_closed? not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/multi_line_string.rb

@@ -0,0 +1,26 @@
+# -----------------------------------------------------------------------------
+#
+# MultiLineString feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A MultiLineString is a MultiCurve whose elements are LineStrings.
+    #
+    # == Notes
+    #
+    # MultiLineString is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module MultiLineString
+      include MultiCurve
+      extend Type
+    end
+  end
+end