runby_pace 0.2.50.111 → 0.2.55

data/lib/runby_pace/golden_pace_set.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-
-  # Maps a set of 5K race times with their pre-calculated pace recommendations.
-  # This is useful in testing as well as defining the fastest and slowest supported 5K times.
-  # GoldenPaceSet could conceivably be used to pre-compute a large number of recommended paces,
-  #  thus reducing runtime CPU overhead.
-  class GoldenPaceSet
-    include Enumerable
-
-    attr_reader :paces
-
-    # The fastest 5K time supported by RunbyPace
-    FASTEST_5K = :'14:00'
-
-    # The slowest 5K time supported by RunbyPace
-    SLOWEST_5K = :'42:00'
-
-    # @param [Hash] paces_hash is a hash mapping 5K time symbols to times, represented as strings.
-    # An example paces_hash is {'14:00':'4:00', '15:00':'4:55'}
-    def initialize(paces_hash)
-      @paces = {}
-      paces_hash.each { |five_k_time, recommended_pace| @paces[five_k_time.to_sym] = Pace.new(recommended_pace) }
-    end
-
-    def each
-      @paces.each do |h, v|
-        yield h, v
-      end
-    end
-
-    # Returns first/fastest recommended pace in the set
-    def first
-      @paces[FASTEST_5K]
-    end
-    alias fastest first
-
-    # Return the last/slowest recommended pace in the set
-    def last
-      @paces[SLOWEST_5K]
-    end
-    alias slowest last
-
-    # Creates and returns a new GoldenPaceSet with only two entries
-    def self.new_from_endpoints(fastest, slowest)
-      GoldenPaceSet.new(FASTEST_5K => fastest, SLOWEST_5K => slowest)
-    end
-  end
-end

data/lib/runby_pace/pace.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  # Represents a pace consisting of a distance and a time in which that distance was covered
-  class Pace
-    include Comparable
-
-    attr_reader :time, :distance
-
-    def self.new(time_or_pace, distance = '1K')
-      return time_or_pace if time_or_pace.is_a? Pace
-      super
-    end
-
-    def initialize(time_or_pace, distance = '1K')
-      case time_or_pace
-      when RunbyTime
-        init_from_time time_or_pace, distance
-      when String
-        init_from_string time_or_pace, distance
-      else
-        raise 'Invalid Time or Pace'
-      end
-      freeze
-    end
-
-    def convert_to(target_distance)
-      target_distance = Distance.new(target_distance) unless target_distance.is_a?(Distance)
-      return self if @distance == target_distance
-      conversion_factor = target_distance / @distance
-      Pace.new @time * conversion_factor, target_distance
-    end
-
-    def to_s(format: :short)
-      leading_one_regex = /^1 ?/
-      distance_s = @distance.to_s(format: format).gsub(leading_one_regex, '')
-      case format
-      when :short then "#{time} p/#{distance_s}"
-      when :long then "#{time} per #{distance_s}"
-      else raise "Invalid string format #{format}"
-      end
-    end
-
-    def as_speed
-      total_minutes = @time.total_minutes
-      multiplier = total_minutes.positive? ? (60 / total_minutes).round(2) : 0
-      distance = Runby::Distance.new(@distance.uom, multiplier)
-      Runby::Speed.new distance
-    end
-
-    def meters_per_minute
-      total_minutes = @time.total_minutes
-      return 0 unless total_minutes.positive?
-      @distance.meters / total_minutes
-    end
-
-    # @param [String] str is either a long-form pace such as "10:00 per mile" or a short-form pace like "10:00 p/mi"
-    def self.parse(str)
-      str = str.to_s.strip.chomp
-      match = str.match %r{^(?<time>[:\d]*) ?(?: per |p\/)(?<distance>(?:[\d.]+ ?)?\w+)$}
-      raise "Invalid pace format (#{str})" unless match
-      time = Runby::RunbyTime.new(match[:time])
-      distance = Runby::Distance.new(match[:distance])
-      Pace.new time, distance
-    end
-
-    def self.try_parse(str)
-      pace = nil
-      error_message = nil
-      warning_message = nil
-      begin
-        pace = Pace.parse str
-      rescue StandardError => ex
-        error_message = ex.message
-      end
-      { pace: pace, error: error_message, warning: warning_message }
-    end
-
-    def <=>(other)
-      raise "Unable to compare Runby::Pace to #{other.class}(#{other})" unless [Pace, RunbyTime, String].include? other.class
-      if other.is_a? Pace
-        meters_per_minute.round(2) <=> other.meters_per_minute.round(2)
-      elsif other.is_a? RunbyTime
-        @time <=> other
-      elsif other.is_a? String
-        return 0 if to_s == other || to_s(format: :long) == other
-        return 0 if @time == other
-        self <=> try_parse(other)[:pace]
-      end
-    end
-
-    def almost_equals?(other_pace, tolerance_time = '00:01')
-      if other_pace.is_a?(RunbyTime)
-        return almost_equals?(Pace.new(other_pace, @distance), tolerance_time)
-      end
-      if other_pace.is_a?(String)
-        return almost_equals?(Pace.new(other_pace, @distance), tolerance_time) if other_pace.match?(/^\d?\d:\d\d$/)
-        other_pace = Pace.parse(other_pace)
-      end
-      tolerance = RunbyTime.new(tolerance_time)
-      fast_end = (self - tolerance)
-      slow_end = (self + tolerance)
-      slow_end <= other_pace && other_pace <= fast_end
-    end
-
-    # @param [Pace, RunbyTime] other
-    def -(other)
-      if other.is_a?(Pace)
-        Pace.new(@time - other.convert_to(@distance).time, @distance)
-      elsif other.is_a?(RunbyTime)
-        Pace.new(@time - other, @distance)
-      end
-    end
-
-    # @param [Pace, RunbyTime] other
-    def +(other)
-      if other.is_a?(Pace)
-        Pace.new(@time + other.convert_to(@distance).time, @distance)
-      elsif other.is_a?(RunbyTime)
-        Pace.new(@time + other, @distance)
-      end
-    end
-
-    def distance_covered_over_time(time)
-      time = Runby.sanitize(time).as(RunbyTime)
-      if time.total_minutes.zero? || @distance.multiplier.zero?
-        return Runby::Distance.new(@distance.uom, 0)
-      end
-      divisor = @time.total_minutes / time.total_minutes / @distance.multiplier
-      distance_covered = Runby::Distance.new(@distance.uom, 1 / divisor)
-      distance_covered
-    end
-
-    private
-
-    def init_from_string(string, distance = '1K')
-      pace = Pace.try_parse(string)
-      if pace[:pace]
-        @time = pace[:pace].time
-        @distance = pace[:pace].distance
-        return
-      end
-      @time = Runby::RunbyTime.new string
-      @distance = Runby::Distance.new distance
-    end
-
-    def init_from_time(time, distance)
-      @time = time
-      @distance = Runby::Distance.new distance
-    end
-  end
-end

data/lib/runby_pace/run_math.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  # An assortment of mathematical functions related to running.
-  class RunMath
-    def self.predict_race_time(race1_distance, race1_time, target_distance)
-      race1_distance = Runby.sanitize(race1_distance).as(Distance)
-      race1_time = Runby.sanitize(race1_time).as(RunbyTime)
-      target_distance = Runby.sanitize(target_distance).as(Distance)
-
-      race1_time * (target_distance / race1_distance)**1.06
-    end
-  end
-end

data/lib/runby_pace/run_types/distance_run.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  module RunTypes
-    # Defines the venerable "distance run", the backbone of any distance running program.
-    #  Most of your runs should be at this pace. Harder than an "easy run" but still conversational.
-    class DistanceRun < RunType
-      attr_reader :slow_pace_calculator, :fast_pace_calculator
-
-      def description
-        'Distance Run'
-      end
-
-      def explanation
-        'Most of your weekly training should be comprised of Distance Runs. They are faster than easy runs, but you should still be able to carry on a conversation.'
-      end
-
-      def initialize
-        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast, 3.675)
-        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow, 2.175)
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_calculator.calc(five_k_time, distance_units)
-        slow = @slow_pace_calculator.calc(five_k_time, distance_units)
-        PaceRange.new(fast, slow)
-      end
-
-      # Used in testing, contains hashes mapping 5K race times with the recommended pace-per-km for this run type.
-      class GoldenPaces
-        def self.fast
-          GoldenPaceSet.new('14:00': '03:44',
-                            '15:00': '03:58',
-                            '20:00': '05:09',
-                            '25:00': '06:18',
-                            '30:00': '07:24',
-                            '35:00': '08:29',
-                            '40:00': '09:33',
-                            '42:00': '09:58')
-        end
-
-        def self.slow
-          GoldenPaceSet.new('14:00': '04:17',
-                            '15:00': '04:33',
-                            '20:00': '05:53',
-                            '25:00': '07:09',
-                            '30:00': '08:23',
-                            '35:00': '09:33',
-                            '40:00': '10:42',
-                            '42:00': '11:10')
-        end
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/fast_tempo_run.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require_relative 'tempo_run'
-
-module Runby
-  module RunTypes
-    # The "fast tempo" pace roughly equates to your half-marathon pace.
-    #  It's a pace you could maintain for about an hour, if pressed.
-    class FastTempoRun < TempoRun
-      def description
-        'Fast Tempo Run'
-      end
-
-      def explanation
-        'The fast tempo run is an interval workout of 15-25 minutes per repetition. The pace roughly corresponds to that of your half-marathon race pace.'
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_calculator.calc(five_k_time, distance_units)
-        PaceRange.new(fast, fast)
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/five_kilometer_race_run.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  module RunTypes
-    # Your 5K race pace, which is also useful for running repetitions at this pace
-    class FiveKilometerRaceRun < RunType
-      def description
-        '5K Race Pace'
-      end
-
-      def explanation
-        'The 5K race (~3.1 miles) is an excellent gauge of overall fitness. Running repetitions of varying duration at 5K race pace can boost stroke volume, blood volume, mitochondrial and capillary density, etc.'
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        five_k_time = RunbyTime.new(five_k_time)
-        pace = Pace.new(five_k_time / 5, '1km').convert_to(distance_units)
-        PaceRange.new(pace, pace)
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/mile_race_run.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  module RunTypes
-    # Your mile race pace, which is also useful for running repetitions at this pace
-    class MileRaceRun < RunType
-      def description
-        'Mile Race Pace'
-      end
-
-      def explanation
-        'Repetitions run at a pace you would use to race one mile can increase the stroke volume of your heart, strengthen your lungs, increase the number of capillaries around your intermediate and fast twitch fibers, and increase mitochondrial densities around the same.'
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        five_k_time = RunbyTime.new(five_k_time)
-        mile = Distance.new('1 mile')
-        mile_time = RunMath.predict_race_time('5K', five_k_time, mile)
-        pace = Pace.new(mile_time, mile).convert_to(distance_units)
-        PaceRange.new(pace, pace)
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/slow_tempo_run.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require_relative 'tempo_run'
-
-module Runby
-  module RunTypes
-    # The "slow tempo" pace roughly equates to your marathon pace.
-    class SlowTempoRun < TempoRun
-      def description
-        'Slow Tempo Run'
-      end
-
-      def explanation
-        'The slow tempo run is an interval workout of 20-40 minutes per repetition. The pace roughly corresponds to that of your marathon race pace.'
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        slow = @slow_pace_calculator.calc(five_k_time, distance_units)
-        PaceRange.new(slow, slow)
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/tempo_run.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  module RunTypes
-    # Combines the fast and slow tempo runs into one convenient range of paces
-    class TempoRun < RunType
-      attr_reader :slow_pace_calculator, :fast_pace_calculator
-
-      def description
-        'Tempo Run'
-      end
-
-      def explanation
-        'Ran at a comfortably hard pace that you could maintain for about an hour, if pressed. However, tempo runs are interval workouts, so you won\'t run for longer than 15-40 minutes per repetition'
-      end
-
-      def initialize
-        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast, 4.025)
-        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow, 3.725)
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_calculator.calc(five_k_time, distance_units)
-        slow = @slow_pace_calculator.calc(five_k_time, distance_units)
-        PaceRange.new(fast, slow)
-      end
-
-      # Used in testing, contains hashes mapping 5K race times with the recommended pace-per-km for this run type.
-      class GoldenPaces
-        def self.fast
-          GoldenPaceSet.new('14:00': '03:07',
-                            '15:00': '03:20',
-                            '20:00': '04:21',
-                            '25:00': '05:20',
-                            '30:00': '06:19',
-                            '35:00': '07:16',
-                            '40:00': '08:12',
-                            '42:00': '08:35')
-        end
-
-        def self.slow
-          GoldenPaceSet.new('14:00': '03:18',
-                            '15:00': '03:31',
-                            '20:00': '04:35',
-                            '25:00': '05:37',
-                            '30:00': '06:38',
-                            '35:00': '07:38',
-                            '40:00': '08:36',
-                            '42:00': '08:59')
-        end
-      end
-    end
-  end
-end

data/lib/runby_pace/run_types/ten_kilometer_race_run.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  module RunTypes
-    # Your 10K race pace, which is also useful for running repetitions at this pace
-    class TenKilometerRaceRun < RunType
-      def description
-        '10K Race Pace'
-      end
-
-      def explanation
-        'Repetitions ran at 10K race pace (10 km is about 6.2 miles) are like 5K pace repetitions, but less intense. They elicit many of the same benefits and help increase speed in races from the 10K to the half-marathon.'
-      end
-
-      def lookup_pace(five_k_time, distance_units = :km)
-        five_k_time = RunbyTime.new(five_k_time)
-        ten_k_time = RunMath.predict_race_time('5K', five_k_time, '10K')
-        pace = Pace.new(ten_k_time / 10, '1km').convert_to(distance_units)
-        PaceRange.new(pace, pace)
-      end
-    end
-  end
-end