fast-polylines 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8481e1a1c0eeda19f205c7900fa58f3608e7092e88a1d90ffd4fabc4520706f1
-  data.tar.gz: d85050fd3d1796b76d40e8fbb2ae6d4ba18871359312c2648cf6831feba92bf8
+  metadata.gz: a3a21f83abca7c1b9ef3bb824145ceea3189fbdb9d428a2faff1daa94e2a50fb
+  data.tar.gz: 0e6578cb705d0121daadb0a019bedd2d0d1b2589b2905134f933f4ae0859d3e2
 SHA512:
-  metadata.gz: 5ed680bb3cb3097c7b060d18d27b4a18a5def03ec6b0a79e918f61e763cb4f32477023e9db76bb660ea33a6fa0f5c8352781c11d63e2b2d1cc2d0a79c45bf134
-  data.tar.gz: e929f7f781e273068542d9b60c8344e6f2fa548dcaf0652787beaf3fd46bd6e162c588cb9c1616bd77342b8e69ce5954ad2799344485b212ba907f07f3f65ee9
+  metadata.gz: 16c293fc12361086fc39002b10fd81faaeb68632e4c6e670de1c2ec242b8277a7c453da2e5f1a9176104ccdafab99447807871f8afdb09188d97f07ed6a307d0
+  data.tar.gz: e48e91654bc2746c4c36d3d6ce744914941ec4966f1aa6b56bbe61cacdcce841dc936b997dd477794ad8a0546ebb7c9317afc007dc1b9f74dd630d9de5d2f417

data/README.md

@@ -1,83 +1,139 @@
 # Fast Polylines
 
 [![Gem Version](https://badge.fury.io/rb/fast-polylines.svg)](https://badge.fury.io/rb/fast-polylines)
-[![CircleCI](https://circleci.com/gh/klaxit/fast-polylines.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/klaxit/fast-polylines)
+[![Build Status](https://travis-ci.org/klaxit/fast-polylines.svg?branch=master)](https://travis-ci.org/klaxit/fast-polylines)
 
-Implementation of the Google polyline algorithm :
-http://code.google.com/apis/maps/documentation/utilities/polylinealgorithm.html
+Implementation of the [Google polyline algorithm][algorithm].
 
-Greatly inspired by Joshua Clayton gem : https://github.com/joshuaclayton/polylines
+**BREAKING CHANGES:** The version 2.0.0 of FastPolylines includes breaking changes, see [Migrate from 1.0.0](#migrate-from-1.0.0)
 
-But an about **8x faster encoding** and **10x faster decoding** implementation (`make benchmark` on a MacBook pro 13 - 2,3 GHz Intel Core i5).
+
+About **300x faster encoding and decoding**  than [Joshua Clayton's gem][polylines].
+
+`make benchmark` on a MacBook pro 13 - 2,3 GHz Intel Core i5:
 
 ```
-** ENCODING **
+——————————————————————————————— ENCODING ————————————————————————————————
 
 Warming up --------------------------------------
-    Polylines encode   282.000  i/100ms
-FastPolylines encode     2.339k i/100ms
+           Polylines   277.000  i/100ms
+     FastPolylinesV1     2.050k i/100ms
+     FastPolylinesV2    73.822k i/100ms
 Calculating -------------------------------------
-    Polylines encode      3.024k (± 7.4%) i/s -     15.228k in   5.068950s
-FastPolylines encode     24.562k (± 6.7%) i/s -    123.967k in   5.074793s
+           Polylines      3.254k (± 1.8%) i/s -     16.343k in   5.023767s
+     FastPolylinesV1     25.715k (± 3.7%) i/s -    129.150k in   5.029675s
+     FastPolylinesV2    933.751k (± 4.3%) i/s -      4.725M in   5.072446s
 
 Comparison:
-FastPolylines encode:    24561.8 i/s
-    Polylines encode:     3023.6 i/s - 8.12x  slower
+     FastPolylinesV2:   933750.7 i/s
+     FastPolylinesV1:    25715.1 i/s - 36.31x  slower
+           Polylines:     3254.3 i/s - 286.93x  slower
 
 
-** DECODING **
+———————————————————————————————  DECODING ————————————————————————————————
 
 Warming up --------------------------------------
-    Polylines decode   125.000  i/100ms
-FastPolylines decode     1.341k i/100ms
+           Polylines   140.000  i/100ms
+     FastPolylinesV1     1.602k i/100ms
+     FastPolylinesV2    36.432k i/100ms
 Calculating -------------------------------------
-    Polylines decode      1.284k (± 9.7%) i/s -      6.375k in   5.023536s
-FastPolylines decode     13.278k (±20.5%) i/s -     61.686k in   5.003858s
+           Polylines      1.401k (± 2.2%) i/s -      7.000k in   5.000321s
+     FastPolylinesV1     16.465k (± 3.7%) i/s -     83.304k in   5.067786s
+     FastPolylinesV2    396.100k (± 5.2%) i/s -      2.004M in   5.074500s
 
 Comparison:
-FastPolylines decode:    13278.0 i/s
-    Polylines decode:     1284.3 i/s - 10.34x  slower
+     FastPolylinesV2:   396100.0 i/s
+     FastPolylinesV1:    16464.6 i/s - 24.06x  slower
+           Polylines:     1400.6 i/s - 282.81x  slower
 ```
 
 ## Install
 
-```
+```bash
 gem install fast-polylines
 ```
 
-or in Bundler:
-```
-gem "fast-polylines"
+or in your `Gemfile`:
+```ruby
+gem "fast-polylines", "~> 2.0.0"
 ```
 
 ## Usage
 
-```
-require 'fast-polylines'
+```ruby
+require "fast-polylines"
 
-FastPolylines::Encoder.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]])
+FastPolylines.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]])
 # "_p~iF~ps|U_ulLnnqC_mqNvxq`@"
 
-FastPolylines::Decoder.decode("_p~iF~ps|U_ulLnnqC_mqNvxq`@")
+FastPolylines.decode("_p~iF~ps|U_ulLnnqC_mqNvxq`@")
 # [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]]
 ```
 
 ## Advanced usage
 
-*  With a different precision (default precision of `1e5`) :
+**Use a different precision**
 
-```
-FastPolylines::Encoder.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]], 1e6)
+Default precision is `5` decimals, to use a precision of `6` decimals:
+```ruby
+FastPolylines.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]], 6)
 # "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI"
 
-FastPolylines::Decoder.decode("_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI", 1e6)
+FastPolylines.decode("_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI", 6)
 # [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]]
 ```
+The precision max is `13`.
+
+## Migrate from 1.0.0
+
+**TL;DR:**
+
+```ruby
+# before
+FastPolylines::Encoder.encode([[1.2, 1.2], [2.4, 2.4]], 1e6)
+# after
+FastPolylines.encode([[1.2, 1.2], [2.4, 2.4]], 6)
+```
+
+The new version of `FastPolylines` doesn't support precision more than `1e13`,
+you should not consider using it anyway since [it is way too precise][xkcd].
+
+`Encoder` and `Decoder` modules are deprecated in favor of the single parent
+module. Even though you can still use those, a deprecation warning will be
+printed.
+
+The precision is now an integer representing the number of decimals. It is
+slightly smaller, and mostly this will avoid having any float value as
+precision.
 
 ## Run the Benchmark
 
 You can run the benchmark with `make benchmark`.
 
+## Contributing
+
+```bash
+git clone git@github.com:klaxit/fast-polylines
+cd fast-polylines
+bundle install
+# Implement a feature, resolve a bug...
+make rubocop
+make test
+git commit "My new feature!"
+# Make a PR
+```
+
+There is a `make console` command as well to open a ruby console with the
+current version loaded.
+
+[And here's a good starting point for Ruby C extensions knowledge.][ruby-c]
+
 ## License
 
 Please see LICENSE
+
+
+[algorithm]: https://code.google.com/apis/maps/documentation/utilities/polylinealgorithm.html
+[polylines]: https://github.com/joshuaclayton/polylines
+[xkcd]:      https://xkcd.com/2170/
+[ruby-c]:    https://github.com/ruby/ruby/blob/master/doc/extension.rdoc

data/ext/fast_polylines/.gitignore

@@ -0,0 +1,3 @@
+*.o
+*.bundle
+Makefile

data/ext/fast_polylines/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "mkmf"
+create_makefile "fast_polylines/fast_polylines"

data/ext/fast_polylines/fast_polylines.c

@@ -0,0 +1,151 @@
+#include <ruby/ruby.h>
+
+// An encoded number can have at most _precision_ characters. However,
+// it seems like we have a fuzzy behavior on low precisions. Hence a guard
+// for those lower precisions.
+#define MAX_ENCODED_CHUNKS(precision) (precision < 5 ? 5 : precision)
+
+#define DEFAULT_PRECISION 5
+
+// Already smaller than a sand grain. https://xkcd.com/2170/
+// In fact, at 15 precision, we can be sure there will be precision loss
+// in the C/Ruby value conversion. And 14 precision may be an edge case
+// since we work with signed values.
+#define MAX_PRECISION 13
+
+// Uncomment this line to show debug logs.
+// #define DEBUG 1
+
+#ifdef DEBUG
+#define dbg(...) printf(__VA_ARGS__)
+#define rdbg(value) rb_funcall(Qnil, rb_intern("p"), 1, value)
+#else
+#define dbg(...)
+#define rdbg(...)
+#endif
+
+static inline uint _get_precision(VALUE value) {
+	int precision = NIL_P(value) ? DEFAULT_PRECISION : NUM2INT(value);
+	if (precision > MAX_PRECISION) rb_raise(rb_eArgError, "precision too high (https://xkcd.com/2170/)");
+	if (precision < 0) rb_raise(rb_eArgError, "negative precision doesn't make sense");
+	return (uint)precision;
+}
+
+static inline VALUE
+rb_FastPolylines__decode(int argc, VALUE *argv, VALUE self) {
+	rb_check_arity(argc, 1, 2);
+	Check_Type(argv[0], T_STRING);
+	char* polyline = StringValueCStr(argv[0]);
+	uint precision = _get_precision(argc > 1 ? argv[1] : Qnil);
+	double precision_value = pow(10.0, precision);
+	VALUE ary = rb_ary_new();
+	// Helps keeping track of whether we are computing lat (0) or lng (1).
+	uint8_t index = 0;
+	size_t shift = 0;
+	int64_t delta = 0;
+	VALUE sub_ary[2];
+	double latlng[2] = {0.0, 0.0};
+	// Loops until end of string nul character is encountered.
+	while (*polyline) {
+		int64_t chunk = *polyline++;
+
+		if (chunk < 63 || chunk > 126) {
+			rb_raise(rb_eArgError, "invalid character '%c'", (char)chunk);
+		}
+
+		chunk -= 63;
+		delta = delta | ((chunk & ~0x20) << shift);
+		shift += 5;
+
+		if (!(chunk & 0x20)) {
+			delta = (delta & 1) ? ~(delta >> 1) : (delta >> 1);
+			latlng[index] += delta;
+			sub_ary[index] = rb_float_new((double) latlng[index] / precision_value);
+			// When both coordinates are parsed, we can push those to the result ary.
+			if (index) rb_ary_push(ary, rb_ary_new_from_values(2, sub_ary));
+			// Reinitilize since we are done for current coordinate.
+			index = 1 - index; delta = 0; shift = 0;
+		}
+	}
+	return ary;
+}
+
+static inline uint8_t
+_polyline_encode_number(char *chunks, int64_t number) {
+	number = number < 0 ? ~(number << 1) : (number << 1);
+	uint8_t i = 0;
+	while (number > 0x20) {
+		uint8_t chunk = number & 0x1f;
+		chunks[i++] = (0x20 | chunk) + 63;
+		number = number >> 5;
+	}
+	dbg("%u encoded chunks\n", i);
+	chunks[i++] = number + 63;
+	return i;
+}
+
+static inline VALUE
+rb_FastPolylines__encode(int argc, VALUE *argv, VALUE self) {
+	rb_check_arity(argc, 1, 2);
+	Check_Type(argv[0], T_ARRAY);
+	size_t len = RARRAY_LEN(argv[0]);
+	uint64_t i;
+	VALUE current_pair;
+	int64_t prev_pair[2] = {0, 0};
+	uint precision = _get_precision(argc > 1 ? argv[1] : Qnil);
+	dbg("rb_FastPolylines__encode(..., %u)\n", precision);
+	rdbg(argv[0]);
+	double precision_value = pow(10.0, precision);
+	// This is the maximum possible size the polyline may have. This
+	// being **without** null character. To copy it later as a Ruby
+	// string we'll have to use `rb_str_new` with the length.
+	dbg("allocated size: %u * 2 * %lu = %lu\n",
+	    MAX_ENCODED_CHUNKS(precision),
+	    len,
+	    MAX_ENCODED_CHUNKS(precision) * 2 * len);
+	char *chunks = malloc(MAX_ENCODED_CHUNKS(precision) * 2 * len * sizeof(char));
+	size_t chunks_index = 0;
+	for (i = 0; i < len; i++) {
+			current_pair = RARRAY_AREF(argv[0], i);
+			uint8_t j;
+			if (RARRAY_LEN(current_pair) != 2) {
+				free(chunks);
+				rb_raise(rb_eArgError, "wrong number of coordinates");
+			}
+			for (j = 0; j < 2; j++) {
+				VALUE current_value =	RARRAY_AREF(current_pair, j);
+				switch (TYPE(current_value)) {
+					case T_BIGNUM:
+					case T_FLOAT:
+					case T_FIXNUM:
+					case T_RATIONAL:
+						break;
+					default:
+						free(chunks);
+						rb_raise(rb_eTypeError, "no implicit conversion to Float from %s", rb_obj_classname(current_value));
+				};
+
+				double parsed_value = NUM2DBL(current_value);
+				if (-180.0 > parsed_value || parsed_value > 180.0) {
+					free(chunks);
+					rb_raise(rb_eArgError, "coordinates must be between -180.0 and 180.0");
+				}
+				int64_t rounded_value = round(parsed_value * precision_value);
+				int64_t delta = rounded_value - prev_pair[j];
+				prev_pair[j] = rounded_value;
+				// We pass a pointer to the current chunk that need to be filled. Doing so
+				// avoid having to copy the string every single iteration.
+				chunks_index += _polyline_encode_number(chunks + chunks_index * sizeof(char), delta);
+			}
+	}
+	dbg("final chunks_index: %zu\n", chunks_index);
+	VALUE polyline = rb_str_new(chunks, chunks_index);
+	free(chunks);
+	return polyline;
+}
+
+void Init_fast_polylines() {
+	VALUE mFastPolylines = rb_define_module("FastPolylines");
+	rb_define_module_function(mFastPolylines, "decode", rb_FastPolylines__decode, -1);
+	rb_define_module_function(mFastPolylines, "encode", rb_FastPolylines__encode, -1);
+}

data/lib/fast_polylines.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "fast_polylines/fast_polylines"
+
+module FastPolylines::Encoder
+  module_function def encode(points, precision = 1e5)
+    warn "Deprecated use of `FastPolylines::Encoder.encode`, " \
+          "use `FastPolylines.encode`."
+    FastPolylines.encode(points, Math.log10(precision))
+  end
+end
+
+module FastPolylines::Decoder
+  module_function def decode(polyline, precision = 1e5)
+    warn "Deprecated use of `FastPolylines::Decoder.decode`, " \
+          "use `FastPolylines.decode`."
+    FastPolylines.decode(polyline, Math.log10(precision))
+  end
+end

data/lib/fast_polylines/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FastPolylines
+  VERSION = "2.0.0"
+end

data/spec/fast_polylines_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+describe FastPolylines do
+  describe ".decode" do
+    let(:points) { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+    context "with default precision" do
+      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode(polyline)).to eq points
+      end
+    end
+    context "with a 6 decimals precision" do
+      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode(polyline, 6)).to eq points
+      end
+    end
+    context "with a 15 decimals precision" do
+      it "should raise" do
+        expect { described_class.decode("_kiF_kiF", 15) }.to raise_error(ArgumentError, /too high/)
+      end
+    end
+    context "with a negative precision" do
+      it "should raise" do
+        expect { described_class.decode("_kiF_kiF", -rand(1..10)) }.to raise_error(ArgumentError, /negative/)
+      end
+    end
+    context "with wrong characters" do
+      it "should raise" do
+        chr = "~".next
+        expect { described_class.decode(chr) }.to raise_error(ArgumentError, /'#{chr}'/)
+      end
+    end
+    context "with points that were close together" do
+      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode("krk{FdxdlO?e@")).to eq points
+      end
+    end
+    context "with points that cause float overflow" do
+      let(:polyline) { "ahdiHsmeMHPDN|A`FVt@" }
+      let(:points) { [[48.85137, 2.32682], [48.85132, 2.32673], [48.85129, 2.32665], [48.85082, 2.32552], [48.8507, 2.32525]] }
+      it "should respect precision" do
+        expect(described_class.decode(polyline)).to eq points
+      end
+    end
+  end
+
+  describe ".encode" do
+    let(:points)   { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+    context "with default precision" do
+      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+      it "should encode points correctly" do
+        expect(described_class.encode(points)).to eq polyline
+      end
+    end
+    context "with a 6 decimals precision" do
+      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
+      it "should encode points correctly" do
+        expect(described_class.encode(points, 6)).to eq polyline
+      end
+    end
+    context "with points that were close together" do
+      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
+      it "should encode points correctly" do
+        expect(described_class.encode(points)).to eq "krk{FdxdlO?e@"
+      end
+    end
+    context "with possible rounding ambiguity" do
+      let(:points) { [[39.13594499,-94.4243478], [39.13558757,-94.4243471]] }
+      it "should encode points as Google API do" do
+        expect(described_class.encode(points)).to eq "svzmFdgi_QdA?"
+      end
+    end
+    context "with points out of bounds" do
+      it "should raise" do
+        expect { described_class.encode([[180.1, 0.0]]) }.to raise_error ArgumentError
+        expect { described_class.encode([[0, 180.1]]) }.to raise_error ArgumentError
+        expect { described_class.encode([[-180.1, 0.0]]) }.to raise_error ArgumentError
+        expect { described_class.encode([[0, -180.1]]) }.to raise_error ArgumentError
+      end
+    end
+    context "with a 15 decimals precision" do
+      it "should raise" do
+        expect { described_class.encode([[1.2, 1.2]], 15) }.to raise_error(ArgumentError, /too high/)
+      end
+    end
+    context "with a negative precision" do
+      it "should raise" do
+        expect { described_class.encode([[1.2, 1.2]], -rand(1..10)) }.to raise_error(ArgumentError, /negative/)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "bundler/setup"
 
-require "fast-polylines"
+require "fast_polylines"
 
 RSpec.configure do |config|
   # Additional config goes here

metadata

@@ -1,29 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: fast-polylines
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cyrille Courtière
+- Ulysse Buonomo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-04 00:00:00.000000000 Z
+date: 2020-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: polylines
   requirement: !ruby/object:Gem::Requirement
@@ -54,20 +55,21 @@ dependencies:
         version: '3.5'
 description: 
 email:
-- cyrille@klaxit.com
+- dev@klaxit.com
 executables: []
-extensions: []
+extensions:
+- ext/fast_polylines/extconf.rb
 extra_rdoc_files: []
 files:
 - README.md
-- lib/fast-polylines.rb
-- lib/fast-polylines/decoder.rb
-- lib/fast-polylines/encoder.rb
-- lib/fast-polylines/version.rb
-- spec/fast-polylines/decoder_spec.rb
-- spec/fast-polylines/encoder_spec.rb
+- ext/fast_polylines/.gitignore
+- ext/fast_polylines/extconf.rb
+- ext/fast_polylines/fast_polylines.c
+- lib/fast_polylines.rb
+- lib/fast_polylines/version.rb
+- spec/fast_polylines_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/klaxit/fast-polylines
+homepage: https://github.com/klaxit/fast-polylines
 licenses:
 - MIT
 metadata: {}
@@ -91,6 +93,5 @@ signing_key:
 specification_version: 4
 summary: Fast & easy Google polylines
 test_files:
-- spec/fast-polylines/decoder_spec.rb
-- spec/fast-polylines/encoder_spec.rb
+- spec/fast_polylines_spec.rb
 - spec/spec_helper.rb

data/lib/fast-polylines.rb

@@ -1,5 +0,0 @@
-require "fast-polylines/encoder"
-require "fast-polylines/decoder"
-
-module FastPolylines
-end

data/lib/fast-polylines/decoder.rb

@@ -1,41 +0,0 @@
-module FastPolylines
-  ##
-  # Provide an interface to decode a Google polyline
-  # to an array of lat / lng points
-  class Decoder
-    ##
-    # Decode a polyline to a list of points
-    #
-    # @param [String] polyline to be decoded
-    # @param [Float] precision of the polyline (default 1e5)
-    # @return [Array<Array>] A list of lat / lng pairs
-    def self.decode(polyline, precision = 1e5)
-      coords = []
-      acc = ""
-      polyline.each_byte do |b|
-        acc << b
-        next unless b < 0x5f
-        coords << acc
-        acc = ""
-      end
-      lat = lng = 0
-      coords.each_slice(2).map do |coords_pair|
-        lat += decode_number(coords_pair[0])
-        lng += decode_number(coords_pair[1])
-        [lat / precision, lng / precision]
-      end
-    end
-
-    def self.decode_number(string)
-      result = 1
-      shift = 0
-      string.each_byte do |b|
-        b = b - 63 - 1
-        result += b << shift
-        shift += 5
-      end
-      (result & 1).nonzero? ? (~result >> 1) : (result >> 1)
-    end
-    private_class_method :decode_number
-  end
-end

data/lib/fast-polylines/encoder.rb

@@ -1,47 +0,0 @@
-module FastPolylines
-  ##
-  # Provides an interface to encode an array of lat / lng points
-  # to a Google polyline
-  #
-  class Encoder
-    ##
-    # Encode a list of points into a polyline string
-    #
-    # @param [Array<Array>] points as lat/lng pairs
-    # @param [Float] precision of the encoding (default 1e5)
-    # @return [String] the encoded polyline
-    def self.encode(points, precision = 1e5)
-      result = ""
-      last_lat = last_lng = 0
-      points.each do |point|
-        lat = (point[0] * precision).round
-        lng = (point[1] * precision).round
-        d_lat = lat - last_lat
-        d_lng = lng - last_lng
-        chunks_lat = encode_number(d_lat)
-        chunks_lng = encode_number(d_lng)
-        result << chunks_lat << chunks_lng
-        last_lat = lat
-        last_lng = lng
-      end
-      result
-    end
-
-    def self.encode_number(num)
-      sgn_num = num << 1
-      sgn_num = ~sgn_num if num < 0
-      encode_unsigned_number(sgn_num)
-    end
-
-    def self.encode_unsigned_number(num)
-      encoded = ""
-      while num >= 0x20
-        encoded << (0x20 | (num & 0x1f)) + 63
-        num = num >> 5
-      end
-      encoded << num + 63
-    end
-    private_class_method :encode_number
-    private_class_method :encode_unsigned_number
-  end
-end

data/lib/fast-polylines/version.rb

@@ -1,3 +0,0 @@
-module FastPolylines
-  VERSION = "1.0.0".freeze
-end

data/spec/fast-polylines/decoder_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe FastPolylines::Decoder do
-  describe ".decode" do
-    let(:points) { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
-    context "with default precision" do
-      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
-      it "should decode a polyline correctly" do
-        expect(described_class.decode(polyline)).to eq points
-      end
-    end
-    context "with 1e6 precision" do
-      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
-      it "should decode a polyline correctly" do
-        expect(described_class.decode(polyline, 1e6)).to eq points
-      end
-    end
-    context "with points that were close together" do
-      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
-      it "should decode a polyline correctly" do
-        expect(described_class.decode("krk{FdxdlO?e@")).to eq points
-      end
-    end
-    context "with points that cause float overflow" do
-      let(:polyline) { "ahdiHsmeMHPDN|A`FVt@" }
-      let(:points) { [[48.85137, 2.32682], [48.85132, 2.32673], [48.85129, 2.32665], [48.85082, 2.32552], [48.8507, 2.32525]] }
-      it "should respect precision" do
-        expect(described_class.decode(polyline)).to eq points
-      end
-    end
-  end
-end

data/spec/fast-polylines/encoder_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe FastPolylines::Encoder do
-  describe ".encode" do
-    let(:points)   { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
-    context "with default precision" do
-      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
-      it "should encode points correctly" do
-        expect(described_class.encode(points)).to eq polyline
-      end
-    end
-    context "with 1e6 precision" do
-      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
-      it "should encode points correctly" do
-        expect(described_class.encode(points, 1e6)).to eq polyline
-      end
-    end
-    context "with points that were close together" do
-      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
-      it "should encode points correctly" do
-        expect(described_class.encode(points)).to eq "krk{FdxdlO?e@"
-      end
-    end
-    context "with possible rounding ambiguity" do
-      let(:points) { [[39.13594499,-94.4243478], [39.13558757,-94.4243471]] }
-      it "should encode points as Google API do" do
-        expect(described_class.encode(points)).to eq "svzmFdgi_QdA?"
-      end
-    end
-  end
-end