geokit-rails 2.0.1 → 2.3.2

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geokit-rails #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+load 'test/tasks.rake'
+
+desc 'Default: run unit tests.'
+task :default => :test

data/gemfiles/rails3.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'activerecord', '~> 3.2.0'
+end
+
+gemspec :path => "../"

data/gemfiles/rails4.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'activerecord', '~> 4.0'
+  gem 'test-unit'
+end
+
+gemspec :path => "../"

data/gemfiles/rails5.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'activerecord', '~> 5.0'
+  gem 'test-unit'
+end
+
+gemspec :path => "../"

data/geokit-rails.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/geokit-rails/version", __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "geokit-rails"
+  spec.version       = GeokitRails::VERSION
+  spec.authors       = ["Michael Noack", "Andre Lewis", "Bill Eisenhauer", "Jeremy Lecour"]
+  spec.email         = ["michael+geokit@noack.com.au", "andre@earthcode.com", "bill_eisenhauer@yahoo.com", "jeremy.lecour@gmail.com"]
+  spec.summary       = "Integrate Geokit with Rails"
+  spec.description   = "Official Geokit plugin for Rails/ActiveRecord. Provides location-based goodness for your Rails app. Requires the Geokit gem."
+  spec.summary       = "Geokit helpers for rails apps."
+  spec.homepage      = "http://github.com/geokit/geokit-rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rails', '>= 3.0'
+  spec.add_dependency 'geokit', '~> 1.5'
+  spec.add_development_dependency "bundler", "> 1.0"
+  spec.add_development_dependency "simplecov", "~> 0.16.1"
+  spec.add_development_dependency "simplecov-rcov"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency "mocha", "~> 0.9"
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency "mysql2", "~> 0.2"
+  spec.add_development_dependency "activerecord-mysql2spatial-adapter"
+  spec.add_development_dependency "pg", "~> 0.10"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/generators/geokit_rails/install_generator.rb

@@ -0,0 +1,13 @@
+module GeokitRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a sample Geokit initializer."
+
+      def copy_initializer
+        copy_file "geokit_config.rb", "config/initializers/geokit_config.rb"
+      end
+    end
+  end
+end

data/lib/generators/templates/geokit_config.rb

@@ -0,0 +1,100 @@
+# These defaults are used in Geokit::Mappable.distance_to and acts_as_mappable
+Geokit::default_units = :miles # others :kms, :nms, :meters
+Geokit::default_formula = :sphere
+
+# This is the timeout value in seconds to be used for calls to the geocoder web
+# services.  For no timeout at all, comment out the setting.  The timeout unit
+# is in seconds.
+Geokit::Geocoders::request_timeout = 3
+
+# This setting can be used if web service calls must be routed through a proxy.
+# These setting can be nil if not needed, otherwise, a valid URI must be
+# filled in at a minimum.  If the proxy requires authentication, the username
+# and password can be provided as well.
+# Geokit::Geocoders::proxy = 'https://user:password@host:port'
+
+# This is your yahoo application key for the Yahoo Geocoder.
+# See http://developer.yahoo.com/faq/index.html#appid
+# and http://developer.yahoo.com/maps/rest/V1/geocode.html
+# Geokit::Geocoders::YahooGeocoder.key = 'REPLACE_WITH_YOUR_YAHOO_KEY'
+# Geokit::Geocoders::YahooGeocoder.secret = 'REPLACE_WITH_YOUR_YAHOO_SECRET'
+
+# This is your Google Maps geocoder keys (all optional).
+# See http://www.google.com/apis/maps/signup.html
+# and http://www.google.com/apis/maps/documentation/#Geocoding_Examples
+# Geokit::Geocoders::GoogleGeocoder.client_id = ''
+# Geokit::Geocoders::GoogleGeocoder.cryptographic_key = ''
+# Geokit::Geocoders::GoogleGeocoder.channel = ''
+
+# You can also use the free API key instead of signed requests
+# See https://developers.google.com/maps/documentation/geocoding/#api_key
+# Geokit::Geocoders::GoogleGeocoder.api_key = ''
+
+# You can also set multiple API KEYS for different domains that may be directed
+# to this same application.
+# The domain from which the current user is being directed will automatically
+# be updated for Geokit via
+# the GeocoderControl class, which gets it's begin filter mixed
+# into the ActionController.
+# You define these keys with a Hash as follows:
+# Geokit::Geocoders::google = {
+# 'rubyonrails.org' => 'RUBY_ON_RAILS_API_KEY',
+# ' ruby-docs.org' => 'RUBY_DOCS_API_KEY' }
+
+# This is your username and password for geocoder.us.
+# To use the free service, the value can be set to nil or false.  For
+# usage tied to an account, the value should be set to username:password.
+# See http://geocoder.us
+# and http://geocoder.us/user/signup
+# Geokit::Geocoders::UsGeocoder.key = 'username:password'
+
+# This is your authorization key for geocoder.ca.
+# To use the free service, the value can be set to nil or false.  For
+# usage tied to an account, set the value to the key obtained from
+# Geocoder.ca.
+# See http://geocoder.ca
+# and http://geocoder.ca/?register=1
+# Geokit::Geocoders::CaGeocoder.key = 'KEY'
+
+# This is your username key for geonames.
+# To use this service either free or premium, you must register a key.
+# See http://www.geonames.org
+# Geokit::Geocoders::GeonamesGeocoder.key = 'KEY'
+
+# Most other geocoders need either no setup or a key
+# Geokit::Geocoders::BingGeocoder.key = ''
+# Geokit::Geocoders::MapQuestGeocoder.key = ''
+# Geokit::Geocoders::YandexGeocoder.key = ''
+# Geokit::Geocoders::MapboxGeocoder.key = 'ACCESS_TOKEN'
+# Geokit::Geocoders::OpencageGeocoder.key = 'some_api_key'
+
+# Geonames has a free service and a premium service, each using a different URL
+# GeonamesGeocoder.premium = true will use http://ws.geonames.net (premium)
+# GeonamesGeocoder.premium = false will use http://api.geonames.org (free)
+# Geokit::Geocoders::GeonamesGeocoder.premium = false
+
+# require "external_geocoder.rb"
+# Please see the section "writing your own geocoders" for more information.
+# Geokit::Geocoders::external_key = 'REPLACE_WITH_YOUR_API_KEY'
+
+# This is the order in which the geocoders are called in a failover scenario
+# If you only want to use a single geocoder, put a single symbol in the array.
+# Valid symbols are :google, :yahoo, :us, and :ca.
+# Be aware that there are Terms of Use restrictions on how you can use the
+# various geocoders.  Make sure you read up on relevant Terms of Use for each
+# geocoder you are going to use.
+# Geokit::Geocoders::provider_order = [:google,:us]
+
+# The IP provider order. Valid symbols are :ip,:geo_plugin.
+# As before, make sure you read up on relevant Terms of Use for each.
+# Geokit::Geocoders::ip_provider_order = [:external,:geo_plugin,:ip]
+
+# Disable HTTPS globally.  This option can also be set on individual
+# geocoder classes.
+# Geokit::Geocoders::secure = false
+
+# Control verification of the server certificate for geocoders using HTTPS
+# Geokit::Geocoders::ssl_verify_mode = OpenSSL::SSL::VERIFY_(PEER/NONE)
+# Setting this to VERIFY_NONE may be needed on systems that don't have
+# a complete or up to date root certificate store. Only applies to
+# the Net::HTTP adapter.

data/lib/geokit-rails.rb

@@ -3,7 +3,6 @@ require 'geokit'
 require 'geokit-rails/railtie'
 require 'geokit-rails/core_extensions'
 
-require 'geokit-rails/defaults'
 require 'geokit-rails/adapters/abstract'
 require 'geokit-rails/acts_as_mappable'
 require 'geokit-rails/geocoder_control'

data/lib/geokit-rails/acts_as_mappable.rb

@@ -11,6 +11,8 @@ module Geokit
       extend ActiveSupport::Concern
 
       module ClassMethods # :nodoc:
+        OPTION_SYMBOLS = [ :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name, :skip_loading ]
+
         def acts_as_mappable(options = {})
           metaclass = (class << self; self; end)
 
@@ -21,20 +23,21 @@ module Geokit
 
           if reflection = Geokit::ActsAsMappable.end_of_reflection_chain(self.through, self)
             metaclass.instance_eval do
-              [ :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name ].each do |method_name|
+              OPTION_SYMBOLS.each do |method_name|
                 define_method method_name do
                   reflection.klass.send(method_name)
                 end
               end
             end
           else
-            cattr_accessor :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name
+            cattr_accessor *OPTION_SYMBOLS
 
             self.distance_column_name = options[:distance_column_name]  || 'distance'
             self.default_units = options[:default_units] || Geokit::default_units
             self.default_formula = options[:default_formula] || Geokit::default_formula
             self.lat_column_name = options[:lat_column_name] || 'lat'
             self.lng_column_name = options[:lng_column_name] || 'lng'
+            self.skip_loading = options[:skip_loading]
             self.qualified_lat_column_name = "#{table_name}.#{lat_column_name}"
             self.qualified_lng_column_name = "#{table_name}.#{lng_column_name}"
 
@@ -91,11 +94,21 @@ module Geokit
     module ClassMethods
 
       # A proxy to an instance of a finder adapter, inferred from the connection's adapter.
-      def adapter
-        @adapter ||= begin
-          require File.join(File.dirname(__FILE__), 'adapters', connection.adapter_name.downcase)
+      def geokit_finder_adapter
+        @geokit_finder_adapter ||= begin
+          unless Adapters.const_defined?(connection.adapter_name.camelcase)
+            filename = connection.adapter_name.downcase
+            require File.join("geokit-rails", "adapters", filename)
+          end
           klass = Adapters.const_get(connection.adapter_name.camelcase)
-          klass.load(self) unless klass.loaded
+          if klass.class == Module
+            # For some reason Mysql2 adapter was defined in Adapters.constants but was Module instead of a Class
+            filename = connection.adapter_name.downcase
+            require File.join("geokit-rails", "adapters", filename)
+            # Re-init the klass after require
+            klass = Adapters.const_get(connection.adapter_name.camelcase)
+          end
+          klass.load(self) unless klass.loaded || skip_loading
           klass.new(self)
         rescue LoadError
           raise UnsupportedAdapter, "`#{connection.adapter_name.downcase}` is not a supported adapter."
@@ -104,8 +117,13 @@ module Geokit
 
       def within(distance, options = {})
         options[:within] = distance
-        #geo_scope(options)
-        where(distance_conditions(options))
+        # Add bounding box to speed up SQL request.
+        bounds = formulate_bounds_from_distance(
+          options,
+          normalize_point_to_lat_lng(options[:origin]),
+          options[:units] || default_units)
+        with_latlng.where(bound_conditions(bounds)).
+          where(distance_conditions(options))
       end
       alias inside within
 
@@ -123,30 +141,35 @@ module Geokit
       end
 
       def in_bounds(bounds, options = {})
+        inclusive = options.delete(:inclusive) || false
         options[:bounds] = bounds
         #geo_scope(options)
         #where(distance_conditions(options))
         bounds  = extract_bounds_from_options(options)
-        where(bound_conditions(bounds))
+        where(bound_conditions(bounds, inclusive))
       end
 
       def by_distance(options = {})
         origin  = extract_origin_from_options(options)
         units   = extract_units_from_options(options)
         formula = extract_formula_from_options(options)
-        bounds  = extract_bounds_from_options(options)
         distance_column_name = distance_sql(origin, units, formula)
-        #geo_scope(options).order("#{distance_column_name} asc")
-        order("#{distance_column_name} asc")
+        with_latlng.order(
+          Arel.sql(distance_column_name).send(options[:reverse] ? 'desc' : 'asc')
+        )
+      end
+
+      def with_latlng
+        where("#{qualified_lat_column_name} IS NOT NULL AND #{qualified_lng_column_name} IS NOT NULL")
       end
 
       def closest(options = {})
-        by_distance(options).first(1)
+        by_distance(options).limit(1)
       end
       alias nearest closest
 
       def farthest(options = {})
-        by_distance(options).last(1)
+        by_distance({:reverse => true}.merge(options)).limit(1)
       end
 
       #def geo_scope(options = {})
@@ -162,9 +185,9 @@ module Geokit
 
       #    if origin
       #      arel.distance_formula = distance_sql(origin, units, formula)
-      #      
+      #
       #      if arel.select_values.blank?
-      #        star_select = Arel::SqlLiteral.new(arel.quoted_table_name + '.*')
+      #        star_select = Arel::Nodes::SqlLiteral.new(arel.quoted_table_name + '.*')
       #        arel = arel.select(star_select)
       #      end
       #    end
@@ -211,10 +234,10 @@ module Geokit
       # If it's a :within query, add a bounding box to improve performance.
       # This only gets called if a :bounds argument is not otherwise supplied.
       def formulate_bounds_from_distance(options, origin, units)
-        distance = options[:within] if options.has_key?(:within)
+        distance = options[:within] if options.has_key?(:within) && options[:within].is_a?(Numeric)
         distance = options[:range].last-(options[:range].exclude_end?? 1 : 0) if options.has_key?(:range)
         if distance
-          res=Geokit::Bounds.from_point_and_radius(origin,distance,:units=>units)
+          Geokit::Bounds.from_point_and_radius(origin,distance,:units=>units)
         else
           nil
         end
@@ -224,25 +247,41 @@ module Geokit
         origin  = extract_origin_from_options(options)
         units   = extract_units_from_options(options)
         formula = extract_formula_from_options(options)
-        bounds  = extract_bounds_from_options(options)
         distance_column_name = distance_sql(origin, units, formula)
 
-        res = if options.has_key?(:within)
-          "#{distance_column_name} <= #{options[:within]}"
+        if options.has_key?(:within)
+          Arel.sql(distance_column_name).lteq(options[:within])
         elsif options.has_key?(:beyond)
-          "#{distance_column_name} > #{options[:beyond]}"
+          Arel.sql(distance_column_name).gt(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}"
+          min_condition = Arel.sql(distance_column_name).gteq(options[:range].begin)
+          max_condition = if options[:range].exclude_end?
+                            Arel.sql(distance_column_name).lt(options[:range].end)
+                          else
+                            Arel.sql(distance_column_name).lteq(options[:range].end)
+                          end
+          min_condition.and(max_condition)
         end
-        Arel::SqlLiteral.new("(#{res})") if res.present?
       end
 
-      def bound_conditions(bounds)
+      def bound_conditions(bounds, inclusive = false)
+        return nil unless bounds
+        if inclusive
+          lt_operator = :lteq
+          gt_operator = :gteq
+        else
+          lt_operator = :lt
+          gt_operator = :gt
+        end
         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}"
-        res = "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
-        #Arel::SqlLiteral.new("(#{res})") if res.present?
-        res if res.present?
+        lat, lng = Arel.sql(qualified_lat_column_name), Arel.sql(qualified_lng_column_name)
+        lat.send(gt_operator, sw.lat).and(lat.send(lt_operator, ne.lat)).and(
+          if bounds.crosses_meridian?
+            lng.send(lt_operator, ne.lng).or(lng.send(gt_operator, sw.lng))
+          else
+            lng.send(gt_operator, sw.lng).and(lng.send(lt_operator, ne.lng))
+          end
+        )
       end
 
       # Extracts the origin instance out of the options if it exists and returns
@@ -315,20 +354,31 @@ module Geokit
       # Returns the distance SQL using the spherical world formula (Haversine).  The SQL is tuned
       # to the database in use.
       def sphere_distance_sql(origin, units)
-        lat = deg2rad(origin.lat)
-        lng = deg2rad(origin.lng)
+        # "origin" can be a Geokit::LatLng (with :lat and :lng methods), e.g.
+        # when using geo_scope or it can be an ActsAsMappable with customized
+        # latitude and longitude methods, e.g. when using distance_sql.
+        lat = deg2rad(get_lat(origin))
+        lng = deg2rad(get_lng(origin))
         multiplier = units_sphere_multiplier(units)
-
-        adapter.sphere_distance_sql(lat, lng, multiplier) if adapter
+        geokit_finder_adapter.sphere_distance_sql(lat, lng, multiplier) if geokit_finder_adapter
       end
 
       # Returns the distance SQL using the flat-world formula (Phythagorean Theory).  The SQL is tuned
       # to the database in use.
       def flat_distance_sql(origin, units)
         lat_degree_units = units_per_latitude_degree(units)
-        lng_degree_units = units_per_longitude_degree(origin.lat, units)
+        lng_degree_units = units_per_longitude_degree(get_lat(origin), units)
+        geokit_finder_adapter.flat_distance_sql(origin, lat_degree_units, lng_degree_units)
+      end
+
+      def get_lat(origin)
+        origin.respond_to?(:lat) ? origin.lat \
+                                 : origin.send(:"#{lat_column_name}")
+      end
 
-        adapter.flat_distance_sql(origin, lat_degree_units, lng_degree_units)
+      def get_lng(origin)
+        origin.respond_to?(:lng) ? origin.lng \
+                                 : origin.send(:"#{lng_column_name}")
       end
 
     end # ClassMethods
@@ -339,8 +389,8 @@ module Geokit
       geo=Geokit::Geocoders::MultiGeocoder.geocode(address)
 
       if geo.success
-        self.send("#{lat_column_name}=", geo.lat)
-        self.send("#{lng_column_name}=", geo.lng)
+        self.send("#{lat_column_name}=", geo.send(:"#{lat_column_name}"))
+        self.send("#{lng_column_name}=", geo.send(:"#{lng_column_name}"))
       else
         errors.add(auto_geocode_field, auto_geocode_error_message)
       end

data/lib/geokit-rails/adapters/oracleenhanced.rb

@@ -0,0 +1,32 @@
+module Geokit
+  module Adapters
+    class OracleEnhanced < Abstract
+      TO_DEGREES = Math::PI / 180
+      def sphere_distance_sql(lat, lng, multiplier)
+        %{
+(
+  ACOS(
+    COS(#{lat}) * COS(#{lng}) *
+    COS(#{TO_DEGREES} * #{qualified_lat_column_name}) *
+    COS(#{TO_DEGREES} * #{qualified_lng_column_name}) +
+    COS(#{lat}) * SIN(#{lng}) *
+    COS(#{TO_DEGREES} * #{qualified_lat_column_name}) *
+    SIN(#{TO_DEGREES} * #{qualified_lng_column_name}) +
+    SIN(#{lat}) *
+    SIN(#{TO_DEGREES} * #{qualified_lat_column_name})
+  ) *
+  #{multiplier})
+}
+      end
+
+      def flat_distance_sql(origin, lat_degree_units, lng_degree_units)
+        %{
+SQRT(
+  POWER(#{lat_degree_units}*(#{origin.lat}-#{qualified_lat_column_name}), 2)
+  POWER(#{lng_degree_units}*(#{origin.lng}-#{qualified_lng_column_name}), 2)
+)
+         }
+      end
+    end
+  end
+end