plus_codes 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69d6043d4051f33ae155cb1659af7e8e533054ae
-  data.tar.gz: 2eddbf67c2fd1e8ae3b230150868a074d173d41a
+  metadata.gz: f6d973ca48c7cbdf04ae78ceae2e41e0788ead86
+  data.tar.gz: 09713b9cbfcbad05b8d24fe8740104f14d8bc031
 SHA512:
-  metadata.gz: 3a1d9f99221ae07169b7dcd1145b7a0a2a863636043fa5f6d602abd919c992e614cd9a2c2f332abd7feb5abb2267406816f4632273f6c93948055c3bb76c632c
-  data.tar.gz: d81015cd0361126dc140b86590bdd28bee3a6f6f26caff6a78a9ef77154c6ced5ebf5992b2b9366a74be16cf56a638b014daa287524feee91fd7c3c30ff4f752
+  metadata.gz: 3e30d6a3c449e5e1c597abd7531a80e567f98eace3f9430414e19c50866c3004b1e70263f281895255e99164b8e0ec37daa18204fec16960aea5bb6558fe4995
+  data.tar.gz: b6e3a2028c1413b280c3dc032c76c00ce773fc7fc6afdf4f2fe74011b0e944d9eaf6671f07d02b3358d3f7909062f0ea6f7cf7c5f9202d03313972408adf4d05

data/Rakefile

@@ -5,13 +5,12 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
+Bundler::GemHelper.install_tasks
+
 require 'yard'
 YARD::Rake::YardocTask.new
 
-Bundler::GemHelper.install_tasks
-
 require 'rake/testtask'
-
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.libs << 'test'

data/lib/plus_codes/code_area.rb

@@ -4,40 +4,34 @@ module PlusCodes
   # The coordinates include the latitude and longitude of the lower left and
   # upper right corners and the center of the bounding box for the area the
   # code represents.
-  # Attributes:
-  #   latitude_lo: The latitude of the SW corner in degrees.
-  #   longitude_lo: The longitude of the SW corner in degrees.
-  #   latitude_hi: The latitude of the NE corner in degrees.
-  #   longitude_hi: The longitude of the NE corner in degrees.
-  #   latitude_center: The latitude of the center in degrees.
-  #   longitude_center: The longitude of the center in degrees.
-  #   code_length: The number of significant characters that were in the code.
-  #   
+  #
   # @author We-Ming Wu
   class CodeArea
-    attr_accessor :latitude_lo, :longitude_lo, :latitude_hi, :longitude_hi,
-      :code_length, :latitude_center, :longitude_center
+    attr_accessor :south_latitude, :west_longitude, :latitude_height,
+    :longitude_width, :latitude_center, :longitude_center
 
     # Creates a [CodeArea].
     #
-    # @param latitude_lo [Numeric] the latitude of the SW corner in degrees
-    # @param longitude_lo [Numeric] the longitude of the SW corner in degrees
-    # @param latitude_hi [Numeric] the latitude of the NE corner in degrees
-    # @param longitude_hi [Numeric] the longitude of the NE corner in degrees
-    # @param code_length [Integer] the number of characters in the code, this excludes the separator
+    # @param south_latitude [Numeric] the latitude of the SW corner in degrees
+    # @param west_longitude [Numeric] the longitude of the SW corner in degrees
+    # @param latitude_height [Numeric] the height from the SW corner in degrees
+    # @param longitude_width [Numeric] the width from the SW corner in degrees
     # @return [CodeArea] a code area which contains the coordinates
-    def initialize(latitude_lo, longitude_lo, latitude_hi, longitude_hi, code_length)
-      @latitude_lo = latitude_lo
-      @longitude_lo = longitude_lo
-      @latitude_hi = latitude_hi
-      @longitude_hi = longitude_hi
-      @code_length = code_length
-      @latitude_center = [@latitude_lo + (@latitude_hi - @latitude_lo) / 2, LATITUDE_MAX].min
-      @longitude_center = [@longitude_lo + (@longitude_hi - @longitude_lo) / 2, LONGITUDE_MAX].min
+    def initialize(south_latitude, west_longitude, latitude_height, longitude_width)
+      @south_latitude = south_latitude
+      @west_longitude = west_longitude
+      @latitude_height = latitude_height
+      @longitude_width = longitude_width
+      @latitude_center = south_latitude + latitude_height / 2.0
+      @longitude_center = west_longitude + longitude_width / 2.0
     end
 
-    def to_s
-      "lat_lo: #{@latitude_lo} long_lo: #{@longitude_lo} lat_hi: #{@latitude_hi} long_hi: #{@longitude_hi} code_len: #{@code_length}"
+    def north_latitude
+      @south_latitude + @latitude_height
+    end
+
+    def east_longitude
+      @west_longitude + @longitude_width
     end
   end
 

data/lib/plus_codes/open_location_code.rb

@@ -8,187 +8,142 @@ module PlusCodes
   # @author We-Ming Wu
   class OpenLocationCode
 
-    # Validates the given plus+codes.
+    # Determines if a string is a valid sequence of Open Location Code(Plus+Codes) characters.
     #
     # @param code [String] a plus+codes
     # @return [TrueClass, FalseClass] true if the code is valid, false otherwise
     def valid?(code)
-      return false if code.nil? || code.length <= 1
-
-      separator_index = code.index(SEPARATOR)
-      # There must be a single separator at an even index and position should be < SEPARATOR_POSITION.
-      return false if separator_index.nil? ||
-        separator_index != code.rindex(SEPARATOR) ||
-        separator_index > SEPARATOR_POSITION ||
-        separator_index.odd?
-
-      # We can have an even number of padding characters before the separator,
-      # but then it must be the final character.
-      if code.include?(PADDING)
-        return false if code.start_with?(PADDING)
-        pad_match = code.scan(/#{PADDING}+/)
-        return false unless pad_match.one?
-        padding = pad_match[0]
-        return false if padding.length.odd?
-        return false if padding.length > SEPARATOR_POSITION - 2
-        return false if code[-2] != PADDING
-        return false if code[-1] != SEPARATOR
-      end
-
-      # If there are characters after the separator, make sure there isn't just
-      # one of them (not legal).
-      return false if code.length - separator_index - 1 == 1
-
-      # Check code contains only valid characters.
-      code.chars.each do |ch|
-        return false if ch.ord >= DECODE.length || DECODE[ch.ord] < -1
-      end
-      true
+      valid_length?(code) &&
+      valid_separator?(code) &&
+      valid_padding?(code) &&
+      valid_character?(code)
     end
 
-    # Checks if the given plus+codes is in short format.
+    # Determines if a string is a valid short Open Location Code(Plus+Codes).
     #
     # @param code [String] a plus+codes
     # @return [TrueClass, FalseClass] true if the code is short, false otherwise
     def short?(code)
-      return false unless valid?(code)
-      # If there are less characters than expected before the SEPARATOR.
-      code.index(SEPARATOR) >= 0 && code.index(SEPARATOR) < SEPARATOR_POSITION
+      valid?(code) && code.index(SEPARATOR) < SEPARATOR_POSITION
     end
 
-    # Checks if the given plus+codes is in full format.
+    # Determines if a string is a valid full Open Location Code(Plus+Codes).
     #
     # @param code [String] a plus+codes
     # @return [TrueClass, FalseClass] true if the code is full, false otherwise
     def full?(code)
-      return false unless valid?(code)
-      #  If it's short, it's not full.
-      return false if short?(code)
-
-      # Work out what the first latitude character indicates for latitude.
-      first_lat_value = DECODE[code[0].ord] * ENCODING_BASE
-      # The code would decode to a latitude of >= 90 degrees.
-      return false if first_lat_value >= LATITUDE_MAX * 2
-      if code.length > 1
-        # Work out what the first longitude character indicates for longitude.
-        first_lng_value = DECODE[code[1].ord] * ENCODING_BASE
-        # The code would decode to a longitude of >= 180 degrees.
-        return false if first_lng_value >= LONGITUDE_MAX * 2
-      end
-      true
+      valid?(code) && !short?(code)
     end
 
-    # Encodes given latitude and longitude with the optionally provided code length.
+    # Converts a latitude and longitude into a Open Location Code(Plus+Codes).
     #
     # @param latitude [Numeric] a latitude in degrees
     # @param longitude [Numeric] a longitude in degrees
     # @param code_length [Integer] the number of characters in the code, this excludes the separator
     # @return [String] a plus+codes
-    def encode(latitude, longitude, code_length = PAIR_CODE_LENGTH)
-      if code_length < 2 || (code_length < SEPARATOR_POSITION && code_length.odd?)
-        raise ArgumentError, "Invalid Open Location Code length: #{code_length}"
-      end
+    def encode(latitude, longitude, code_length = 10)
+      raise ArgumentError,
+      "Invalid Open Location Code(Plus+Codes) length: #{code_length}" if invalid_length?(code_length)
 
       latitude = clip_latitude(latitude)
       longitude = normalize_longitude(longitude)
-      if latitude == 90
-        latitude = latitude - compute_latitude_precision(code_length).to_f
-      end
-      code = encode_pairs(latitude, longitude, [code_length, PAIR_CODE_LENGTH].min)
-      # If the requested length indicates we want grid refined codes.
-      if code_length > PAIR_CODE_LENGTH
-        code += encode_grid(latitude, longitude, code_length - PAIR_CODE_LENGTH)
+      latitude -= precision_by_length(code_length) if latitude == 90
+
+      lat = (latitude + 90).to_r
+      lng = (longitude + 180).to_r
+
+      digit = 0
+      code = ''
+      while digit < code_length
+        lat, lng = narrow_region(digit, lat, lng)
+        digit, lat, lng = build_code(digit, code, lat, lng)
+        code << SEPARATOR if (digit == SEPARATOR_POSITION)
       end
-      code
+
+      digit < SEPARATOR_POSITION ? padded(code) : code
     end
 
-    # Decodes the given plus+codes in to a [CodeArea].
+    # Decodes an Open Location Code(Plus+Codes) into a [CodeArea].
     #
     # @param code [String] a plus+codes
     # @return [CodeArea] a code area which contains the coordinates
     def decode(code)
       raise ArgumentError,
-        "Passed Open Location Code is not a valid full code: #{code}" unless full?(code)
+      "Open Location Code(Plus+Codes) is not a valid full code: #{code}" unless full?(code)
 
-      # Strip out separator character (we've already established the code is
-      # valid so the maximum is one), padding characters and convert to upper
-      # case.
       code = code.gsub(SEPARATOR, '')
       code = code.gsub(/#{PADDING}+/, '')
       code = code.upcase
-      # Decode the lat/lng pair component.
-      code_area = decode_pairs(code[0...[code.length, PAIR_CODE_LENGTH].min])
-      # If there is a grid refinement component, decode that.
-      return code_area if code.length <= PAIR_CODE_LENGTH
-
-      grid_area = decode_grid(code[PAIR_CODE_LENGTH..-1])
-      CodeArea.new(code_area.latitude_lo + grid_area.latitude_lo,
-        code_area.longitude_lo + grid_area.longitude_lo,
-        code_area.latitude_lo + grid_area.latitude_hi,
-        code_area.longitude_lo + grid_area.longitude_hi,
-        code_area.code_length + grid_area.code_length)
+
+      south_latitude = -90.0
+      west_longitude = -180.0
+
+      lat_resolution = 400.to_r
+      lng_resolution = 400.to_r
+
+      digit = 0
+      while digit < code.length
+        if digit < 10
+          lat_resolution /= 20
+          lng_resolution /= 20
+          south_latitude += lat_resolution * DECODE[code[digit].ord]
+          west_longitude += lng_resolution * DECODE[code[digit + 1].ord]
+          digit += 2
+        else
+          lat_resolution /= 5
+          lng_resolution /= 4
+          row = DECODE[code[digit].ord] / 4
+          column = DECODE[code[digit].ord] % 4
+          south_latitude += lat_resolution * row
+          west_longitude += lng_resolution * column
+          digit += 1
+        end
+      end
+
+      CodeArea.new(south_latitude, west_longitude, lat_resolution, lng_resolution)
     end
 
-    # Finds the full plus+codes from given short plus+codes, reference latitude and longitude.
+    # Recovers a full Open Location Code(Plus+Codes) from a short code and a reference location.
     #
-    # @param code [String] a plus+codes
+    # @param short_code [String] a plus+codes
     # @param reference_latitude [Numeric] a reference latitude in degrees
     # @param reference_longitude [Numeric] a reference longitude in degrees
     # @return [String] a plus+codes
     def recover_nearest(short_code, reference_latitude, reference_longitude)
-      unless short?(short_code)
-        if full?(short_code)
-          return short_code
-        else
-          raise ArgumentError, "ValueError: Passed short code is not valid: #{short_code}"
-        end
-      end
+      return short_code if full?(short_code)
+      raise ArgumentError,
+      "Open Location Code(Plus+Codes) is not valid: #{short_code}" unless short?(short_code)
+
+      ref_lat = clip_latitude(reference_latitude)
+      ref_lng = normalize_longitude(reference_longitude)
+
+      prefix_len = SEPARATOR_POSITION - short_code.index(SEPARATOR)
+      code = prefix_by_reference(ref_lat, ref_lng, prefix_len) << short_code
+      code_area = decode(code)
+
+      area_range = precision_by_length(prefix_len)
+      area_edge = area_range / 2
 
-      # Ensure that latitude and longitude are valid.
-      reference_latitude = clip_latitude(reference_latitude)
-      reference_longitude = normalize_longitude(reference_longitude)
-
-      # Clean up the passed code.
-      short_code = short_code.upcase
-      # Compute the number of digits we need to recover.
-      padding_length = SEPARATOR_POSITION - short_code.index(SEPARATOR)
-      # The resolution (height and width) of the padded area in degrees.
-      resolution = 20 ** (2 - (padding_length / 2))
-      # Distance from the center to an edge (in degrees).
-      area_to_edge = resolution / 2.0
-
-      # Now round down the reference latitude and longitude to the resolution.
-      rounded_latitude = (reference_latitude / resolution).floor * resolution
-      rounded_longitude = (reference_longitude / resolution).floor * resolution
-
-      # Use the reference location to pad the supplied short code and decode it.
-      code_area = decode(
-        encode(rounded_latitude, rounded_longitude).slice(0, padding_length) +
-          short_code)
-      # How many degrees latitude is the code from the reference? If it is more
-      # than half the resolution, we need to move it east or west.
-      degrees_difference = code_area.latitude_center - reference_latitude
-      if degrees_difference > area_to_edge
-        # If the center of the short code is more than half a cell east,
-        # then the best match will be one position west.
-        code_area.latitude_center -= resolution
-      elsif degrees_difference < -area_to_edge
-        # If the center of the short code is more than half a cell west,
-        # then the best match will be one position east.
-        code_area.latitude_center += resolution
+      latitude = code_area.latitude_center
+      latitude_diff = latitude - ref_lat
+      if (latitude_diff > area_edge)
+        latitude -= area_range
+      elsif (latitude_diff < -area_edge)
+        latitude += area_range
       end
 
-      # How many degrees longitude is the code from the reference?
-      degrees_difference = code_area.longitude_center - reference_longitude
-      if degrees_difference > area_to_edge
-        code_area.longitude_center -= resolution
-      elsif degrees_difference < -area_to_edge
-        code_area.longitude_center += resolution
+      longitude = code_area.longitude_center
+      longitude_diff = longitude - ref_lng
+      if (longitude_diff > area_edge)
+        longitude -= area_range
+      elsif (longitude_diff < -area_edge)
+        longitude += area_range
       end
-      encode(code_area.latitude_center, code_area.longitude_center, code_area.code_length)
+
+      encode(latitude, longitude, code.length - SEPARATOR.length)
     end
 
-    # Shortens the given full plus+codes by provided reference latitude and longitude.
+    # Removes four, six or eight digits from the front of an Open Location Code(Plus+Codes) given a reference location.
     #
     # @param code [String] a plus+codes
     # @param latitude [Numeric] a latitude in degrees
@@ -196,154 +151,114 @@ module PlusCodes
     # @return [String] a short plus+codes
     def shorten(code, latitude, longitude)
       raise ArgumentError,
-        "ValueError: Passed code is not valid and full: #{code}" unless full?(code)
+      "Open Location Code(Plus+Codes) is a valid full code: #{code}" unless full?(code)
       raise ArgumentError,
-        "ValueError: Cannot shorten padded codes: #{code}" unless code.index(PADDING).nil?
+      "Cannot shorten padded codes: #{code}" unless code.index(PADDING).nil?
 
-      code = code.upcase
       code_area = decode(code)
-      if code_area.code_length < MIN_TRIMMABLE_CODE_LEN
-        raise RangeError,
-          "ValueError: Code length must be at least #{MIN_TRIMMABLE_CODE_LEN}"
-      end
-      # Ensure that latitude and longitude are valid.
-      latitude = clip_latitude(latitude)
-      longitude = normalize_longitude(longitude)
-      # How close are the latitude and longitude to the code center.
-      range = [(code_area.latitude_center - latitude).abs,
-        (code_area.longitude_center - longitude).abs].max
-      i = PAIR_RESOLUTIONS.length - 2
-      while i >= 1 do
-        # Check if we're close enough to shorten. The range must be less than 1/2
-        # the resolution to shorten at all, and we want to allow some safety, so
-        # use 0.3 instead of 0.5 as a multiplier.
-        return code[(i + 1) * 2..-1] if range < (PAIR_RESOLUTIONS[i] * 0.3)
-        # Trim it.
-        i -= 1
+      lat_diff = (latitude - code_area.latitude_center).abs
+      lng_diff = (longitude - code_area.longitude_center).abs
+      max_diff = [lat_diff, lng_diff].max
+      [8, 6, 4].each do |removal_len|
+        area_edge = precision_by_length(removal_len + 2) / 2
+        return code[removal_len..-1] if max_diff < area_edge
       end
-      code
+
+      code.upcase
     end
 
     private
 
-    def encode_pairs(latitude, longitude, code_length)
-      code = ''
-      # Adjust latitude and longitude so they fall into positive ranges.
-      adjusted_latitude = latitude + LATITUDE_MAX
-      adjusted_longitude = longitude + LONGITUDE_MAX
-      # Count digits - can't use string length because it may include a separator
-      # character.
-      digit_count = 0
-      while (digit_count < code_length) do
-        # Provides the value of digits in this place in decimal degrees.
-        place_value = PAIR_RESOLUTIONS[(digit_count / 2).to_i]
-        # Do the latitude - gets the digit for this place and subtracts that for
-        # the next digit.
-        digit_value = (adjusted_latitude / place_value).to_i
-        adjusted_latitude -= digit_value * place_value
-        code += CODE_ALPHABET[digit_value]
-        digit_count += 1
-        # And do the longitude - gets the digit for this place and subtracts that
-        # for the next digit.
-        digit_value = (adjusted_longitude / place_value).to_i
-        adjusted_longitude -= digit_value * place_value
-        code += CODE_ALPHABET[digit_value]
-        digit_count +=1
-        # Should we add a separator here?
-        code += SEPARATOR if digit_count == SEPARATOR_POSITION && digit_count < code_length
-      end
-      # If necessary, Add padding.
-      if code.length < SEPARATOR_POSITION
-        code = code + (PADDING * (SEPARATOR_POSITION - code.length))
+    def prefix_by_reference(latitude, longitude, prefix_len)
+      precision = precision_by_length(prefix_len)
+      rounded_latitude = (latitude / precision).floor * precision
+      rounded_longitude = (longitude / precision).floor * precision
+      encode(rounded_latitude, rounded_longitude)[0...prefix_len]
+    end
+
+    def narrow_region(digit, latitude, longitude)
+      if digit == 0
+        latitude /= 20
+        longitude /= 20
+      elsif digit < 10
+        latitude *= 20
+        longitude *= 20
+      else
+        latitude *= 5
+        longitude *= 4
       end
-      code = code + SEPARATOR if code.length == SEPARATOR_POSITION
-      code
+      [latitude, longitude]
     end
 
-    def encode_grid(latitude, longitude, code_length)
-      code = ''
-      lat_place_value = GRID_SIZE_DEGREES
-      lng_place_value = GRID_SIZE_DEGREES
-      # Adjust latitude and longitude so they fall into positive ranges and
-      # get the offset for the required places.
-      adjusted_latitude = (latitude + LATITUDE_MAX) % lat_place_value
-      adjusted_longitude = (longitude + LONGITUDE_MAX) % lng_place_value
-      (1..code_length).each do
-        # Work out the row and column.
-        row = (adjusted_latitude / (lat_place_value / GRID_ROWS)).floor
-        col = (adjusted_longitude / (lng_place_value / GRID_COLUMNS)).floor
-        lat_place_value /= GRID_ROWS
-        lng_place_value /= GRID_COLUMNS
-        adjusted_latitude -= row * lat_place_value
-        adjusted_longitude -= col * lng_place_value
-        code += CODE_ALPHABET[row * GRID_COLUMNS + col]
+    def build_code(digit_count, code, latitude, longitude)
+      lat_digit = latitude.to_i
+      lng_digit = longitude.to_i
+      if digit_count < 10
+        code << CODE_ALPHABET[lat_digit]
+        code << CODE_ALPHABET[lng_digit]
+        [digit_count + 2, latitude - lat_digit, longitude - lng_digit]
+      else
+        code << CODE_ALPHABET[4 * lat_digit + lng_digit]
+        [digit_count + 1, latitude - lat_digit, longitude - lng_digit]
       end
-      code
     end
 
-    def decode_pairs(code)
-      # Get the latitude and longitude values. These will need correcting from
-      # positive ranges.
-      latitude = decode_pairs_sequence(code, 0.0)
-      longitude = decode_pairs_sequence(code, 1.0)
-      # Correct the values and set them into the CodeArea object.
-      CodeArea.new(latitude[0] - LATITUDE_MAX,
-        longitude[0] - LONGITUDE_MAX, latitude[1] - LATITUDE_MAX,
-        longitude[1] - LONGITUDE_MAX, code.length)
+    def valid_length?(code)
+      !code.nil? && code.length >= 2 + SEPARATOR.length && code.split(SEPARATOR).last.length != 1
     end
 
-    def decode_pairs_sequence(code, offset)
-      i = 0
-      value = 0
-      while i * 2 + offset < code.length do
-        value += DECODE[code[i * 2 + offset.floor].ord] * PAIR_RESOLUTIONS[i]
-        i += 1
-      end
-      [value, value + PAIR_RESOLUTIONS[i - 1]]
+    def valid_separator?(code)
+      separator_idx = code.index(SEPARATOR)
+      code.count(SEPARATOR) == 1 && separator_idx <= SEPARATOR_POSITION && separator_idx.even?
     end
 
-    def decode_grid(code)
-      latitude_lo = 0.0
-      longitude_lo = 0.0
-      lat_place_value = GRID_SIZE_DEGREES
-      lng_place_value = GRID_SIZE_DEGREES
-      (0...code.length).each do |i|
-        code_index = DECODE[code[i].ord]
-        row = (code_index / GRID_COLUMNS).floor
-        col = code_index % GRID_COLUMNS
-
-        lat_place_value /= GRID_ROWS
-        lng_place_value /= GRID_COLUMNS
-
-        latitude_lo += row * lat_place_value
-        longitude_lo += col * lng_place_value
+    def valid_padding?(code)
+      if code.include?(PADDING)
+        return false if code.start_with?(PADDING)
+        return false if code[-2..-1] != PADDING + SEPARATOR
+
+        paddings = code.scan(/#{PADDING}+/)
+        return false if !paddings.one? || paddings[0].length.odd?
+        return false if paddings[0].length > SEPARATOR_POSITION - 2
       end
-      CodeArea.new(latitude_lo, longitude_lo, latitude_lo + lat_place_value,
-        longitude_lo + lng_place_value, code.length)
+      true
     end
 
-    def clip_latitude(latitude)
-      [90.0, [-90.0, latitude].max].min
+    def valid_character?(code)
+      code.chars.each { |ch| return false if DECODE[ch.ord].nil? }
+      true
     end
 
-    def compute_latitude_precision(code_length)
+    def invalid_length?(code_length)
+      code_length < 2 || (code_length < SEPARATOR_POSITION && code_length.odd?)
+    end
+
+    def padded(code)
+      code << PADDING * (SEPARATOR_POSITION - code.length) << SEPARATOR
+    end
+
+    def precision_by_length(code_length)
       if code_length <= 10
-        20 ** ((code_length / -2).to_i + 2)
+        precision = 20 ** ((code_length / -2).to_i + 2)
       else
-        (20 ** -3) / (GRID_ROWS ** (code_length - 10))
+        precision = (20 ** -3) / (5 ** (code_length - 10))
       end
+      precision.to_r
+    end
+
+    def clip_latitude(latitude)
+      [90.0, [-90.0, latitude].max].min
     end
 
     def normalize_longitude(longitude)
-      begin
-        longitude += 360
-      end while longitude < -180
-      begin
+      until longitude < 180
         longitude -= 360
-      end while longitude >= 180
+      end
+      until longitude >= -180
+        longitude += 360
+      end
       longitude
     end
-
   end
 
 end

data/lib/plus_codes/version.rb

@@ -1,3 +1,3 @@
 module PlusCodes
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/plus_codes.rb

@@ -1,63 +1,26 @@
 # Plus+Codes is a Ruby implementation of Google Open Location Code(Plus+Codes).
-# 
+#
 # @author We-Ming Wu
 module PlusCodes
 
-  # A separator used to break the code into two parts to aid memorability.
+  # A separator used to separate the code into two parts.
   SEPARATOR = '+'.freeze
 
-  # The number of characters to place before the separator.
+  # The max number of characters can be placed before the separator.
   SEPARATOR_POSITION = 8
 
-  # The character used to pad codes.
+  # The character used to pad a code
   PADDING = '0'.freeze
 
-  # The character set used to encode the values.
+  # The character set used to encode coordinates.
   CODE_ALPHABET = '23456789CFGHJMPQRVWX'.freeze
 
-  # The base to use to convert numbers to/from.
-  ENCODING_BASE = CODE_ALPHABET.length
-
-  # The maximum value for latitude in degrees.
-  LATITUDE_MAX = 90
-
-  # The maximum value for longitude in degrees.
-  LONGITUDE_MAX = 180
-
-  # Maximum code length using lat/lng pair encoding. The area of such a
-  # code is approximately 13x13 meters (at the equator), and should be suitable
-  # for identifying buildings. This excludes prefix and separator characters.
-  PAIR_CODE_LENGTH = 10
-
-  # The resolution values in degrees for each position in the lat/lng pair
-  # encoding. These give the place value of each position, and therefore the
-  # dimensions of the resulting area.
-  PAIR_RESOLUTIONS = [20.0, 1.0, 0.05, 0.0025, 0.000125].freeze
-
-  # Number of columns in the grid refinement method.
-  GRID_COLUMNS = 4
-
-  #  Number of rows in the grid refinement method.
-  GRID_ROWS = 5
-
-  # Size of the initial grid in degrees.
-  GRID_SIZE_DEGREES = 0.000125
-
-  # Minimum length of a code that can be shortened.
-  MIN_TRIMMABLE_CODE_LEN = 6
-
-  # Decoder lookup table.
-  # -2: illegal.
-  # -1: Padding or Separator
-  # >= 0: index in the alphabet.
-  DECODE = [
-    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2,
-    -1, -2,  0,  1,  2,  3,  4,  5,  6,  7, -2, -2, -2, -2, -2, -2,
-    -2, -2, -2,  8, -2, -2,  9, 10, 11, -2, 12, -2, -2, 13, -2, -2,
-    14, 15, 16, -2, -2, -2, 17, 18, 19, -2, -2, -2, -2, -2, -2, -2,
-    -2, -2, -2,  8, -2, -2,  9, 10, 11, -2, 12, -2, -2, 13, -2, -2,
-    14, 15, 16, -2, -2, -2, 17, 18, 19, -2, -2, -2, -2, -2, -2, -2,].freeze
+  # ASCII lookup table.
+  DECODE = (CODE_ALPHABET.chars + [PADDING, SEPARATOR]).reduce([]) do |ary, c|
+    ary[c.ord] = CODE_ALPHABET.index(c)
+    ary[c.downcase.ord] = CODE_ALPHABET.index(c)
+    ary[c.ord] ||= -1
+    ary
+  end.freeze
 
 end

data/test/plus_codes_test.rb

@@ -27,12 +27,16 @@ class PlusCodesTest < Test::Unit::TestCase
     read_csv_lines('encodingTests.csv').each do |line|
       cols = line.split(',')
       code_area = @olc.decode(cols[0])
-      code = @olc.encode(cols[1].to_f, cols[2].to_f, code_area.code_length)
+      if cols[0].index('0')
+        code = @olc.encode(cols[1].to_f, cols[2].to_f, cols[0].index('0'))
+      else
+        code = @olc.encode(cols[1].to_f, cols[2].to_f, cols[0].length - 1)
+      end
       assert_equal(cols[0], code)
-      assert_true((code_area.latitude_lo - cols[3].to_f).abs < 0.001)
-      assert_true((code_area.longitude_lo - cols[4].to_f).abs < 0.001)
-      assert_true((code_area.latitude_hi - cols[5].to_f).abs < 0.001)
-      assert_true((code_area.longitude_hi - cols[6].to_f).abs < 0.001)
+      assert_true((code_area.south_latitude - cols[3].to_f).abs < 0.001)
+      assert_true((code_area.west_longitude - cols[4].to_f).abs < 0.001)
+      assert_true((code_area.north_latitude - cols[5].to_f).abs < 0.001)
+      assert_true((code_area.east_longitude - cols[6].to_f).abs < 0.001)
     end
   end
 
@@ -48,20 +52,11 @@ class PlusCodesTest < Test::Unit::TestCase
       expanded = @olc.recover_nearest(short, lat, lng)
       assert_equal(code, expanded)
     end
+    @olc.shorten('9C3W9QCJ+2VX', 60.3701125, 10.202665625)
   end
 
   def test_longer_encoding_with_speacial_case
-    assert_equal('CFX3X2X2+X2XXXXQ', @olc.encode(90.0, 1.0, 15));
-  end
-
-  def test_code_area_to_s
-    read_csv_lines('encodingTests.csv').each do |line|
-      cols = line.split(',')
-      code_area = @olc.decode(cols[0])
-      assert_equal("lat_lo: #{code_area.latitude_lo} long_lo: #{code_area.longitude_lo} " <<
-          "lat_hi: #{code_area.latitude_hi} long_hi: #{code_area.longitude_hi} " <<
-          "code_len: #{code_area.code_length}", code_area.to_s)
-    end
+    assert_equal('CFX3X2X2+X2RRRRJ', @olc.encode(90.0, 1.0, 15));
   end
 
   def test_exceptions
@@ -72,9 +67,18 @@ class PlusCodesTest < Test::Unit::TestCase
       @olc.recover_nearest('9C3W9QCJ-2VX', 51.3708675, -1.217765625)
     end
     @olc.recover_nearest('9C3W9QCJ+2VX', 51.3708675, -1.217765625)
+    assert_raise ArgumentError do
+      @olc.decode('sfdg')
+    end
+    assert_raise ArgumentError do
+      @olc.shorten('9C3W9Q+', 1, 2)
+    end
+    assert_raise ArgumentError do
+      @olc.shorten('9C3W9Q00+', 1, 2)
+    end
   end
 
-  def test_valid?_with_speacial_case
+  def test_valid_with_speacial_case
     assert_false(@olc.valid?('3W00CJJJ+'))
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plus_codes
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Wei-Ming Wu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler