geos-extensions 0.2.2 → 0.3.0

data/lib/geos/geometry_collection.rb

@@ -0,0 +1,60 @@
+
+module Geos
+  class GeometryCollection
+    if !GeometryCollection.included_modules.include?(Enumerable)
+      include Enumerable
+
+      # Iterates the collection through the given block.
+      def each
+        self.num_geometries.times do |n|
+          yield self.get_geometry_n(n)
+        end
+        nil
+      end
+
+      # Returns the nth geometry from the collection.
+      def [](*args)
+        self.to_a[*args]
+      end
+      alias :slice :[]
+    end
+
+    # Returns the last geometry from the collection.
+    def last
+      self.get_geometry_n(self.num_geometries - 1) if self.num_geometries > 0
+    end
+
+    # Returns a Hash suitable for converting to JSON.
+    def as_json(options = {})
+      self.collect do |p|
+        p.to_jsonable options
+      end
+    end
+    alias :to_jsonable :as_json
+
+    # Build some XmlMarkup for KML.
+    def to_kml(*args)
+      self.collect do |p|
+        p.to_kml(*args)
+      end
+    end
+
+    # Build some XmlMarkup for GeoRSS. Since GeoRSS is pretty trimed down,
+    # we just take the entire collection and use the exterior_ring as
+    # a Polygon. Not to bright, mind you, but until GeoRSS stops with the
+    # suck, what are we to do. You should include the appropriate georss
+    # and gml XML namespaces in your document.
+    def to_georss(*args)
+      self.exterior_ring.to_georss(*args)
+    end
+
+    def as_geojson(options = {})
+      {
+        :type => 'GeometryCollection',
+        :geometries => self.to_a.collect { |g| g.to_geojsonable(options) }
+      }
+    end
+    alias :to_geojsonable :as_geojson
+  end
+end
+

data/lib/geos/geos_helper.rb

@@ -10,95 +10,109 @@ module Geos::Helper
     "'"     => "\\'"
   }
 
-  # Escape carrier returns and single and double quotes for JavaScript
-  # segments. Borrowed from ActiveSupport.
-  def self.escape_javascript(javascript) #:nodoc:
-    if javascript
-      javascript.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { JS_ESCAPE_MAP[$1] }
-    else
-      ''
-    end
-  end
-
-  def self.escape_json(hash, ignore_keys = [])
-    json = hash.inject([]) do |memo, (k, v)|
-      memo.tap {
-        k = k.to_s
-        memo << if ignore_keys.include?(k)
-          "#{k.to_json}: #{v}"
-        else
-          "#{k.to_json}: #{v.to_json}"
-        end
-      }
+  class << self
+    # Escape carrier returns and single and double quotes for JavaScript
+    # segments. Borrowed from ActiveSupport.
+    def escape_javascript(javascript) #:nodoc:
+      if javascript
+        javascript.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { JS_ESCAPE_MAP[$1] }
+      else
+        ''
+      end
     end
 
-    "{#{json.join(', ')}}"
-  end
+    def escape_json(hash, ignore_keys = [])
+      json = hash.inject([]) do |memo, (k, v)|
+        memo.tap {
+          k = k.to_s
+          memo << if ignore_keys.include?(k)
+            "#{k.to_json}: #{v}"
+          else
+            "#{k.to_json}: #{v.to_json}"
+          end
+        }
+      end
 
-  def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = false)
-    if first_letter_in_uppercase
-      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    else
-      lower_case_and_underscored_word.to_s[0..0].downcase + camelize(lower_case_and_underscored_word, true)[1..-1]
+      "{#{json.join(', ')}}"
     end
-  end
 
-  def self.xml_options(*args) #:nodoc:
-    xml = if Builder::XmlMarkup === args.first
-      args.first
-    else
-      Builder::XmlMarkup.new(:indent => 4)
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = false)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.to_s[0..0].downcase + camelize(lower_case_and_underscored_word, true)[1..-1]
+      end
     end
 
-    options = if Hash === args.last
-      args.last
-    else
-      Hash.new
-    end
+    def xml_options(*args) #:nodoc:
+      xml = if Builder::XmlMarkup === args.first
+        args.first
+      else
+        Builder::XmlMarkup.new(:indent => 4)
+      end
 
-    [ xml, options ]
-  end
+      options = if Hash === args.last
+        args.last
+      else
+        Hash.new
+      end
 
-  # Return a new Hash with all keys converted to camelized Strings.
-  def self.camelize_keys(hash, first_letter_in_uppercase = false)
-    hash.inject({}) do |options, (key, value)|
-      options[camelize(key, first_letter_in_uppercase)] = value
-      options
+      [ xml, options ]
     end
-  end
 
-  # Destructively convert all keys to camelized Strings.
-  def camelize_keys!(hash, first_letter_in_uppercase = false)
-    hash.tap {
-      hash.keys.each do |key|
-        unless key.class.to_s == 'String'
-          hash[camelize(key, first_letter_in_uppercase)] = hash[key]
-          hash.delete(key)
-        end
+    # Return a new Hash with all keys converted to camelized Strings.
+    def camelize_keys(hash, first_letter_in_uppercase = false)
+      hash.inject({}) do |options, (key, value)|
+        options[camelize(key, first_letter_in_uppercase)] = value
+        options
       end
-    }
-  end
+    end
+
+    # Destructively convert all keys to camelized Strings.
+    def camelize_keys!(hash, first_letter_in_uppercase = false)
+      hash.tap {
+        hash.keys.each do |key|
+          unless key.class.to_s == 'String'
+            hash[camelize(key, first_letter_in_uppercase)] = hash[key]
+            hash.delete(key)
+          end
+        end
+      }
+    end
 
-  # Deeply camelize a Hash.
-  def deep_camelize_keys(hash, first_letter_in_uppercase = false)
-    camelize_keys(hash, first_letter_in_upppcase).inject({}) do |memo, (k, v)|
-      memo.tap do
-        if v.is_a? Hash
-          memo[k] = deep_camelize_keys(v, first_letter_in_uppercase)
-        else
-          memo[k] = v
+    # Deeply camelize a Hash.
+    def deep_camelize_keys(hash, first_letter_in_uppercase = false)
+      camelize_keys(hash, first_letter_in_upppcase).inject({}) do |memo, (k, v)|
+        memo.tap do
+          if v.is_a? Hash
+            memo[k] = deep_camelize_keys(v, first_letter_in_uppercase)
+          else
+            memo[k] = v
+          end
         end
       end
     end
-  end
 
-  # Destructively deeply camelize a Hash.
-  def deep_camelize_keys!(hash, first_letter_in_uppercase = false)
-    hash.replace(deep_camelize_keys(hash, first_letter_in_uppercase))
-  end
+    # Destructively deeply camelize a Hash.
+    def deep_camelize_keys!(hash, first_letter_in_uppercase = false)
+      hash.replace(deep_camelize_keys(hash, first_letter_in_uppercase))
+    end
+
+    def number_with_precision(number, precision = 6)
+      rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
+      "%01.#{precision}f" % rounded_number
+    end
 
-  def self.number_with_precision(number, precision = 6)
-    rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
-    "%01.#{precision}f" % rounded_number
+    # Makes sure an object is wrapped in an Array.
+    def array_wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [ object ]
+      else
+        [ object ]
+      end
+    end
   end
 end
+

data/lib/geos/google_maps.rb

@@ -22,6 +22,7 @@ module Geos
 
     autoload :PolylineEncoder, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps polyline_encoder })
     autoload :ApiIncluder, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_includer })
+    autoload :ApiCommon, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_common })
     autoload :Api2, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_2 })
     autoload :Api3, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_3 })
   end

data/lib/geos/google_maps/api_2.rb

@@ -1,29 +1,7 @@
 
 module Geos::GoogleMaps::Api2
   module Geometry
-    # Spit out Google's JSON geocoder Point format. The extra 0 is added
-    # on as Google's format seems to like including the Z coordinate.
-    def to_g_json_point_api2
-      {
-        :coordinates => (self.centroid.to_a << 0)
-      }
-    end
-
-    # Spit out Google's JSON geocoder ExtendedData LatLonBox format.
-    def to_g_lat_lon_box_api2
-      {
-        :north => self.north,
-        :east => self.east,
-        :south => self.south,
-        :west => self.west
-      }
-    end
-
-    # Spit out Google's toUrlValue format.
-    def to_g_url_value_api2(precision = 6)
-      c = self.centroid
-      "#{Geos::Helper.number_with_precision(c.lat, precision)},#{Geos::Helper.number_with_precision(c.lng, precision)}"
-    end
+    include Geos::GoogleMaps::ApiCommon::Geometry
 
     # Returns a new GLatLngBounds object with the proper GLatLngs in place
     # for determining the geometry bounds.
@@ -167,6 +145,8 @@ module Geos::GoogleMaps::Api2
   end
 
   module Polygon
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+
     # Returns a GPolyline of the exterior ring of the Polygon. This does
     # not take into consideration any interior rings the Polygon may
     # have.
@@ -182,7 +162,13 @@ module Geos::GoogleMaps::Api2
     end
   end
 
+  module LineString
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+  end
+
   module GeometryCollection
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+
     # Returns a Ruby Array of GPolylines for each geometry in the
     # collection.
     def to_g_polyline_api2(polyline_options = {}, options = {})

data/lib/geos/google_maps/api_3.rb

@@ -26,29 +26,7 @@ module Geos::GoogleMaps
   end
 
   module Api3::Geometry
-    # Spit out Google's JSON geocoder Point format. The extra 0 is added
-    # on as Google's format seems to like including the Z coordinate.
-    def to_g_json_point_api3
-      {
-        :coordinates => (self.centroid.to_a << 0)
-      }
-    end
-
-    # Spit out Google's JSON geocoder ExtendedData LatLonBox format.
-    def to_g_lat_lon_box_api3
-      {
-        :north => self.north,
-        :east => self.east,
-        :south => self.south,
-        :west => self.west
-      }
-    end
-
-    # Spit out Google's toUrlValue format.
-    def to_g_url_value_api3(precision = 6)
-      c = self.centroid
-      "#{Geos::Helper.number_with_precision(c.lat, precision)},#{Geos::Helper.number_with_precision(c.lng, precision)}"
-    end
+    include Geos::GoogleMaps::ApiCommon::Geometry
 
     # Returns a new LatLngBounds object with the proper LatLngs in place
     # for determining the geometry bounds.
@@ -58,7 +36,7 @@ module Geos::GoogleMaps
 
     # Returns a bounds parameter for the Google Maps API 3 geocoder service.
     def to_g_geocoder_bounds_api3(precision = 6)
-      "#{self.lower_left.to_g_url_value_api3(precision)}|#{self.upper_right.to_g_url_value_api3(precision)}"
+      "#{self.lower_left.to_g_url_value(precision)}|#{self.upper_right.to_g_url_value(precision)}"
     end
 
     # Returns a String in Google Maps' LatLngBounds#toString() format.
@@ -172,6 +150,8 @@ module Geos::GoogleMaps
   end
 
   module Api3::Polygon
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+
     # Returns a Polyline of the exterior ring of the Polygon. This does
     # not take into consideration any interior rings the Polygon may
     # have.
@@ -187,7 +167,13 @@ module Geos::GoogleMaps
     end
   end
 
+  module Api3::LineString
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+  end
+
   module Api3::GeometryCollection
+    include Geos::GoogleMaps::ApiCommon::UrlValueBounds
+
     # Returns a Ruby Array of Polylines for each geometry in the
     # collection.
     def to_g_polyline_api3(polyline_options = {}, options = {})

data/lib/geos/google_maps/api_common.rb

@@ -0,0 +1,41 @@
+
+module Geos
+  module GoogleMaps
+    module ApiCommon
+      module Geometry
+        # Spit out Google's JSON geocoder Point format. The extra 0 is added
+        # on as Google's format seems to like including the Z coordinate.
+        def to_g_json_point
+          {
+            :coordinates => (self.centroid.to_a << 0)
+          }
+        end
+
+        # Spit out Google's JSON geocoder ExtendedData LatLonBox format.
+        def to_g_lat_lon_box
+          {
+            :north => self.north,
+            :east => self.east,
+            :south => self.south,
+            :west => self.west
+          }
+        end
+
+        # Spit out Google's toUrlValue format.
+        def to_g_url_value(precision = 6)
+          c = self.centroid
+          "#{Geos::Helper.number_with_precision(c.lat, precision)},#{Geos::Helper.number_with_precision(c.lng, precision)}"
+        end
+      end
+
+      module UrlValueBounds
+        # Spit out Google's toUrlValue format.
+        def to_g_url_value(precision = 6)
+          e = self.envelope
+          "#{e.southwest.to_g_url_value(precision)},#{e.northeast.to_g_url_value(precision)}"
+        end
+      end
+    end
+  end
+end
+

data/lib/geos/line_string.rb

@@ -0,0 +1,15 @@
+
+module Geos
+  class LineString
+    def as_json(options = {})
+      self.coord_seq.as_json(options)
+    end
+    alias :to_jsonable :as_json
+
+    def as_geojson(options = {})
+      self.coord_seq.to_geojsonable(options)
+    end
+    alias :to_geojsonable :as_geojson
+  end
+end
+

data/lib/geos/multi_line_string.rb

@@ -0,0 +1,15 @@
+
+module Geos
+  class MultiLineString < GeometryCollection
+    def to_geojsonable(options = {})
+      {
+        :type => 'MultiLineString',
+        :coordinates => self.to_a.collect { |linestring|
+          linestring.coord_seq.to_a
+        }
+      }
+    end
+    alias :as_geojson :to_geojsonable
+  end
+end
+

data/lib/geos/multi_point.rb

@@ -0,0 +1,15 @@
+
+module Geos
+  class MultiPoint < GeometryCollection
+    def to_geojsonable(options = {})
+      {
+        :type => 'MultiPoint',
+        :coordinates => self.to_a.collect { |point|
+          point.to_a
+        }
+      }
+    end
+    alias :as_geojson :to_geojsonable
+  end
+end
+