runby_pace 0.2.50.111 → 0.2.55

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA256:
-  metadata.gz: c865faf1b57fa5d059871913a9ffe259c5cfccc6f5e5c80819c2bcf7c7477ee9
-  data.tar.gz: d34065214cd2129a7f433c201150afdaf88bbf845b7214c2c88ec095f1064a4c
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzcyNTgxZjZiMzBlZGU2NTcyNzIzOGU1M2RiMTAxMDA0Y2ViOTRmMA==
+  data.tar.gz: !binary |-
+    YTVmNWNlNGJhYTcyYTVjYmE0OThjNDY1MWE0NmVhMjljMWYxOWQxOA==
 SHA512:
-  metadata.gz: 1e20444a7feb901736b98135e27ac2f63d6d06e7f0cd0e594bbd5a2853a2e2586dad8338733d5f32c06265ddbc04eaf79ca3e672b08f2e3f495b350bca7d620d
-  data.tar.gz: e2405ad249c55e3473b9999cf761373aab346b26d395417921865d6e7d9b44b9f7a26cebebc1aedae27a531feacc2d20f3be98df520458d739cd2d25f944887a
+  metadata.gz: !binary |-
+    YzdhOGFkODU2MjhjMTg2NGNkZDcwM2U3MzdkODQyYjE4MTVmYWI4Y2EwYzA3
+    OTdhNDMxOTUwOGI0M2ZmN2ZiZTc2M2VhMzk3YjRiNDY4MGU5NDg5YmRhNWI2
+    ZjI4N2RmZTVlYTk1Mjc5ZGQxZGUxNzA1NzEyYzNiNTM4ZTcyMGQ=
+  data.tar.gz: !binary |-
+    ZmQ2M2Y5ZTNjYThkY2ViNjRkN2FhMDI5Zjc3YTVjZmE4ZjI0MWE1YmJjMjBk
+    NTlkMmNjZmZiODVmZjVmNDNjNzM0YzY1MzliZGViNmU4YmM5MjYxZDhjYzYx
+    MWEzNGU3OWU0ZDRiNTAxMzkyN2U2NjY1MDA0MmI1ZmNmMjFlMGQ=

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-- 2.4
+- 2.2.4
 before_install: gem install bundler -v 1.12.5
 deploy:
   skip_cleanup: true
@@ -12,7 +12,3 @@ deploy:
     repo: tygerbytes/runby-pace
 git:
   depth: 1024
-notifications:
-  email:
-    on_success: always
-    on_failure: always

data/Gemfile

@@ -1,9 +1,5 @@
 source 'https://rubygems.org'
 
-group :development do
-  gem 'rubocop', require: false
-end
-
 group :test do
   gem 'coveralls', require: false
 end

data/README.md

@@ -6,7 +6,6 @@ RunbyPace contains the core logic for calculating the target "paces" used by run
 | | |
 | --- | --- |
 | **Build** | [![Build Status](https://travis-ci.org/tygerbytes/runby-pace.svg?branch=master)](https://travis-ci.org/tygerbytes/runby-pace) |
-| **Grade** | [![Codacy Badge](https://api.codacy.com/project/badge/Grade/7c228c8601ff4eeb9dfe0f6c60867f25)](https://www.codacy.com/app/tygerbytes/runby-pace?utm_source=github.com&utm_medium=referral&utm_content=tygerbytes/runby-pace&utm_campaign=badger) |
 | **Coverage** | [![Coverage Status](https://coveralls.io/repos/github/tygerbytes/runby-pace/badge.svg?branch=master)](https://coveralls.io/github/tygerbytes/runby-pace?branch=master) |
 | **Gem** | [![gem](https://img.shields.io/gem/v/runby_pace.svg)](https://rubygems.org/gems/runby_pace) |
 
@@ -21,9 +20,7 @@ Any sort of running program will include runs at varying paces, easy runs, dista
 So this is great, but a little tedious. RunbyPace automates this whole process by calculating all of the paces for you.
  All you need is your current 5K time and some Ruby, and you're off running at just the right pace.
 
-RunbyPace also encapsulates the logic and math necessary for many running-related calculations based on time, pace, speed, unit coversions, etc. If you're tired of constantly converting minutes and seconds to decimal and back again, RunbyPace is for you.
-
-[![RunbyPace logo](misc/runbypace_logo.png)](https://runbypace.com)
+Note that this project is currently being developed, so much of the functionality is pending.
 
 ## Installation
 
@@ -37,32 +34,24 @@ And then execute:
 
     $ bundle
 
-Or install it yourself:
+Or install it yourself as:
 
     $ gem install runby_pace
 
 ## Usage
 
-I plan to craft better docs in the future, but for now the **specs** make for excellent class usage documentation: https://github.com/tygerbytes/runby-pace/tree/master/spec/runby_pace
-
-For a live front end written in **Rails**, see https://runbypace.com. It's code will be open-sourced as well, as soon as we can guarantee secure deployment.
-
-For an open-source example front end written in **Elm**, see https://github.com/tygerbytes/pacebyelm
-
-The CLI is still in its infancy, but the gem comes with a basic CLI/REPL (`bin/runbypace`)
+TODO: Coming soon... When the class interfaces are fleshed out.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` or `bin/runbypace` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/tygerbytes/runby-pace.
 
-Contribute front-end and CLI ideas at [@runbypace](https://twitter.com/runbypace).
-
 ## Acknowledgements
 
 Crafted with care, with the support of [JetBrains RubyMine](https://www.jetbrains.com/ruby/)

data/Rakefile

@@ -1,17 +1,15 @@
-# frozen_string_literal: true
-
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :build
+task :default => :build
 
-task build: %i[gen_version_number gen_all_run_types spec]
+task :build => [:gen_all_run_types,:spec]
 
 desc 'Generate the all_run_types.g.rb file'
 task :gen_all_run_types do
-  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', '> Generate all_run_types.g.rb')
+  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', 'Generate all_run_types.g.rb')
   run_types_path = './lib/runby_pace/run_types'
 
   # Parse *_run.rb file names to generate array of the run type class names
@@ -21,48 +19,16 @@ task :gen_all_run_types do
     filename_sans_extension = filename[0, filename.length - 3]
     parts = filename_sans_extension.to_s.downcase.split(/_|\./)
     run_type = ''
-    parts.each do |part|
+    parts.each { |part|
       run_type += part[0].upcase + part[-(part.length - 1), part.length - 1]
-    end
+    }
     run_type
   end
   puts all_run_types.join(' ')
 
   # Write run types to the generated file, all_run_types.g.rb
   template = File.read(File.join(run_types_path, 'all_run_types.template'))
-  template.gsub!('__RUN_TYPE_NAMES__', all_run_types.join(' '))
-  template.gsub!('__RUN_TYPES__', all_run_types.join(', '))
+  template.gsub!('__RUN_TYPES__', all_run_types.join(' '))
   File.write(File.join(run_types_path, 'all_run_types.g.rb'), template)
   puts "\e[32mDone\e[0m\n\n"
 end
-
-desc 'Generate version number'
-task :gen_version_number do
-  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', '> Generate version number')
-
-  # Generate "teeny" version number based on the number of commits since the last tagged major/minor release
-  latest_tagged_release = `git describe --tags --abbrev=0 --match v*`.to_s.chomp
-  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', "Latest tagged release is #{latest_tagged_release}")
-  version = "#{latest_tagged_release[1..-1]}.#{`git rev-list --count #{latest_tagged_release}..HEAD`}".chomp
-
-  # Write version number to generated file
-  path = './lib/runby_pace'
-  template = File.read(File.join(path, 'version.seed'))
-  template.gsub!('__VERSION__', version)
-  version_file_path = File.join(path, 'version.g.rb')
-  File.write(version_file_path, template)
-  with_no_warnings do
-    # Silencing warnings about redefining constants, since it's intentional
-    load version_file_path
-    Runby::VERSION = Runby::GENERATED_VERSION
-  end
-  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', "Version: #{Runby::VERSION}")
-end
-
-def with_no_warnings
-  warning_level = $VERBOSE
-  $VERBOSE = nil
-  result = yield
-  $VERBOSE = warning_level
-  result
-end

data/bin/_guard-core

@@ -1,17 +1,16 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application '_guard-core' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("guard", "_guard-core")
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application '_guard-core' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "_guard-core")

data/bin/guard

@@ -1,17 +1,16 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application 'guard' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("guard", "guard")
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "guard")

data/lib/runby_pace.rb

@@ -1,10 +1,7 @@
 
 require 'runby_pace/version'
 Dir[File.dirname(__FILE__) + '/runby_pace/*.rb'].each { |file| require file }
-Dir[File.dirname(__FILE__) + '/runby_pace/cli/*.rb'].each { |file| require file }
 Dir[File.dirname(__FILE__) + '/runby_pace/run_types/*.rb'].each { |file| require file }
-Dir[File.dirname(__FILE__) + '/runby_pace/utility/*.rb'].each { |file| require file }
 
-# The main module
-module Runby
+module RunbyPace
 end

data/lib/runby_pace/{pace_calculator.rb → pace_data.rb}

@@ -1,8 +1,7 @@
-# frozen_string_literal: true
+module RunbyPace
+
+  class PaceData
 
-module Runby
-  # Encapsulates the algorithms used to calculate target paces.
-  class PaceCalculator
     # The number of data points plotted on our line of 5K times.
     #  We take 5K times from 14:00 to 42:00 with a sample rate
     #  of 30 seconds, and out pops 57.
@@ -27,41 +26,26 @@ module Runby
     #  until it matches that of the data. (See #curve_minutes)
     attr_reader :midpoint_radius_divisor
 
-    def initialize(golden_pace_set, midpoint_radius_divisor)
-      @fastest_pace_km = golden_pace_set.fastest
-      @slowest_pace_km = golden_pace_set.slowest
+    def initialize(fastest_pace_km, slowest_pace_km, midpoint_radius_divisor)
+      @fastest_pace_km = RunbyPace::PaceTime.new(fastest_pace_km)
+      @slowest_pace_km = RunbyPace::PaceTime.new(slowest_pace_km)
       @midpoint_radius_divisor = midpoint_radius_divisor
     end
 
     # Calculate the slope of the line between the fastest and slowest paces
     def slope
-      (@slowest_pace_km.time.total_minutes - @fastest_pace_km.time.total_minutes) / (DATA_POINTS_COUNT - 1)
+      (@slowest_pace_km.total_minutes - @fastest_pace_km.total_minutes) / (DATA_POINTS_COUNT - 1)
     end
 
     # Calculate the prescribed pace for the given 5K time
-    # @return [Pace]
-    def calc(five_k_time, distance_units = :km)
-      five_k_time = Runby.sanitize(five_k_time).as(RunbyTime)
-      distance_units = Runby.sanitize(distance_units).as(DistanceUnit)
-
-      minutes_per_unit = calculate_minutes_per_unit(distance_units, five_k_time)
-      build_pace minutes_per_unit, distance_units
+    def calc(five_k_time)
+      five_k_time = RunbyPace::PaceTime.new(five_k_time)
+      x2 = ((five_k_time.total_minutes * 2) - (MIDPOINT_X - 1)) - 1
+      RunbyPace::PaceTime.from_minutes(slope * x2 + @fastest_pace_km.total_minutes + curve_minutes(x2))
     end
 
     private
 
-    def build_pace(minutes_per_unit, distance_units)
-      time = RunbyTime.from_minutes(minutes_per_unit)
-      distance = Distance.new distance_units, 1
-      Pace.new time, distance
-    end
-
-    def calculate_minutes_per_unit(distance_units, five_k_time)
-      x2 = ((five_k_time.total_minutes * 2) - (MIDPOINT_X - 1)) - 1
-      minutes_per_km = slope * x2 + @fastest_pace_km.time.total_minutes + curve_minutes(x2)
-      minutes_per_km * distance_units.conversion_factor
-    end
-
     # Since the paces for each 5K time do not progress in a straight line
     #  when plotted on a graph, but rather a curve with its highest point near
     #  the center, we must add some seconds to the calculated time depending on
@@ -71,12 +55,12 @@ module Runby
     # The default curve radius is the same as the midpoint of the X axis,
     #  forming a circle. Use #midpoint_radius_divisor to reduce it's size.
     def curve_minutes(x_axis)
-      return 0 if @midpoint_radius_divisor.zero?
+      return 0 if @midpoint_radius_divisor == 0
       midpoint_reduction = x_axis
       midpoint = MIDPOINT_X
       if midpoint_reduction > midpoint
         midpoint_reduction = midpoint - (midpoint_reduction - midpoint)
-        midpoint_reduction = 0 if midpoint_reduction.negative?
+        midpoint_reduction = 0 if midpoint_reduction < 0
       end
       # TODO: Use an actual curve instead of a triangle to calculate the number of minutes to add.
       midpoint_reduction / @midpoint_radius_divisor / 60

data/lib/runby_pace/pace_range.rb

@@ -1,33 +1,15 @@
-# frozen_string_literal: true
+module RunbyPace
 
-require_relative 'runby_range'
+  class PaceRange
+    attr_reader :fast, :slow
 
-module Runby
-  # Represents a range of paces, from fast to slow.
-  class PaceRange < RunbyRange
-    def initialize(fast, slow, distance_units = :km)
-      if fast.is_a?(Pace) && slow.is_a?(Pace)
-        @fast = fast
-        @slow = slow
-      else
-        # Hopefully 'fast' and 'slow' are parseable as a RunbyTime
-        distance = Distance.new distance_units, 1
-        @fast = Pace.new(fast, distance)
-        @slow = Pace.new(slow, distance)
-      end
-      freeze
+    def initialize(fast, slow)
+      @fast = RunbyPace::PaceTime.new(fast)
+      @slow = RunbyPace::PaceTime.new(slow)
     end
 
-    def as_speed_range
-      SpeedRange.new @fast.as_speed, @slow.as_speed
-    end
-
-    def to_s(format: :short)
-      if @fast == @slow
-        @fast.to_s(format: format)
-      else
-        @fast.to_s(format: format).sub(@fast.time.to_s, "#{@fast.time}-#{@slow.time}")
-      end
+    def to_s
+      "#{@fast}-#{@slow}"
     end
   end
-end
+end

data/lib/runby_pace/pace_time.rb

@@ -0,0 +1,110 @@
+module RunbyPace
+
+  class PaceTime
+    attr_reader :time_s, :minutes_part, :seconds_part
+
+    def initialize(time)
+      if time.is_a?(String) || time.is_a?(Symbol)
+        init_from_string(time)
+      elsif time.is_a?(PaceTime)
+        init_from_clone(time)
+      end
+    end
+
+    # @param [numeric] total_seconds
+    def self.from_seconds(total_seconds)
+      minutes = total_seconds.abs.to_i / 60
+      seconds = total_seconds.abs.to_i % 60
+      PaceTime.new("#{'%02d' % minutes}:#{'%02d' % seconds}")
+    end
+
+    # @param [numeric] total_minutes
+    def self.from_minutes(total_minutes)
+      self.from_seconds(total_minutes * 60.0)
+    end
+
+    def to_s
+      @time_s
+    end
+
+    def total_seconds
+      @minutes_part * 60 + @seconds_part
+    end
+
+    def total_minutes
+      @minutes_part + (@seconds_part / 60.0)
+    end
+
+    # @param [PaceTime] value
+    def -(value)
+      if value.is_a?(PaceTime)
+        PaceTime.from_seconds(total_seconds - value.total_seconds)
+      end
+    end
+
+    # @param [PaceTime] value
+    def +(value)
+      if value.is_a?(PaceTime)
+        PaceTime.from_seconds(total_seconds + value.total_seconds)
+      end
+    end
+
+    def ==(value)
+      if value.is_a?(PaceTime)
+        total_seconds == value.total_seconds
+      elsif value.is_a?(String)
+        @time_s == value
+      end
+    end
+
+    def almost_equals?(other_time, tolerance_time = '00:01')
+      if other_time.is_a?(String)
+        other_time = PaceTime.new(other_time)
+      end
+      tolerance = PaceTime.new(tolerance_time)
+      self >= (other_time - tolerance) && self <= (other_time + tolerance)
+    end
+
+    def >(value)
+      if value.is_a?(PaceTime)
+        total_seconds > value.total_seconds
+      end
+    end
+
+    def >=(value)
+      if value.is_a?(PaceTime)
+        total_seconds >= value.total_seconds
+      end
+    end
+
+    def <(value)
+      if value.is_a?(PaceTime)
+        total_seconds < value.total_seconds
+      end
+    end
+
+    def <=(value)
+      if value.is_a?(PaceTime)
+        total_seconds <= value.total_seconds
+      end
+    end
+
+    private
+
+    def init_from_string(time)
+      raise 'Invalid time format' if !time.match(/(-)?\d\d:\d\d/)
+      @time_s = time.to_s
+      parts = time.to_s.split(':')
+      @minutes_part = parts[0].to_i
+      @seconds_part = parts[1].to_i
+      raise 'Seconds must be less than 60' if @seconds_part.abs > 59
+    end
+
+    # @param [PaceTime] time
+    def init_from_clone(time)
+      @time_s = time.time_s
+      @minutes_part = time.minutes_part
+      @seconds_part = time.seconds_part
+    end
+  end
+end