rgeo 0.1.12 → 0.1.13

data/lib/rgeo/geography/simple_spherical/{line_string_impl.rb → feature_methods.rb}

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Spherical LineString implementation
+# Spherical geometry common methods
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -38,10 +38,21 @@ module RGeo
   
   module Geography
     
-    module SimpleSpherical
+    module SimpleSpherical  # :nodoc:
       
       
-      module LineStringMethods
+      module GeometryMethods  # :nodoc:
+        
+        
+        def srid
+          4326
+        end
+        
+        
+      end
+      
+      
+      module LineStringMethods  # :nodoc:
         
         
         def _arcs
@@ -57,9 +68,9 @@ module RGeo
         def is_simple?
           arcs_ = _arcs
           len_ = arcs_.length
-          return false if arcs_.any?{ |a_| a_.nil? }
+          return false if arcs_.any?{ |a_| a_.degenerate? }
           return true if len_ == 1
-          return arcs_[0].start != arcs_[1].end if len_ == 2
+          return arcs_[0].s != arcs_[1].e if len_ == 2
           arcs_.each_with_index do |arc_, index_|
             nindex_ = index_ + 1
             nindex_ = nil if nindex_ == len_
@@ -83,65 +94,6 @@ module RGeo
       end
       
       
-      class LineStringImpl
-        
-        
-        include Features::LineString
-        include Common::GeometryMethods
-        include SimpleSpherical::GeometryMethods
-        include Common::LineStringMethods
-        include SimpleSpherical::LineStringMethods
-        
-        
-        def initialize(factory_, points_)
-          _set_factory(factory_)
-          _setup(points_)
-        end
-        
-        
-      end
-      
-      
-      class LineImpl
-        
-        
-        include Features::Line
-        include Common::GeometryMethods
-        include SimpleSpherical::GeometryMethods
-        include Common::LineStringMethods
-        include SimpleSpherical::LineStringMethods
-        include Common::LineMethods
-        
-        
-        def initialize(factory_, start_, end_)
-          _set_factory(factory_)
-          _setup([start_, end_])
-        end
-        
-        
-      end
-      
-      
-      class LinearRingImpl
-        
-        
-        include Features::Line
-        include Common::GeometryMethods
-        include SimpleSpherical::GeometryMethods
-        include Common::LineStringMethods
-        include SimpleSpherical::LineStringMethods
-        include Common::LinearRingMethods
-        
-        
-        def initialize(factory_, points_)
-          _set_factory(factory_)
-          _setup(points_)
-        end
-        
-        
-      end
-      
-      
     end
     
   end

data/lib/rgeo/geos/factory.rb

@@ -43,7 +43,7 @@ module RGeo
     
     class Factory
       
-      include Features::Factory
+      include Features::Factory::Instance
       
       
       class << self
@@ -103,12 +103,12 @@ module RGeo
       
       # Returns true if this factory is lenient with MultiPolygon assertions
       
-      def lenient_multi_polygons?
+      def lenient_multi_polygon_assertions?
         _flags & 0x1 != 0
       end
       
       
-      # Equivalence test.
+      # Factory equivalence test.
       
       def eql?(rhs_)
         rhs_.is_a?(Factory) && rhs_.srid == _srid && rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags
@@ -156,9 +156,6 @@ module RGeo
       
       def linear_ring(points_)
         points_ = points_.to_a unless points_.kind_of?(::Array)
-        if points_.size > 1 && points_.first != points_.last
-          points_ << points_.first
-        end
         LinearRingImpl.create(self, points_) rescue nil
       end
       
@@ -203,46 +200,35 @@ module RGeo
       end
       
       
-      # See ::RGeo::Features::Factory#cast
+      # See ::RGeo::Features::Factory#override_cast
       
-      def cast(original_, force_new_=false)
+      def override_cast(original_, ntype_, keep_subtype_, force_new_)
         return nil unless Geos.supported?
-        case original_
-        when GeometryImpl
-          if original_.factory != self
+        type_ = original_.geometry_type
+        ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
+        if original_.factory != self && ntype_ == type_
+          if GeometryImpl === original_
             result_ = original_.dup
-            result_.instance_variable_set(:@_factory, self)
-            result_
-          elsif force_new_
-            original_.dup
-          else
-            original_
+            result_._set_factory(self)
+            return result_
+          end
+          if type_ == Features::Point && original_.respond_to?(:z)
+            z_ = original_.z
+            return PointImpl.create(self, original_.x, original_.y, z_) if z_
           end
-        when Features::Point
-          if original_.respond_to?(:z)
-            PointImpl.create(self, original_.x, original_.y, original_.z)
-          else
-            PointImpl.create(self, original_.x, original_.y)
+        end
+        if GeometryImpl === original_ && (original_.factory != self || ntype_ != type_) &&
+            (type_ == Features::LineString || type_ == Features::Line || type_ == Features::LinearRing)
+        then
+          if ntype_ == Features::LineString
+            return LineStringImpl._copy_from(self, original_)
+          elsif ntype_ == Features::Line
+            return LineImpl._copy_from(self, original_)
+          elsif ntype_ == Features::LinearRing
+            return LinearRingImpl._copy_from(self, original_)
           end
-        when Features::Line
-          LineImpl.create(self, cast(original_.start_point), cast(original_.end_point))
-        when Features::LinearRing
-          LinearRingImpl.create(self, original_.points.map{ |g_| cast(g_) })
-        when Features::LineString
-          LineStringImpl.create(self, original_.points.map{ |g_| cast(g_) })
-        when Features::Polygon
-          PolygonImpl.create(self, cast(original_.exterior_ring), original_.interior_rings.map{ |g_| cast(g_) })
-        when Features::MultiPoint
-          MultiPointImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
-        when Features::MultiLineString
-          MultiLineStringImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
-        when Features::MultiPolygon
-          MultiPolygonImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
-        when Features::GeometryCollection
-          GeometryCollectionImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
-        else
-          nil
         end
+        false
       end
       
       

data/lib/rgeo/geos/impl_additions.rb

@@ -34,14 +34,14 @@
 ;
 
 
-# :stopdoc:
-
 module RGeo
   
   module Geos
     
     
-    class GeometryImpl
+    class GeometryImpl  # :nodoc:
+      
+      include ::RGeo::Features::Type::Instance
       
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
@@ -53,5 +53,3 @@ module RGeo
   end
   
 end
-
-# :startdoc:

data/lib/rgeo/{geography/simple_spherical/polygon_impl.rb → impl_helpers.rb}

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Spherical Polygon implementation
+# Implementation helpers namespace for RGeo
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -36,31 +36,21 @@
 
 module RGeo
   
-  module Geography
-    
-    module SimpleSpherical
-      
-      
-      class PolygonImpl
-        
-        
-        include Features::Polygon
-        include Common::GeometryMethods
-        include GeometryMethods
-        include Common::PolygonMethods
-        
-        
-        def initialize(factory_, exterior_ring_, interior_rings_)
-          _set_factory(factory_)
-          _setup(exterior_ring_, interior_rings_)
-        end
-        
-        
-      end
-      
-      
-    end
-    
+  
+  module ImplHelpers  # :nodoc:
   end
   
+  
 end
+
+
+# Dependency source files.
+paths_ = [
+  'impl_helpers/basic_geometry_methods',
+  'impl_helpers/basic_geometry_collection_methods',
+  'impl_helpers/basic_point_methods',
+  'impl_helpers/basic_line_string_methods',
+  'impl_helpers/basic_polygon_methods',
+  'impl_helpers/serialization',
+]
+paths_.each{ |path_| require "rgeo/#{path_}" }

data/lib/rgeo/impl_helpers/basic_geometry_collection_methods.rb

@@ -0,0 +1,186 @@
+# -----------------------------------------------------------------------------
+# 
+# Common methods for GeometryCollection features
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module ImplHelpers  # :nodoc:
+    
+    
+    module BasicGeometryCollectionMethods  # :nodoc:
+      
+      
+      def initialize(factory_, elements_)
+        _set_factory(factory_)
+        @elements = elements_.map do |elem_|
+          elem_ = Features.cast(elem_, factory_)
+          unless elem_
+            raise Errors::InvalidGeometry, "Could not cast #{elem_}"
+          end
+          elem_
+        end
+        _validate_geometry
+      end
+      
+      
+      def eql?(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_].eql?(p_) }
+        else
+          false
+        end
+      end
+      
+      
+      def num_geometries
+        @elements.size
+      end
+      
+      
+      def geometry_n(n_)
+        @elements[n_]
+      end
+      
+      
+      def each(&block_)
+        @elements.each(&block_)
+      end
+      
+      
+      def dimension
+        unless @dimension
+          @dimension = -1
+          @elements.each do |elem_|
+            dim_ = elem_.dimension
+            @dimension = dim_ if @dimension < dim_
+          end
+        end
+        @dimension
+      end
+      
+      
+      def geometry_type
+        Features::GeometryCollection
+      end
+      
+      
+      def is_empty?
+        @elements.size == 0
+      end
+      
+      
+    end
+    
+    
+    module BasicMultiLineStringMethods  # :nodoc:
+      
+      
+      def initialize(factory_, elements_)
+        _set_factory(factory_)
+        @elements = elements_.map do |elem_|
+          elem_ = Features.cast(elem_, factory_, Features::LineString, :keep_subtype)
+          unless elem_
+            raise Errors::InvalidGeometry, "Could not cast #{elem_}"
+          end
+          elem_
+        end
+        _validate_geometry
+      end
+      
+      
+      def geometry_type
+        Features::MultiLineString
+      end
+      
+      
+      def is_closed?
+        all?{ |elem_| elem_.is_closed? }
+      end
+      
+      
+    end
+    
+    
+    module BasicMultiPointMethods  # :nodoc:
+      
+      
+      def initialize(factory_, elements_)
+        _set_factory(factory_)
+        @elements = elements_.map do |elem_|
+          elem_ = Features.cast(elem_, factory_, Features::Point, :keep_subtype)
+          unless elem_
+            raise Errors::InvalidGeometry, "Could not cast #{elem_}"
+          end
+          elem_
+        end
+        _validate_geometry
+      end
+      
+      
+      def geometry_type
+        Features::MultiPoint
+      end
+      
+      
+    end
+    
+    
+    module BasicMultiPolygonMethods  # :nodoc:
+      
+      
+      def initialize(factory_, elements_)
+        _set_factory(factory_)
+        @elements = elements_.map do |elem_|
+          elem_ = Features.cast(elem_, factory_, Features::Polygon, :keep_subtype)
+          unless elem_
+            raise Errors::InvalidGeometry, "Could not cast #{elem_}"
+          end
+          elem_
+        end
+        _validate_geometry
+      end
+      
+      
+      def geometry_type
+        Features::MultiPolygon
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end