activerecord-spatial 1.0.0 → 2.0.0

data/lib/activerecord-spatial/spatial_function.rb

@@ -2,8 +2,8 @@
 module ActiveRecordSpatial
   class SpatialFunction
     DEFAULT_OPTIONS = {
-      :column => ActiveRecordSpatial.default_column_name,
-      :use_index => true
+      column: ActiveRecordSpatial.default_column_name,
+      use_index: true
     }.freeze
 
     def initialize(klass)
@@ -18,30 +18,32 @@ module ActiveRecordSpatial
       options = default_options(args.extract_options!)
 
       geom = options.fetch(:geom_arg, args.first)
-      args = Array.wrap(options.fetch(:args, args.from(1)))
+      args = Array.wrap(options.fetch(:args, args.from(1))).collect do |arg|
+        arel_quoted_value(arg)
+      end
 
-      column_name = self.column_name(options[:column])
-      first_geom_arg = self.wrap_column_or_geometry(
+      column_name = column_name(options[:column])
+      first_geom_arg = wrap_column_or_geometry(
         @klass.arel_table[column_name],
         options[:column]
       )
-      geom_args = [ first_geom_arg ]
+      geom_args = [first_geom_arg]
 
       if geom.present?
         column_type = @klass.spatial_column_by_name(column_name).spatial_type
         column_srid = @klass.srid_for(column_name)
 
-        unless geom.is_a?(Hash)
+        if !geom.is_a?(Hash)
           geom_arg = read_geos(geom, column_srid)
           geom_srid = read_geom_srid(geom_arg, column_type)
-          geom_args << self.set_srid_or_transform(column_srid, geom_srid, geom_arg, column_type)
+          geom_args << set_srid_or_transform(column_srid, geom_srid, geom_arg, column_type)
         else
           klass = if geom[:class]
             geom[:class]
           elsif geom[:class_name]
             geom[:class_name].classify.constantize
           else
-            raise ArgumentError.new("Need either a :class or :class_name option to determine the class.")
+            raise ArgumentError, 'Need either a :class or :class_name option to determine the class.'
           end
 
           if geom[:value]
@@ -49,35 +51,49 @@ module ActiveRecordSpatial
             geom_srid = read_geom_srid(geom_arg, column_type)
           else
             geom_arg = geom
-            geom_srid = klass.srid_for(self.column_name(geom[:column]))
+            geom_srid = klass.srid_for(column_name(geom[:column]))
           end
 
-          transformed_geom = self.set_srid_or_transform(column_srid, geom_srid, geom_arg, column_type)
-          geom_args << self.wrap_column_or_geometry(transformed_geom, geom)
+          transformed_geom = set_srid_or_transform(column_srid, geom_srid, geom_arg, column_type)
+          geom_args << wrap_column_or_geometry(transformed_geom, geom)
         end
       end
 
-      if options[:invert] && geom_args.length > 1
-        geom_args.reverse!
-      end
+      geom_args.reverse! if options[:invert] && geom_args.length > 1
 
       ret = Arel::Nodes::NamedFunction.new(
         function_name(function, options[:use_index]),
         geom_args + args
       )
 
-      if options[:allow_null]
-        ret = ret.or(first_geom_arg.eq(nil))
-      end
+      ret = ret.or(first_geom_arg.eq(nil)) if options[:allow_null]
 
       ret
     end
 
-    protected
+    class << self
+      def additional_ordering(*args)
+        options = args.extract_options!
+
+        desc = if args.first == :desc
+          true
+        else
+          options[:desc]
+        end
+
+        ''.tap do |ret|
+          ret << ' DESC' if desc
+          ret << " NULLS #{options[:nulls].to_s.upcase}" if options[:nulls]
+        end
+      end
+    end
+
+    private
+
       def set_srid_or_transform(column_srid, geom_srid, geom, type)
         geom_param = case geom
           when Geos::Geometry
-            Arel.sql("#{@klass.connection.quote(geom.to_ewkb)}::#{type}")
+            Arel.sql("#{@klass.connection.quote(geom.to_ewkb)}::geometry")
           when Hash
             table_name = if geom[:table_alias]
               @klass.connection.quote_table_name(geom[:table_alias])
@@ -87,22 +103,22 @@ module ActiveRecordSpatial
               geom[:class_name].classify.constantize.quoted_table_name
             end
 
-            Arel.sql("#{table_name}.#{@klass.connection.quote_table_name(self.column_name(geom[:column]))}")
+            Arel.sql("#{table_name}.#{@klass.connection.quote_table_name(column_name(geom[:column]))}")
           else
-            raise ArgumentError.new("Expected either a Geos::Geometry or a Hash.")
+            raise ArgumentError, 'Expected either a Geos::Geometry or a Hash.'
         end
 
-        sql = if type != :geography && column_srid != geom_srid
+        if column_srid != geom_srid
           if column_srid == ActiveRecordSpatial::UNKNOWN_SRIDS[type] || geom_srid == ActiveRecordSpatial::UNKNOWN_SRIDS[type]
             Arel::Nodes::NamedFunction.new(
               function_name('SetSRID'),
-              [ geom_param, column_srid ]
+              [geom_param, column_srid]
             )
 
           else
             Arel::Nodes::NamedFunction.new(
               function_name('Transform'),
-              [ geom_param, column_srid ]
+              [geom_param, column_srid]
             )
           end
         else
@@ -118,7 +134,7 @@ module ActiveRecordSpatial
       end
 
       def read_geom_srid(geos, column_type = :geometry)
-        if geos.srid == 0 || geos.srid == -1
+        if geos.srid.zero? || geos.srid == -1
           ActiveRecordSpatial::UNKNOWN_SRIDS[column_type]
         else
           geos.srid
@@ -128,16 +144,16 @@ module ActiveRecordSpatial
       def default_options(*args)
         options = args.extract_options!
 
-        if args.length > 0
+        if args.length.positive?
           desc = if args.first == :desc
             true
           else
             options[:desc]
           end
 
-          DEFAULT_OPTIONS.merge({
-            :desc => desc
-          }).merge(options || {})
+          DEFAULT_OPTIONS.merge(
+            desc: desc
+          ).merge(options || {})
         else
           DEFAULT_OPTIONS.merge(options || {})
         end
@@ -156,47 +172,42 @@ module ActiveRecordSpatial
           column_name_or_options[:name]
         else
           column_name_or_options
-        end || ActiveRecordSpatial.default_column_name
+        end
+
+        column_name || ActiveRecordSpatial.default_column_name
       end
 
       def wrap_column_or_geometry(column_name_or_geometry, options = nil)
         if options.is_a?(Hash) && options[:wrapper]
           wrapper, args = if options[:wrapper].is_a?(Hash)
-            [ options[:wrapper].keys.first, Array.wrap(options[:wrapper].values.first) ]
+            [options[:wrapper].keys.first, Array.wrap(options[:wrapper].values.first)]
           else
-            [ options[:wrapper], [] ]
+            [options[:wrapper], []]
           end
 
           Arel::Nodes::NamedFunction.new(
             function_name(wrapper),
-            [ column_name_or_geometry, *args ]
+            [column_name_or_geometry, *args.collect { |arg| arel_quoted_value(arg) }]
           )
         else
           column_name_or_geometry
         end
       end
 
-    class << self
-      def additional_ordering(*args)
-        options = args.extract_options!
-
-        desc = if args.first == :desc
-          true
+      def arel_nodes_quoted?
+        if defined?(@arel_nodes_quoted)
+          @arel_nodes_quoted
         else
-          options[:desc]
+          @arel_nodes_quoted = defined?(Arel::Nodes::Quoted)
         end
+      end
 
-        ''.tap do |ret|
-            if desc
-              ret << ' DESC'
-            end
-
-            if options[:nulls]
-              ret << " NULLS #{options[:nulls].to_s.upcase}"
-            end
+      def arel_quoted_value(value)
+        if arel_nodes_quoted?
+          Arel::Nodes::Quoted.new(value)
+        else
+          value
         end
       end
-    end
   end
 end
-

data/lib/activerecord-spatial/spatial_scope_constants/postgis_2_0.rb

@@ -0,0 +1,48 @@
+
+module ActiveRecordSpatial
+  module SpatialScopeConstants
+    ONE_ARGUMENT_MEASUREMENTS = %w{
+      3dlength_spheroid
+      length2d_spheroid
+      length_spheroid
+    }
+
+    ONE_ARGUMENT_MEASUREMENTS.concat(%w{
+      3dlength_spheroid
+    })
+
+    RELATIONSHIPS.concat(%w{
+      3dintersects
+    })
+
+    ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
+      3dlength
+      3dperimeter
+    })
+
+    ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.concat(%w{
+      3ddistance
+      3dmaxdistance
+      distance_sphere
+    })
+
+    ONE_GEOMETRY_ARGUMENT_AND_ONE_ARGUMENT_RELATIONSHIPS.concat(%w{
+      3ddwithin
+      3ddfullywithin
+    })
+
+    COMPATIBILITY_FUNCTION_ALIASES.merge!(
+      'order_by_st_length3d' => 'order_by_st_3dlength',
+      'order_by_st_perimeter3d' => 'order_by_st_3dperimeter',
+      'order_by_st_length3d_spheroid' => 'order_by_st_3dlength_spheroid',
+      'order_by_st_distancesphere' => 'order_by_st_distance_sphere'
+    )
+
+    FUNCTION_ALIASES.merge!(
+      'st_3d_dwithin' => 'st_3ddwithin',
+      'st_3d_dfully_within' => 'st_3ddfullywithin',
+      'order_by_st_3d_distance' => 'order_by_st_3ddistance',
+      'order_by_st_3d_max_distance' => 'order_by_st_3dmaxdistance'
+    )
+  end
+end

data/lib/activerecord-spatial/spatial_scope_constants/postgis_2_2.rb

@@ -0,0 +1,46 @@
+
+module ActiveRecordSpatial
+  module SpatialScopeConstants
+    ONE_ARGUMENT_MEASUREMENTS = %w{
+      lengthspheroid
+    }
+
+    RELATIONSHIPS.concat(%w{
+      3dintersects
+    })
+
+    ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
+      3dlength
+      3dperimeter
+    })
+
+    ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.concat(%w{
+      3ddistance
+      3dmaxdistance
+      distancesphere
+    })
+
+    ONE_GEOMETRY_ARGUMENT_AND_ONE_ARGUMENT_RELATIONSHIPS.concat(%w{
+      3ddwithin
+      3ddfullywithin
+    })
+
+    COMPATIBILITY_FUNCTION_ALIASES.merge!(
+      'order_by_st_length3d' => 'order_by_st_3dlength',
+      'order_by_st_perimeter3d' => 'order_by_st_3dperimeter',
+      'order_by_st_3dlength_spheroid' => 'order_by_st_lengthspheroid',
+      'order_by_st_length3d_spheroid' => 'order_by_st_lengthspheroid',
+      'order_by_st_2dlength_spheroid' => 'order_by_st_lengthspheroid',
+      'order_by_st_length2d_spheroid' => 'order_by_st_lengthspheroid',
+      'order_by_st_length_spheroid' => 'order_by_st_lengthspheroid',
+      'order_by_st_distance_sphere' => 'order_by_st_distancesphere'
+    )
+
+    FUNCTION_ALIASES.merge!(
+      'st_3d_dwithin' => 'st_3ddwithin',
+      'st_3d_dfully_within' => 'st_3ddfullywithin',
+      'order_by_st_3d_distance' => 'order_by_st_3ddistance',
+      'order_by_st_3d_max_distance' => 'order_by_st_3dmaxdistance'
+    )
+  end
+end

data/lib/activerecord-spatial/spatial_scope_constants/postgis_legacy.rb

@@ -0,0 +1,30 @@
+
+module ActiveRecordSpatial
+  module SpatialScopeConstants
+    ONE_ARGUMENT_MEASUREMENTS = %w{
+      3dlength_spheroid
+      length2d_spheroid
+      length_spheroid
+    }
+
+    ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.concat(%w{
+      distance_sphere
+    })
+
+    ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
+      length3d
+      perimeter3d
+    })
+
+    ONE_ARGUMENT_MEASUREMENTS.concat(%w{
+      length3d_spheroid
+    })
+
+    COMPATIBILITY_FUNCTION_ALIASES.merge!(
+      'order_by_st_3dlength' => 'order_by_st_length3d',
+      'order_by_st_3dperimeter' => 'order_by_st_perimeter3d',
+      'order_by_st_3dlength_spheroid' => 'order_by_st_length3d_spheroid',
+      'order_by_st_distancesphere' => 'order_by_st_distance_sphere'
+    )
+  end
+end

data/lib/activerecord-spatial/spatial_scope_constants.rb

@@ -33,7 +33,7 @@ module ActiveRecordSpatial
 
     ONE_GEOMETRY_ARGUMENT_MEASUREMENTS = %w{
       distance
-      distance_sphere
+      distancesphere
       maxdistance
     }
 
@@ -42,73 +42,22 @@ module ActiveRecordSpatial
       dfullywithin
     }
 
-    ONE_ARGUMENT_MEASUREMENTS = %w{
-      length2d_spheroid
-      length_spheroid
-    }
-
-    # Some functions were renamed in PostGIS 2.0.
-    if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
-      RELATIONSHIPS.concat(%w{
-        3dintersects
-      })
-
-      ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
-        3dlength
-        3dperimeter
-      })
-
-      ONE_ARGUMENT_MEASUREMENTS.concat(%w{
-        3dlength_spheroid
-      })
-
-      ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.concat(%w{
-        3ddistance
-        3dmaxdistance
-      })
-
-      ONE_GEOMETRY_ARGUMENT_AND_ONE_ARGUMENT_RELATIONSHIPS.concat(%w{
-        3ddwithin
-        3ddfullywithin
-      })
-    else
-      ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
-        length3d
-        perimeter3d
-      })
-
-      ONE_ARGUMENT_MEASUREMENTS.concat(%w{
-        length3d_spheroid
-      })
-    end
-
     FUNCTION_ALIASES = {
       'order_by_st_max_distance' => 'order_by_st_maxdistance',
       'st_geometrytype' => 'st_geometry_type'
     }
 
-    COMPATIBILITY_FUNCTION_ALIASES = if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
-      {
-        'order_by_st_length3d' => 'order_by_st_3dlength',
-        'order_by_st_perimeter3d' => 'order_by_st_3dperimeter',
-        'order_by_st_length3d_spheroid' => 'order_by_st_3dlength_spheroid'
-      }
+    COMPATIBILITY_FUNCTION_ALIASES = {}
+
+    # Some functions were renamed or deprecated in PostGIS 2.2.
+    if ActiveRecordSpatial::POSTGIS[:lib] >= '2.2'
+      require 'activerecord-spatial/spatial_scope_constants/postgis_2_2'
+    elsif ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
+      require 'activerecord-spatial/spatial_scope_constants/postgis_2_0'
     else
-      {
-        'order_by_st_3dlength' => 'order_by_st_length3d',
-        'order_by_st_3dperimeter' => 'order_by_st_perimeter3d',
-        'order_by_st_3dlength_spheroid' => 'order_by_st_length3d_spheroid'
-      }
+      require 'activerecord-spatial/spatial_scope_constants/postgis_legacy'
     end
 
-    if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
-      FUNCTION_ALIASES.merge!({
-        'st_3d_dwithin' => 'st_3ddwithin',
-        'st_3d_dfully_within' => 'st_3ddfullywithin',
-        'order_by_st_3d_distance' => 'order_by_st_3ddistance',
-        'order_by_st_3d_max_distance' => 'order_by_st_3dmaxdistance'
-      })
-    end
+    constants.each(&:freeze)
   end
 end
-

data/lib/activerecord-spatial/spatial_scopes.rb

@@ -71,14 +71,14 @@ module ActiveRecordSpatial
   #   When wrapping a geometry column in a function, you can set the name of
   #   the function and its methods like so:
   #
-  #     Foo.st_within(geom, :column => {
-  #       :name => :the_geom,
-  #       :wrapper => :centroid
+  #     Foo.st_within(geom, column: {
+  #       name: :the_geom,
+  #       wrapper: :centroid
   #     })
   #
-  #     Foo.st_within(geom, :column => {
-  #       :wrapper => {
-  #         :snap => [ 'POINT (0 0)', 1 ]
+  #     Foo.st_within(geom, column: {
+  #       wrapper: {
+  #         snap: [ 'POINT (0 0)', 1 ]
   #       }
   #     })
   #
@@ -131,126 +131,120 @@ module ActiveRecordSpatial
     extend ActiveSupport::Concern
 
     DEFAULT_OPTIONS = {
-      :column => ActiveRecordSpatial.default_column_name,
-      :use_index => true
+      column: ActiveRecordSpatial.default_column_name,
+      use_index: true
     }.freeze
 
     included do
-      assert_arguments_length = proc { |args, min, max = (1.0 / 0.0)|
-        raise ArgumentError.new("wrong number of arguments (#{args.length} for #{min}-#{max})") unless
-          args.length.between?(min, max)
-      }
+      assert_arguments_length = proc do |args, min, max = (1.0 / 0.0)|
+        raise ArgumentError, "wrong number of arguments (#{args.length} for #{min}-#{max})" unless args.length.between?(min, max)
+      end
 
       SpatialScopeConstants::RELATIONSHIPS.each do |relationship|
-        src, line = <<-EOF, __LINE__ + 1
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           scope :st_#{relationship}, lambda { |geom, options = {}|
             options = {
-              :geom_arg => geom
+              geom_arg: geom
             }.merge(options)
 
             unless geom.nil?
-              self.where(
+              where(
                 ActiveRecordSpatial::SpatialFunction.build!(self, '#{relationship}', options).to_sql
               )
             end
           }
-        EOF
-        self.class_eval(src, __FILE__, line)
+        RUBY
       end
 
       SpatialScopeConstants::ONE_GEOMETRY_ARGUMENT_AND_ONE_ARGUMENT_RELATIONSHIPS.each do |relationship|
-        src, line = <<-EOF, __LINE__ + 1
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           scope :st_#{relationship}, lambda { |geom, distance, options = {}|
             options = {
-              :geom_arg => geom,
-              :args => distance
+              geom_arg: geom,
+              args: distance
             }.merge(options)
 
-            self.where(
+            where(
               ActiveRecordSpatial::SpatialFunction.build!(self, '#{relationship}', options).to_sql
             )
           }
-        EOF
-        self.class_eval(src, __FILE__, line)
+        RUBY
       end
 
-      self.class_eval do
+      class_eval do
         scope :st_geometry_type, lambda { |*args|
           assert_arguments_length[args, 1]
           options = args.extract_options!
           types = args
 
-          self.where(
+          where(
             ActiveRecordSpatial::SpatialFunction.build!(self, 'GeometryType', options).in(types).to_sql
           )
         }
       end
 
       SpatialScopeConstants::ZERO_ARGUMENT_MEASUREMENTS.each do |measurement|
-        src, line = <<-EOF, __LINE__ + 1
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           scope :order_by_st_#{measurement}, lambda { |options = {}|
             if options.is_a?(Symbol)
               options = {
-                :desc => options
+                desc: options
               }
             end
 
             function_call = ActiveRecordSpatial::SpatialFunction.build!(self, '#{measurement}', options).to_sql
             function_call << ActiveRecordSpatial::SpatialFunction.additional_ordering(options)
 
-            self.order(function_call)
+            order(function_call)
           }
-        EOF
-        self.class_eval(src, __FILE__, line)
+        RUBY
       end
 
       SpatialScopeConstants::ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.each do |measurement|
-        src, line = <<-EOF, __LINE__ + 1
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           scope :order_by_st_#{measurement}, lambda { |geom, options = {}|
             if options.is_a?(Symbol)
               options = {
-                :desc => options
+                desc: options
               }
             end
 
             options = {
-              :geom_arg => geom
+              geom_arg: geom
             }.merge(options)
 
             function_call = ActiveRecordSpatial::SpatialFunction.build!(self, '#{measurement}', options).to_sql
             function_call << ActiveRecordSpatial::SpatialFunction.additional_ordering(options)
 
-            self.order(function_call)
+            order(function_call)
           }
-        EOF
-        self.class_eval(src, __FILE__, line)
+        RUBY
       end
 
       SpatialScopeConstants::ONE_ARGUMENT_MEASUREMENTS.each do |measurement|
-        src, line = <<-EOF, __LINE__ + 1
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           scope :order_by_st_#{measurement}, lambda { |argument, options = {}|
             options = {
-              :args => argument
+              args: argument
             }.merge(options)
 
             function_call = ActiveRecordSpatial::SpatialFunction.build!(self, '#{measurement}', options).to_sql
             function_call << ActiveRecordSpatial::SpatialFunction.additional_ordering(options)
 
-            self.order(function_call)
+            order(function_call)
           }
-        EOF
-        self.class_eval(src, __FILE__, line)
+        RUBY
       end
 
-      self.class_eval do
+      class_eval do
         scope :order_by_st_hausdorffdistance, lambda { |*args|
           assert_arguments_length[args, 1, 3]
           options = args.extract_options!
           geom, densify_frac = args
 
           options = {
-            :geom_arg => geom,
-            :args => densify_frac
+            geom_arg: geom,
+            args: densify_frac
           }.merge(options)
 
           function_call = ActiveRecordSpatial::SpatialFunction.build!(
@@ -260,23 +254,27 @@ module ActiveRecordSpatial
           ).to_sql
           function_call << ActiveRecordSpatial::SpatialFunction.additional_ordering(options)
 
-          self.order(function_call)
+          order(function_call)
         }
 
         scope :order_by_st_distance_spheroid, lambda { |geom, spheroid, options = {}|
           options = {
-            :geom_arg => geom,
-            :args => spheroid
+            geom_arg: geom,
+            args: spheroid
           }.merge(options)
 
           function_call = ActiveRecordSpatial::SpatialFunction.build!(
             self,
-            'distance_spheroid',
+            if ActiveRecordSpatial::POSTGIS[:lib] >= '2.2'
+              'distancespheroid'
+            else
+              'distance_spheroid'
+            end,
             options
           ).to_sql
           function_call << ActiveRecordSpatial::SpatialFunction.additional_ordering(options)
 
-          self.order(function_call)
+          order(function_call)
         }
 
         class << self

data/lib/activerecord-spatial/version.rb

@@ -1,5 +1,4 @@
 
 module ActiveRecordSpatial
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'.freeze
 end
-