runby_pace 0.6.91 → 0.6.94

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjdhNDYyNjQzZmE3ZTQzNDU3MTlhMmIzYWY0OTgxMWUwNmJlMTJlZA==
+    ZmNhZWE5YjE0YmI5MzQxZGUxNDBjZjk0MWRiNzRkYmViYTY1ZTJkMg==
   data.tar.gz: !binary |-
-    Y2IyYWI4MTNlMTVkNDdkOGM2NTI2YjljMzEyMzgzNjNlNmM4NzkyYQ==
+    YmUzY2JjOWQ4YWRlZTlhYWRiMjZiMDU0YTFjNDVmNWExYmQwOTE5MQ==
 SHA512:
   metadata.gz: !binary |-
-    NDg2MDRkMjAzN2MyY2ZhZjk2ODFjZjBlMGMxOGEyNjViNjM2YWFhOWM0Njcz
-    OTY5ODljYjY4NzUzMmI1MWViZWE5ZDg3MzUzNGE2MTNmZTI2MjdkYTY0Y2Vm
-    Yzg4MDM3MDAxMWE1NTk1YjQ2MGI4ZjczZTM5MWYxN2NiYWVmMDk=
+    YWY1NTBhOGU1M2FiOTA0ZTliM2E5YjUwM2MxZWQwNjgzMGNmYjBjNWM5YzIw
+    Mjc3NTFiOGM3YzVjYzMzOTg5NmZjNjZmODUxYzIwYWU1NmZkYTkxYTcyNGU1
+    NWVjMzg3NGZjNGJmMGMxMzMxYjlkYzYwMWRhNjkwZWYxMzVkM2Q=
   data.tar.gz: !binary |-
-    NzE0ZDFmNjM3NWRlMjQzNWNhZjIyMDJiNGEwZTU4ZGQzMWViNjhiM2U0NmFi
-    N2QwOGI5ODA1OGQ2ZmM1OTNkMDYyZTJkZWI2NWI4NTNhNjhjOGNlNTUwODFh
-    NTJiYjZjYTBlYjRkYjUwMGViYTMzZDhjMmMwN2FmZTBmZWQxZTU=
+    MDQ4ZmYwYTU2ZTI3ZGE3YzkxZjlhZGIwNjY5ZGRjNDU4M2FmMWVhNzFhYmI4
+    YTA0ZTc0ODYwZTBhMDFiMWY0ZjkwZjI1Y2IzMmE3Mzg4NmMxZTU3M2Q4ZDBk
+    ZjQ3ZTE0NGNiODM4ZDlhM2VkMTIxYmY0NTg2ZjNkZDgzNzA0Y2U=

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

@@ -1,6 +1,6 @@
 module Runby
   # Encapsulates the algorithms used to calculate target paces.
-  class PaceData
+  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.

data/lib/runby_pace/run_type.rb

@@ -5,7 +5,7 @@ module Runby
       'No description'
     end
 
-    def pace(five_k_time, distance_units = :km)
+    def lookup_pace(five_k_time, distance_units = :km)
     end
   end
 

data/lib/runby_pace/run_types/distance_run.rb

@@ -3,20 +3,20 @@ module Runby
     # 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_data, :fast_pace_data
+      attr_reader :slow_pace_calculator, :fast_pace_calculator
 
       def description
         'Distance Run'
       end
 
       def initialize
-        @fast_pace_data = PaceData.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 3.675)
-        @slow_pace_data = PaceData.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 2.175)
+        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 3.675)
+        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 2.175)
       end
 
-      def pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_data.calc(five_k_time, distance_units)
-        slow = @slow_pace_data.calc(five_k_time, distance_units)
+      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
 

data/lib/runby_pace/run_types/easy_run.rb

@@ -2,20 +2,20 @@ module Runby
   module RunTypes
     # An easy run is basically a jog. It should be conversational.
     class EasyRun < RunType
-      attr_reader :slow_pace_data, :fast_pace_data
+      attr_reader :slow_pace_calculator, :fast_pace_calculator
 
       def description
         'Easy Run'
       end
 
       def initialize
-        @fast_pace_data = PaceData.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 1.99)
-        @slow_pace_data = PaceData.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 1.35)
+        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 1.99)
+        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 1.35)
       end
 
-      def pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_data.calc(five_k_time, distance_units)
-        slow = @slow_pace_data.calc(five_k_time, distance_units)
+      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
 

data/lib/runby_pace/run_types/fast_tempo_run.rb

@@ -9,8 +9,8 @@ module Runby
         'Fast Tempo Run'
       end
 
-      def pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_data.calc(five_k_time, distance_units)
+      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

data/lib/runby_pace/run_types/find_divisor.rb

@@ -3,8 +3,8 @@ module Runby
   module RunTypes
     # Currently, to find the radius of the curve in the pace table data for a given run time,
     #   we start with a radius equal to that of the midpoint of the X axis for the data when
-    #   plotted on a graph. Then we use a radius divisor for the PaceData for each run type to
-    #   dial in the height of the curve. (See Runby::PaceData)
+    #   plotted on a graph. Then we use a radius divisor for the PaceCalculator for each run type to
+    #   dial in the height of the curve. (See Runby::PaceCalculator)
     # This method, #find_divisor, accepts a hash of "golden paces" for a run type along with
     #   the number of seconds of allowable deviation from the golden pace. Then it proceeds
     #   to brute force the divisor.
@@ -21,7 +21,7 @@ module Runby
 
         golden_paces.each do |five_k, golden_pace|
           five_k_time = Runby::RunbyTime.new(five_k.to_s)
-          pace_data = Runby::PaceData.new(first_pace, last_pace, candidate_divisor)
+          pace_data = Runby::PaceCalculator.new(first_pace, last_pace, candidate_divisor)
           calculated_pace = pace_data.calc(five_k_time)
           unless calculated_pace.time.almost_equals?(golden_pace, allowable_deviation)
             viable_divisor = nil

data/lib/runby_pace/run_types/long_run.rb

@@ -3,20 +3,20 @@ module Runby
     # Arguably one of the most important run types, the "long run" is harder than an "easy run", but easier than
     #  a "distance run". It should remain conversational.
     class LongRun < RunType
-      attr_reader :slow_pace_data, :fast_pace_data
+      attr_reader :slow_pace_calculator, :fast_pace_calculator
 
       def description
         'Long Run'
       end
 
       def initialize
-        @fast_pace_data = PaceData.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 2.125)
-        @slow_pace_data = PaceData.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 1.55)
+        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 2.125)
+        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 1.55)
       end
 
-      def pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_data.calc(five_k_time, distance_units)
-        slow = @slow_pace_data.calc(five_k_time, distance_units)
+      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
 

data/lib/runby_pace/run_types/slow_tempo_run.rb

@@ -8,8 +8,8 @@ module Runby
         'Slow Tempo Run'
       end
 
-      def pace(five_k_time, distance_units = :km)
-        slow = @slow_pace_data.calc(five_k_time, distance_units)
+      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

data/lib/runby_pace/run_types/tempo_run.rb

@@ -2,20 +2,20 @@ module Runby
   module RunTypes
     # Combines the fast and slow tempo runs into one convenient range of paces
     class TempoRun < RunType
-      attr_reader :slow_pace_data, :fast_pace_data
+      attr_reader :slow_pace_calculator, :fast_pace_calculator
 
       def description
         'Tempo Run'
       end
 
       def initialize
-        @fast_pace_data = PaceData.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 4.025)
-        @slow_pace_data = PaceData.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 3.725)
+        @fast_pace_calculator = PaceCalculator.new(GoldenPaces.fast[:'14:00'], GoldenPaces.fast[:'42:00'], 4.025)
+        @slow_pace_calculator = PaceCalculator.new(GoldenPaces.slow[:'14:00'], GoldenPaces.slow[:'42:00'], 3.725)
       end
 
-      def pace(five_k_time, distance_units = :km)
-        fast = @fast_pace_data.calc(five_k_time, distance_units)
-        slow = @slow_pace_data.calc(five_k_time, distance_units)
+      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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: runby_pace
 version: !ruby/object:Gem::Version
-  version: 0.6.91
+  version: 0.6.94
 platform: ruby
 authors:
 - Ty Walls
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-26 00:00:00.000000000 Z
+date: 2016-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,7 +76,7 @@ files:
 - lib/runby_pace/distance.rb
 - lib/runby_pace/distance_unit.rb
 - lib/runby_pace/pace.rb
-- lib/runby_pace/pace_data.rb
+- lib/runby_pace/pace_calculator.rb
 - lib/runby_pace/pace_range.rb
 - lib/runby_pace/run_math.rb
 - lib/runby_pace/run_type.rb
@@ -99,7 +99,7 @@ homepage: https://github.com/tygerbytes/runby-pace
 licenses:
 - MIT
 metadata:
-  commit-hash: bca3bf3dde2a647c39066155a2eaba08968521ce
+  commit-hash: 4801763d3e46a9ae2f309aa80b8c1d9d7a074e15
 post_install_message: 
 rdoc_options: []
 require_paths: