fast-polylines 0.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 188b873d21a061c22675b35f10d0364dd81407c2
-  data.tar.gz: d0a78755d81d3eecc329023a5956af078c1930b1
+SHA256:
+  metadata.gz: 0ab14d087b6992d7abec3047ad38aea4e7474f4bfff06b921ea91699bd788172
+  data.tar.gz: 4225fc53ff0801e6b145058461d9cf6d5f65be902787a7496e85c83883b52ba5
 SHA512:
-  metadata.gz: 206c7ddc05a9cd4585f3090ff3a75eec0a888a59c2413ffcfa3dfb6a60152f3295e0298eff098528bee4f1e9289a8f44ab71a5658aa2ca48aa9605ca6ff182cb
-  data.tar.gz: 6ece894847da8d830754b09a096c250232e9f7cc4dd80758ea093a463130a24724b6c114b98f4db190684394720951bf4000a0afa5615b9e3b9300f46092036b
+  metadata.gz: 82f43939d565a422fdf0696539f1c668d851aa88ff36d52a9f3ad2d909ebfe095c1ccd0b7266243943c834f70dc5c954c85715a3c435768df2c6ccce871443b4
+  data.tar.gz: 97ab65e7683ecbb53bf5673532e5ff99399b7f0b97b140221127b302e2d54020c1e3b1b6c174a624c49d276801b0f76089e3378cf5949b7a8fdad64494d89db0

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+The format is based on [Keep a Changelog](http://keepachangelog.com/).
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [unreleased] —
+
+### Added
+
+### Changed
+
+### Fixed
+
+## [2.2.0] — 2020-11-24
+
+### Added
+
+- support for windows (#19 #23) by [@mohits]
+
+### Changed
+
+- Speedup calculation by avoiding calling pow(10,x) (#22) by [@mohits]
+
+### Fixed
+
+- move from travis to github actions
+
+[@mohits]: https://github.com/mohits
+
+## [2.1.0] — 2020-04-30
+
+### Added
+
+- A Require ptah that match the gem name (#18)
+
+## [2.0.1] — 2020-04-02
+
+### Fixed
+
+- Broken behavior when approaching the chunk size limit (#16)
+
+
+[unreleased]: https://github.com/klaxit/fast-polylines/compare/v2.2.0...HEAD
+[2.2.0]: https://github.com/klaxit/fast-polylines/compare/v2.1.0...v2.2.0
+[2.1.0]: https://github.com/klaxit/fast-polylines/compare/v2.0.1...v2.1.0
+[2.0.1]: https://github.com/klaxit/fast-polylines/compare/v2.0.0...v2.0.1

data/README.md

@@ -1,50 +1,146 @@
 # 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 of FastPolylines includes breaking changes, see [Migrate from V1](#migrate-from-V1)
 
-But an **at least 5x faster** implementation.
 
-## Install
+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:
 
 ```
-gem install fast-polylines
+——————————————————————————————— ENCODING ————————————————————————————————
+
+Warming up --------------------------------------
+           Polylines   310.000  i/100ms
+     FastPolylinesV1     2.607k i/100ms
+     FastPolylinesV2    59.833k i/100ms
+Calculating -------------------------------------
+           Polylines      2.957k (± 5.9%) i/s -     14.880k in   5.049867s
+     FastPolylinesV1     25.644k (± 5.8%) i/s -    127.743k in   4.999954s
+     FastPolylinesV2    682.981k (± 7.7%) i/s -      3.410M in   5.025952s
+
+Comparison:
+     FastPolylinesV2:   682980.7 i/s
+     FastPolylinesV1:    25643.7 i/s - 26.63x  slower
+           Polylines:     2957.1 i/s - 230.97x  slower
+
+
+———————————————————————————————  DECODING ————————————————————————————————
+
+Warming up --------------------------------------
+           Polylines   127.000  i/100ms
+     FastPolylinesV1     1.225k i/100ms
+     FastPolylinesV2    40.667k i/100ms
+Calculating -------------------------------------
+           Polylines      1.289k (± 6.1%) i/s -      6.477k in   5.046552s
+     FastPolylinesV1     15.445k (± 4.4%) i/s -     77.175k in   5.006896s
+     FastPolylinesV2    468.413k (± 7.8%) i/s -      2.359M in   5.068936s
+
+Comparison:
+     FastPolylinesV2:   468412.8 i/s
+     FastPolylinesV1:    15445.4 i/s - 30.33x  slower
+           Polylines:     1288.8 i/s - 363.46x  slower
 ```
 
-or in Bundler:
+## Install
+
+```bash
+gem install fast-polylines
 ```
-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`:
+```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 V1
+
+**TL;DR:**
+
+```ruby
+# before
+require "fast-polylines"
+FastPolylines::Encoder.encode([[1.2, 1.2], [2.4, 2.4]], 1e6)
+# after
+require "fast_polylines"
+FastPolylines.encode([[1.2, 1.2], [2.4, 2.4]], 6)
+```
+
+**Detailled:**
+
+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.
+
+The file name to require is now snake_cased, you'll have to require
+`fast_polylines`. The gem name stays the same however.
+
+## 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/extconf.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+if ENV["DEBUG"]
+  warn "DEBUG MODE."
+  $CFLAGS << " " << %w(
+    -Wall
+    -ggdb
+    -DDEBUG
+    -pedantic
+  ) * " "
+end
+create_makefile "fast_polylines/fast_polylines"

data/ext/fast_polylines/fast_polylines.c

@@ -0,0 +1,173 @@
+#include <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
+
+typedef unsigned int uint;
+
+// Speed up the code a bit by not calling pow(10.0, precision) since it is
+// always 10^precision. Convert that into a lookup instead of doing the
+// calculation.
+// The precision parameter is already checked in +_get_precision()+ to ensure
+// that it is within the range.
+static inline double _fast_pow10(uint precision) {
+	const double lookup[MAX_PRECISION + 1] = {
+		1.0, 10.0, 1.0e+2, 1.0e+3, 1.0e+4, 1.0e+5, 1.0e+6, 1.0e+7,
+		1.0e+8, 1.0e+9, 1.0e+10, 1.0e+11, 1.0e+12, 1.0e+13
+	};
+	return lookup[precision];
+}
+
+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 = _fast_pow10(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) {
+	dbg("_polyline_encode_number(\"%s\", %lli)\n", chunks, 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;
+	}
+	chunks[i++] = number + 63;
+	dbg("%u encoded chunks\n", i);
+	dbg("chunks: %s\n", chunks);
+	dbg("/_polyline_encode_number\n");
+	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 = _fast_pow10(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;
+			Check_Type(current_pair, T_ARRAY);
+			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("%s\n", chunks);
+			}
+	}
+	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

@@ -1,5 +1,3 @@
-require "fast-polylines/encoder"
-require "fast-polylines/decoder"
-
-module FastPolylines
-end
+# frozen_string_literal: true
+# Allow both snake_case and kebab-case way to require
+require_relative "fast_polylines"

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.2.0"
+end

data/spec/fast-polylines_spec.rb

@@ -0,0 +1,10 @@
+require "fast-polylines"
+
+describe FastPolylines do
+  let(:points) { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+  let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+  it "should work with kebab-case requirement" do
+    expect(FastPolylines.encode(points)).to eq polyline
+    expect(FastPolylines.decode(polyline)).to eq points
+  end
+end

data/spec/fast_polylines_spec.rb

@@ -0,0 +1,119 @@
+require "fast_polylines"
+
+describe FastPolylines do
+  describe ".decode" do
+    let(:points) { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+    let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+    context "with default precision" do
+      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]] }
+    let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+    it "should raise for invalid input" do
+      expect { described_class.encode(points[0]) }.to raise_error(
+        TypeError,
+        "wrong argument type Float (expected Array)"
+      )
+      expect { described_class.encode([points]) }.to raise_error(
+        ArgumentError,
+        "wrong number of coordinates"
+      )
+      expect { described_class.encode([points[0..1]]) }.to raise_error(
+        TypeError,
+        "no implicit conversion to Float from Array"
+      )
+    end
+    # The method `_polyline_encode_number("", 16)` will check for a chunk
+    # of the size 32, which is the chunk size limit. This was errored due to
+    # a bad sign.
+    # Reported in issue #15, closed in PR #16
+    context "with points close to the chunk size limit" do
+      let(:points) { [[0, 0.00016]] }
+      let(:polyline) { "?_@" }
+      it "should encode points correctly" do
+        expect(described_class.encode(points)).to eq polyline
+      end
+    end
+    context "with default precision" do
+      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,11 +1,9 @@
 require "rubygems"
 require "bundler/setup"
 
-require "fast-polylines"
-
-require "rspec-benchmark"
-require "polylines"
+$LOAD_PATH.unshift File.join(__dir__, "..", "lib")
+$LOAD_PATH.unshift File.join(__dir__, "..", "ext")
 
 RSpec.configure do |config|
-  include RSpec::Benchmark::Matchers
+  # Additional config goes here
 end

metadata

@@ -1,29 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: fast-polylines
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Cyrille Courtière
-autorequire: 
+- Ulysse Buonomo
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-10-22 00:00:00.000000000 Z
+date: 2020-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '2.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: polylines
   requirement: !ruby/object:Gem::Requirement
@@ -39,39 +40,43 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
-  name: rspec-benchmark
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
-description: 
+        version: '3.5'
+description:
 email:
-- cyrille@klaxit.com
+- dev@klaxit.com
 executables: []
-extensions: []
+extensions:
+- ext/fast_polylines/extconf.rb
 extra_rdoc_files: []
 files:
+- ".rspec"
+- CHANGELOG.md
 - README.md
+- ext/fast_polylines/extconf.rb
+- ext/fast_polylines/fast_polylines.c
 - 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
+- lib/fast_polylines.rb
+- lib/fast_polylines/version.rb
+- spec/fast-polylines_spec.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: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,19 +84,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
-signing_key: 
+rubygems_version: 3.1.2
+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/spec_helper.rb
+- spec/fast-polylines_spec.rb
+- spec/fast_polylines_spec.rb
+- ".rspec"

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 = "0.1.1".freeze
-end

data/spec/fast-polylines/decoder_spec.rb

@@ -1,39 +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
-      it "should perform at least 5x faster than the Polylines gem" do
-        expect {
-          described_class.decode(polyline)
-        }.to perform_faster_than {
-          Polylines::Decoder.decode_polyline(polyline)
-        }.at_least(5).times
-      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,38 +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
-      it "should perform at least 5x faster than the Polylines gem" do
-        expect {
-          described_class.encode(points)
-        }.to perform_faster_than {
-          Polylines::Encoder.encode_points(points)
-        }.at_least(5).times
-      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