piste_pal 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 893460445f1be425c25ce56ae12ef4e629c77c91dbed7e90667a0659a1d74bf6
+  data.tar.gz: da58a5516d4f98b355a6bc2fe2f3b55fe5b5b31300818bf7915982688cfce609
+SHA512:
+  metadata.gz: 006fe9c2eb0e264d762fadd5cccc2aabbd9a58b901e16cacf153e85e3727d045c9d3cd5914a51559f6ba811a0272212f91b980e892583f3451547ebd01461f81
+  data.tar.gz: c2a92c099977e96d9c18df1fc6d7b094a076f4dd149486d1232f99d194bd2a7d451da4f8081d5a993dd41e5940d645ca76d8e8a43d1c7d733e505afc1afbd51b

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.3
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in piste_pal.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    piste_pal (1.0.0)
+      nokogiri (~> 1.10)
+      rake (~> 10.0)
+      vincenty_distance (~> 1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.0.1)
+    diff-lcs (1.3)
+    mini_portile2 (2.4.0)
+    nokogiri (1.10.3)
+      mini_portile2 (~> 2.4.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    vincenty_distance (1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  byebug (~> 11.0)
+  piste_pal!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Josh Menden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# PistePal
+
+Fill your time off the slopes thinking about them. This gem takes .gpx files from popular activity tracking apps and turns them into fun stats.
+
+The code can be accessed at a high level by "purchasing" either Day Passes or Season Passes, but most of the functionality is modularized to allow you access to the stats you want.
+
+It is tailored for .gpx files exported from the [Slopes](https://getslopes.com/) app for now.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'piste_pal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install piste_pal
+
+## Usage
+
+```ruby
+require 'piste_pal'
+
+# "Purchase" your day pass with a single .gpx data object
+
+gpx_data = File.read('/path/to/gpx/file')
+sundance = PistePal::DayPass.purchase(gpx_data)
+
+sundance.resort                         # Sundance Mountain Resort
+sundance.date                           # 2019-03-01 00:00:00 -0700
+sundance.maximum_speed                  # {:value=>30.290415, :unit=>"mph"}
+sundance.peak_altitude                  # {:value=>8261.18916855752, :unit=>"feet"}
+sundance.vertical                       # {:value=>3797.6879430483204, :unit=>"feet"}
+sundance.distance                       # {:value=>4.796952318157319, :unit=>"miles"}
+sundance.tallest_run                    # {:value=>1282.958728718721, :unit=>"feet"}
+sundance.longest_run                    # {:value=>1.9052295991405417, :unit=>"miles"}
+sundance.runs                           # [[@trackpoint1, @trackpoint2, ...], [@trackpoint1, @trackpoint2, ...]]
+sundance.lifts                          # [[@trackpoint1, @trackpoint2, ...], [@trackpoint1, @trackpoint2, ...]]
+
+# Or, purchase a season pass with an array of .gpx data objects
+
+season_data = []
+season_data.push(File.read('/path/to/gpx/file1'))
+season_data.push(File.read('/path/to/gpx/file2'))
+season_data.push(File.read('/path/to/gpx/file3'))
+
+season = PistePal::SeasonPass.purchase(season_data)
+
+season.days                             # [<PistePal::DayPass>, <PistePal::DayPass>, ...]
+season.days(timestamp_only: true)       # [2019-03-30 00:00:00 -0600, 2019-03-01 00:00:00 -0700, ...]
+season.runs                             # 134
+season.resorts                          # ["Sundance Resort", "Solitude Mountain Resort", "Park City Mountain Resort"]
+season.vertical                         # {:value=>51900.38487275453, :unit=>"feet"}
+season.distance                         # {:value=>52.35386405859661, :unit=>"miles"}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/joshmenden/piste_pal). No PR is too small.
+
+Some things that need cleaning up / fixing:
+
+* Should probably write some tests...
+* Cleaner, more comprehensive way to handle different measurement systems (Metric vs. Imperial). I have this half-baked in some places but it could use a lot of improvment.
+* Save trackpoint nodes to object and only extract data when necessary -- that is, only calculate the maximum_velocity when that method is invoked
+* Check compatibility with files exported from other Apps (right now it is mostly tailored towards the "Slopes" app)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "piste_pal"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/piste_pal/data_services/date_and_resort.rb

@@ -0,0 +1,25 @@
+require 'nokogiri'
+require 'time'
+module PistePal
+  module DataServices
+    class DateAndResort
+      def self.call
+        new().call
+      end
+
+      def call
+        name_node = @doc.xpath("//xmlns:name")
+        @date, @resort_name = name_node.children.first.text.strip.split(" - ")
+        @date = Time.parse(@date)
+        return [@date, @resort_name]
+      end
+
+      private
+
+      def initialize
+        @doc = PistePal::DataServices::GpxDoc.instance.doc
+      end
+    end
+  end
+end
+

data/lib/piste_pal/data_services/distance.rb

@@ -0,0 +1,51 @@
+require 'vincenty'
+module PistePal
+  module DataServices
+    class Distance
+      def self.call(trackpoints:)
+        new(trackpoints: trackpoints).call
+      end
+
+      def call
+        if @trackpoints.first.is_a? Array
+          distance = 0
+          @trackpoints.each do |trackpoints|
+            distance += calculate_distance trackpoints
+          end
+        else
+          distance = calculate_distance @trackpoints
+        end
+        distance
+      end
+
+      private
+
+      def initialize(trackpoints:)
+        @trackpoints = trackpoints
+      end
+
+      def calculate_distance trackpoints
+        distance = 0
+        total_points = trackpoints.count - 1
+
+        point_a = nil
+        point_b = nil
+
+        for i in 0..total_points do
+          if i == 0
+            point_a = { latitude: trackpoints[i].lat, longitude: trackpoints[i].lon }
+            next
+          end
+
+          point_b = { latitude: trackpoints[i].lat, longitude: trackpoints[i].lon }
+          distance += Vincenty.distance_between_points(point_a, point_b)
+          point_a = point_b
+        end
+
+        distance
+      end
+    end
+  end
+end
+
+

data/lib/piste_pal/data_services/gpx_doc.rb

@@ -0,0 +1,24 @@
+require 'nokogiri'
+module PistePal
+  module DataServices
+    class GpxDoc
+      # include Singleton
+      attr_accessor :doc
+
+      def self.set_instance(file_content)
+        @instance = new(file_content)
+      end
+      def self.instance
+        @instance || nil
+      end
+
+      private
+      def initialize file_content
+        # TODO: Support Nokogiri reading from http website instead of file path
+        @doc = Nokogiri::XML(file_content) do |config|
+          config.strict.noblanks
+        end
+      end
+    end
+  end
+end

data/lib/piste_pal/data_services/max_speed_and_altitude.rb

@@ -0,0 +1,30 @@
+module PistePal
+  module DataServices
+    class MaxSpeedAndAltitude
+      def self.call(trackpoints:)
+        new(trackpoints).call
+      end
+
+      def call
+        max_speed_and_altitude
+      end
+
+      private
+
+      def initialize(trackpoints)
+        @trackpoints = trackpoints
+      end
+
+      def max_speed_and_altitude
+        max_speed = 0
+        max_alt = 0
+        @trackpoints.each do |trackpoint|
+          max_speed = trackpoint.speed if trackpoint.speed > max_speed
+          max_alt = trackpoint.elevation if trackpoint.elevation > max_alt
+        end
+        [max_speed, max_alt]
+      end
+    end
+  end
+end
+

data/lib/piste_pal/data_services/runs_and_lifts.rb

@@ -0,0 +1,119 @@
+module PistePal
+  module DataServices
+    class RunsAndLifts
+
+      MINIMUM_DEVIATION = 5
+
+      def self.call(trackpoints:)
+        new(trackpoints: trackpoints).call
+      end
+
+      def call
+        runs_and_lifts
+      end
+
+      private
+
+      def initialize(trackpoints:)
+        @trackpoints = trackpoints
+      end
+
+      def runs_and_lifts
+        group_runs_and_lifts(aggregate_runs_by_direction)
+      end
+
+      def group_runs_and_lifts groupings
+        runs = []
+        lifts = []
+        total_groups_count = groupings.count - 1
+
+        previous_group = nil
+
+        for i in 1..total_groups_count do
+          previous_group = groupings[i - 1] if i == 1
+
+          if groupings[i][:trackpoints].count > MINIMUM_DEVIATION
+            if groupings[i][:direction] == previous_group[:direction]
+              previous_group[:trackpoints].concat(groupings[i][:trackpoints])
+            else
+              if previous_group[:direction] == "ascending"
+                lifts.push(previous_group)
+              else
+                runs.push(previous_group)
+              end
+              previous_group = groupings[i]
+            end
+          elsif groupings[i][:trackpoints].count <= MINIMUM_DEVIATION
+            previous_group[:trackpoints].concat(groupings[i][:trackpoints])
+          end
+
+          if i == total_groups_count
+            if previous_group[:direction] == "ascending"
+              lifts.push(previous_group)
+            else
+              runs.push(previous_group)
+            end
+          end
+        end
+
+        # Not a perfect system, but for now let's delete the runs that have bad data
+        runs = runs.delete_if {|run| run[:trackpoints].first.elevation < run[:trackpoints].last.elevation}
+
+        [runs.map {|run| run[:trackpoints]}, lifts.map {|lift| lift[:trackpoints]}]        
+      end
+
+      def aggregate_runs_by_direction
+        groupings = []
+        current_group = [] 
+        total_points = @trackpoints.count - 1
+        descending = true
+
+        for i in 1..total_points do
+          if i == 1
+            current_group.push(@trackpoints[i - 1])
+            current_group.push(@trackpoints[i])
+            if @trackpoints[i].elevation < @trackpoints[i - 1].elevation
+              descending = true
+            elsif @trackpoints[i].elevation > @trackpoints[i - 1].elevation
+              descending = false
+            # else they are equal, and it doesn't matter what direction we choose to start
+            end
+            next
+          end
+
+          if @trackpoints[i].elevation < @trackpoints[i - 1].elevation
+            if !descending
+              groupings.push({ direction: descending ? "descending" : "ascending", trackpoints: current_group })
+              current_group = []
+              descending = true
+            end
+          elsif @trackpoints[i].elevation > @trackpoints[i - 1].elevation
+            if descending
+              groupings.push({ direction: descending ? "descending" : "ascending", trackpoints: current_group })
+              current_group = []
+              descending = false
+            end
+          end
+
+          current_group.push(@trackpoints[i])
+
+          if i == total_points
+            groupings.push({ direction: descending ? "descending" : "ascending", trackpoints: current_group })
+          end
+
+        end
+        #
+        # groupings.each do |group|
+        #   puts "\n\nNew Group:\nDirection: #{group[:direction]}\n"
+        #   group[:trackpoints].each do |point|
+        #     puts point.elevation
+        #   end
+        # end
+        groupings
+      end
+    end
+  end
+end
+
+
+

data/lib/piste_pal/data_services/tallest_and_longest_run.rb

@@ -0,0 +1,30 @@
+module PistePal
+  module DataServices
+    class TallestAndLongestRun
+      def self.call(runs:)
+        new(runs: runs).call
+      end
+
+      def call
+        tallest = 0
+        longest = 0
+        @runs.each do |run|
+          vertical = run.first.elevation - run.last.elevation
+          distance = PistePal::DataServices::Distance.call(trackpoints: run)
+          
+          tallest = vertical if vertical > tallest
+          longest = distance if distance > longest
+        end
+
+        [tallest, longest]
+      end
+
+      private
+
+      def initialize(runs:)
+        @runs = runs
+      end
+    end
+  end
+end
+

data/lib/piste_pal/data_services/trackpoints.rb

@@ -0,0 +1,50 @@
+require 'nokogiri'
+module PistePal
+  module DataServices
+    class Trackpoints
+
+      MINIMUM_ACCEPTABLE_DOP = 10
+
+      def self.call
+        new().call
+      end
+
+      def call
+        extract_trackpoints
+        @trackpoints
+      end
+
+      private
+
+      def initialize()
+        @doc = PistePal::DataServices::GpxDoc.instance.doc
+        @trackpoints = []
+      end
+
+      def extract_trackpoints
+        trackpoints = @doc.xpath("//xmlns:trkpt")
+        trackpoints.each do |tp|
+          trackpoint = PistePal::Trackpoint.new(**extract_params_from_trackpoint_node(tp))
+          @trackpoints.push(trackpoint) if trackpoint.hdop <= MINIMUM_ACCEPTABLE_DOP && trackpoint.vdop <= MINIMUM_ACCEPTABLE_DOP
+        end
+      end
+
+      def extract_params_from_trackpoint_node trackpoint
+        params = Hash.new
+        params[:lat] = trackpoint.xpath('@lat').to_s.to_f
+        params[:lon] = trackpoint.xpath('@lon').to_s.to_f
+        trackpoint.children.each do |child|
+          params[:elevation] = child.text.strip.to_f if child.name == "ele"
+          params[:time] = child.text.strip if child.name == "time"
+          params[:hdop] = child.text.strip.to_i if child.name == "hdop"
+          params[:vdop] = child.text.strip.to_i if child.name == "vdop"
+        end
+        extensions = trackpoint.children.search("extensions").first
+        extensions.children.each do |child|
+          params[:speed] = child.attributes["speed"].value.to_s.to_f if child.name == "gps" && !child.attributes["speed"].nil?
+        end
+        return params
+      end
+    end
+  end
+end

data/lib/piste_pal/data_services/vertical.rb

@@ -0,0 +1,26 @@
+module PistePal
+  module DataServices
+    class Vertical
+      def self.call(trackpoints:)
+        new(trackpoints: trackpoints).call
+      end
+
+      def call
+        vertical = 0
+        @trackpoints.each do |trackpoints|
+          vertical += (trackpoints.first.elevation - trackpoints.last.elevation)
+        end
+        vertical
+      end
+
+      private
+
+      def initialize(trackpoints:)
+        @trackpoints = trackpoints
+      end
+    end
+  end
+end
+
+
+

data/lib/piste_pal/day_pass.rb

@@ -0,0 +1,100 @@
+module PistePal
+  class DayPass
+    attr_accessor :resort, :date, :trackpoints, :maximum_speed, :peak_altitude, :vertical, :distance, :tallest_run, :longest_run, :runs, :lifts
+
+    def self.purchase file_content
+      new(file_content: file_content)
+    end
+
+    # convert mp/h to km/h
+    def maximum_speed(system = "imperial")
+      if system == "metric"
+        value = (@maximum_speed * 1.60934)
+        unit = "kmh"
+      elsif system == "imperial"
+        value = @maximum_speed
+        unit = "mph"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    # convert meters to feet
+    def peak_altitude(system = "imperial")
+      if system == "metric"
+        value = @peak_altitude
+        unit = "meters"
+      elsif system == "imperial"
+        value = @peak_altitude * 3.28084
+        unit = "feet"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    # convert meters to km / miles
+    def distance(system = "imperial")
+      if system == "metric"
+        value = @distance / 1000
+        unit = "kilometers"
+      elsif system == "imperial"
+        value = @distance / 1609.344
+        unit = "miles"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    # convert meters to feet
+    def vertical(system = "imperial")
+      if system == "metric"
+        value = @vertical
+        unit = "meters"
+      elsif system == "imperial"
+        value = @vertical * 3.28084
+        unit = "feet"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    # convert meters to feet
+    def tallest_run(system = "imperial")
+      if system == "metric"
+        value = @tallest_run
+        unit = "meters"
+      elsif system == "imperial"
+        value = @tallest_run * 3.28084
+        unit = "feet"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    # convert meters to miles
+    def longest_run(system = "imperial")
+      if system == "metric"
+        value = @longest_run / 1000
+        unit = "kilometers"
+      elsif system == "imperial"
+        value = @longest_run / 1609.344
+        unit = "miles"
+      end
+
+      { :value => value, :unit => unit }
+    end
+
+    private
+
+    def initialize(file_content:)
+      PistePal::DataServices::GpxDoc.set_instance(file_content)
+      @trackpoints = PistePal::DataServices::Trackpoints.call
+      @date, @resort = PistePal::DataServices::DateAndResort.call
+      @maximum_speed, @peak_altitude = PistePal::DataServices::MaxSpeedAndAltitude.call(trackpoints: @trackpoints)
+      @runs, @lifts = PistePal::DataServices::RunsAndLifts.call(trackpoints: @trackpoints)
+      @distance = PistePal::DataServices::Distance.call(trackpoints: @runs)
+      @vertical = PistePal::DataServices::Vertical.call(trackpoints: @runs)
+      @tallest_run, @longest_run = PistePal::DataServices::TallestAndLongestRun.call(runs: @runs)
+    end
+  end
+end

data/lib/piste_pal/season_pass.rb

@@ -0,0 +1,35 @@
+module PistePal
+  class SeasonPass
+    attr_accessor :days, :resorts, :runs, :vertical, :distance
+
+    def self.purchase files
+      new(files: files)
+    end
+
+    def days(timestamp_only: false)
+      return @days if !timestamp_only
+      return @days.map {|day| day.date }
+    end
+
+    private
+
+    def initialize(files:)
+      @days = []
+      files.each do |f|
+        @days.push(PistePal::DayPass.purchase(f))
+      end
+
+      @resorts = @days.map {|day| day.resort }.uniq
+      @runs = @days.map {|day| day.runs.count }.reduce(0, :+)
+      @vertical = {
+        :value => @days.map {|day| day.vertical[:value] }.reduce(0, :+),
+        :unit => @days.first.vertical[:unit]
+      }
+      @distance = {
+        :value => @days.map {|day| day.distance[:value] }.reduce(0, :+),
+        :unit => @days.first.distance[:unit]
+      }
+    end
+  end
+end
+

data/lib/piste_pal/trackpoint.rb

@@ -0,0 +1,15 @@
+module PistePal
+  class Trackpoint
+    attr_accessor :lat, :lon, :elevation, :time, :hdop, :vdop, :speed
+
+    def initialize(lat: nil, lon: nil, elevation: nil, time: nil, hdop: nil, vdop: nil, speed: nil)
+      @lat = lat
+      @lon = lon
+      @elevation = elevation
+      @time = time
+      @hdop = hdop
+      @vdop = vdop
+      @speed = speed
+    end
+  end
+end

data/lib/piste_pal/version.rb

@@ -0,0 +1,3 @@
+module PistePal
+  VERSION = "1.0.0"
+end

data/lib/piste_pal.rb

@@ -0,0 +1,12 @@
+require "piste_pal/version"
+require "piste_pal/day_pass"
+require "piste_pal/season_pass"
+require "piste_pal/trackpoint"
+require "piste_pal/data_services/gpx_doc"
+require "piste_pal/data_services/trackpoints"
+require "piste_pal/data_services/date_and_resort"
+require "piste_pal/data_services/max_speed_and_altitude"
+require "piste_pal/data_services/distance"
+require "piste_pal/data_services/runs_and_lifts"
+require "piste_pal/data_services/vertical"
+require "piste_pal/data_services/tallest_and_longest_run"

data/piste_pal.gemspec

@@ -0,0 +1,34 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "piste_pal/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "piste_pal"
+  spec.version       = PistePal::VERSION
+  spec.authors       = ["Josh Menden"]
+  spec.email         = ["josh.menden@gmail.com"]
+
+  spec.summary       = %q{A Ruby Gem that helps calculate Skiing statistics from GPS data.}
+  # spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/joshmenden/piste_pal"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug", "~> 11.0"
+  spec.add_dependency "nokogiri", "~> 1.10"
+  spec.add_dependency "rake", "~> 10.0"
+  spec.add_dependency "vincenty_distance", "~> 1.0.0"
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: piste_pal
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Menden
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: vincenty_distance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: 
+email:
+- josh.menden@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/piste_pal.rb
+- lib/piste_pal/data_services/date_and_resort.rb
+- lib/piste_pal/data_services/distance.rb
+- lib/piste_pal/data_services/gpx_doc.rb
+- lib/piste_pal/data_services/max_speed_and_altitude.rb
+- lib/piste_pal/data_services/runs_and_lifts.rb
+- lib/piste_pal/data_services/tallest_and_longest_run.rb
+- lib/piste_pal/data_services/trackpoints.rb
+- lib/piste_pal/data_services/vertical.rb
+- lib/piste_pal/day_pass.rb
+- lib/piste_pal/season_pass.rb
+- lib/piste_pal/trackpoint.rb
+- lib/piste_pal/version.rb
+- piste_pal.gemspec
+homepage: https://github.com/joshmenden/piste_pal
+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.7.6
+signing_key: 
+specification_version: 4
+summary: A Ruby Gem that helps calculate Skiing statistics from GPS data.
+test_files: []