plus_codes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7430998fc47b7df06e1254f74ca980b1c33fbd12
+  data.tar.gz: f503a83dd1b483d57d2dc917b3abe5d95dc22ee0
+SHA512:
+  metadata.gz: 114f48473a81ead5f78179d0293892ff4c7f43b891b5c4cb9f4d4524806a80bacaf8242e042ee1f866c665f025f7381fc2a568b33b83bbe544b605e81a7519ab
+  data.tar.gz: c289c5db96763ff688bc8d6ed77d26b9442e1f248a29b0bd92099ecb659192239f4ec825a9780e240cb08b6a8cf019a08a6c186dfb005a1217d0122079e7843d

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2015 Wei-Ming Wu
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,70 @@
+# PlusCodes
+
+Ruby implementation of Google Open Location Code(Plus+Codes)
+
+[Open Location Code project](https://github.com/google/open-location-code)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'plus_codes'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install plus_codes
+
+## Usage
+
+```ruby
+require 'plus_codes/open_location_code'
+
+olc = PlusCodes::OpenLocationCode.new
+
+# Encodes the latitude and longitude into a Plus+Codes
+code = olc.encode(47.0000625,8.0000625)
+# => "8FVC2222+22"
+
+# Encodes any latitude and longitude into a Plus+Codes with preferred length
+code = olc.encode(47.0000625,8.0000625, 16)
+# => "8FVC2222+22GCCCCC"
+
+# Decodes a Plus+Codes back into coordinates
+code_area = olc.decode(code)
+puts code_area
+# => lat_lo: 47.000062496 long_lo: 8.0000625 lat_hi: 47.000062504 long_hi: 8.000062530517578 code_len: 16
+
+# Checks if a Plus+Codes is valid or not
+olc.valid?(code)
+# => true
+
+# Checks if a Plus+Codes is full or not
+olc.full?(code)
+# => true
+
+# Checks if a Plus+Codes is short or not
+olc.short?(code)
+# => false
+
+# Shorten a Plus+Codes as possible by given reference latitude and longitude
+olc.shorten('9C3W9QCJ+2VX', 51.3708675, -1.217765625)
+# => "CJ+2VX"
+
+# Extends a Plus+Codes by given reference latitude and longitude
+olc.recover_nearest('CJ+2VX', 51.3708675, -1.217765625)
+# => "9C3W9QCJ+2VX"
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/wnameless/plus_codes-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+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'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/plus_codes.rb

@@ -0,0 +1,62 @@
+# 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.
+  SEPARATOR = '+'.freeze
+
+  # The number of characters to place before the separator.
+  SEPARATOR_POSITION = 8
+
+  # The character used to pad codes.
+  PADDING = '0'.freeze
+
+  # The character set used to encode the values.
+  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
+
+end

data/lib/plus_codes/code_area.rb

@@ -0,0 +1,43 @@
+module PlusCodes
+
+  # [CodeArea] contains coordinates of a decoded Open Location Code(Plus+Codes).
+  # 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
+
+    # 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
+    # @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
+    end
+
+    def to_s
+      "lat_lo: #{@latitude_lo} long_lo: #{@longitude_lo} lat_hi: #{@latitude_hi} long_hi: #{@longitude_hi} code_len: #{@code_length}"
+    end
+  end
+
+end

data/lib/plus_codes/open_location_code.rb

@@ -0,0 +1,351 @@
+require 'plus_codes'
+require 'plus_codes/code_area'
+
+module PlusCodes
+
+  # [OpenLocationCode] implements the Google Open Location Code(Plus+Codes) algorithm.
+  # @author We-Ming Wu
+  class OpenLocationCode
+
+    # Validates the given plus+codes.
+    #
+    # @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 % 2 == 1
+
+      # We can have an even number of padding characters before the separator,
+      # but then it must be the final character.
+      if code.include?(PADDING)
+        # Not allowed to start with them!
+        return false if code.index(PADDING) == 0
+
+        # There can only be one group and it must have even length.
+        pad_match = /(#{PADDING}+)/.match(code).to_a
+        return false if pad_match.length != 2
+        match = pad_match[1]
+        return false if match.length % 2 == 1 || match.length > SEPARATOR_POSITION - 2
+
+        # If the code is long enough to end with a separator, make sure it does.
+        return false if code[code.length - 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
+    end
+
+    # Checks if the given plus+codes is in short format.
+    #
+    # @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
+    end
+
+    # Checks if the given plus+codes is in full format.
+    #
+    # @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
+    end
+
+    # Encodes given latitude and longitude with the optionally provided code length.
+    #
+    # @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 % 2 == 1)
+        raise ArgumentError, "Invalid Open Location Code length: #{code_length}"
+      end
+
+      latitude = clip_latitude(latitude)
+      longitude = normalize_longitude(longitude)
+      if latitude == 90
+        latitude = latitude - compute_latitude_precision(code_length).to_f
+        p latitude
+      end
+      code = encode_pairs(latitude, longitude, [code_length, PAIR_CODE_LENGTH].min)
+      # If the requested length indicates we want grid refined codes.
+      code += encode_grid(latitude, longitude, code_length - PAIR_CODE_LENGTH) if code_length > PAIR_CODE_LENGTH
+      code
+    end
+
+    # Decodes the given plus+codes in to 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)
+
+      # 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)
+    end
+
+    # Finds the full plus+codes from given short plus+codes, reference latitude and longitude.
+    #
+    # @param 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
+
+      # 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
+      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
+      end
+      encode(code_area.latitude_center, code_area.longitude_center, code_area.code_length)
+    end
+
+    # Shortens the given full plus+codes by provided reference latitude and longitude.
+    #
+    # @param code [String] a plus+codes
+    # @param latitude [Numeric] a latitude in degrees
+    # @param longitude [Numeric] a longitude in degrees
+    # @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)
+      raise ArgumentError,
+        "ValueError: 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
+      end
+      code
+    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))
+      end
+      code = code + SEPARATOR if code.length == SEPARATOR_POSITION
+      code
+    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]
+      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)
+    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]]
+    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
+      end
+      CodeArea.new(latitude_lo, longitude_lo, latitude_lo + lat_place_value,
+        longitude_lo + lng_place_value, code.length)
+    end
+
+    def clip_latitude(latitude)
+      [90.0, [-90.0, latitude].max].min
+    end
+
+    def compute_latitude_precision(code_length)
+      if code_length <= 10
+        20 ** ((code_length / -2).to_i + 2)
+      else
+        (20 ** -3) / (GRID_ROWS ** (code_length - 10))
+      end
+    end
+
+    def normalize_longitude(longitude)
+      begin
+        longitude += 360
+      end while longitude < -180
+      begin
+        longitude -= 360
+      end while longitude >= 180
+      longitude
+    end
+
+  end
+
+end

data/lib/plus_codes/version.rb

@@ -0,0 +1,3 @@
+module PlusCodes
+  VERSION = "0.1.0"
+end

data/test/plus_codes_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+require 'plus_codes/open_location_code'
+
+class PlusCodesTest < Test::Unit::TestCase
+
+  def setup
+    @test_data_folder_path = File.join(File.dirname(__FILE__), 'test_data')
+    @olc = PlusCodes::OpenLocationCode.new
+  end
+
+  def test_validity
+    read_csv_lines('validityTests.csv').each do |line|
+      cols = line.split(',')
+      code = cols[0]
+      is_valid = cols[1] == 'true'
+      is_short = cols[2] == 'true'
+      is_full = cols[3] == 'true'
+      is_valid_olc = @olc.valid?(code)
+      is_short_olc = @olc.short?(code)
+      is_full_olc = @olc.full?(code)
+      result = is_full == is_full_olc && is_short_olc == is_short && is_valid_olc == is_valid
+      assert_true(result)
+    end
+  end
+
+  def test_encode_decode
+    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)
+      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)
+    end
+  end
+
+  def test_shorten
+    read_csv_lines('shortCodeTests.csv').each do |line|
+      cols = line.split(',')
+      code = cols[0]
+      lat = cols[1].to_f
+      lng = cols[2].to_f
+      short_code = cols[3]
+      short = @olc.shorten(code, lat, lng)
+      assert_equal(short_code, short)
+      expanded = @olc.recover_nearest(short, lat, lng)
+      assert_equal(code, expanded)
+    end
+  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
+  end
+
+  def read_csv_lines(csv_file)
+    f = File.open(File.join(@test_data_folder_path, csv_file), 'r')
+    f.each_line.lazy.select { |line| line !~ /^\s*#/ }.map { |line| line.chop }
+  end
+
+end

data/test/test_data/encodingTests.csv

@@ -0,0 +1,23 @@
+# Test encoding and decoding Open Location Codes.
+#
+# Provides test cases for encoding latitude and longitude to codes and expected
+# values for decoding.
+#
+# Format:
+#   code,lat,lng,latLo,lngLo,latHi,lngHi
+7FG49Q00+,20.375,2.775,20.35,2.75,20.4,2.8
+7FG49QCJ+2V,20.3700625,2.7821875,20.37,2.782125,20.370125,2.78225
+7FG49QCJ+2VX,20.3701125,2.782234375,20.3701,2.78221875,20.370125,2.78225
+7FG49QCJ+2VXGJ,20.3701135,2.78223535156,20.370113,2.782234375,20.370114,2.78223632813
+8FVC2222+22,47.0000625,8.0000625,47.0,8.0,47.000125,8.000125
+4VCPPQGP+Q9,-41.2730625,174.7859375,-41.273125,174.785875,-41.273,174.786
+62G20000+,0.5,-179.5,0.0,-180.0,1,-179
+22220000+,-89.5,-179.5,-90,-180,-89,-179
+7FG40000+,20.5,2.5,20.0,2.0,21.0,3.0
+22222222+22,-89.9999375,-179.9999375,-90.0,-180.0,-89.999875,-179.999875
+6VGX0000+,0.5,179.5,0,179,1,180
+# Special cases over 90 latitude and 180 longitude
+CFX30000+,90,1,89,1,90,2
+CFX30000+,92,1,89,1,90,2
+62H20000+,1,180,1,-180,2,-179
+62H30000+,1,181,1,-179,2,-178

data/test/test_data/shortCodeTests.csv

@@ -0,0 +1,15 @@
+# Test shortening and extending codes.
+#
+# Format:
+# full code,lat,lng,shortcode
+9C3W9QCJ+2VX,51.3701125,-1.217765625,+2VX
+# Adjust so we can't trim by 8 (+/- .000755)
+9C3W9QCJ+2VX,51.3708675,-1.217765625,CJ+2VX
+9C3W9QCJ+2VX,51.3693575,-1.217765625,CJ+2VX
+9C3W9QCJ+2VX,51.3701125,-1.218520625,CJ+2VX
+9C3W9QCJ+2VX,51.3701125,-1.217010625,CJ+2VX
+# Adjust so we can't trim by 6 (+/- .0151)
+9C3W9QCJ+2VX,51.3852125,-1.217765625,9QCJ+2VX
+9C3W9QCJ+2VX,51.3550125,-1.217765625,9QCJ+2VX
+9C3W9QCJ+2VX,51.3701125,-1.232865625,9QCJ+2VX
+9C3W9QCJ+2VX,51.3701125,-1.202665625,9QCJ+2VX

data/test/test_data/validityTests.csv

@@ -0,0 +1,23 @@
+# Test data for validity tests.
+# Format of each line is:
+#   code,isValid,isShort,isFull
+# Valid full codes:
+8FWC2345+G6,true,false,true
+8FWC2345+G6G,true,false,true
+8fwc2345+,true,false,true
+8FWCX400+,true,false,true
+# Valid short codes:
+WC2345+G6g,true,true,false
+2345+G6,true,true,false
+45+G6,true,true,false
++G6,true,true,false
+# Invalid codes
+G+,false,false,false
++,false,false,false
+8FWC2345+G,false,false,false
+8FWC2_45+G6,false,false,false
+8FWC2η45+G6,false,false,false
+8FWC2345+G6+,false,false,false
+8FWC2300+G6,false,false,false
+WC2300+G6g,false,false,false
+WC2345+G,false,false,false

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+require 'simplecov'
+SimpleCov.start
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'plus_codes'

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: plus_codes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wei-Ming Wu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby implementation of Google Open Location Code(Plus+Codes)
+email:
+- wnameless@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/plus_codes.rb
+- lib/plus_codes/code_area.rb
+- lib/plus_codes/open_location_code.rb
+- lib/plus_codes/version.rb
+- test/plus_codes_test.rb
+- test/test_data/encodingTests.csv
+- test/test_data/shortCodeTests.csv
+- test/test_data/validityTests.csv
+- test/test_helper.rb
+homepage: https://github.com/wnameless/plus_codes-ruby
+licenses:
+- Apache License, Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of Google Open Location Code(Plus+Codes)
+test_files:
+- test/plus_codes_test.rb
+- test/test_data/encodingTests.csv
+- test/test_data/shortCodeTests.csv
+- test/test_data/validityTests.csv
+- test/test_helper.rb
+has_rdoc: