rgeo 0.1.21 → 0.1.22

data/lib/rgeo/active_record/base_modifications.rb

@@ -68,7 +68,7 @@ module ActiveRecord
     class_attribute :rgeo_factory_generator, :instance_writer => false
     self.rgeo_factory_generator = ::Proc.new do |config_|
       if config_.delete(:geographic)
-        ::RGeo::Geography.spherical_factory(config_)
+        ::RGeo::Geographic.spherical_factory(config_)
       else
         ::RGeo::Cartesian.preferred_factory(config_)
       end

data/lib/rgeo/all.rb

@@ -44,6 +44,6 @@ require 'rgeo/impl_helper'
 require 'rgeo/wkrep'
 require 'rgeo/geos'
 require 'rgeo/cartesian'
-require 'rgeo/geography'
+require 'rgeo/geographic'
 require 'rgeo/geo_json'
 require 'rgeo/shapefile'

data/lib/rgeo/cartesian/bounding_box.rb

@@ -73,8 +73,8 @@ module RGeo
       
       def initialize(factory_, opts_={})
         @factory = factory_
-        @has_z = !opts_[:ignore_z] && factory_.has_capability?(:z_coordinate) ? true : false
-        @has_m = !opts_[:ignore_m] && factory_.has_capability?(:m_coordinate) ? true : false
+        @has_z = !opts_[:ignore_z] && factory_.property(:has_z_coordinate) ? true : false
+        @has_m = !opts_[:ignore_m] && factory_.property(:has_m_coordinate) ? true : false
         @min_x = @max_x = @min_y = @max_y = @min_z = @max_z = @min_m = @max_m = nil
       end
       

data/lib/rgeo/cartesian/factory.rb

@@ -53,8 +53,8 @@ module RGeo
       
       def initialize(opts_={})
         @srid = opts_[:srid].to_i
-        @support_z = opts_[:support_z_coordinate] ? true : false
-        @support_m = opts_[:support_m_coordinate] ? true : false
+        @has_z = opts_[:has_z_coordinate] ? true : false
+        @has_m = opts_[:has_m_coordinate] ? true : false
         @proj4 = opts_[:proj4]
         if CoordSys::Proj4.supported?
           if @proj4.kind_of?(::String) || @proj4.kind_of?(::Hash)
@@ -69,7 +69,7 @@ module RGeo
       # Equivalence test.
       
       def eql?(rhs_)
-        rhs_.is_a?(self.class) && @srid == rhs_.srid
+        rhs_.is_a?(self.class) && @srid == rhs_.srid && @has_z == rhs_.property(:has_z_coordinate) && @has_m == rhs_.property(:has_m_coordinate)
       end
       alias_method :==, :eql?
       
@@ -81,16 +81,16 @@ module RGeo
       end
       
       
-      # See ::RGeo::Feature::Factory#has_capability?
+      # See ::RGeo::Feature::Factory#property
       
-      def has_capability?(name_)
+      def property(name_)
         case name_
-        when :z_coordinate
-          @support_z
-        when :m_coordinate
-          @support_m
-        when :proj4
-          !@proj4.nil?
+        when :has_z_coordinate
+          @has_z
+        when :has_m_coordinate
+          @has_m
+        when :is_cartesian
+          true
         else
           nil
         end
@@ -181,6 +181,13 @@ module RGeo
       end
       
       
+      # See ::RGeo::Feature::Factory#coord_sys
+      
+      def coord_sys
+        nil
+      end
+      
+      
     end
     
     

data/lib/rgeo/cartesian/interface.rb

@@ -89,10 +89,10 @@ module RGeo
       # <tt>:srid</tt>::
       #   Set the SRID returned by geometries created by this factory.
       #   Default is 0.
-      # <tt>:support_z_coordinate</tt>::
-      #   Support <tt>z_coordinate</tt>. Default is false.
-      # <tt>:support_m_coordinate</tt>::
-      #   Support <tt>m_coordinate</tt>. Default is false.
+      # <tt>:has_z_coordinate</tt>::
+      #   Support a Z coordinate. Default is false.
+      # <tt>:has_m_coordinate</tt>::
+      #   Support an M coordinate. Default is false.
       
       def simple_factory(opts_={})
         Cartesian::Factory.new(opts_)

data/lib/rgeo/coord_sys.rb

@@ -41,7 +41,14 @@ require 'rgeo'
 module RGeo
   
   
-  # Coordinate reference systems.
+  # This module provides data structures and tools related to coordinate
+  # systems and coordinate transforms.
+  # 
+  # Currently, the Proj4 class provides a wrapper around the proj4
+  # library, which specifies geographic and projected coordinate systems
+  # and performs transformations. In the future, this module will also
+  # contain an implementation of the OGC coordinate transformation
+  # specification.
   
   module CoordSys
   end

data/lib/rgeo/coord_sys/proj4.rb

@@ -240,10 +240,10 @@ module RGeo
         
         def _transform_point(from_proj_, from_point_, to_proj_, to_factory_)  # :nodoc:
           from_factory_ = from_point_.factory
-          from_has_z_ = from_factory_.has_capability?(:z_coordinate)
-          from_has_m_ = from_factory_.has_capability?(:m_coordinate)
-          to_has_z_ = to_factory_.has_capability?(:z_coordinate)
-          to_has_m_ = to_factory_.has_capability?(:m_coordinate)
+          from_has_z_ = from_factory_.property(:has_z_coordinate)
+          from_has_m_ = from_factory_.property(:has_m_coordinate)
+          to_has_z_ = to_factory_.property(:has_z_coordinate)
+          to_has_m_ = to_factory_.property(:has_m_coordinate)
           coords_ = _transform_coords(from_proj_, to_proj_, from_point_.x, from_point_.y,
                                       from_has_z_ ? from_point_.z : nil)
           extras_ = []

data/lib/rgeo/feature/factory.rb

@@ -72,35 +72,42 @@ module RGeo
       end
       
       
-      # Determine support for the given capability, identified by a
-      # symbolic name. This method may be used to test this factory, and
-      # any features created by it, to determine whether they support
-      # certain capabilities or operations. Most queries return a boolean
-      # value, though some may return other values to indicate different
-      # levels of support. Generally speaking, if a query returns a false
-      # or nil value, support for that capability is not guaranteed, and
-      # calls related to that function may fail or raise exceptions.
+      # Returns meta-information about this factory, by key. This
+      # information may involve support for optional functionality,
+      # properties of the coordinate system, or other characteristics.
       # 
-      # Each capability must have a symbolic name. Names that have no
-      # periods are considered well-known names and are reserved for use
-      # by RGeo. If you want to define your own capabilities, use a name
-      # that is namespaced, such as <tt>:'mycompany.mycapability'</tt>.
+      # Each property has a symbolic name. Names that have no periods are
+      # considered well-known names and are reserved for use by RGeo. If
+      # you want to define your own capabilities, use a name that is
+      # namespaced with periods, such as <tt>:'mycompany.myprop'</tt>.
       # 
-      # Currently defined standard capabilities are:
+      # Property values are dependent on the individual property.
+      # Generally, properties that involve testing for functionality
+      # should return true if the functionality is support, or false or
+      # nil if not. A property value could also invlove different values
+      # indicating different levels of support. In any case, the factory
+      # should return nil for property names it does not recognize. This
+      # value is considered the "default" or "no value" value.
       # 
-      # <tt>:z_coordinate</tt>::
-      #   Supports a "z" coordinate. When an implementation supports
-      #   this capability, geometries know about Z coordinates, and the
-      #   Point#z method is available.
-      # <tt>:m_coordinate</tt>::
-      #   Supports an "m" coordinate. When an implementation supports
-      #   this capability, geometries know about M coordinates, and the
-      #   Point#m method is available.
-      # <tt>:proj4</tt>::
-      #   Has a proj4-defined projection. When an implementation supports
-      #   this capability, the Factory#proj4 method is available.
-      
-      def has_capability?(name_)
+      # Currently defined well-known properties are:
+      # 
+      # <tt>:has_z_coordinate</tt>::
+      #   Set to true if geometries created by this factory include a Z
+      #   coordinate, and the Point#z method is available.
+      # <tt>:has_m_coordinate</tt>::
+      #   Set to true if geometries created by this factory include a M
+      #   coordinate, and the Point#z method is available.
+      # <tt>:is_cartesian</tt>::
+      #   Set to true if this Factory guarantees that it operates in
+      #   Cartesian geometry. If false or nil, no such guarantee is made,
+      #   though it is possible the geometries may still be Cartesian.
+      # <tt>:is_geographic</tt>::
+      #   Set to true if this Factory's coordinate system is meant to be
+      #   interpreted as x=longitude and y=latitude. If false or nil, no
+      #   information is present about whether the coordinate system is
+      #   meant to be so interpreted.
+      
+      def property(name_)
         nil
       end
       
@@ -135,7 +142,7 @@ module RGeo
       
       # Create a feature of type LineString.
       # The given points argument should be an Enumerable of Point
-      # objects, or objects that can be casted to Point.
+      # objects, or objects that can be cast to Point.
       
       def line_string(points_)
         nil
@@ -144,7 +151,7 @@ module RGeo
       
       # Create a feature of type Line.
       # The given point arguments should be Point objects, or objects
-      # that can be casted to Point.
+      # that can be cast to Point.
       
       def line(start_, end_)
         nil
@@ -153,7 +160,7 @@ module RGeo
       
       # Create a feature of type LinearRing.
       # The given points argument should be an Enumerable of Point
-      # objects, or objects that can be casted to Point.
+      # objects, or objects that can be cast to Point.
       # If the first and last points are not equal, the ring is
       # automatically closed by appending the first point to the end of the
       # string.
@@ -165,7 +172,7 @@ module RGeo
       
       # Create a feature of type Polygon.
       # The outer_ring should be a LinearRing, or an object that can be
-      # casted to LinearRing.
+      # cast to LinearRing.
       # The inner_rings should be a possibly empty Enumerable of
       # LinearRing (or objects that can be casted to LinearRing).
       # You may also pass nil to indicate no inner rings.
@@ -185,7 +192,7 @@ module RGeo
       
       # Create a feature of type MultiPoint.
       # The elems should be an Enumerable of Point objects, or objects
-      # that can be casted to Point.
+      # that can be cast to Point.
       # Returns nil if any of the contained geometries is not a Point,
       # which would break the MultiPoint contract.
       
@@ -196,7 +203,7 @@ module RGeo
       
       # Create a feature of type MultiLineString.
       # The elems should be an Enumerable of objects that are or can be
-      # casted to LineString or any of its subclasses.
+      # cast to LineString or any of its subclasses.
       # Returns nil if any of the contained geometries is not a
       # LineString, which would break the MultiLineString contract.
       
@@ -207,17 +214,39 @@ module RGeo
       
       # Create a feature of type MultiPolygon.
       # The elems should be an Enumerable of objects that are or can be
-      # casted to Polygon or any of its subclasses.
+      # cast to Polygon or any of its subclasses.
       # Returns nil if any of the contained geometries is not a Polygon,
       # which would break the MultiPolygon contract.
       # Also returns nil if any of the other assertions for MultiPolygon
-      # are not met-- e.g. if any of the polygons overlap.
+      # are not met, e.g. if any of the polygons overlap.
       
       def multi_polygon(elems_)
         nil
       end
       
       
+      # Returns a RGeo::CoordSys::Proj4 representing the projection for
+      # the coordinate system of features created by this factory, or nil
+      # if there is no such proj4 projection.
+      
+      def proj4
+        nil
+      end
+      
+      
+      # Returns the coordinate system specification for the features
+      # created by this factory, or nil if there is no such coordinate
+      # system.
+      # 
+      # NOTE: This is a required method of the factory interface, but the
+      # coordinate system objects themselves are not yet available, so
+      # implementations should just return nil for now.
+      
+      def coord_sys
+        nil
+      end
+      
+      
       # This is an optional method that may be implemented to customize
       # casting for this factory. Basically, RGeo defines standard ways
       # to cast certain types of objects from one factory to another and
@@ -237,11 +266,14 @@ module RGeo
       #   of the current type
       # <tt>:force_new</tt>::
       #   indicates whether to force the creation of a new object even if
-      #   the original is already of the desired factory and type.
+      #   the original is already of the desired factory and type
+      # <tt>:project</tt>::
+      #   indicates whether to project the coordinates from the source to
+      #   the destination proj4 coordinate system, if available
       # 
       # It should return either a casted result object, false, or nil.
       # A nil return value indicates that casting should be forced to
-      # fail (and ::RGeo::Feature::cast will return nil).
+      # fail (and RGeo::Feature::cast will return nil).
       # A false return value indicates that this method declines to
       # override the casting algorithm, and RGeo should use its default
       # algorithm to cast the object. Therefore, by default, you should
@@ -252,19 +284,6 @@ module RGeo
       end
       
       
-      # This is an optional method that returns a RGeo::CoordSys::Proj4
-      # representing the projection for the coordinate system of features
-      # created by this factory, or nil if there is no such proj4
-      # projection.
-      # 
-      # If a factory supports this method, it should indicate this by
-      # returning true for the <tt>:proj4</tt> capability.
-      
-      def proj4
-        nil
-      end
-      
-      
     end
   
     

data/lib/rgeo/feature/factory_generator.rb

@@ -89,10 +89,10 @@ module RGeo
       # <tt>:srid</tt>::
       #   The SRID for the factory and objects it creates.
       #   Default is usually 0.
-      # <tt>:support_z_coordinate</tt>::
+      # <tt>:has_z_coordinate</tt>::
       #   Support the <tt>z_coordinate</tt> capability.
       #   Default is usually false.
-      # <tt>:support_m_coordinate</tt>::
+      # <tt>:has_m_coordinate</tt>::
       #   Support the <tt>m_coordinate</tt> capability.
       #   Default is usually false.
       

data/lib/rgeo/feature/types.rb

@@ -189,12 +189,12 @@ module RGeo
           else
             if type_ == Point
               proj_ = nproj_ = nil
-              if project_ && factory_.has_capability?(:proj4) && nfactory_.has_capability?(:proj4)
+              if project_
                 proj_ = factory_.proj4
                 nproj_ = nfactory_.proj4
               end
-              hasz_ = factory_.has_capability?(:z_coordinate)
-              nhasz_ = nfactory_.has_capability?(:z_coordinate)
+              hasz_ = factory_.property(:has_z_coordinate)
+              nhasz_ = nfactory_.property(:has_z_coordinate)
               if proj_ && nproj_
                 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
@@ -202,7 +202,7 @@ module RGeo
                 coords_ = [obj_.x, obj_.y]
                 coords_ << (hasz_ ? obj_.z : 0.0) if nhasz_
               end
-              coords_ << (factory_.has_capability?(:m_coordinate) ? obj_.m : 0.0) if nfactory_.has_capability?(:m_coordinate)
+              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_))

data/lib/rgeo/geo_json/coder.rb

@@ -131,8 +131,8 @@ module RGeo
           raise ::ArgumentError, "Unrecognzied json_parser: #{@json_parser.inspect}"
         end
         @num_coordinates = 2
-        @num_coordinates += 1 if @geo_factory.has_capability?(:z_coordinate)
-        @num_coordinates += 1 if @geo_factory.has_capability?(:m_coordinate)
+        @num_coordinates += 1 if @geo_factory.property(:has_z_coordinate)
+        @num_coordinates += 1 if @geo_factory.property(:has_m_coordinate)
       end
       
       
@@ -222,14 +222,14 @@ module RGeo
       
       def _encode_geometry(object_, point_encoder_=nil)  # :nodoc:
         unless point_encoder_
-          if object_.factory.has_capability?(:z_coordinate)
-            if object_.factory.has_capability?(:m_coordinate)
+          if object_.factory.property(:has_z_coordinate)
+            if object_.factory.property(:has_m_coordinate)
               point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z, p_.m] }
             else
               point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z] }
             end
           else
-            if object_.factory.has_capability?(:m_coordinate)
+            if object_.factory.property(:has_m_coordinate)
               point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.m] }
             else
               point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y] }

data/lib/rgeo/{geography.rb → geographic.rb}

@@ -41,25 +41,25 @@ require 'rgeo'
 module RGeo
   
   
-  # The Geography implementation actually comprises a suite of
+  # 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 = geography_factory.point(long, lat)
+  #  location = geographic_factory.point(long, lat)
   # 
-  # Some geography implementations include a secondary factory that
+  # 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 Geography for more information on
+  # See the various class methods of Geographic for more information on
   # the behaviors of the factories they generate.
   
-  module Geography
+  module Geographic
   end
   
   
@@ -74,13 +74,13 @@ require 'rgeo/impl_helper'
 require 'rgeo/cartesian'
 
 # Implementation files.
-require 'rgeo/geography/factory'
-require 'rgeo/geography/projected_window'
-require 'rgeo/geography/interface'
-require 'rgeo/geography/spherical_math'
-require 'rgeo/geography/spherical_feature_methods'
-require 'rgeo/geography/spherical_feature_classes'
-require 'rgeo/geography/proj4_projector'
-require 'rgeo/geography/simple_mercator_projector'
-require 'rgeo/geography/projected_feature_methods'
-require 'rgeo/geography/projected_feature_classes'
+require 'rgeo/geographic/factory'
+require 'rgeo/geographic/projected_window'
+require 'rgeo/geographic/interface'
+require 'rgeo/geographic/spherical_math'
+require 'rgeo/geographic/spherical_feature_methods'
+require 'rgeo/geographic/spherical_feature_classes'
+require 'rgeo/geographic/proj4_projector'
+require 'rgeo/geographic/simple_mercator_projector'
+require 'rgeo/geographic/projected_feature_methods'
+require 'rgeo/geographic/projected_feature_classes'