timezone_finder 1.5.6 → 1.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e74c3bfc9784467f66b1c270bc2473168e8b8838
-  data.tar.gz: c5bce138f2d33d467b46a3cdf8bfd214e3d01971
+  metadata.gz: df6c6cb43816fb26a809e41666886aa1482abdb6
+  data.tar.gz: db835dab01964df180ee3d9edbe56439ae521ddf
 SHA512:
-  metadata.gz: 205cb31ffe251b8c2104fbe97f4535462d94a1a71625f7e090ecdb05937fd9c79861e8c912858d344ff6cf6b8aa8e00ab720c5d48f62ac2fa82010b0b3e1d4b9
-  data.tar.gz: c183ace8223052a82150e8627e91779647be2ca83ee83b33ca456c0033c56eecb2e40e315d70734794232cca6f6db355db4e015b4fdf7ebbcd4e283e5c39dad3
+  metadata.gz: 3dd3d72c1dd9dd6b43949748874c9aea5e2591ddb87f3f3413a8b5cf4b29147c8ec753aecac0ae27559de63f1b5e46436e95a3d4f21a05b985e1fef46a8e9636
+  data.tar.gz: 497db6944dba486a6db9b4033b8c6d9540b46f082d67737a905ecc2589125396c17498599c319cbcb9d5b960dc24078e74f2c81216ad7f9d69f21313cae21371

data/ChangeLog

@@ -1,3 +1,9 @@
+== 2017-03-14 version 1.5.7
+
+* clarified usage of the API in the Readme
+* all functions are now keyword-args only (to prevent lng lat mix-up errors)
+* sorting the polygons to check in the order of how often their zones appear gives a speed bonus
+
 == 2016-06-19 version 1.5.6
 
 * using little endian encoding now

data/README.md

@@ -2,13 +2,16 @@
 
 [![Build Status](https://travis-ci.org/gunyarakun/timezone_finder.svg?branch=master)](https://travis-ci.org/gunyarakun/timezone_finder)
 [![Gem Version](https://badge.fury.io/rb/timezone_finder.svg)](https://badge.fury.io/rb/timezone_finder)
+![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)
 
-This is a fast and lightweight ruby project for looking up the corresponding
+**NOTE:** version 1.5.7 is incompatible with version 1.5.6 because the argument were changed into named arguments following the original Python version's change.
+
+This is a fast and lightweight pure ruby project with no runtime dependency for looking up the corresponding
 timezone for a given lat/lng on earth entirely offline.
 
 This project is derived from
 [timezonefinder](https://pypi.python.org/pypi/timezonefinder)
-([github](https://github.com/MrMinimal64/timezonefinder>)).
+([github](https://github.com/MrMinimal64/timezonefinder)).
 
 The underlying timezone data is based on work done by [Eric Muller](http://efele.net/maps/tz/world/).
 
@@ -36,16 +39,17 @@ tf = TimezoneFinder.create
 
 #### timezone\_at():
 
-This is the default function to check which timezone a point lies in.
+This is the default function to check which timezone a point lies within.
 If no timezone has been found, `nil` is being returned.
-**NOTE:** This approach is optimized for speed and the common case to only query points actually within a timezone.
-This might not be what you are looking for however: When there is only one possible timezone in proximity, this timezone would be returned
-(without checking if the point is included first).
+
+**PLEASE NOTE:** This approach is optimized for speed and the common case to only query points within a timezone.
+The last possible timezone in proximity is always returned (without checking if the point is really included).
+So results might be misleading for points outside of any timezone.
 
 ```ruby
-# point = (longitude, latitude)
-point = (13.358, 52.5061)
-puts tf.timezone_at(*point)
+longitude = 13.358
+latitude = 52.5061
+puts tf.timezone_at(lng: longitude, lat: latitude)
 # = Europe/Berlin
 ```
 
@@ -55,18 +59,19 @@ This function is for making sure a point is really inside a timezone. It is slow
 are checked until one polygon is matched.
 
 ```ruby
-puts tf.certain_timezone_at(*point)
+puts tf.certain_timezone_at(lng: longitude, lat: latitude)
 # = Europe/Berlin
 ```
 
 #### Proximity algorithm
 
 Only use this when the point is not inside a polygon, because the approach otherwise makes no sense.
-This returns the closest timezone of all polygons within +-1 degree lng and +-1 degree lat (or None).
+This returns the closest timezone of all polygons within +-1 degree lng and +-1 degree lat (or nil).
 
 ```ruby
-point = (12.773955, 55.578595)
-puts tf.closest_timezone_at(*point)
+longitude = 12.773955
+latitude = 55.578595
+puts tf.closest_timezone_at(lng: longitude, lat: latitude)
 # = Europe/Copenhagens
 ```
 
@@ -75,7 +80,7 @@ puts tf.closest_timezone_at(*point)
 To increase search radius even more, use the `delta_degree`-option:
 
 ```ruby
-puts tf.closest_timezone_at(*point, 3)
+puts tf.closest_timezone_at(lng: longitude, lat: latitude, delta_degree: 3)
 # = Europe/Copenhagens
 ```
 
@@ -85,10 +90,10 @@ I recommend only slowly increasing the search radius, since computation time inc
 
 Also keep in mind that x degrees lat are not the same distance apart than x degree lng (earth is a sphere)!
 So to really make sure you got the closest timezone increase the search radius until you get a result,
-then increase the radius once more and take this result. (this should only make a difference in really rare cases)
+then increase the radius once more and take this result. (should only make a difference in really rare cases)
 
-With `exact_computation=true` the distance to every polygon edge is computed (way more complicated)
-, instead of just evaluating the distances to all the vertices. This only makes a real difference when polygons are very close.
+With `exact_computation=true` the distance to every polygon edge is computed (way more complicated), instead of just evaluating the distances to all the vertices.
+ This only makes a real difference when polygons are very close.
 
 With `return_distances=true` the output looks like this:
 
@@ -97,11 +102,22 @@ With `return_distances=true` the output looks like this:
 Note that some polygons might not be tested (for example when a zone is found to be the closest already).
 To prevent this use `force_evaluation=true`.
 
+```ruby
+longitude = 42.1052479
+latitude = -16.622686
+puts tf.closest_timezone_at(lng: longitude, lat: latitude, delta_degree: 2,
+                            exact_computation: true, return_distances: true, force_evaluation: true)
+# = ["uninhabited",
+#     [238.1846260648566, 267.91867468894895, 207.43831938964382, 209.6790144988556, 228.4213564154256, 80.66907784731693, 217.1092486625455, 293.54672523493076, 304.527493783916],
+#     ["Africa/Maputo", "Africa/Maputo", "Africa/Maputo", "Africa/Maputo", "Africa/Maputo", "uninhabited", "Indian/Antananarivo", "Indian/Antananarivo", "Indian/Antananarivo"]
+#   ]
+```
+
 ## Developer
 
 ### Using the conversion tool:
 
-Make sure you installed the GDAL framework (thats for converting .shp shapefiles into .json)
+Make sure you installed the GDAL framework (that's for converting .shp shapefiles into .json)
 Change to the directory of the timezone\_finder package (location of ``file_converter.rb``) in your terminal and then:
 
 ```sh

data/lib/timezone_finder/file_converter.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # rubocop:disable Metrics/ClassLength,Metrics/MethodLength,Metrics/LineLength
 # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/ParameterLists
-# rubocop:disable Style/PredicateName,Style/Next
+# rubocop:disable Style/PredicateName
 # rubocop:disable Lint/Void
 require 'set'
 require_relative 'helpers'
@@ -112,7 +112,7 @@ module TimezoneFinder
         # tz_name = /(TZID)/.match(row)
         # puts tz_name
         if tz_name_match
-          tz_name = tz_name_match['name'].gsub('\\', '')
+          tz_name = tz_name_match['name'].delete('\\')
           @all_tz_names << tz_name
           @nr_of_lines += 1
           # puts tz_name
@@ -135,14 +135,14 @@ module TimezoneFinder
           end
 
           if actual_depth != 0
-            fail ArgumentError, "uneven number of brackets detected. Something is wrong in line #{file_line}"
+            raise ArgumentError, "uneven number of brackets detected. Something is wrong in line #{file_line}"
           end
 
           coordinates = row.scan(/[-]?\d+\.?\d+/)
 
           sum = encountered_nr_of_coordinates.inject(0) { |a, e| a + e }
           if coordinates.length != sum * 2
-            fail ArgumentError, "There number of coordinates is counten wrong: #{coordinates.length} #{sum * 2}"
+            raise ArgumentError, "There number of coordinates is counten wrong: #{coordinates.length} #{sum * 2}"
           end
           # TODO: detect and store all the holes in the bin
           # puts coordinates
@@ -386,7 +386,7 @@ module TimezoneFinder
 
           nr_of_intersects = intersects.length
           if nr_of_intersects.odd?
-            fail 'an uneven number of intersections has been accounted'
+            raise 'an uneven number of intersections has been accounted'
           end
 
           (0...nr_of_intersects).step(2).each do |i|
@@ -458,7 +458,7 @@ module TimezoneFinder
 
           nr_of_intersects = intersects.length
           if nr_of_intersects.odd?
-            fail 'an uneven number of intersections has been accounted'
+            raise 'an uneven number of intersections has been accounted'
           end
 
           possible_latitudes = []
@@ -591,10 +591,10 @@ EOT
 EOT
 
             if shortcuts_for_line.length > column_nrs.length * row_nrs.length
-              fail 'there are more shortcuts than before now. there is something wrong with the algorithm!'
+              raise 'there are more shortcuts than before now. there is something wrong with the algorithm!'
             end
             if shortcuts_for_line.length < 3
-              fail 'algorithm not valid! less than 3 zones detected (should be at least 4)'
+              raise 'algorithm not valid! less than 3 zones detected (should be at least 4)'
             end
 
           else
@@ -668,7 +668,7 @@ EOT
       amount_of_shortcuts = nr_of_entries_in_shortcut.length
       if amount_of_shortcuts != 64_800 * NR_SHORTCUTS_PER_LNG * NR_SHORTCUTS_PER_LAT
         puts(amount_of_shortcuts)
-        fail ArgumentError, 'this number of shortcut zones is wrong'
+        raise ArgumentError, 'this number of shortcut zones is wrong'
       end
 
       puts("number of filled shortcut zones are: #{amount_filled_shortcuts} (=#{(amount_filled_shortcuts.fdiv(amount_of_shortcuts) * 100).round(2)}% of all shortcuts)")
@@ -716,7 +716,7 @@ EOT
 
       if shortcut_start_address != polygon_address
         # both should be the same!
-        fail 'shortcut_start_address and polygon_address should now be the same!'
+        raise 'shortcut_start_address and polygon_address should now be the same!'
       end
 
       # write boundary_data
@@ -739,7 +739,7 @@ EOT
       # [SHORTCUT AREA]
       # write all nr of entries
       nr_of_entries_in_shortcut.each do |nr|
-        fail "There are too many polygons in this shortcuts: #{nr}" if nr > 300
+        raise "There are too many polygons in this shortcuts: #{nr}" if nr > 300
         output_file.write([nr].pack('S<'))
       end
 
@@ -759,7 +759,7 @@ EOT
       # write Line_Nrs for every shortcut
       shortcut_entries.each do |entries|
         entries.each do |entry|
-          fail entry if entry > @nr_of_lines
+          raise entry if entry > @nr_of_lines
           output_file.write([entry].pack('S<'))
         end
       end
@@ -769,13 +769,13 @@ EOT
       # 'S<' for every hole store the related line
       i = 0
       @related_line.each do |line|
-        fail ArgumentError, line if line > @nr_of_lines
+        raise ArgumentError, line if line > @nr_of_lines
         output_file.write([line].pack('S<'))
         i += 1
       end
 
       if i > @amount_of_holes
-        fail ArgumentError, 'There are more related lines than holes.'
+        raise ArgumentError, 'There are more related lines than holes.'
       end
 
       # 'S<'  Y times [H unsigned short: nr of values (coordinate PAIRS! x,y in int32 int32) in this hole]
@@ -805,13 +805,13 @@ EOT
       last_address = output_file.tell
       hole_space = last_address - hole_start_address
       if shortcut_space != last_address - shortcut_start_address - hole_space
-        fail ArgumentError, 'shortcut space is computed wrong'
+        raise ArgumentError, 'shortcut space is computed wrong'
       end
       polygon_space = nr_of_floats * 4
 
       puts("the polygon data makes up #{(polygon_space.fdiv(last_address) * 100).round(2)}% of the file")
-      puts("the shortcuts make up #{(shortcut_space.fdiv(last_address) * 100).round(2) }% of the file")
-      puts("the holes make up #{(hole_space.fdiv(last_address) * 100).round(2) }% of the file")
+      puts("the shortcuts make up #{(shortcut_space.fdiv(last_address) * 100).round(2)}% of the file")
+      puts("the holes make up #{(hole_space.fdiv(last_address) * 100).round(2)}% of the file")
 
       puts('Success!')
     end

data/lib/timezone_finder/gem_version.rb

@@ -1,5 +1,5 @@
 module TimezoneFinder
-  VERSION = '1.5.6' unless defined? TimezoneFinder::Version
+  VERSION = '1.5.7'.freeze unless defined? TimezoneFinder::Version
   # https://github.com/MrMinimal64/timezonefinder
-  BASED_SHA1_OF_PYTHON = 'c948967a2f9c8bd03535b181fa6faa13168955ca'
+  BASED_SHA1_OF_PYTHON = '82bc84ab145c69494c1efe15c0afc9cdd46ab626'.freeze
 end

data/lib/timezone_finder/helpers.rb

@@ -1,7 +1,5 @@
 # rubocop:disable Metrics/ClassLength,Metrics/MethodLength,Metrics/LineLength
 # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/ParameterLists
-# rubocop:disable Style/PredicateName,Style/Next
-# rubocop:disable Lint/Void
 module TimezoneFinder
   class Helpers
     # tests if a point pX(x,y) is Left|On|Right of an infinite line from p1 to p2
@@ -69,7 +67,7 @@ module TimezoneFinder
       # compute the x-intersection of the point with the line p1-p2
       # delta_y cannot be 0 here because of the condition 'y lies within ]y1;y2]'
       # NOTE: bracket placement is important here (we are dealing with 64-bit ints!). first divide then multiply!
-      delta_x = ((y - y1) * ((x2 - x1).fdiv(y2 - y1))) + x1 - x
+      delta_x = ((y - y1) * (x2 - x1).fdiv(y2 - y1)) + x1 - x
 
       if delta_x > 0
         if x1gtx2
@@ -210,7 +208,7 @@ module TimezoneFinder
       # this is actually a rotation with -rad (use symmetry of sin/cos)
       sin_rad = Math.sin(rad)
       cos_rad = Math.cos(rad)
-      [point[0] * cos_rad - point[2] * sin_rad, point[1], point[2] * cos_rad - point[0] * sin_rad]
+      [point[0] * cos_rad + point[2] * sin_rad, point[1], point[2] * cos_rad - point[0] * sin_rad]
     end
 
     def self.coords2cartesian(lng_rad, lat_rad)
@@ -225,7 +223,7 @@ module TimezoneFinder
     # this is only an approximation since the earth is not a real sphere
     def self.distance_to_point_on_equator(lng_rad, lat_rad, lng_rad_p1)
       # 2* for the distance in rad and * 12742 (mean diameter of earth) for the distance in km
-      12742 * Math.asin(Math.sqrt((Math.sin(lat_rad / 2.0)) ** 2 + Math.cos(lat_rad) * Math.sin((lng_rad - lng_rad_p1) / 2.0) ** 2))
+      12_742 * Math.asin(Math.sqrt(Math.sin(lat_rad / 2.0)**2 + Math.cos(lat_rad) * Math.sin((lng_rad - lng_rad_p1) / 2.0)**2))
     end
 
     # :param lng_p1: the longitude of point 1 in radians
@@ -236,7 +234,7 @@ module TimezoneFinder
     # this is only an approximation since the earth is not a real sphere
     def self.haversine(lng_p1, lat_p1, lng_p2, lat_p2)
       # 2* for the distance in rad and * 12742(mean diameter of earth) for the distance in km
-      12742 * Math.asin(Math.sqrt(Math.sin((lat_p1 - lat_p2) / 2.0) ** 2 + Math.cos(lat_p2) * Math.cos(lat_p1) * Math.sin((lng_p1 - lng_p2) / 2.0) ** 2))
+      12_742 * Math.asin(Math.sqrt(Math.sin((lat_p1 - lat_p2) / 2.0)**2 + Math.cos(lat_p2) * Math.cos(lat_p1) * Math.sin((lng_p1 - lng_p2) / 2.0)**2))
     end
 
     # :param lng_rad: lng of px in radians
@@ -320,7 +318,7 @@ module TimezoneFinder
 
         min_distance = [min_distance,
                         compute_min_distance(lng_rad, lat_rad, trans_points[0][index_p0], trans_points[1][index_p0],
-                        pm1_lng, pm1_lat, p1_lng, p1_lat)].min
+                                             pm1_lng, pm1_lat, p1_lng, p1_lat)].min
 
         index_p0 += 2
         index_p1 += 2
@@ -332,11 +330,11 @@ module TimezoneFinder
     end
 
     def self.distance_to_polygon(lng_rad, lat_rad, nr_points, points)
-      min_distance = 40100000
+      min_distance = 40_100_000
 
       (0...nr_points).each do |i|
         min_distance = [min_distance, haversine(lng_rad, lat_rad, radians(int2coord(points[0][i])),
-          radians(int2coord(points[1][i])))].min
+                                                radians(int2coord(points[1][i])))].min
       end
 
       min_distance
@@ -360,7 +358,7 @@ module TimezoneFinder
       end
 
       unless unpack_format
-        fail "#{unsigned ? 'unsigned' : 'signed'} #{byte_width}-byte width is not supported in fromfile"
+        raise "#{unsigned ? 'unsigned' : 'signed'} #{byte_width}-byte width is not supported in fromfile"
       end
 
       file.read(count * byte_width).unpack(unpack_format)

data/lib/timezone_finder/timezone_finder.rb

@@ -1,7 +1,7 @@
 # rubocop:disable Metrics/ClassLength,Metrics/MethodLength,Metrics/LineLength
 # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/ParameterLists
-# rubocop:disable Style/PredicateName,Style/Next,Style/AndOr
-# rubocop:disable Lint/Void,Lint/HandleExceptions
+# rubocop:disable Style/Next,Style/AndOr
+# rubocop:disable Lint/HandleExceptions
 require_relative 'helpers'
 require_relative 'timezone_names'
 
@@ -62,12 +62,12 @@ module TimezoneFinder
       # write the entry for the last hole(s) in the registry
       @hole_registry.update(last_encountered_line_nr => [amount_of_holes, first_hole_id])
 
-      ObjectSpace.define_finalizer(self, self.class.__del__)
+      ObjectSpace.define_finalizer(self, self.class.__del__(@binary_file))
     end
 
-    def self.__del__
+    def self.__del__(file)
       proc do
-        @binary_file.close
+        file.close
       end
     end
 
@@ -152,6 +152,97 @@ module TimezoneFinder
     rescue KeyError
     end
 
+    # sorts the polygons_id list from least to most occurrences of the zone ids (->speed up)
+    # approx. 0.24% of all realistic points benefit from sorting (0.4% for random points)
+    # = percentage of sorting usage for 100k points
+    # in most of those cases there are only two types of zones (= entries in counted_zones) and one of them
+    # has only one entry. That means after checking one polygon timezone_at() already stops.
+    # Sorting only really makes sense for closest_timezone_at().
+    # :param polygon_id_list:
+    # :param nr_of_polygons: length of polygon_id_list
+    # :param dont_sort: if this is set to True, the sorting algorithms is skipped
+    # :return: sorted list of polygon_ids, sorted list of zone_ids, boolean: do all entries belong to the same zone
+    def compile_id_list(polygon_id_list, nr_of_polygons, dont_sort: false)
+      all_equal = lambda do |input_data|
+        x = nil
+        for x in input_data
+          # first_val = x
+          break
+        end
+        input_data.each do |y|
+          return false if x != y
+        end
+        true
+      end
+
+      # print(polygon_id_list)
+      # print(zone_id_list)
+      zone_id_list = [0] * nr_of_polygons
+      if dont_sort
+        pointer_local = 0
+        first_id = id_of(polygon_id_list[0])
+        equal = true
+        polygon_id_list.each do |polygon_id|
+          zone_id = id_of(polygon_id)
+          equal = false if zone_id != first_id
+          zone_id_list[pointer_local] = zone_id
+          pointer_local += 1
+        end
+
+        return polygon_id_list, zone_id_list, equal
+      end
+
+      counted_zones = {}
+      pointer_local = 0
+      polygon_id_list.each do |polygon_id|
+        zone_id = id_of(polygon_id)
+        zone_id_list[pointer_local] = zone_id
+        pointer_local += 1
+        counted_zones[zone_id] = counted_zones.fetch(zone_id, 0) + 1
+      end
+      # print(counted_zones)
+
+      return polygon_id_list, zone_id_list, true if counted_zones.length == 1
+
+      if all_equal.call(counted_zones.values)
+        return polygon_id_list, zone_id_list, false
+      end
+
+      counted_zones_sorted = counted_zones.sort_by { |_key, value| value }
+      # print(counted_zones_sorted)
+
+      sorted_polygon_id_list = [0] * nr_of_polygons
+      sorted_zone_id_list = [0] * nr_of_polygons
+
+      pointer_output = 0
+      pointer_output2 = 0
+      counted_zones_sorted.each do |zone_id, amount|
+        # write all polygons from this zone in the new list
+        pointer_local = 0
+        detected_polygons = 0
+        while detected_polygons < amount
+          if zone_id_list[pointer_local] == zone_id
+            # the polygon at the pointer has the wanted zone_id
+            detected_polygons += 1
+            sorted_polygon_id_list[pointer_output] = polygon_id_list[pointer_local]
+            pointer_output += 1
+          end
+
+          pointer_local += 1
+        end
+
+        (0...amount).each do |_pointer_local|
+          sorted_zone_id_list[pointer_output2] = zone_id
+          pointer_output2 += 1
+        end
+      end
+
+      # print(sorted_polygon_id_list)
+      # print(sorted_zone_id_list)
+
+      [sorted_polygon_id_list, sorted_zone_id_list, false]
+    end
+
     # This function searches for the closest polygon in the surrounding shortcuts.
     # Make sure that the point does not lie within a polygon (for that case the algorithm is simply wrong!)
     # Note that the algorithm won't find the closest polygon when it's on the 'other end of earth'
@@ -172,7 +263,7 @@ module TimezoneFinder
     # ( 'tz_name_of_the_closest_polygon',[ distances to all polygons in km], [tz_names of all polygons])
     # :param force_evaluation:
     # :return: the timezone name of the closest found polygon, the list of distances or None
-    def closest_timezone_at(lng, lat, delta_degree = 1, exact_computation = false, return_distances = false, force_evaluation = false)
+    def closest_timezone_at(lng: nil, lat: nil, delta_degree: 1, exact_computation: false, return_distances: false, force_evaluation: false)
       exact_routine = lambda do |polygon_nr|
         coords = coords_of(polygon_nr)
         nr_points = coords[0].length
@@ -187,17 +278,17 @@ module TimezoneFinder
       end
 
       if lng > 180.0 or lng < -180.0 or lat > 90.0 or lat < -90.0
-        fail "The coordinates are out ouf bounds: (#{lng}, #{lat})"
+        raise "The coordinates are out ouf bounds: (#{lng}, #{lat})"
       end
 
-      if exact_computation
-        routine = exact_routine
-      else
-        routine = normal_routine
-      end
+      routine = if exact_computation
+                  exact_routine
+                else
+                  normal_routine
+                end
 
       # the maximum possible distance is half the perimeter of earth pi * 12743km = 40,054.xxx km
-      min_distance = 40100
+      min_distance = 40_100
       # transform point X into cartesian coordinates
       current_closest_id = nil
       central_x_shortcut = (lng + 180).floor.to_i
@@ -206,7 +297,7 @@ module TimezoneFinder
       lng = Helpers.radians(lng)
       lat = Helpers.radians(lat)
 
-      polygon_nrs = []
+      possible_polygons = []
 
       # there are 2 shortcuts per 1 degree lat, so to cover 1 degree two shortcuts (rows) have to be checked
       # the highest shortcut is 0
@@ -223,32 +314,30 @@ module TimezoneFinder
       (left..right).each do |x|
         (top..bottom).each do |y|
           polygons_of_shortcut(x, y).each do |p|
-            polygon_nrs << p if polygon_nrs.index(p).nil?
+            possible_polygons << p if possible_polygons.index(p).nil?
           end
         end
       end
 
-      polygons_in_list = polygon_nrs.length
+      polygons_in_list = possible_polygons.length
 
       return nil if polygons_in_list == 0
 
       # initialize the list of ids
-      ids = polygon_nrs.map { |x| id_of(x) }
+      # TODO sorting doesn't give a bonus here?!
+      possible_polygons, ids, zones_are_equal = compile_id_list(possible_polygons, polygons_in_list,
+                                                                dont_sort: true)
 
       # if all the polygons in this shortcut belong to the same zone return it
-      first_entry = ids[0]
-      if ids.count(first_entry) == polygons_in_list
-        unless return_distances || force_evaluation
-          return TIMEZONE_NAMES[first_entry]
-          # TODO: sort from least to most occurrences
-        end
+      if zones_are_equal
+        return TIMEZONE_NAMES[ids[0]] unless return_distances || force_evaluation
       end
 
       distances = [nil] * polygons_in_list
       pointer = 0
       if force_evaluation
-        polygon_nrs.each do |polygon_nr|
-          distance = routine.call(polygon_nr)
+        possible_polygons.each do |possible_polygon|
+          distance = routine.call(possible_polygon)
           distances[pointer] = distance
           if distance < min_distance
             min_distance = distance
@@ -269,11 +358,11 @@ module TimezoneFinder
 
           else
             # this polygon has to be checked
-            distance = routine.call(polygon_nrs[pointer])
+            distance = routine.call(possible_polygons[pointer])
             distances[pointer] = distance
 
             already_checked[pointer] = true
-            if distance < min_distance
+            if distance < min_distance # rubocop:disable Metrics/BlockNesting
               min_distance = distance
               current_closest_id = ids[pointer]
               # whole list has to be searched again!
@@ -300,9 +389,9 @@ module TimezoneFinder
     # :param lng: longitude of the point in degree (-180 to 180)
     # :param lat: latitude in degree (90 to -90)
     # :return: the timezone name of the matching polygon or None
-    def timezone_at(lng = 0.0, lat = 0.0)
+    def timezone_at(lng: 0.0, lat: 0.0)
       if lng > 180.0 or lng < -180.0 or lat > 90.0 or lat < -90.0
-        fail "The coordinates are out ouf bounds: (#{lng}, #{lat})"
+        raise "The coordinates are out ouf bounds: (#{lng}, #{lat})"
       end
 
       possible_polygons = shortcuts_of(lng, lat)
@@ -318,24 +407,23 @@ module TimezoneFinder
       return TIMEZONE_NAMES[id_of(possible_polygons[0])] if nr_possible_polygons == 1
 
       # initialize the list of ids
-      # TODO: sort from least to most occurrences
-      ids = possible_polygons.map { |p| id_of(p) }
+      # and sort possible_polygons from least to most occurrences of zone_id
+      possible_polygons, ids, only_one_zone = compile_id_list(possible_polygons, nr_possible_polygons)
+
+      return TIMEZONE_NAMES[ids[0]] if only_one_zone
 
       # otherwise check if the point is included for all the possible polygons
       (0...nr_possible_polygons).each do |i|
         polygon_nr = possible_polygons[i]
 
-        same_element = Helpers.all_the_same(i, nr_possible_polygons, ids)
-        return TIMEZONE_NAMES[same_element] if same_element != -1
-
         # get the boundaries of the polygon = (lng_max, lng_min, lat_max, lat_min)
         @binary_file.seek((@bound_start_address + 16 * polygon_nr))
         boundaries = Helpers.fromfile(@binary_file, false, 4, 4)
-        # only run the algorithm if it the point is withing the boundaries
+        # only run the expensive algorithm if the point is withing the boundaries
         unless x > boundaries[0] or x < boundaries[1] or y > boundaries[2] or y < boundaries[3]
 
           outside_all_holes = true
-          # when the point is within a hole of the polygon this timezone doesn't need to be checked
+          # when the point is within a hole of the polygon, this timezone doesn't need to be checked
           _holes_of_line(polygon_nr) do |hole_coordinates|
             if Helpers.inside_polygon(x, y, hole_coordinates)
               outside_all_holes = false
@@ -349,6 +437,9 @@ module TimezoneFinder
             end
           end
         end
+        # when after the current polygon only polygons from the same zone appear, return this zone
+        same_element = Helpers.all_the_same(i + 1, nr_possible_polygons, ids)
+        return TIMEZONE_NAMES[same_element] if same_element != -1
       end
       nil
     end
@@ -358,9 +449,9 @@ module TimezoneFinder
     # :param lng: longitude of the point in degree
     # :param lat: latitude in degree
     # :return: the timezone name of the polygon the point is included in or None
-    def certain_timezone_at(lng = 0.0, lat = 0.0)
+    def certain_timezone_at(lng: 0.0, lat: 0.0)
       if lng > 180.0 or lng < -180.0 or lat > 90.0 or lat < -90.0
-        fail "The coordinates are out ouf bounds: (#{lng}, #{lat})"
+        raise "The coordinates are out ouf bounds: (#{lng}, #{lat})"
       end
 
       possible_polygons = shortcuts_of(lng, lat)

data/timezone_finder.gemspec

@@ -10,11 +10,11 @@ Gem::Specification.new do |spec|
   spec.email         = ['tasuku-s-github@titech.ac']
 
   spec.summary       = 'Look up timezone from lat / long offline.'
-  spec.description = %(
+  spec.description   = %(
     A pure Ruby library to look up timezone from latitude / longitude offline.
     Ported version of 'timezonefinder' on PyPI.
   ).strip.gsub(/\s+/, ' ')
-  spec.homepage     = 'https://github.com/gunyarakun/timezone_finder'
+  spec.homepage      = 'https://github.com/gunyarakun/timezone_finder'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timezone_finder
 version: !ruby/object:Gem::Version
-  version: 1.5.6
+  version: 1.5.7
 platform: ruby
 authors:
 - Tasuku SUENAGA a.k.a. gunyarakun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-19 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Look up timezone from lat / long offline.