geos-extensions 0.0.7 → 0.1.0

data/README.rdoc

@@ -31,7 +31,7 @@ ZGEL contains a number of enhancements to the GEOS Ruby library:
   JavaScript output formats that we use for our applications. There are
   also similar methods for outputting to WKT and WKB such as
   Geos::Geometry#to_wkt, #to_kml, #to_georss and a number of methods to
-  output to Google Maps API v2-style JavaScript.
+  output to Google Maps API-style JavaScript.
 
 * a bunch of helper methods to quickly grab some information from
   geometries like Geos::Point#lat and Geos::Point#lng.
@@ -83,6 +83,30 @@ We've also included some Rails integration for PostGIS, including:
   * st_within
   * st_dwithin
 
+  Ordering scopes are also included:
+
+  * order_by_ndims
+  * order_by_npoints
+  * order_by_nrings
+  * order_by_numgeometries
+  * order_by_numinteriorring
+  * order_by_numinteriorrings
+  * order_by_numpoints
+  * order_by_length3d
+  * order_by_length
+  * order_by_length2d
+  * order_by_perimeter
+  * order_by_perimeter2d
+  * order_by_perimeter3d
+  * order_by_distance
+  * order_by_distance_sphere
+  * order_by_maxdistance
+  * order_by_hausdorffdistance
+  * order_by_distance_spheroid
+  * order_by_length2d_spheroid
+  * order_by_length3d_spheroid
+  * order_by_length_spheroid
+
   These let you chain together scopes to build geospatial queries:
 
     neighbourhood = Neighbourhood.find(12345)
@@ -94,6 +118,30 @@ We've also included some Rails integration for PostGIS, including:
         :limit => 10
       )
 
+=== Google Maps API Output
+
+Starting with version 0.1.0, ZGEL supports both Google Maps API
+version 2 and version 3 style outputs. By default and for the sake of
+backwards compatibility, API version 2 output will remain the default
+but as Google has deprecated API version 2, so shall we at some point
+in the future. To switch between API versions, use the
+Geos::GoogleMaps.use_api(version) method:
+
+  g = Geos.read('point(0 0)')
+  Geos::GoogleMaps.use_api(2)
+  puts g.to_g_marker
+  Geos::GoogleMaps.use_api(3)
+  puts g.to_g_marker
+
+Outputs
+
+  new google.maps.Marker(new google.maps.LatLng(0.0, 0.0), {})
+  new google.maps.Marker({"position": new google.maps.LatLng(0.0, 0.0)})
+
+At an unspecified point in the future, we'll likely make Google Maps
+API version 3 the default, but for the time being, we'll stick with
+version 2 since switching between the two is pretty painless.
+
 === Running ActiveRecord Tests
 
 ActiveRecord unit tests can be run by setting the TEST_ACTIVERECORD
@@ -105,4 +153,3 @@ to the directory the files are in to create the database properly. You
 can also set the database up manually before running the tests -- just
 make sure the database has PostGIS installed with the spatial_ref_sys
 table populated and you'll be fine.
-

data/Rakefile

@@ -2,17 +2,18 @@
 # -*- ruby -*-
 
 require 'rubygems'
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 $:.push 'lib'
 
+version = File.read('VERSION') rescue ''
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "geos-extensions"
-    gem.version = "0.0.7"
     gem.summary = "Extensions for the GEOS library."
     gem.description = gem.summary
     gem.email = "code@zoocasa.com"
@@ -32,8 +33,9 @@ end
 
 desc 'Build docs'
 Rake::RDocTask.new do |t|
-  require 'rdoc/rdoc'
+  require 'rdoc'
   t.main = 'README.rdoc'
+  t.title = "Geos Extensions #{version}"
   t.rdoc_dir = 'doc'
   t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
 end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/app/models/geos/geometry_column.rb

@@ -0,0 +1,39 @@
+
+module Geos
+  class GeometryColumn < ::ActiveRecord::Base
+    set_table_name 'geometry_columns'
+    set_inheritance_column 'nonexistent_column_name_type'
+
+    belongs_to :spatial_ref_sys,
+      :foreign_key => :srid,
+      :inverse_of => :geometry_columns
+
+    after_initialize proc { |row|
+      row.f_table_catalog ||= ''
+    }
+
+    validates :f_table_catalog,
+      :length => {
+        :minimum => 0
+      }
+
+    validates :f_table_schema,
+      :presence => true
+
+    validates :f_table_name,
+      :presence => true
+
+    validates :f_geometry_column,
+      :presence => true
+
+    validates :coord_dimension,
+      :presence => true
+
+    validates :srid,
+      :presence => true
+
+    validates :type,
+      :presence => true
+  end
+end
+

data/app/models/geos/spatial_ref_sys.rb

@@ -0,0 +1,12 @@
+
+module Geos
+  class SpatialRefSys < ::ActiveRecord::Base
+    set_table_name 'spatial_ref_sys'
+    set_primary_key 'srid'
+
+    has_many :geometry_columns,
+      :foreign_key => :srid,
+      :inverse_of => :spatial_ref_sys
+  end
+end
+

data/geos-extensions.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{geos-extensions}
-  s.version = "0.0.7"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["J Smith"]
-  s.date = %q{2011-03-21}
+  s.date = %q{2011-06-27}
   s.description = %q{Extensions for the GEOS library.}
   s.email = %q{code@zoocasa.com}
   s.extra_rdoc_files = [
@@ -19,36 +19,36 @@ Gem::Specification.new do |s|
     "MIT-LICENSE",
     "README.rdoc",
     "Rakefile",
+    "VERSION",
+    "app/models/geos/geometry_column.rb",
+    "app/models/geos/spatial_ref_sys.rb",
     "geos-extensions.gemspec",
-    "lib/active_record_extensions.rb",
-    "lib/active_record_extensions/connection_adapters/postgresql_adapter.rb",
-    "lib/active_record_extensions/geometry_columns.rb",
-    "lib/active_record_extensions/geospatial_scopes.rb",
     "lib/geos-extensions.rb",
+    "lib/geos/active_record_extensions.rb",
+    "lib/geos/active_record_extensions/connection_adapters/postgresql_adapter.rb",
+    "lib/geos/active_record_extensions/geometry_columns.rb",
+    "lib/geos/active_record_extensions/geospatial_scopes.rb",
+    "lib/geos/geos_helper.rb",
+    "lib/geos/google_maps.rb",
+    "lib/geos/google_maps/api_2.rb",
+    "lib/geos/google_maps/api_3.rb",
+    "lib/geos/google_maps/polyline_encoder.rb",
+    "lib/geos/rails/engine.rb",
     "lib/geos_extensions.rb",
-    "lib/geos_helper.rb",
-    "lib/google_maps.rb",
-    "lib/google_maps/polyline_encoder.rb",
-    "rails/railtie.rb",
-    "rails/tasks/test.rake",
+    "lib/tasks/test.rake",
     "test/fixtures/foos.yml",
     "test/geometry_columns_test.rb",
     "test/geospatial_scopes_test.rb",
+    "test/google_maps_api_2_test.rb",
+    "test/google_maps_api_3_test.rb",
     "test/reader_test.rb",
     "test/test_helper.rb",
     "test/writer_test.rb"
   ]
   s.homepage = %q{http://github.com/zoocasa/geos-extensions}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
+  s.rubygems_version = %q{1.7.2}
   s.summary = %q{Extensions for the GEOS library.}
-  s.test_files = [
-    "test/geometry_columns_test.rb",
-    "test/geospatial_scopes_test.rb",
-    "test/reader_test.rb",
-    "test/test_helper.rb",
-    "test/writer_test.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/lib/{active_record_extensions → geos/active_record_extensions}/geometry_columns.rb

@@ -1,8 +1,4 @@
 
-if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-  require File.join(GEOS_EXTENSIONS_BASE, *%w{ active_record_extensions connection_adapters postgresql_adapter })
-end
-
 module Geos
   module ActiveRecord #:nodoc:
 
@@ -185,8 +181,8 @@ module Geos
 
               GEOMETRY_COLUMN_OUTPUT_FORMATS.reject { |f| f == 'geos' }.each do |f|
                 src, line = <<-EOF, __LINE__ + 1
-                  def #{k.name}_#{f}
-                    @#{k.name}_#{f} ||= self.#{k.name}_geos.to_#{f} rescue nil
+                  def #{k.name}_#{f}(*args)
+                    @#{k.name}_#{f} ||= self.#{k.name}_geos.to_#{f}(*args) rescue nil
                   end
                 EOF
                 self.class_eval(src, __FILE__, line)

data/lib/{active_record_extensions → geos/active_record_extensions}/geospatial_scopes.rb

@@ -71,8 +71,15 @@ module Geos
     # * :wkb_options - in order to facilitate some conversions, geometries
     #   are converted to WKB. The default is `{:include_srid => true}` to
     #   force the geometry to use PostGIS's Extended WKB.
+    # * :allow_null - relationship scopes have the option of treating NULL
+    #   geometry values as TRUE, i.e.
+    #
+    #     ST_within(the_geom, ...) OR the_geom IS NULL
+    #
     # * :desc - the order_by scopes have an additional :desc option to alllow
     #   for DESC ordering.
+    # * :nulls - the order_by scopes also allow you to specify whether you
+    #   want NULL values to be sorted first or last.
     #
     # == SRID Detection
     #
@@ -206,7 +213,11 @@ module Geos
                   end
 
                   ret << ', ?' * function_options[:additional_args]
-                  ret << %{)#{options[:append]}}
+                  ret << ')'
+
+                  if options[:allow_null]
+                    ret << " OR #{self.quoted_table_name}.#{column_name} IS NULL"
+                  end
                 end
               end
 

data/lib/geos/active_record_extensions.rb

@@ -0,0 +1,10 @@
+
+require File.join(Geos::GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions connection_adapters postgresql_adapter })
+
+module Geos
+  module ActiveRecord
+    autoload :GeometryColumns, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions geometry_columns })
+    autoload :GeospatialScopes, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions geospatial_scopes })
+  end
+end
+

data/lib/geos/geos_helper.rb

@@ -0,0 +1,104 @@
+
+module Geos::Helper
+  JS_ESCAPE_MAP = {
+    '\\'    => '\\\\',
+    '</'    => '<\/',
+    "\r\n"  => '\n',
+    "\n"    => '\n',
+    "\r"    => '\n',
+    '"'     => '\\"',
+    "'"     => "\\'"
+  }
+
+  # 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
+      }
+    end
+
+    "{#{json.join(', ')}}"
+  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]
+    end
+  end
+
+  def self.xml_options(*args) #:nodoc:
+    xml = if Builder::XmlMarkup === args.first
+      args.first
+    else
+      Builder::XmlMarkup.new(:indent => 4)
+    end
+
+    options = if Hash === args.last
+      args.last
+    else
+      Hash.new
+    end
+
+    [ xml, options ]
+  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
+    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
+        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
+
+  def self.number_with_precision(number, precision = 6)
+    rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
+    "%01.#{precision}f" % rounded_number
+  end
+end

data/lib/geos/google_maps/api_2.rb

@@ -0,0 +1,180 @@
+
+module Geos::GoogleMaps::Api2
+  module Geometry
+    # Returns a new GLatLngBounds object with the proper GLatLngs in place
+    # for determining the geometry bounds.
+    def to_g_lat_lng_bounds_api2(options = {})
+      klass = if options[:short_class]
+        'GLatLngBounds'
+      else
+        'google.maps.LatLngBounds'
+      end
+
+      "new #{klass}(#{self.lower_left.to_g_lat_lng_api2(options)}, #{self.upper_right.to_g_lat_lng_api2(options)})"
+    end
+
+    # Returns a String in Google Maps' GLatLngBounds#toString() format.
+    def to_g_lat_lng_bounds_string_api2(precision = 10)
+      "((#{self.lower_left.to_g_url_value_api2(precision)}), (#{self.upper_right.to_g_url_value_api2(precision)}))"
+    end
+
+    # Returns a new GPolyline.
+    def to_g_polyline_api2(polyline_options = {}, options = {})
+      self.coord_seq.to_g_polyline_api2(polyline_options, options)
+    end
+
+    # Returns a new GPolygon.
+    def to_g_polygon_api2(polygon_options = {}, options = {})
+      self.coord_seq.to_g_polygon_api2(polygon_options, options)
+    end
+
+    # Returns a new GMarker at the centroid of the geometry. The options
+    # Hash works the same as the Google Maps API GMarkerOptions class does,
+    # but allows for underscored Ruby-like options which are then converted
+    # to the appropriate camel-cased Javascript options.
+    def to_g_marker_api2(marker_options = {}, options = {})
+      klass = if options[:short_class]
+        'GMarker'
+      else
+        'google.maps.Marker'
+      end
+
+      opts = Geos::Helper.camelize_keys(marker_options)
+
+      "new #{klass}(#{self.centroid.to_g_lat_lng(options)}, #{opts.to_json})"
+    end
+  end
+
+  module CoordinateSequence
+    # Returns a Ruby Array of GLatLngs.
+    def to_g_lat_lng_api2(options = {})
+      klass = if options[:short_class]
+        'GLatLng'
+      else
+        'google.maps.LatLng'
+      end
+
+      self.to_a.collect do |p|
+        "new #{klass}(#{p[1]}, #{p[0]})"
+      end
+    end
+
+    # Returns a new GPolyline. Note that this GPolyline just uses whatever
+    # coordinates are found in the sequence in order, so it might not
+    # make much sense at all.
+    #
+    # The options Hash follows the Google Maps API arguments to the
+    # GPolyline constructor and include :color, :weight, :opacity and
+    # :options. 'null' is used in place of any unset options.
+    def to_g_polyline_api2(polyline_options = {}, options = {})
+      klass = if options[:short_class]
+        'GPolyline'
+      else
+        'google.maps.Polyline'
+      end
+
+      poly_opts = if polyline_options[:polyline_options]
+        Geos::Helper.camelize_keys(polyline_options[:polyline_options])
+      end
+
+      args = [
+        (polyline_options[:color] ? "'#{Geos::Helper.escape_javascript(polyline_options[:color])}'" : 'null'),
+        (polyline_options[:weight] || 'null'),
+        (polyline_options[:opacity] || 'null'),
+        (poly_opts ? poly_opts.to_json : 'null')
+      ].join(', ')
+
+      "new #{klass}([#{self.to_g_lat_lng(options).join(', ')}], #{args})"
+    end
+
+    # Returns a new GPolygon. Note that this GPolygon just uses whatever
+    # coordinates are found in the sequence in order, so it might not
+    # make much sense at all.
+    #
+    # The options Hash follows the Google Maps API arguments to the
+    # GPolygon constructor and include :stroke_color, :stroke_weight,
+    # :stroke_opacity, :fill_color, :fill_opacity and :options. 'null' is
+    # used in place of any unset options.
+    def to_g_polygon_api2(polygon_options = {}, options = {})
+      klass = if options[:short_class]
+        'GPolygon'
+      else
+        'google.maps.Polygon'
+      end
+
+      poly_opts = if polygon_options[:polygon_options]
+        Geos::Helper.camelize_keys(polygon_options[:polygon_options])
+      end
+
+      args = [
+        (polygon_options[:stroke_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:stroke_color])}'" : 'null'),
+        (polygon_options[:stroke_weight] || 'null'),
+        (polygon_options[:stroke_opacity] || 'null'),
+        (polygon_options[:fill_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:fill_color])}'" : 'null'),
+        (polygon_options[:fill_opacity] || 'null'),
+        (poly_opts ? poly_opts.to_json : 'null')
+      ].join(', ')
+      "new #{klass}([#{self.to_g_lat_lng_api2(options).join(', ')}], #{args})"
+    end
+  end
+
+  module Point
+    # Returns a new GLatLng.
+    def to_g_lat_lng_api2(options = {})
+      klass = if options[:short_class]
+        'GLatLng'
+      else
+        'google.maps.LatLng'
+      end
+
+      "new #{klass}(#{self.lat}, #{self.lng})"
+    end
+
+    # Returns a new GPoint
+    def to_g_point_api2(options = {})
+      klass = if options[:short_class]
+        'GPoint'
+      else
+        'google.maps.Point'
+      end
+
+      "new #{klass}(#{self.x}, #{self.y})"
+    end
+  end
+
+  module Polygon
+    # Returns a GPolyline of the exterior ring of the Polygon. This does
+    # not take into consideration any interior rings the Polygon may
+    # have.
+    def to_g_polyline_api2(polyline_options = {}, options = {})
+      self.exterior_ring.to_g_polyline_api2(polyline_options, options)
+    end
+
+    # Returns a GPolygon of the exterior ring of the Polygon. This does
+    # not take into consideration any interior rings the Polygon may
+    # have.
+    def to_g_polygon_api2(polygon_options = {}, options = {})
+      self.exterior_ring.to_g_polygon_api2(polygon_options, options)
+    end
+  end
+
+  module GeometryCollection
+    # Returns a Ruby Array of GPolylines for each geometry in the
+    # collection.
+    def to_g_polyline_api2(polyline_options = {}, options = {})
+      self.collect do |p|
+        p.to_g_polyline_api2(polyline_options, options)
+      end
+    end
+
+    # Returns a Ruby Array of GPolygons for each geometry in the
+    # collection.
+    def to_g_polygon_api2(polygon_options = {}, options = {})
+      self.collect do |p|
+        p.to_g_polygon_api2(polygon_options, options)
+      end
+    end
+  end
+end
+
+Geos::GoogleMaps.use_api(2)