geokit-rails 2.3.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 60cc7291a94e6384a48947ecb040a472b26c0ac6
-  data.tar.gz: e067b31c96bf53bbe4a3be1f6acf9f490e0c2c16
+SHA256:
+  metadata.gz: c4bc1edb34957251330bf39e6c777d1b8e01fba0e23388b08b3f07918bb9d1ab
+  data.tar.gz: c4f0899abed4cbc930dba47b122851a8ac34debdf5e05bbc39a8143fc61a3d36
 SHA512:
-  metadata.gz: 06e80fa935a623e414e484df78abbc3fb8795c59babe7c40acc152a415b0ca12563be5c3bbaca82be6b36701cea934a8d5d9ae79b1a77defd9a5dd7735e71eb3
-  data.tar.gz: 617c4629c9a48b244dbaa9c8afed2cfb7315de6309e11c1d775892174e5d4166c23158d150a506f6f8f7084c0fd1f42e7549baddc8194d83f4c8e62cf40e59b3
+  metadata.gz: d3f0175f5717e228e12cf36df832b792ec9da4ea8ba30bee8511222dfacd89a2634308d734c84b514e57d4055400e6899c62d774c1baff0d1d65e9d5b666dae3
+  data.tar.gz: e6939ec41db36ce5603606d3815952f32c2826390bac2a68752cc97c695094e15759ae1417150d5343bebdd606d29e6aa0397a9db62ad65b84bf11114795bc88

data/.travis.yml

@@ -5,10 +5,15 @@ rvm:
   - 2.2
   - 2.3
   - 2.4
+  - 2.5
+  - 2.6
+  - ruby-head
 gemfile:
   - gemfiles/rails3.gemfile
   - gemfiles/rails4.gemfile
   - gemfiles/rails5.gemfile
+  - gemfiles/rails6.0.gemfile
+  - gemfiles/rails6.1.gemfile
 matrix:
   exclude:
     - rvm: 2.2
@@ -21,9 +26,30 @@ matrix:
       gemfile: gemfiles/rails5.gemfile
     - rvm: 2.1
       gemfile: gemfiles/rails5.gemfile
+    - rvm: 2.6
+      gemfile: gemfiles/rails5.gemfile
+    - rvm: ruby-head
+      gemfile: gemfiles/rails5.gemfile
+    - rvm: 2.0
+      gemfile: gemfiles/rails6.0.gemfile
+    - rvm: 2.0
+      gemfile: gemfiles/rails6.1.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails6.0.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails6.1.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/rails6.0.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/rails6.1.gemfile
+    - rvm: 2.3
+      gemfile: gemfiles/rails6.0.gemfile
+    - rvm: 2.3
+      gemfile: gemfiles/rails6.1.gemfile
+    - rvm: 2.4
+      gemfile: gemfiles/rails6.0.gemfile
+    - rvm: 2.4
+      gemfile: gemfiles/rails6.1.gemfile
 script: "bundle exec rake coverage"
-before_install:
-  - gem install bundler
 bundler_args: --retry 5
-sudo: false
 cache: bundler

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.5.0
+
+* Fixed dangerous YAML loading vulnerability
+* Rebuilt integration tests
+
+## 2.3.2
+
+* Fix sqlite3 adapter error
+
 ## 2.3.1
 
 * Fix Rails 5.2 deprecation warning

data/README.markdown

@@ -1,11 +1,10 @@
 Geokit Rails
 ============
 
-[![Gem Version](https://badge.fury.io/rb/geokit-rails.png)](http://badge.fury.io/rb/geokit-rails)
-[![Build Status](https://travis-ci.org/geokit/geokit-rails.png?branch=master)](https://travis-ci.org/geokit/geokit-rails)
-[![Coverage Status](https://coveralls.io/repos/geokit/geokit-rails/badge.png?branch=master)](https://coveralls.io/r/geokit/geokit-rails)
-[![Dependency Status](https://gemnasium.com/geokit/geokit-rails.png?travis)](https://gemnasium.com/geokit/geokit-rails)
-[![Code Climate](https://codeclimate.com/github/geokit/geokit-rails.png)](https://codeclimate.com/github/geokit/geokit-rails)
+[![Gem Version](https://badge.fury.io/rb/geokit-rails.svg)](http://badge.fury.io/rb/geokit-rails)
+[![Build Status](https://travis-ci.org/geokit/geokit-rails.svg?branch=master)](https://travis-ci.org/geokit/geokit-rails)
+[![Coverage Status](https://coveralls.io/repos/geokit/geokit-rails/badge.svg?branch=master)](https://coveralls.io/r/geokit/geokit-rails)
+[![Code Climate](https://codeclimate.com/github/geokit/geokit-rails.svg)](https://codeclimate.com/github/geokit/geokit-rails)
 
 ## COMMUNICATION
 
@@ -264,6 +263,12 @@ If you are displaying points on a map, you probably need to query for whatever f
 Store.in_bounds([sw_point,ne_point]).all
 ```
 
+If you want the query to return things that are located on the rectangular bounds, specify the `inclusive` option set to true:
+
+```ruby
+Store.in_bounds([sw_point,ne_point], :inclusive => true).all
+```
+
 The input to `bounds` can be an array with the two points or a Bounds object. However you provide them, the order should always be the southwest corner, northeast corner of the rectangle. Typically, you will be getting the sw\_point and ne\_point from a map that is displayed on a web page.
 
 If you need to calculate the bounding box from a point and radius, you can do that:
@@ -492,8 +497,9 @@ Pass the lat/lng as a string, array or LatLng instance:
 
 ```ruby
 res=Geokit::Geocoders::GoogleGeocoder.reverse_geocode "37.791821,-122.394679"
-=> #<Geokit::GeoLoc:0x558ed0 ...
-res.full_address "101-115 Main St, San Francisco, CA 94105, USA"
+# => #<Geokit::GeoLoc:0x558ed0 ...
+res.full_address
+# => "101-115 Main St, San Francisco, CA 94105, USA"
 ```
 
 The address will usually appear as a range, as it does in the above example.

data/gemfiles/rails3.gemfile

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

data/gemfiles/rails4.gemfile

@@ -2,7 +2,7 @@ source 'https://rubygems.org'
 
 group :development, :test do
   gem 'activerecord', '~> 4.0'
-  gem 'test-unit'
+  gem 'sqlite3', '1.3.7'
 end
 
 gemspec :path => "../"

data/gemfiles/rails5.gemfile

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

data/gemfiles/rails6.0.gemfile

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

data/gemfiles/rails6.1.gemfile

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

data/geokit-rails.gemspec

@@ -20,14 +20,15 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rails', '>= 3.0'
   spec.add_dependency 'geokit', '~> 1.5'
   spec.add_development_dependency "bundler", "> 1.0"
-  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov", ">= 0.16.1"
   spec.add_development_dependency "simplecov-rcov"
+  spec.add_development_dependency 'net-http'
   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 'coveralls_reborn'
+  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/geokit-rails/acts_as_mappable/class_methods.rb

@@ -0,0 +1,297 @@
+module Geokit
+  module ActsAsMappable
+
+    # Class methods included in models when +acts_as_mappable+ is called
+    module ClassMethods
+
+      # A proxy to an instance of a finder adapter, inferred from the connection's adapter.
+      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)
+                                     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."
+                                   end
+      end
+
+      def within(distance, options = {})
+        options[:within] = distance
+        # 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
+
+      def beyond(distance, options = {})
+        options[:beyond] = distance
+        #geo_scope(options)
+        where(distance_conditions(options))
+      end
+      alias outside beyond
+
+      def in_range(range, options = {})
+        options[:range] = range
+        #geo_scope(options)
+        where(distance_conditions(options))
+      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, inclusive))
+      end
+
+      def by_distance(options = {})
+        origin  = extract_origin_from_options(options)
+        units   = extract_units_from_options(options)
+        formula = extract_formula_from_options(options)
+        distance_column_name = distance_sql(origin, units, formula)
+        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).limit(1)
+      end
+      alias nearest closest
+
+      def farthest(options = {})
+        by_distance({:reverse => true}.merge(options)).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
+      #      arel.distance_formula = distance_sql(origin, units, formula)
+      #
+      #      if arel.select_values.blank?
+      #        star_select = Arel::Nodes::SqlLiteral.new(arel.quoted_table_name + '.*')
+      #        arel = arel.select(star_select)
+      #      end
+      #    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
+
+      #    if self.through
+      #      arel = arel.includes(self.through)
+      #    end
+      #  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)
+        case formula
+        when :sphere
+          sql = sphere_distance_sql(origin, units)
+        when :flat
+          sql = flat_distance_sql(origin, units)
+        end
+        sql
+      end
+
+      private
+
+      # Override ActiveRecord::Base.relation to return an instance of Geokit::ActsAsMappable::Relation.
+      # TODO: Do we need to override JoinDependency#relation too?
+      #def relation
+      #  # NOTE: This cannot be @relation as ActiveRecord already uses this to
+      #  # cache *its* Relation object
+      #  @_geokit_relation ||= Relation.new(self, arel_table)
+      #  finder_needs_type_condition? ? @_geokit_relation.where(type_condition) : @_geokit_relation
+      #end
+
+      # 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) && options[:within].is_a?(Numeric)
+        distance = options[:range].last-(options[:range].exclude_end?? 1 : 0) if options.has_key?(:range)
+        if distance
+          Geokit::Bounds.from_point_and_radius(origin,distance,:units=>units)
+        else
+          nil
+        end
+      end
+
+      def distance_conditions(options)
+        origin  = extract_origin_from_options(options)
+        units   = extract_units_from_options(options)
+        formula = extract_formula_from_options(options)
+        distance_column_name = distance_sql(origin, units, formula)
+
+        if options.has_key?(:within)
+          Arel.sql(distance_column_name).lteq(options[:within])
+        elsif options.has_key?(:beyond)
+          Arel.sql(distance_column_name).gt(options[:beyond])
+        elsif options.has_key?(:range)
+          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
+      end
+
+      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
+        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
+      # it.  If there is no origin, looks for latitude and longitude values to
+      # create an origin.  The side-effect of the method is to remove these
+      # option keys from the hash.
+      def extract_origin_from_options(options)
+        origin = options.delete(:origin)
+        res = normalize_point_to_lat_lng(origin) if origin
+        res
+      end
+
+      # Extract the units out of the options if it exists and returns it.  If
+      # there is no :units key, it uses the default.  The side effect of the
+      # method is to remove the :units key from the options hash.
+      def extract_units_from_options(options)
+        units = options[:units] || default_units
+        options.delete(:units)
+        units
+      end
+
+      # Extract the formula out of the options if it exists and returns it.  If
+      # there is no :formula key, it uses the default.  The side effect of the
+      # method is to remove the :formula key from the options hash.
+      def extract_formula_from_options(options)
+        formula = options[:formula] || default_formula
+        options.delete(:formula)
+        formula
+      end
+
+      def extract_bounds_from_options(options)
+        bounds = options.delete(:bounds)
+        bounds = Geokit::Bounds.normalize(bounds) if bounds
+      end
+
+      # Geocode IP address.
+      def geocode_ip_address(origin)
+        geo_location = Geokit::Geocoders::MultiGeocoder.geocode(origin)
+        return geo_location if geo_location.success
+        raise Geokit::Geocoders::GeocodeError
+      end
+
+      # Given a point in a variety of (an address to geocode,
+      # an array of [lat,lng], or an object with appropriate lat/lng methods, an IP addres)
+      # this method will normalize it into a Geokit::LatLng instance. The only thing this
+      # method adds on top of LatLng#normalize is handling of IP addresses
+      def normalize_point_to_lat_lng(point)
+        res = geocode_ip_address(point) if point.is_a?(String) && /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(point)
+        res = Geokit::LatLng.normalize(point) unless res
+        res
+      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_where_values(arel, origin, units=default_units, formula=default_formula)
+        pattern = Regexp.new("\\b#{distance_column_name}\\b")
+        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
+      # to the database in use.
+      def sphere_distance_sql(origin, units)
+        # "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)
+        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(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
+
+      def get_lng(origin)
+        origin.respond_to?(:lng) ? origin.lng \
+                                 : origin.send(:"#{lng_column_name}")
+      end
+
+    end # ClassMethods
+  end
+end

data/lib/geokit-rails/acts_as_mappable/glue.rb

@@ -0,0 +1,54 @@
+module Geokit
+  module ActsAsMappable
+
+    # Add the +acts_as_mappable+ method into ActiveRecord subclasses
+    module Glue # :nodoc:
+      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)
+
+          include Geokit::ActsAsMappable
+
+          cattr_accessor :through
+          self.through = options[:through]
+
+          if reflection = Geokit::ActsAsMappable.end_of_reflection_chain(self.through, self)
+            metaclass.instance_eval do
+              OPTION_SYMBOLS.each do |method_name|
+                define_method method_name do
+                  reflection.klass.send(method_name)
+                end
+              end
+            end
+          else
+            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}"
+
+            if options.include?(:auto_geocode) && options[:auto_geocode]
+              # if the form auto_geocode=>true is used, let the defaults take over by suppling an empty hash
+              options[:auto_geocode] = {} if options[:auto_geocode] == true
+              cattr_accessor :auto_geocode_field, :auto_geocode_error_message
+              self.auto_geocode_field = options[:auto_geocode][:field] || 'address'
+              self.auto_geocode_error_message = options[:auto_geocode][:error_message] || 'could not locate address'
+
+              # set the actual callback here
+              before_validation :auto_geocode_address, :on => :create
+            end
+          end
+        end
+      end
+    end # Glue
+  end
+end