geos-extensions 0.2.2 → 0.3.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDdiYzQwZjU5MjYzNDMzNDI4ZGZjOTI5NmI0Yzc2NDJjOTYxNzE1Zg==
+  data.tar.gz: !binary |-
+    NDc0MWJiM2RmOTJiMzE5NTA2NGM3ZmZhMmQ3MDk1YWZjZTEwNmRkNw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MGM2NDQ3ODUzYTBkM2Y3OGViZGZkNWE3OTc2OTA4NWE1NTc3OTc5ZTM2MTZj
+    MGMwNDA0OTY2Nzg4MTQ5OWRiMDlkODYwMjc4ZDhlZmJjMTQxMjFjMjVkZTAx
+    MzRmYTFmNmY2ZTk2NTdjZTI3Zjc4NTFlNWI0Y2UzMWYyZjFkZDA=
+  data.tar.gz: !binary |-
+    YTkxYzA1NTMzYTdjNzU4NmFkZTY4YTEwNjM5MjhjYWE1MWMzNTJmOWM1MTNi
+    ZTE5YjJhZDU3MDY2M2JjMzUyZGIyYWQxM2E5OGM2MGNkZTRhMDQ1ZTVjYTc1
+    MDg4YjdhY2VjOWFkMzNjNzM4NWRjZjRiOTRlM2QxZTI5YmY2Yjc=

data/.gitignore

@@ -8,6 +8,7 @@
 *tmp*
 pkg/
 doc/
+coverage/
 *.orig
 *.patch
 .vimrc_local
@@ -19,3 +20,5 @@ test/local_database.yml
 .config
 .yardoc
 Gemfile.lock
+Gemfile.local
+Guardfile.local

data/Gemfile

@@ -1,3 +1,20 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem "rdoc", "~> 3.12"
+gem "rake", "~> 10.0"
+gem "minitest"
+gem "minitest-reporters"
+gem "guard-minitest"
+gem "simplecov"
+
+if RbConfig::CONFIG['host_os'] =~ /^darwin/
+  gem "rb-fsevent"
+  gem "growl"
+end
+
+if File.exists?('Gemfile.local')
+  instance_eval File.read('Gemfile.local')
+end
+

data/Guardfile

@@ -0,0 +1,17 @@
+
+guard 'minitest', :test_folders => 'test', :test_file_patterns => '*_tests.rb' do
+  watch(%r|^test/(.+)_tests\.rb|)
+
+  watch(%r|^lib/(.*)([^/]+)\.rb|) do |m|
+    "test/#{m[1]}#{m[2]}_tests.rb"
+  end
+
+  watch(%r|^test/test_helper\.rb|) do
+    "test"
+  end
+end
+
+if File.exists?('Guardfile.local')
+  instance_eval File.read('Guardfile.local')
+end
+

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 2167961 Ontario Inc., Zoocasa <code@zoocasa.com>
+Copyright (c) 2013 2167961 Ontario Inc., Zoocasa <code@zoocasa.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.rdoc

@@ -1,5 +1,5 @@
 
-== Zoocasa GEOS Extensions
+= Zoocasa GEOS Extensions
 
 The Zoocasa GEOS Extensions library (ZGEL) is a set of utilities and tools that
 extend the GEOS Ruby bindings module. From http://geos.refractions.net/ ...
@@ -46,85 +46,7 @@ ZGEL contains a number of enhancements to the GEOS Ruby library:
 
 * Geos::GeometryCollection has been made an Enumerable.
 
-We've also included some Rails integration for PostGIS, including:
-
-* automatic detection of geometry columns and just-in-time conversions
-  for input and output to and from WKB when using PostGIS. This allows
-  you to do stuff like this with your ActiveRecord models:
-
-    m = MyModel.find(12345)
-    m.the_geom # => spits out the untouched geometry value as a string in WKB
-    m.the_geom_geos # => spits out the geometry wrapped in a Geos::Geometry object
-    m.the_geom = 'POINT(0 0)' # => setters will automatically make
-    conversions from any of the formats that the Geos.read can recognize,
-    so Google Maps formats, WKT, WKB, etc. are all converted
-    automatically.
-    m.the_geom_wkt # => automatically converts to a WKT string
-    m.the_geom_wkb_bin # => automatically converts to WKB in binary
-
-  There's also some funky SRID handling code that will automatically
-  look in the geometry_columns table to make conversions for you when
-  necessary. Saving WKT as "SRID=default; POINT(0 0)" for instance will
-  automatically set the SRID when saving the ActiveRecord, or the SRID
-  can be specified manually.
-
-* multiple geometry columns are supported and detected for
-  automatically. These column accessors are all generated dynamically at
-  run time.
-
-* automatic generation of named scopes for ActiveRecord models. The
-  usual suspects are supported:
-
-  * st_contains
-  * st_containsproperly
-  * st_covers
-  * st_coveredby
-  * st_crosses
-  * st_disjoint
-  * st_equals
-  * st_intersects
-  * st_orderingequals
-  * st_overlaps
-  * st_touches
-  * 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)
-    my_model = MyModel.active.
-      recent.
-      st_within(neighbourhood.the_geom_geos.envelope).
-      st_dwithin(point, 0.1).
-      all(
-        :limit => 10
-      )
-
-=== Google Maps API Output
+== 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
@@ -148,14 +70,20 @@ 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
-environment variable when running `rake test`. The test database name
-is geos_extensions_unit_tests and requires PostGIS to be installed. The
-test scripts will try to find your postgis.sql and spatial_ref_sys.sql
-files, but if it needs a hint, set the POSTGIS_PATH environment variable
-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.
+== ActiveRecord Extensions
+
+This extension used to contain a bunch of extensions to ActiveRecord, but as of
+version 0.3.0 we have decided to strip those extensions out and move them into
+their own gem called activerecord-spatial available at
+https://github.com/zoocasa/activerecord-spatial .
+
+== Thanks
+
+* Thanks to Charlie Savage for donating for YAML dumping and loading
+  support.
+
+== License
+
+This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
+details.
+

data/Rakefile

@@ -2,23 +2,12 @@
 # -*- ruby -*-
 
 require 'rubygems'
-
-gem 'rdoc', '~> 3.12'
-
 require 'rubygems/package_task'
 require 'rake/testtask'
 require 'rdoc/task'
 require 'bundler/gem_tasks'
 
-if RUBY_VERSION >= '1.9'
-  begin
-    gem 'psych'
-  rescue Exception => e
-    # it's okay, fall back on the bundled psych
-  end
-end
-
-$:.push 'lib'
+$:.push File.expand_path(File.dirname(__FILE__), 'lib')
 
 version = Geos::Extensions::VERSION
 

data/geos-extensions.gemspec

@@ -20,14 +20,6 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/zoocasa/geos-extensions"
   s.require_paths = ["lib"]
 
-  s.add_dependency("activerecord", [">= 2.3"])
-  s.add_dependency("ffi-geos", ["~> 0.0.4"])
-  if RUBY_PLATFORM == "java"
-    s.add_dependency("activerecord-jdbcpostgresql-adapter")
-  else
-    s.add_dependency("pg")
-  end
-  s.add_dependency("rdoc")
-  s.add_dependency("rake", ["~> 0.9"])
+  s.add_dependency("ffi-geos", ["~> 0.1"])
 end
 

data/lib/geos-extensions.rb

@@ -1,13 +1,5 @@
 
 require File.join(File.dirname(__FILE__), *%w{ geos_extensions })
 
-if defined?(ActiveRecord)
-  require File.join(Geos::GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions })
-end
-
-if defined?(Rails) && Rails::VERSION::MAJOR >= 3
-  require File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos rails engine })
-end
-
-Geos::GoogleMaps.use_api(2)
+Geos::GoogleMaps.use_api(3)
 

data/lib/geos/coordinate_sequence.rb

@@ -0,0 +1,92 @@
+
+module Geos
+  class CoordinateSequence
+    # Returns a Ruby Array of Arrays of coordinates within the
+    # CoordinateSequence in the form [ x, y, z ].
+    def to_a
+      (0...self.length).to_a.collect do |p|
+        [
+          self.get_x(p),
+          (self.dimensions >= 2 ? self.get_y(p) : nil),
+          (self.dimensions >= 3 && self.get_z(p) > 1.7e-306 ? self.get_z(p) : nil)
+        ].compact
+      end
+    end
+
+    # Build some XmlMarkup for KML. You can set various KML options like
+    # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
+    # will be converted automatically, i.e. :altitudeMode, not
+    # :altitude_mode.
+    def to_kml(*args)
+      xml, options = Geos::Helper.xml_options(*args)
+
+      xml.LineString(:id => options[:id]) do
+        xml.extrude(options[:extrude]) if options[:extrude]
+        xml.tessellate(options[:tessellate]) if options[:tessellate]
+        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitudeMode]
+        xml.coordinates do
+          self.to_a.each do
+            xml << (self.to_a.join(','))
+          end
+        end
+      end
+    end
+
+    # Build some XmlMarkup for GeoRSS GML. You should include the
+    # appropriate georss and gml XML namespaces in your document.
+    def to_georss(*args)
+      xml = Geos::Helper.xml_options(*args)[0]
+
+      xml.georss(:where) do
+        xml.gml(:LineString) do
+          xml.gml(:posList) do
+            xml << self.to_a.collect do |p|
+              "#{p[1]} #{p[0]}"
+            end.join(' ')
+          end
+        end
+      end
+    end
+
+    # Returns a Hash suitable for converting to JSON.
+    #
+    # Options:
+    #
+    # * :encoded - enable or disable Google Maps encoding. The default is
+    #   true.
+    # * :level - set the level of the Google Maps encoding algorithm.
+    def as_json(options = {})
+      options = {
+        :encoded => true,
+        :level => 3
+      }.merge options
+
+      if options[:encoded]
+        {
+          :type => 'lineString',
+          :encoded => true
+        }.merge(Geos::GoogleMaps::PolylineEncoder.encode(self.to_a, options[:level]))
+      else
+        {
+          :type => 'lineString',
+          :encoded => false,
+          :points => self.to_a
+        }
+      end
+    end
+    alias :to_jsonable :as_json
+
+    def as_geojson(options = {})
+      {
+        :type => 'LineString',
+        :coordinates => self.to_a
+      }
+    end
+    alias :to_geojsonable :as_geojson
+
+    def to_geojson(options = {})
+      self.to_geojsonable(options).to_json
+    end
+  end
+end
+

data/lib/geos/extensions/version.rb

@@ -1,7 +1,7 @@
 
 module Geos
   module Extensions
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end
 

data/lib/geos/geometry.rb

@@ -0,0 +1,252 @@
+
+module Geos
+  # This is our base module that we use for some generic methods used all
+  # over the place.
+  class Geometry
+    protected
+
+    WKB_WRITER_OPTIONS = [ :output_dimensions, :byte_order, :include_srid ].freeze
+    def wkb_writer(options = {}) #:nodoc:
+      writer = WkbWriter.new
+      options.reject { |k, v| !WKB_WRITER_OPTIONS.include?(k) }.each do |k, v|
+        writer.send("#{k}=", v)
+      end
+      writer
+    end
+
+    public
+
+    # Spits the geometry out into WKB in binary.
+    #
+    # You can set the :output_dimensions, :byte_order and :include_srid
+    # options via the options Hash.
+    def to_wkb_bin(options = {})
+      wkb_writer(options).write(self)
+    end
+
+    # Quickly call to_wkb_bin with :include_srid set to true.
+    def to_ewkb_bin(options = {})
+      options = {
+        :include_srid => true
+      }.merge options
+      to_wkb_bin(options)
+    end
+
+    # Spits the geometry out into WKB in hex.
+    #
+    # You can set the :output_dimensions, :byte_order and :include_srid
+    # options via the options Hash.
+    def to_wkb(options = {})
+      wkb_writer(options).write_hex(self)
+    end
+
+    # Quickly call to_wkb with :include_srid set to true.
+    def to_ewkb(options = {})
+      options = {
+        :include_srid => true
+      }.merge options
+      to_wkb(options)
+    end
+
+    # Spits the geometry out into WKT. You can specify the :include_srid
+    # option to create a PostGIS-style EWKT output.
+    def to_wkt(options = {})
+      writer = WktWriter.new
+
+      # Older versions of the Geos library don't allow for options here.
+      args = if WktWriter.instance_method(:write).arity < -1
+        [ options ]
+      else
+        []
+      end
+
+      ret = ''
+
+      if options[:include_srid]
+        srid = if options[:srid]
+          options[:srid]
+        else
+          self.srid
+        end
+
+        ret << "SRID=#{srid};"
+      end
+
+      ret << writer.write(self, *args)
+      ret
+    end
+
+    # Quickly call to_wkt with :include_srid set to true.
+    def to_ewkt(options = {})
+      options = {
+        :include_srid => true
+      }.merge options
+      to_wkt(options)
+    end
+
+    # Returns a Point for the envelope's upper left coordinate.
+    def upper_left
+      if defined?(@upper_left)
+        @upper_left
+      else
+        cs = self.envelope.exterior_ring.coord_seq
+        @upper_left = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(3)} #{cs.get_y(3)})")
+      end
+    end
+    alias :nw :upper_left
+    alias :northwest :upper_left
+
+    # Returns a Point for the envelope's upper right coordinate.
+    def upper_right
+      if defined?(@upper_right)
+        @upper_right
+      else
+        cs = self.envelope.exterior_ring.coord_seq
+        @upper_right = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(2)} #{cs.get_y(2)})")
+      end
+    end
+    alias :ne :upper_right
+    alias :northeast :upper_right
+
+    # Returns a Point for the envelope's lower right coordinate.
+    def lower_right
+      if defined?(@lower_right)
+        @lower_right
+      else
+        cs = self.envelope.exterior_ring.coord_seq
+        @lower_right = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(1)} #{cs.get_y(1)})")
+      end
+    end
+    alias :se :lower_right
+    alias :southeast :lower_right
+
+    # Returns a Point for the envelope's lower left coordinate.
+    def lower_left
+      if defined?(@lower_left)
+        @lower_left
+      else
+        cs = self.envelope.exterior_ring.coord_seq
+        @lower_left = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(0)} #{cs.get_y(0)})")
+      end
+    end
+    alias :sw :lower_left
+    alias :southwest :lower_left
+
+    # Northern-most Y coordinate.
+    def top
+      if defined?(@top)
+        @top
+      else
+        @top = self.upper_right.y
+      end
+    end
+    alias :n :top
+    alias :north :top
+
+    # Eastern-most X coordinate.
+    def right
+      if defined?(@right)
+        @right
+      else
+        @right = self.upper_right.x
+      end
+    end
+    alias :e :right
+    alias :east :right
+
+    # Southern-most Y coordinate.
+    def bottom
+      if defined?(@bottom)
+        @bottom
+      else
+        @bottom = self.lower_left.y
+      end
+    end
+    alias :s :bottom
+    alias :south :bottom
+
+    # Western-most X coordinate.
+    def left
+      if defined?(@left)
+        @left
+      else
+        @left = self.lower_left.x
+      end
+    end
+    alias :w :left
+    alias :west :left
+
+    # Spits out a bounding box the way Flickr likes it. You can set the
+    # precision of the rounding using the :precision option. In order to
+    # ensure that the box is indeed a box and not merely a point, the
+    # southwest coordinates are floored and the northeast point ceiled.
+    def to_flickr_bbox(options = {})
+      options = {
+        :precision => 1
+      }.merge(options)
+      precision = 10.0 ** options[:precision]
+
+      [
+        (self.west  * precision).floor / precision,
+        (self.south * precision).floor / precision,
+        (self.east  * precision).ceil / precision,
+        (self.north * precision).ceil / precision
+      ].join(',')
+    end
+
+    # Spits out the actual stringified GeoJSON.
+    def to_geojson(options = {})
+      self.to_geojsonable(options).to_json
+    end
+
+    # Returns the Y and X coordinates of the Geometry's centroid in an Array.
+    def lat_lng
+      self.centroid.to_a[0, 2].reverse
+    end
+    alias :lat_long :lat_lng
+    alias :latlng :lat_lng
+    alias :latlong :lat_lng
+    alias :lat_lon :lat_lng
+    alias :latlon :lat_lng
+
+    # Returns the X and Y coordinates of the Geometry's centroid in an Array.
+    def lng_lat
+      self.centroid.to_a[0, 2]
+    end
+    alias :long_lat :lng_lat
+    alias :lnglat :lng_lat
+    alias :longlat :lng_lat
+    alias :lon_lat :lng_lat
+    alias :lonlat :lng_lat
+
+    # Spits out a Hash containing the cardinal points that describe the
+    # Geometry's bbox.
+    def to_bbox(long_or_short_names = :long)
+      case long_or_short_names
+        when :long
+          {
+            :north => self.north,
+            :east => self.east,
+            :south => self.south,
+            :west => self.west
+          }
+        when :short
+          {
+            :n => self.north,
+            :e => self.east,
+            :s => self.south,
+            :w => self.west
+          }
+        else
+          raise ArgumentError.new("Expected either :long or :short for long_or_short_names argument")
+      end
+    end
+
+    # Spits out a PostGIS BOX2D-style representing the Geometry's bounding
+    # box.
+    def to_box2d
+      "BOX(#{self.southwest.to_a.join(' ')}, #{self.northeast.to_a.join(' ')})"
+    end
+  end
+end
+