geos-extensions 0.0.6 → 0.0.7

data/Rakefile

@@ -12,7 +12,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "geos-extensions"
-    gem.version = "0.0.6"
+    gem.version = "0.0.7"
     gem.summary = "Extensions for the GEOS library."
     gem.description = gem.summary
     gem.email = "code@zoocasa.com"

data/geos-extensions.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{geos-extensions}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["J Smith"]
-  s.date = %q{2011-03-17}
+  s.date = %q{2011-03-21}
   s.description = %q{Extensions for the GEOS library.}
   s.email = %q{code@zoocasa.com}
   s.extra_rdoc_files = [

data/lib/active_record_extensions/geospatial_scopes.rb

@@ -23,10 +23,46 @@ module Geos
     # * st_within
     # * st_dwithin
     #
-    # The first argument to each method is can be a Geos::Geometry-based
+    # The first argument to each of these methods can be a Geos::Geometry-based
     # object or anything readable by Geos.read along with an optional
     # options Hash.
     #
+    # For ordering, we have the following:
+    #
+    # The following scopes take no arguments:
+    #
+    #  * 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
+    #
+    # These next scopes allow you to specify a geometry argument for
+    # measurement:
+    #
+    #  * order_by_distance
+    #  * order_by_distance_sphere
+    #  * order_by_maxdistance
+    #  * order_by_hausdorffdistance (additionally allows you to set the
+    #    densify_frac argument)
+    #  * order_by_distance_spheroid (requires an additional SPHEROID
+    #    string to calculate against)
+    #
+    # These next scopes allow you to specify a SPHEROID string to calculate
+    # against:
+    #
+    #  * order_by_length2d_spheroid
+    #  * order_by_length3d_spheroid
+    #  * order_by_length_spheroid
+    #
     # == Options
     #
     # * :column - the column to compare against. The default is 'the_geom'.
@@ -35,6 +71,8 @@ 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.
+    # * :desc - the order_by scopes have an additional :desc option to alllow
+    #   for DESC ordering.
     #
     # == SRID Detection
     #
@@ -71,108 +109,251 @@ module Geos
         within
       }.freeze
 
-      def self.included(base)
-        RELATIONSHIPS.each do |relationship|
-          src, line = <<-EOF, __LINE__ + 1
-            #{SCOPE_METHOD} :st_#{relationship}, lambda { |*args|
-              raise ArgumentError.new("wrong number of arguments (\#{args.length} for 1-2)") unless
-                args.length.between?(1, 2)
+      ZERO_ARGUMENT_MEASUREMENTS = %w{
+        ndims
+        npoints
+        nrings
+        numgeometries
+        numinteriorring
+        numinteriorrings
+        numpoints
+        length3d
+        length
+        length2d
+        perimeter
+        perimeter2d
+        perimeter3d
+      }
 
-              options = {
-                :column => 'the_geom',
-                :use_index => true
-              }.merge(args.extract_options!)
+      ONE_GEOMETRY_ARGUMENT_MEASUREMENTS = %w{
+        distance
+        distance_sphere
+        maxdistance
+      }
 
-              column_name = self.connection.quote_table_name(options[:column])
-              column_srid = self.srid_for(options[:column])
+      ONE_ARGUMENT_MEASUREMENTS = %w{
+        length2d_spheroid
+        length3d_spheroid
+        length_spheroid
+      }
 
-              geom = if args.first.is_a?(String) && args.first =~ /^SRID=default;/
-                args.first.sub(/default/, column_srid.to_s)
-              else
-                args.first
+      def self.included(base)
+        base.class_eval do
+          class << self
+            protected
+              def set_srid_or_transform(column_srid, geom_srid, geos)
+                sql = if column_srid != geom_srid
+                  if column_srid == -1 || geom_srid == -1
+                    %{ST_SetSRID(?, #{column_srid})}
+                  else
+                    %{ST_Transform(?, #{column_srid})}
+                  end
+                else
+                  %{?}
+                end
+
+                sanitize_sql([ sql, geos.to_ewkb ])
               end
 
-              geos = Geos.read(geom)
+              def read_geos(geom, column_srid)
+                if geom.is_a?(String) && geom =~ /^SRID=default;/
+                  geom = geom.sub(/default/, column_srid.to_s)
+                end
+                Geos.read(geom)
+              end
 
-              geom_srid = if geos.srid == 0
-                -1
-              else
-                geos.srid
+              def read_geom_srid(geos)
+                if geos.srid == 0
+                  -1
+                else
+                  geos.srid
+                end
               end
 
-              function = if options[:use_index]
-                "ST_#{relationship}"
-              else
-                "_ST_#{relationship}"
+              def default_options(options)
+                {
+                  :column => 'the_geom',
+                  :use_index => true
+                }.merge(options || {})
               end
 
-              conditions = if column_srid != geom_srid
-                if column_srid == -1 || geom_srid == -1
-                  %{\#{function}(\#{column_name}, ST_SetSRID(?, \#{column_srid}))}
+              def function_name(function, use_index)
+                if use_index
+                  "ST_#{function}"
                 else
-                  %{\#{function}(\#{column_name}, ST_Transform(?, \#{column_srid}))}
+                  "_ST_#{function}"
+                end
+              end
+
+              def build_function_call(function, geom = nil, options = {}, function_options = {})
+                options = default_options(options)
+
+                function_options = {
+                  :additional_args => 0
+                }.merge(function_options)
+
+                ''.tap do |ret|
+                  column_name = self.connection.quote_table_name(options[:column])
+                  ret << "#{function_name(function, options[:use_index])}(#{self.quoted_table_name}.#{column_name}"
+
+                  if geom
+                    column_srid = self.srid_for(options[:column])
+
+                    geos = read_geos(geom, column_srid)
+                    geom_srid = read_geom_srid(geos)
+
+                    ret << %{, #{self.set_srid_or_transform(column_srid, geom_srid, geos)}}
+                  end
+
+                  ret << ', ?' * function_options[:additional_args]
+                  ret << %{)#{options[:append]}}
                 end
-              else
-                %{\#{function}(\#{column_name}, ?)}
               end
 
+              def additional_ordering(options = nil)
+                options ||= {}
+
+                ''.tap do |ret|
+                    if options[:desc]
+                      ret << ' DESC'
+                    end
+
+                    if options[:nulls]
+                      ret << " NULLS #{options[:nulls].to_s.upcase}"
+                    end
+                end
+              end
+
+              def assert_arguments_length(args, min, max)
+                raise ArgumentError.new("wrong number of arguments (#{args.length} for #{min}-#{max})") unless
+                  args.length.between?(min, max)
+              end
+          end
+        end
+
+        RELATIONSHIPS.each do |relationship|
+          src, line = <<-EOF, __LINE__ + 1
+            #{SCOPE_METHOD} :st_#{relationship}, lambda { |*args|
+              assert_arguments_length(args, 1, 2)
+
               {
-                :conditions => [
-                  conditions,
-                  geos.to_ewkb
-                ]
+                :conditions => build_function_call(
+                  '#{relationship}',
+                  *args
+                )
               }
             }
           EOF
           base.class_eval(src, __FILE__, line)
         end
 
-        src, line = <<-EOF, __LINE__ + 1
-          #{SCOPE_METHOD} :st_dwithin, lambda { |*args|
-            raise ArgumentError.new("wrong number of arguments (\#{args.length} for 2-3)") unless
-              args.length.between?(2, 3)
-
-            options = {
-              :column => 'the_geom',
-              :use_index => true
-            }.merge(args.extract_options!)
-
-            geom, distance = Geos.read(args.first), args[1]
-
-            column_name = ::ActiveRecord::Base.connection.quote_table_name(options[:column])
-            column_srid = self.srid_for(options[:column])
-            geom_srid = if geom.srid == 0
-              -1
-            else
-              geom.srid
-            end
-
-            function = if options[:use_index]
-              'ST_dwithin'
-            else
-              '_ST_dwithin'
-            end
-
-            conditions = if column_srid != geom_srid
-              if column_srid == -1 || geom_srid == -1
-                %{\#{function}(\#{column_name}, ST_SetSRID(?, \#{column_srid}), ?)}
-              else
-                %{\#{function}(\#{column_name}, ST_Transform(?, \#{column_srid}), ?)}
-              end
-            else
-              %{\#{function}(\#{column_name}, ?, ?)}
-            end
+        base.class_eval do
+          send(SCOPE_METHOD, :st_dwithin, lambda { |*args|
+            assert_arguments_length(args, 2, 3)
+            geom, distance, options = args
 
             {
               :conditions => [
-                conditions,
-                geom.to_ewkb,
+                build_function_call('dwithin', geom, options, :additional_args => 1),
                 distance
               ]
             }
-          }
-        EOF
-        base.class_eval(src, __FILE__, line)
+          })
+        end
+
+        ZERO_ARGUMENT_MEASUREMENTS.each do |measurement|
+          src, line = <<-EOF, __LINE__ + 1
+            #{SCOPE_METHOD} :order_by_#{measurement}, lambda { |*args|
+              assert_arguments_length(args, 0, 1)
+              options = args[0]
+
+              function_call = build_function_call('#{measurement}', nil, options)
+              function_call << additional_ordering(options)
+
+              {
+                :order => function_call
+              }
+            }
+          EOF
+          base.class_eval(src, __FILE__, line)
+        end
+
+        ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.each do |measurement|
+          src, line = <<-EOF, __LINE__ + 1
+            #{SCOPE_METHOD} :order_by_#{measurement}, lambda { |*args|
+              assert_arguments_length(args, 1, 2)
+              geom, options = args
+
+              function_call = build_function_call('#{measurement}', geom, options)
+              function_call << additional_ordering(options)
+
+              {
+                :order => function_call
+              }
+            }
+          EOF
+          base.class_eval(src, __FILE__, line)
+        end
+
+        ONE_ARGUMENT_MEASUREMENTS.each do |measurement|
+          src, line = <<-EOF, __LINE__ + 1
+            #{SCOPE_METHOD} :order_by_#{measurement}, lambda { |*args|
+              assert_arguments_length(args, 1, 2)
+              argument, options = args
+
+              function_call = build_function_call('#{measurement}', nil, options, :additional_args => 1)
+              function_call << additional_ordering(options)
+
+              {
+                :order => sanitize_sql([ function_call, argument ])
+              }
+            }
+          EOF
+          base.class_eval(src, __FILE__, line)
+        end
+
+        base.class_eval do
+          send(SCOPE_METHOD, :order_by_hausdorffdistance, lambda { |*args|
+            assert_arguments_length(args, 1, 3)
+            options = args.extract_options!
+            geom, densify_frac = args
+
+            function_call = build_function_call(
+              'hausdorffdistance',
+              geom,
+              options,
+              :additional_args => (densify_frac.present? ? 1 : 0)
+            )
+            function_call << additional_ordering(options)
+
+            {
+              :order => sanitize_sql([
+                function_call,
+                densify_frac
+              ])
+            }
+          })
+
+          send(SCOPE_METHOD, :order_by_distance_spheroid, lambda { |*args|
+            assert_arguments_length(args, 2, 3)
+            geom, spheroid, options = args
+
+            function_call = build_function_call(
+              'distance_spheroid',
+              geom,
+              options,
+              :additional_args => 1
+            )
+            function_call << additional_ordering(options)
+
+            {
+              :order => sanitize_sql([
+                function_call,
+                spheroid
+              ])
+            }
+          })
+        end
       end
     end
   end

data/lib/geos_extensions.rb

@@ -196,9 +196,17 @@ module Geos
     # 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 = ''
       ret << "SRID=#{self.srid};" if options[:include_srid]
-      ret << writer.write(self, options)
+      ret << writer.write(self, *args)
       ret
     end
 

data/test/geospatial_scopes_test.rb

@@ -84,5 +84,179 @@ if ENV['TEST_ACTIVERECORD']
       assert_equal([1, 2, 3], Foo.st_disjoint('SRID=4269; POINT(100 100)', :column => :the_other_geom).all.collect(&:id).sort)
       assert_equal([3], Foo.st_contains('SRID=4269; POINT(7 7)', :column => :the_other_geom).all.collect(&:id).sort)
     end
+
+    def test_order_by_distance
+      assert_equal([3, 1, 2], Foo.order_by_distance('POINT(1 1)').all.collect(&:id))
+    end
+
+    def test_order_by_distance_desc
+      assert_equal([2, 1, 3], Foo.order_by_distance('POINT(1 1)', :desc => true).all.collect(&:id))
+    end
+
+    def test_order_by_distance_sphere
+      assert_equal([3, 1, 2], Foo.order_by_distance_sphere('POINT(1 1)').all.collect(&:id))
+    end
+
+    def test_order_by_distance_sphere_desc
+      assert_equal([2, 1, 3], Foo.order_by_distance_sphere('POINT(1 1)', :desc => true).all.collect(&:id))
+    end
+
+    def test_order_by_maxdistance
+      assert_equal([1, 3, 2], Foo.order_by_maxdistance('POINT(1 1)').all.collect(&:id))
+    end
+
+    def test_order_by_maxdistance_desc
+      assert_equal([2, 3, 1], Foo.order_by_maxdistance('POINT(1 1)', :desc => true).all.collect(&:id))
+    end
+
+    def test_order_by_ndims
+      assert_equal([1, 2, 3], Foo.order_by_ndims.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_ndims_desc
+      assert_equal([1, 2, 3], Foo.order_by_ndims(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_npoints
+      assert_equal([1, 2, 3], Foo.order_by_npoints.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_npoints_desc
+      assert_equal([3, 1, 2], Foo.order_by_npoints(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_nrings
+      assert_equal([1, 2, 3], Foo.order_by_nrings.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_nrings_desc
+      assert_equal([3, 1, 2], Foo.order_by_nrings(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numgeometries
+      assert_equal([1, 2, 3], Foo.order_by_numgeometries.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numgeometries_desc
+      assert_equal([1, 2, 3], Foo.order_by_numgeometries(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numinteriorring
+      assert_equal([3, 1, 2], Foo.order_by_numinteriorring.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numinteriorring_desc
+      assert_equal([1, 2, 3], Foo.order_by_numinteriorring(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numinteriorrings
+      assert_equal([3, 1, 2], Foo.order_by_numinteriorrings.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numinteriorrings_desc
+      assert_equal([1, 2, 3], Foo.order_by_numinteriorrings(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numpoints
+      assert_equal([1, 2, 3], Foo.order_by_numpoints.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_numpoints_desc
+      assert_equal([1, 2, 3], Foo.order_by_numpoints(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length3d
+      assert_equal([1, 2, 3], Foo.order_by_length3d.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length3d_desc
+      assert_equal([1, 2, 3], Foo.order_by_length3d(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length
+      assert_equal([1, 2, 3], Foo.order_by_length.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length_desc
+      assert_equal([1, 2, 3], Foo.order_by_length(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length2d
+      assert_equal([1, 2, 3], Foo.order_by_length2d.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length2d_desc
+      assert_equal([1, 2, 3], Foo.order_by_length2d(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length3d_spheroid
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length3d_spheroid_desc
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+    end
+
+
+    def test_order_by_length2d_spheroid
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length2d_spheroid_desc
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length_spheroid
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+    end
+
+    def test_order_by_length_spheroid_desc
+      assert_equal([1, 2, 3], Foo.order_by_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter
+      assert_equal([1, 2, 3], Foo.order_by_perimeter.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter_desc
+      assert_equal([3, 1, 2], Foo.order_by_perimeter(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter2d
+      assert_equal([1, 2, 3], Foo.order_by_perimeter2d.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter2d_desc
+      assert_equal([3, 1, 2], Foo.order_by_perimeter2d(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter3d
+      assert_equal([1, 2, 3], Foo.order_by_perimeter3d.order('id').all.collect(&:id))
+    end
+
+    def test_order_by_perimeter3d_desc
+      assert_equal([3, 1, 2], Foo.order_by_perimeter3d(:desc => true).order('id').all.collect(&:id))
+    end
+
+    def test_order_by_hausdorffdistance
+      assert_equal([1, 3, 2], Foo.order_by_hausdorffdistance('POINT(1 1)').all.collect(&:id))
+    end
+
+    def test_order_by_hausdorffdistance_desc
+      assert_equal([2, 3, 1], Foo.order_by_hausdorffdistance('POINT(1 1)', :desc => true).all.collect(&:id))
+    end
+
+    def test_order_by_hausdorffdistance_with_densify_frac
+      assert_equal([1, 3, 2], Foo.order_by_hausdorffdistance('POINT(1 1)', 0.314).all.collect(&:id))
+    end
+
+
+    def test_order_by_distance_spheroid
+      assert_equal([2, 3, 1], Foo.order_by_distance_spheroid('POINT(10 10)', 'SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+    end
+
+    def test_order_by_distance_spheroid_desc
+      assert_equal([1, 3, 2], Foo.order_by_distance_spheroid('POINT(10 10)', 'SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+    end
   end
 end

data/test/writer_test.rb

@@ -283,5 +283,19 @@ class GeosWriterTests < Test::Unit::TestCase
         out.read
       )
     end
+
+    def test_to_wkt_handles_binary_geos_arity
+      if @point.to_wkt(:rounding_precision => 0) =~ /^POINT\s*\((\d+(\.\d+)?)\s*(\d+(\.\d+)?)\)$/
+        lng, lat = $1.to_f, $3.to_f
+      end
+
+      if defined?(Geos::FFIGeos)
+        assert_equal(lng, 10.0, 0.000001)
+        assert_equal(lat, 10.0, 0.000001)
+      else
+        assert_equal(lng, 10.00, 0.000001)
+        assert_equal(lat, 10.01, 0.000001)
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: geos-extensions
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - J Smith
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-17 00:00:00 -04:00
+date: 2011-03-21 00:00:00 -04:00
 default_executable: 
 dependencies: []