geokit-rails3 0.0.5 → 0.1.0

data/lib/geokit-rails3/acts_as_mappable.rb

@@ -48,38 +48,6 @@ module Geokit
               # set the actual callback here
               before_validation :auto_geocode_address, :on => :create
             end
-
-            scope :select_with_distance, lambda { |origin, units, formula|
-              distance_formula = distance_sql(origin, units, formula)
-
-              select('*').
-                select("#{distance_formula} AS #{distance_column_name}")
-            }
-
-            scope :within, lambda { |options|
-              origin  = extract_origin_from_options(options)
-              units   = extract_units_from_options(options)
-              formula = extract_formula_from_options(options)
-
-              distance_formula = distance_sql(origin, units, formula)
-
-              within  = options.delete(:within)
-
-              select_with_distance(origin, units, formula).
-                where("#{distance_formula} < #{within}")
-            }
-
-            scope :closest, lambda { |options|
-              origin  = extract_origin_from_options(options)
-              units   = extract_units_from_options(options)
-              formula = extract_formula_from_options(options)
-
-              distance_formula = distance_sql(origin, units, formula)
-
-              select_with_distance(origin, units, formula).
-                order("#{distance_formula} ASC").
-                limit(1)
-            }
           end
         end
       end
@@ -106,6 +74,68 @@ module Geokit
         end
       end
       
+      def within(distance, options = {})
+        options[:within] = distance
+        geo_scope(options)
+      end
+      alias inside within
+      
+      def beyond(distance, options = {})
+        options[:beyond] = distance
+        geo_scope(options)
+      end
+      alias outside beyond
+      
+      def in_range(range, options = {})
+        options[:range] = range
+        geo_scope(options)
+      end
+      
+      def in_bounds(bounds, options = {})
+        options[:bounds] = bounds
+        geo_scope(options)
+      end
+
+      def closest(options = {})
+        geo_scope(options).order("#{distance_column_name} asc").limit(1)
+      end
+      alias nearest closest
+
+      def farthest(options = {})
+        geo_scope(options).order("#{distance_column_name} desc").limit(1)
+      end
+
+      def geo_scope(options = {})
+        arel = self.is_a?(ActiveRecord::Relation) ? self : self.scoped
+        
+        origin  = extract_origin_from_options(options)
+        units   = extract_units_from_options(options)
+        formula = extract_formula_from_options(options)
+        bounds  = extract_bounds_from_options(options)
+      
+        if origin || bounds
+          bounds = formulate_bounds_from_distance(options, origin, units) unless bounds
+        
+          if origin
+            distance_formula = distance_sql(origin, units, formula)
+            arel = arel.select('*') if arel.select_values.blank?
+            arel = arel.select("#{distance_formula} AS #{distance_column_name}")
+          end
+
+          if bounds
+            bound_conditions = bound_conditions(bounds)
+            arel = arel.where(bound_conditions) if bound_conditions
+          end
+        
+          distance_conditions = distance_conditions(options)
+          arel = arel.where(distance_conditions) if distance_conditions
+          
+          arel = substitute_distance_in_where_values(arel, origin, units, formula)
+        end
+
+        arel
+      end
+
       # Returns the distance calculation to be used as a display column or a condition.  This
       # is provide for anyone wanting access to the raw SQL.
       def distance_sql(origin, units=default_units, formula=default_formula)
@@ -131,30 +161,21 @@ module Geokit
           nil
         end
       end
-      
-      # Replace :within, :beyond and :range distance tokens with the appropriate distance 
-      # where clauses.  Removes these tokens from the options hash.
-      def apply_distance_scope(options)
-        distance_condition = if options.has_key?(:within)
+
+      def distance_conditions(options)
+        if options.has_key?(:within)
           "#{distance_column_name} <= #{options[:within]}"
         elsif options.has_key?(:beyond)
           "#{distance_column_name} > #{options[:beyond]}"
         elsif options.has_key?(:range)
           "#{distance_column_name} >= #{options[:range].first} AND #{distance_column_name} <#{'=' unless options[:range].exclude_end?} #{options[:range].last}"
         end
-      
-        if distance_condition
-          [:within, :beyond, :range].each { |option| options.delete(option) }
-          options[:conditions] = merge_conditions(options[:conditions], distance_condition)
-        end
       end
-      
-      # Alters the conditions to include rectangular bounds conditions.
-      def apply_bounds_conditions(options,bounds)
+
+      def bound_conditions(bounds)
         sw,ne = bounds.sw, bounds.ne
         lng_sql = bounds.crosses_meridian? ? "(#{qualified_lng_column_name}<#{ne.lng} OR #{qualified_lng_column_name}>#{sw.lng})" : "#{qualified_lng_column_name}>#{sw.lng} AND #{qualified_lng_column_name}<#{ne.lng}"
-        bounds_sql = "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
-        options[:conditions] = merge_conditions(options[:conditions], bounds_sql)
+        "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
       end
       
       # Extracts the origin instance out of the options if it exists and returns
@@ -207,23 +228,21 @@ module Geokit
         res
       end
       
-      # Augments the select with the distance SQL.
-      def add_distance_to_select(options, origin, units=default_units, formula=default_formula)
-        if origin
-          distance_selector = distance_sql(origin, units, formula) + " AS #{distance_column_name}"
-          selector = options.has_key?(:select) && options[:select] ? options[:select] : "*"
-          options[:select] = "#{selector}, #{distance_selector}"  
-        end
-      end
-      
       # Looks for the distance column and replaces it with the distance sql. If an origin was not 
       # passed in and the distance column exists, we leave it to be flagged as bad SQL by the database.
       # Conditions are either a string or an array.  In the case of an array, the first entry contains
       # the condition.
-      def substitute_distance_in_conditions(options, origin, units=default_units, formula=default_formula)
-        condition = options[:conditions].is_a?(String) ? options[:conditions] : options[:conditions].first
+      def substitute_distance_in_where_values(arel, origin, units=default_units, formula=default_formula)
         pattern = Regexp.new("\\b#{distance_column_name}\\b")
-        condition.gsub!(pattern, distance_sql(origin, units, formula))
+        value   = distance_sql(origin, units, formula)
+        arel.where_values.map! do |where_value|
+          if where_value.is_a?(String)
+            where_value.gsub(pattern, value)
+          else
+            where_value
+          end
+        end
+        arel
       end
       
       # Returns the distance SQL using the spherical world formula (Haversine).  The SQL is tuned

data/lib/geokit-rails3/version.rb

@@ -1,3 +1,3 @@
 module GeokitRails3
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: geokit-rails3
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 5
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors: 
 - Andre Lewis
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-12 00:00:00 +02:00
+date: 2010-10-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency