loc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 372cb2c5d886cc5369727d21a6e7a731fab38957
+  data.tar.gz: 29e686c1057bb8b7a10a0ac25848ffce3827404c
+SHA512:
+  metadata.gz: cf63d7d19c2cfa2964a7c0fd319af6648febb9343a2e395130f1bb0003da7d2e6371828ddef14bf26af4de152841c41f325d8490752ca6eebd6a1d9e7038aa5c
+  data.tar.gz: 27819b8ac2f6bd74541332cfabf551083fe9a6d62a69b9caca7d0737757b30cf009326b2c5abea28188efae5072a31adce3bea451a9da9c43f09d4636e773b11

data/README.md

@@ -0,0 +1,74 @@
+# Loc
+
+[![Gem Version](https://badge.fury.io/rb/loc.svg)](https://badge.fury.io/rb/loc)
+[![CircleCI](https://circleci.com/gh/wayzup/loc.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/wayzup/loc)
+
+Location handling & geographical computations. No external API or DB.
+
+## Install
+
+```
+gem install loc
+```
+
+or in Bundler:
+```
+gem "loc"
+```
+
+## Usage
+
+### Location
+
+```
+require "loc"
+
+loc1 = Loc::Location[49.1, 2]
+
+loc1.lat_degrees_per_km
+# 0.008993210126354604
+
+loc1.lng_degrees_per_km
+# 0.013735635666645289
+
+loc2 = Loc::Location[50, 3]
+
+loc1.distance_to(loc2)
+# 123364.76538823603
+
+loc1.bearing_to(loc2)
+# 48.01278750418339
+```
+
+### LocationCollection
+
+```
+require "loc"
+
+collection = Loc::LocationCollection[[1,2],[3,4]]
+
+collection.distance
+# 314402.95102362486
+
+collection[0]
+# <Loc::Location {:lat=>1, :lng=>2}>
+
+collection.each { |l| puts l.to_a }
+# <Loc::Location {:lat=>1, :lng=>2}>
+# <Loc::Location {:lat=>3, :lng=>4}>
+
+collection.map(&:to_a)
+# [[1, 2], [3, 4]]
+```
+
+## Versioning
+
+We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/wayzup/loc/tags).
+
+## Authors
+
+See the list of [contributors](https://github.com/wayzup/loc/contributors) who participated in this project.
+
+## License
+
+Please see LICENSE

data/lib/loc.rb

@@ -0,0 +1,5 @@
+module Loc
+end
+
+require "loc/location"
+require "loc/location_collection"

data/lib/loc/location.rb

@@ -0,0 +1,97 @@
+module Loc
+  class Location
+    attr_reader :lat, :lng
+
+    def initialize(lat, lng)
+      @lat = lat
+      @lng = lng
+    end
+
+    class << self
+      def from_array(a)
+        new(a[0], a[1])
+      end
+
+      def [](*args)
+        from_array(args)
+      end
+
+      alias from_a from_array
+    end
+
+    # Calculate the distance in meters betwen the object
+    # and another location using the 'Haversine' formula.
+    # Params :
+    # +other+:: Location
+    def distance_to(other)
+      dlat = to_radians(other.lat - lat)
+      dlon = to_radians(other.lng - lng)
+      a = Math.sin(dlat / 2) * Math.sin(dlat / 2) +
+          Math.cos(to_radians(lat)) * Math.cos(to_radians(other.lat)) *
+          Math.sin(dlon / 2) * Math.sin(dlon / 2)
+      c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+      6371 * c * 1000
+    end
+
+    # Give the bearing from the object to the other.
+    # Params :
+    # +other+:: Location
+    def bearing_to(other)
+      dlat = to_radians(other.lat - lat)
+      dlng = to_radians(other.lng - lng)
+      bearing = Math.atan2(dlat, dlng)
+      (90 - to_degrees(bearing) + 360) % 360
+    end
+
+    # Give the number of latitude degrees
+    # for a kilometer distance at location
+    def lat_degrees_per_km
+      1 / 111.195
+    end
+
+    # Calculate the number of longitude degrees
+    # for kilometer distance at location
+    def lng_degrees_per_km
+      1 / (distance_to(Location[lat, lng + 1]) / 1000)
+    end
+
+    def ==(other)
+      return true if other.equal?(self)
+      return false unless other.instance_of?(self.class)
+      lat == other.lat && lng == other.lng
+    end
+
+    def [](*args)
+      to_array[*args]
+    end
+
+    def to_array
+      [lat, lng]
+    end
+
+    def to_hash
+      { lat: lat, lng: lng }
+    end
+
+    def to_s
+      "#{lat},#{lng}"
+    end
+
+    def inspect
+      "<#{self.class} #{{ lat: lat, lng: lng }}>"
+    end
+
+    alias to_a to_array
+    alias to_h to_hash
+
+    private
+
+    def to_radians(deg)
+      deg * Math::PI / 180
+    end
+
+    def to_degrees(rad)
+      rad * 180 / Math::PI
+    end
+  end
+end

data/lib/loc/location_collection.rb

@@ -0,0 +1,89 @@
+module Loc
+  class LocationCollection
+    attr_reader :locations
+
+    def initialize(locations = [])
+      @locations = locations.map { |o| to_location(o) }
+    end
+
+    class << self
+      def from_array(a)
+        new(a)
+      end
+
+      def [](*args)
+        new(args)
+      end
+
+      alias from_a from_array
+    end
+
+    # Give the distance in meters between ordered
+    # location points using the 'Haversine' formula
+    def distance
+      return nil unless @locations.size > 1
+      locations.each_cons(2).reduce(0) do |acc, (loc1, loc2)|
+        acc + loc1.distance_to(loc2)
+      end
+    end
+
+    def size
+      locations.size
+    end
+
+    def [](*args)
+      locations[*args]
+    end
+
+    def each(&block)
+      locations.each(&block)
+    end
+
+    def map
+      locations.map { |l| yield l }
+    end
+
+    def shift
+      locations.shift
+    end
+
+    def pop
+      locations.pop
+    end
+
+    def ==(other)
+      to_a == other.to_a
+    end
+
+    def eql?(other)
+      to_a.eql?(other.to_a)
+    end
+
+    def hash
+      to_a.hash
+    end
+
+    def to_array
+      locations.map(&:to_a)
+    end
+
+    def inspect
+      "<#{self.class} #{{ locations: @locations }}>"
+    end
+
+    alias to_a to_array
+
+    private
+
+    def to_location(object)
+      case object
+      when Location
+        object
+      when Array
+        Location.from_array(object)
+      else
+        raise "Unsupported type #{object.class.name} for locations"
+      end
+    end
+  end
+end

data/lib/loc/version.rb

@@ -0,0 +1,3 @@
+module Loc
+  VERSION = "0.1.0".freeze
+end

data/spec/loc/location_collection_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Loc::LocationCollection do
+
+  it "can be created from an Array" do
+    collection = described_class.from_array([[1, 2], [3, 4]])
+    expect(collection.locations[0]).to eq Loc::Location[1, 2]
+    expect(collection.locations[1]).to eq Loc::Location[3, 4]
+  end
+
+  it "can be created from array with [] syntax" do
+    collection = described_class[[1, 2], [3, 4]]
+    expect(collection.locations[0]).to eq Loc::Location[1, 2]
+    expect(collection.locations[1]).to eq Loc::Location[3, 4]
+  end
+
+  it "should understand [] syntax" do
+    collection = described_class.new([[1, 2], [3, 4]])
+    expect(collection[0]).to eq Loc::Location[1, 2]
+    expect(collection[1]).to eq Loc::Location[3, 4]
+  end
+
+  it "should give geodesic distance between ordered locations" do
+    locs = described_class.new([[1, 2], [2, 3], [3, 4]])
+    expect(locs.distance).to eq 314402.9838527136
+  end
+
+  it "should understand equality" do
+    collection_1 = described_class.new([[1, 2], [3, 4]])
+    collection_2 = described_class.new([[1, 2], [3, 4]])
+    collection_3 = described_class.new([[5, 6], [7, 8]])
+    expect(collection_1).to eql collection_2
+    expect(collection_1).to eq collection_2
+    expect(collection_1).to_not eql collection_3
+    expect(collection_1).to_not eq collection_3
+  end
+
+  describe "#size" do
+    it "should give location collection size" do
+      collection = described_class.new(
+        [Loc::Location[1, 2], Loc::Location[3, 4]]
+      )
+      expect(collection.size).to eq 2
+    end
+  end
+
+  describe "#each" do
+    let(:array) { [Loc::Location[1, 2], Loc::Location[3, 4]] }
+    let(:collection) { described_class.new(array) }
+    it "should return enum" do
+      expect(collection.each).to contain_exactly *array
+    end
+    it "should execute block for all locations" do
+      each_location = []
+      collection.each { |location| each_location << location }
+      expect(each_location).to contain_exactly *array
+    end
+  end
+
+  describe "#map" do
+    it "should map each location" do
+      collection = described_class.new([[1,2],[3,4]])
+      expect(
+        collection.map{|l| l.class.name }
+      ).to eq(["Loc::Location", "Loc::Location"])
+    end
+  end
+
+  describe "#shift" do
+    let(:array) { [Loc::Location[1, 2], Loc::Location[3, 4]] }
+    let(:collection) { described_class.new(array) }
+    it "should give first element" do
+      expect(collection.shift).to eq Loc::Location[1, 2]
+    end
+    it "should remove first element" do
+      collection.shift
+      expect(collection.locations).to eq [Loc::Location[3, 4]]
+    end
+  end
+
+  describe "#pop" do
+    let(:array) { [Loc::Location[1, 2], Loc::Location[3, 4]] }
+    let(:collection) { described_class.new(array) }
+    it "should give last element" do
+      expect(collection.pop).to eq Loc::Location[3, 4]
+    end
+    it "should remove last element" do
+      collection.pop
+      expect(collection.locations).to eq [Loc::Location[1, 2]]
+    end
+  end
+
+  describe "#hash" do
+    it "should give hash based on collection" do
+      collection_1 = described_class.new([[1, 2], [3, 4]])
+      collection_2 = described_class.new([[1, 2], [3, 4]])
+      collection_3 = described_class.new([[5, 6], [7, 8]])
+      expect(collection_1.hash).to eq collection_2.hash
+      expect(collection_1.hash).to_not eq collection_3.hash
+    end
+  end
+
+  describe "#to_array" do
+    it "should give an array of locations as array" do
+      array = [[1,2],[3,4]]
+      collection = described_class.new(array)
+      expect(collection.to_array).to eq array
+    end
+  end
+end

data/spec/loc/location_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Loc::Location do
+  it "can be created from an Array" do
+    location = described_class.from_array([1, 2])
+    expect(location.lat).to eq 1
+    expect(location.lng).to eq 2
+  end
+
+  it "can be created from array with [] syntax" do
+    location = described_class[1, 2]
+    expect(location.lat).to eq 1
+    expect(location.lng).to eq 2
+  end
+
+  it "can be accessed with [] syntax" do
+    location = described_class[1, 2]
+    expect(location[0]).to eq 1
+    expect(location[1]).to eq 2
+  end
+
+  it "should give the distance in meters using \"Haversine\" formula" do
+    loc1 = described_class.new(50, 2)
+    loc2 = described_class.new(49, 3)
+    expect(loc1.distance_to(loc2)).to eq 132584.3578090791
+  end
+
+  it "should give bearing from object to another" do
+    loc1 = described_class.new(50, 2)
+    loc2 = described_class.new(51, 2)
+    expect(loc1.bearing_to(loc2)).to eq 0
+    loc2 = described_class.new(51, 3)
+    expect(loc1.bearing_to(loc2)).to eq 45.0
+    loc2 = described_class.new(50, 3)
+    expect(loc1.bearing_to(loc2)).to eq 90.0
+    loc2 = described_class.new(49, 2)
+    expect(loc1.bearing_to(loc2)).to eq 180.0
+    loc2 = described_class.new(50, 1)
+    expect(loc1.bearing_to(loc2)).to eq 270.0
+  end
+
+  it "should give latitude degrees per kilometer" do
+    loc = described_class.new(50, 2)
+    expect(loc.lat_degrees_per_km.round(7)).to eq 0.0089932
+  end
+
+  it "should give longitude degrees per kilometer" do
+    loc = described_class.new(50, 2)
+    expect(loc.lng_degrees_per_km.round(7)).to eq 0.0139911
+  end
+
+  it "can understand equality" do
+    loc1 = described_class.new(1, 2)
+    loc2 = described_class.new(1, 2)
+    expect(loc1).to eq(loc2)
+  end
+
+  it "can be converted to Hash" do
+    loc = described_class.new(1, 2)
+    expect(loc.to_hash).to eq(lat: 1, lng: 2)
+  end
+
+  it "can be converted to an Array" do
+    loc = described_class.new(1, 2)
+    expect(loc.to_a).to eq([1, 2])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require "bundler/setup"
+require "byebug"
+require "loc"
+
+RSpec.configure do |config|
+  # Config goes here
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: loc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cyrille Courtière
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: 
+email:
+- cyrille@wayzup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/loc.rb
+- lib/loc/location.rb
+- lib/loc/location_collection.rb
+- lib/loc/version.rb
+- spec/loc/location_collection_spec.rb
+- spec/loc/location_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/wayzup/loc
+licenses:
+- MIT
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Location handling & geographical computations
+test_files:
+- spec/loc/location_collection_spec.rb
+- spec/loc/location_spec.rb
+- spec/spec_helper.rb