calcpace 1.1.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08aafc87c8fa3b75db3dfac8e186f803cbfec584991945e9849648a0d91c7341'
-  data.tar.gz: 886d0b4b83bc2bbc07b3f2dc5d4b3b605459cc15df13a51c22e4ba87f2620ff4
+  metadata.gz: 8d2fca26e59f2126bc2c6912786ea9808f8e73af4bc2860de63c5ab85ccf4b01
+  data.tar.gz: 11907a7faff02d37df75a1db8d2540f114f46afe70bdb6a426ed3ed6f6bd1a81
 SHA512:
-  metadata.gz: 0e3b69e165c445f5c2885c91a8b866020095ba3de87431817eed0d75df2f6f3e65da15cb73205904cff8c3844d590ce3b3edeabdf91cd74f31bbeafe84ac085c
-  data.tar.gz: 311f84fa56b4f5d3bec6e0c16cac2d6650a488828058f169c8bf1f12c410bff8a91c9be667ffd30ed6dcf40a856f5c64a63aa4b9386095f9a0fdbd7c83548844
+  metadata.gz: 451d2883e1b75c140bf5fbd85e9d1ec5b03dc770a471a173a8698ad6243b025736221ea157288c0ad23e5796287db4941f9177dfb3c7130deed50ac0bac6e126
+  data.tar.gz: 7141e05845a0d88fcd52fb50dfef307ab3f8c73bbc8b332108fb3dfd13d4a3294ae3ae93b1eb983b98b2134ec67407aa8ba49659e38b169eddce342381bfd8c0

data/lib/calcpace/calculator.rb

@@ -1,42 +1,52 @@
-# frozen_string_literal: true
-
-require 'bigdecimal'
-
-module Calculator
-  def pace(time, distance, bigdecimal = false)
-    pace_in_seconds = pace_seconds(time, distance, bigdecimal)
-    convert_to_clocktime(pace_in_seconds)
-  end
-
-  def pace_seconds(time, distance, bigdecimal = false)
-    check_time(time)
-    check_distance(distance)
-    seconds = convert_to_seconds(time)
-    bigdecimal ? seconds / BigDecimal(distance.to_s) : seconds / distance
-  end
-
-  def total_time(pace, distance, bigdecimal = false)
-    total_time_in_seconds = total_time_seconds(pace, distance, bigdecimal)
-    convert_to_clocktime(total_time_in_seconds)
-  end
-
-  def total_time_seconds(pace, distance, bigdecimal = false)
-    check_time(pace)
-    check_distance(distance)
-    pace_seconds = convert_to_seconds(pace)
-    bigdecimal ? pace_seconds * BigDecimal(distance.to_s) : pace_seconds * distance
-  end
-
-  def distance(time, pace, bigdecimal = false)
-    check_time(time)
-    check_time(pace)
-    if bigdecimal
-      time_seconds = BigDecimal(convert_to_seconds(time).to_s)
-      pace_seconds = BigDecimal(convert_to_seconds(pace).to_s)
-    else
-      time_seconds = convert_to_seconds(time)
-      pace_seconds = convert_to_seconds(pace)
-    end
-    time_seconds / pace_seconds
-  end
-end
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+# Module to calculate time, distance and velocity
+module Calculator
+  def velocity(time, distance)
+    time / distance
+  end
+
+  def checked_velocity(time, distance)
+    check_time(time)
+    check_positive(distance)
+    distance_to_calc = convert_to_bigdecimal(distance)
+    seconds = convert_to_bigdecimal(convert_to_seconds(time))
+    velocity(seconds, distance_to_calc)
+  end
+
+  def clock_velocity(time, distance)
+    velocity_in_seconds = checked_velocity(time, distance)
+    convert_to_clocktime(velocity_in_seconds)
+  end
+
+  def time(velocity, distance)
+    velocity * distance
+  end
+
+  def checked_time(velocity, distance)
+    check_time(velocity)
+    check_positive(distance)
+    distance_to_calc = convert_to_bigdecimal(distance)
+    velocity_seconds = convert_to_bigdecimal(convert_to_seconds(velocity))
+    time(velocity_seconds, distance_to_calc)
+  end
+
+  def clock_time(velocity, distance)
+    total_time_in_seconds = checked_time(velocity, distance)
+    convert_to_clocktime(total_time_in_seconds)
+  end
+
+  def distance(time, velocity)
+    time / velocity
+  end
+
+  def checked_distance(time, velocity)
+    check_time(time)
+    check_time(velocity)
+    time_seconds = convert_to_bigdecimal(convert_to_seconds(time))
+    velocity_seconds = convert_to_bigdecimal(convert_to_seconds(velocity))
+    distance(time_seconds, velocity_seconds)
+  end
+end

data/lib/calcpace/checker.rb

@@ -1,19 +1,12 @@
-# frozen_string_literal: true
-
-module Checker
-  def check_distance(distance)
-    raise 'It must be a X.X positive number' unless distance.positive?
-  end
-
-  def check_time(time_string)
-    raise 'It must be a XX:XX:XX time' unless time_string =~ /\d{0,2}(:)*?\d{1,2}(:)\d{1,2}/
-  end
-
-  def check_integer(second)
-    raise 'It must be a positive number' unless second.is_a?(Integer) && second.positive?
-  end
-
-  def check_unit(unit)
-    raise 'It must be km or mi' unless %w[km mi].include?(unit)
-  end
-end
+# frozen_string_literal: true
+
+# Module to check if the input is valid
+module Checker
+  def check_positive(number)
+    raise 'It must be a X.X positive number' unless number.positive?
+  end
+
+  def check_time(time_string)
+    raise 'It must be a XX:XX:XX time' unless time_string =~ /\d{0,2}(:)*?\d{1,2}(:)\d{1,2}/
+  end
+end

data/lib/calcpace/converter.rb

@@ -2,25 +2,42 @@
 
 require 'bigdecimal'
 
+# Module to convert units
 module Converter
-  KM_TO_MI = BigDecimal('0.621371')
-  MI_TO_KM = BigDecimal('1.60934')
+  KM_TO_MI = 0.621371
+  MI_TO_KM = 1.60934
+  NAUTICAL_MI_TO_KM = 1.852
+  KM_TO_NAUTICAL_MI = 0.539957
+  METERS_TO_KM = 0.001
+  KM_TO_METERS = 1000
+  METERS_TO_MI = 0.000621371
+  MI_TO_METERS = 1609.34
+  METERS_TO_FEET = 3.28084
+  FEET_TO_METERS = 0.3048
+  METERS_TO_YARDS = 1.09361
+  YARDS_TO_METERS = 0.9144
+  METERS_TO_INCHES = 39.3701
+  INCHES_TO_METERS = 0.0254
 
-  def to_seconds(time)
-    check_time(time)
-    convert_to_seconds(time)
-  end
-
-  def to_clocktime(seconds)
-    check_integer(seconds)
-    convert_to_clocktime(seconds)
-  end
+  M_S_TO_KM_H = 3.6
+  KM_H_TO_M_S = 0.277778
+  M_S_TO_MI_H = 2.23694
+  MI_H_TO_M_S = 0.44704
+  M_S_TO_NAUTICAL_MI_H = 1.94384
+  NAUTICAL_MI_H_TO_M_S = 0.514444
+  M_S_TO_FEET_S = 3.28084
+  FEET_S_TO_M_S = 0.3048
+  M_S_TO_KNOTS = 1.94384
+  KNOTS_TO_M_S = 0.514444
+  KM_H_TO_MI_H = 0.621371
+  MI_H_TO_KM_H = 1.60934
 
-  def convert(distance, unit, round_limit = 2)
-    check_distance(distance)
-    check_unit(unit)
-    check_integer(round_limit)
-    convert_the_distance(BigDecimal(distance.to_s), unit, round_limit)
+  def convert(value, unit)
+    check_positive(value)
+    unit_constant = constant(unit)
+    value_to_convert = convert_to_bigdecimal(value)
+    unit_to_convert = convert_to_bigdecimal(unit_constant)
+    value_to_convert * unit_to_convert
   end
 
   def convert_to_seconds(time)
@@ -33,12 +50,15 @@ module Converter
     Time.at(seconds.to_i).utc.strftime(format)
   end
 
-  def convert_the_distance(distance, unit, round_limit = 2)
-    case unit
-    when 'km'
-      (distance * KM_TO_MI).round(round_limit)
-    when 'mi'
-      (distance * MI_TO_KM).round(round_limit)
-    end
+  def convert_to_bigdecimal(value)
+    bigdecimal ? BigDecimal(value.to_s) : value
+  end
+
+  def constant(string)
+    Converter.const_get(string.upcase.gsub(' ', '_'))
+  end
+
+  def list_constants
+    Converter.constants
   end
 end

data/lib/calcpace.rb

@@ -1,13 +1,18 @@
-# frozen_string_literal: true
-
-require_relative 'calcpace/calculator'
-require_relative 'calcpace/checker'
-require_relative 'calcpace/converter'
-
-class Calcpace
-  include Calculator
-  include Checker
-  include Converter
-
-  def initialize; end
-end
+# frozen_string_literal: true
+
+require_relative 'calcpace/calculator'
+require_relative 'calcpace/checker'
+require_relative 'calcpace/converter'
+
+# Main class to calculate velocity, time, distance and velocity
+class Calcpace
+  include Calculator
+  include Checker
+  include Converter
+
+  attr_reader :bigdecimal
+
+  def initialize(bigdecimal = false)
+    @bigdecimal = bigdecimal
+  end
+end

data/test/calcpace/test_calculator.rb

@@ -7,62 +7,77 @@ require_relative '../../lib/calcpace'
 class TestCalculator < Minitest::Test
   def setup
     @checker = Calcpace.new
+    @checker_bigdecimal = Calcpace.new(true)
   end
 
-  def test_pace
-    assert_raises(RuntimeError) { @checker.pace('', 10) }
-    assert_raises(RuntimeError) { @checker.pace('invalid', 10) }
-    assert_raises(RuntimeError) { @checker.pace('00:00:00', 0) }
-    assert_raises(RuntimeError) { @checker.pace('00:00:00', -1) }
-    assert_equal '00:06:00', @checker.pace('01:00:00', 10)
-    assert_equal '00:07:54', @checker.pace('01:37:21', 12.3)
+  def test_velocity
+    assert_equal 300, @checker.velocity(3600, 12)
+    assert_equal 122.81076923076924, @checker.velocity(71_844.3, 585.0)
   end
 
-  def test_pace_without_bigdecimal_precision
-    assert_equal '00:07:54', @checker.pace('01:37:21', 12.3, false)
+  def test_checked_velocity
+    assert_raises(RuntimeError) { @checker.checked_velocity('', 10) }
+    assert_raises(RuntimeError) { @checker.checked_velocity('invalid', 10) }
+    assert_raises(RuntimeError) { @checker.checked_velocity('00:00:00', 0) }
+    assert_raises(RuntimeError) { @checker.checked_velocity('00:00:00', -1) }
+    assert_equal 360, @checker.checked_velocity('01:00:00', 10)
+    assert_equal 474.8780487804878, @checker.checked_velocity('01:37:21', 12.3)
   end
 
-  def test_pace_seconds
-    assert_raises(RuntimeError) { @checker.pace_seconds('', 10) }
-    assert_raises(RuntimeError) { @checker.pace_seconds('invalid', 10) }
-    assert_raises(RuntimeError) { @checker.pace_seconds('00:00:00', 0) }
-    assert_raises(RuntimeError) { @checker.pace_seconds('00:00:00', -1) }
-    assert_equal BigDecimal('474.8780487804878'), @checker.pace_seconds('01:37:21', 12.3)
+  def test_checked_velocity_with_bigdecimal_precision
+    assert_equal BigDecimal('0.474878048780487804878048780487804878049e3'),
+                 @checker_bigdecimal.checked_velocity('01:37:21', 12.3)
   end
 
-  def test_pace_seconds_with_bigdecimal_precision
-    assert_equal BigDecimal('0.474878048780487804878048780487804878049e3'), @checker.pace_seconds('01:37:21', 12.3, true)
+  def test_clock_velocity
+    assert_raises(RuntimeError) { @checker.clock_velocity('', 10) }
+    assert_raises(RuntimeError) { @checker.clock_velocity('invalid', 10) }
+    assert_raises(RuntimeError) { @checker.clock_velocity('00:00:00', 0) }
+    assert_raises(RuntimeError) { @checker.clock_velocity('00:00:00', -1) }
+    assert_equal '00:06:00', @checker.clock_velocity('01:00:00', 10)
+    assert_equal '00:07:54', @checker.clock_velocity('01:37:21', 12.3)
   end
 
-  def test_total_time
-    assert_raises(RuntimeError) { @checker.total_time('', 10) }
-    assert_raises(RuntimeError) { @checker.total_time('invalid', 10) }
-    assert_raises(RuntimeError) { @checker.total_time('00:00:00', 0) }
-    assert_raises(RuntimeError) { @checker.total_time('00:00:00', -1) }
-    assert_equal '01:00:00', @checker.total_time('00:05:00', 12)
+  def test_time
+    assert_equal 43_200, @checker.time(3600, 12)
+    assert_equal 5841.0, @checker.time(12.3, 474.8780487804878)
   end
 
-  def test_total_time_seconds
-    assert_raises(RuntimeError) { @checker.total_time_seconds('', 10) }
-    assert_raises(RuntimeError) { @checker.total_time_seconds('invalid', 10) }
-    assert_raises(RuntimeError) { @checker.total_time_seconds('00:00:00', 0) }
-    assert_raises(RuntimeError) { @checker.total_time_seconds('00:00:00', -1) }
-    assert_equal 3600, @checker.total_time_seconds('00:05:00', 12)
-    assert_equal 71_844.3, @checker.total_time_seconds('01:37:21', 12.3)
+  def test_checked_time
+    assert_raises(RuntimeError) { @checker.checked_time('', 10) }
+    assert_raises(RuntimeError) { @checker.checked_time('invalid', 10) }
+    assert_raises(RuntimeError) { @checker.checked_time('00:00:00', 0) }
+    assert_raises(RuntimeError) { @checker.checked_time('00:00:00', -1) }
+    assert_equal 3600, @checker.checked_time('00:05:00', 12)
+    assert_equal 71_844.3, @checker.checked_time('01:37:21', 12.3)
   end
 
-  def test_total_time_seconds_with_bigdecimal_precision
-    assert_equal BigDecimal('0.718443e5'), @checker.total_time_seconds('01:37:21', 12.3, true)
+  def test_checked_time_with_bigdecimal_precision
+    assert_equal BigDecimal('0.718443e5'), @checker_bigdecimal.checked_time('01:37:21', 12.3)
+  end
+
+  def test_clock_time
+    assert_raises(RuntimeError) { @checker.clock_time('', 10) }
+    assert_raises(RuntimeError) { @checker.clock_time('invalid', 10) }
+    assert_raises(RuntimeError) { @checker.clock_time('00:00:00', 0) }
+    assert_raises(RuntimeError) { @checker.clock_time('00:00:00', -1) }
+    assert_equal '01:00:00', @checker.clock_time('00:05:00', 12)
   end
 
   def test_distance
-    assert_raises(RuntimeError) { @checker.distance('', '00:05:00') }
-    assert_raises(RuntimeError) { @checker.distance('01:00:00', '') }
-    assert_equal 18.0, @checker.distance('01:30:00', '00:05:00')
-    assert_equal 15.0, @checker.distance('01:37:21', '00:06:17')
+    assert_equal 30, @checker.distance(3600, 120)
+    assert_equal 12.3, @checker.distance(5841.0, 474.8780487804878)
+  end
+
+  def test_checked_distance
+    assert_raises(RuntimeError) { @checker.checked_distance('', '00:05:00') }
+    assert_raises(RuntimeError) { @checker.checked_distance('01:00:00', '') }
+    assert_equal 18.0, @checker.checked_distance('01:30:00', '00:05:00')
+    assert_equal 15.0, @checker.checked_distance('01:37:21', '00:06:17')
   end
 
-  def test_distance_with_bigdecimal_precision
-    assert_equal BigDecimal('0.15493368700265251989389920424403183024e2'), @checker.distance('01:37:21', '00:06:17', true)
+  def test_checked_distance_with_bigdecimal_precision
+    assert_equal BigDecimal('0.15493368700265251989389920424403183024e2'),
+                 @checker_bigdecimal.checked_distance('01:37:21', '00:06:17')
   end
 end

data/test/calcpace/test_checker.rb

@@ -1,27 +1,21 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require_relative '../../lib/calcpace'
-
-class TestChecker < Minitest::Test
-  def setup
-    @checker = Calcpace.new
-  end
-
-  def test_check_distance
-    assert_raises(RuntimeError) { @checker.check_distance(-1) }
-    assert_raises(RuntimeError) { @checker.check_distance(0) }
-    assert_nil @checker.check_distance(1)
-  end
-
-  def test_check_time
-    assert_raises(RuntimeError) { @checker.check_time('') }
-    assert_nil @checker.check_time('00:00:00')
-  end
-
-  def test_check_integer
-    assert_raises(RuntimeError) { @checker.check_integer(-1) }
-    assert_raises(RuntimeError) { @checker.check_integer(0) }
-    assert_nil @checker.check_integer(1)
-  end
-end
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../lib/calcpace'
+
+class TestChecker < Minitest::Test
+  def setup
+    @checker = Calcpace.new
+  end
+
+  def test_check_positive
+    assert_raises(RuntimeError) { @checker.check_positive(-1) }
+    assert_raises(RuntimeError) { @checker.check_positive(0) }
+    assert_nil @checker.check_positive(1)
+  end
+
+  def test_check_time
+    assert_raises(RuntimeError) { @checker.check_time('') }
+    assert_nil @checker.check_time('00:00:00')
+  end
+end

data/test/calcpace/test_converter.rb

@@ -6,44 +6,54 @@ require_relative '../../lib/calcpace'
 class TestConverter < Minitest::Test
   def setup
     @checker = Calcpace.new
+    @checker_bigdecimal = Calcpace.new(true)
   end
 
   def test_convert_to_seconds
     assert_equal 4262, @checker.convert_to_seconds('01:11:02')
   end
 
-  def test_to_seconds
-    assert_equal 3600, @checker.to_seconds('01:00:00')
-    assert_raises(RuntimeError) { @checker.to_seconds('invalid') }
-  end
-
   def test_convert_to_clocktime
     assert_equal '01:11:02', @checker.convert_to_clocktime(4262)
   end
 
-  def test_to_clocktime
-    assert_equal '01:00:00', @checker.to_clocktime(3600)
-    assert_equal '02 01:00:00', @checker.to_clocktime(90_000)
-    assert_raises(RuntimeError) { @checker.to_clocktime(-1) }
-    assert_raises(RuntimeError) { @checker.to_clocktime(0) }
-    assert_raises(RuntimeError) { @checker.to_clocktime('invalid') }
+  def test_convert_distance
+    assert_equal 0.621371, @checker.convert(1, 'KM_TO_MI')
+    assert_equal 1.60934, @checker.convert(1, 'MI_TO_KM')
+    assert_equal 1.852, @checker.convert(1, 'NAUTICAL_MI_TO_KM')
+    assert_equal 0.539957, @checker.convert(1, 'KM_TO_NAUTICAL_MI')
+    assert_equal 0.001, @checker.convert(1, 'METERS_TO_KM')
+    assert_equal 1000, @checker.convert(1, 'KM_TO_METERS')
+    assert_equal 0.000621371, @checker.convert(1, 'METERS_TO_MI')
+    assert_equal 1609.34, @checker.convert(1, 'MI_TO_METERS')
+    assert_equal 3.28084, @checker.convert(1, 'METERS_TO_FEET')
+    assert_equal 0.3048, @checker.convert(1, 'FEET_TO_METERS')
+    assert_equal 1.09361, @checker.convert(1, 'METERS_TO_YARDS')
+    assert_equal 0.9144, @checker.convert(1, 'YARDS_TO_METERS')
+    assert_equal 39.3701, @checker.convert(1, 'METERS_TO_INCHES')
+    assert_equal 0.0254, @checker.convert(1, 'INCHES_TO_METERS')
+  end
+
+  def test_convert_velocity
+    assert_equal 3.60, @checker.convert(1, 'M_S_TO_KM_H')
+    assert_equal 0.277778, @checker.convert(1, 'KM_H_TO_M_S')
+    assert_equal 2.23694, @checker.convert(1, 'M_S_TO_MI_H')
+    assert_equal 0.44704, @checker.convert(1, 'MI_H_TO_M_S')
+    assert_equal 1.94384, @checker.convert(1, 'M_S_TO_NAUTICAL_MI_H')
+    assert_equal 0.514444, @checker.convert(1, 'NAUTICAL_MI_H_TO_M_S')
+    assert_equal 0.621371, @checker.convert(1, 'KM_H_TO_MI_H')
+    assert_equal 1.60934, @checker.convert(1, 'MI_H_TO_KM_H')
+    assert_equal 1.94384, @checker.convert(1, 'M_S_TO_KNOTS')
+    assert_equal 0.514444, @checker.convert(1, 'KNOTS_TO_M_S')
   end
 
-  def test_convert_the_distance
-    assert_equal 6.21, @checker.convert_the_distance(10, 'km')
-    assert_equal 6.2, @checker.convert_the_distance(10, 'km', 1)
-    assert_equal 6.214, @checker.convert_the_distance(10, 'km', 3)
-    assert_equal 16.09, @checker.convert_the_distance(10, 'mi')
+  def test_constant
+    assert_equal 0.621371, @checker.constant('KM_TO_MI')
+    assert_equal 1.60934, @checker.constant('MI_TO_KM')
+    assert_equal 1.852, @checker.constant('NAUTICAL_MI_TO_KM')
   end
 
-  def test_convert
-    assert_equal 6.21, @checker.convert(10, 'km')
-    assert_equal 16.09, @checker.convert(10, 'mi')
-    assert_equal 6.2, @checker.convert(10, 'km', 1)
-    assert_raises(RuntimeError) { @checker.convert(10, 'invalid') }
-    assert_raises(RuntimeError) { @checker.convert(-1, 'km') }
-    assert_raises(RuntimeError) { @checker.convert(10, 'km', -2) }
-    assert_raises(RuntimeError) { @checker.convert(10, 'km', 0) }
-    assert_raises(RuntimeError) { @checker.convert(10, 'km', 'invalid') }
+  def test_list_constants
+    assert_equal 26, @checker.list_constants.size
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calcpace
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Joao Gilberto Saraiva
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-21 00:00:00.000000000 Z
+date: 2024-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -72,34 +72,17 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.79'
+        version: '1.66'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.79'
-- !ruby/object:Gem::Dependency
-  name: rubocop-minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-description: 'Calcpace is a Ruby gem that helps with calculations related to running/cycling
-  activities or general purposes involving distance and time. It can calculate pace,
-  total time, and distance. It also converts distances between miles and kilometers
-  and check formats of time and distance. The results are provided in a readable format,
-  with times in HH:MM:SS or seconds and distances in X.X format. If you need, the
-  gem supports BigDecimal to handle the calculations, '
+        version: '1.66'
+description: Calcpace is a Ruby gem that helps with calculations related to distance
+  and time. It can calculate velocity, total time, and distance. It also converts
+  distance and velocity, check formats of time and can handle calculus with BigDecimal.
 email: joaogilberto@tuta.io
 executables: []
 extensions: []
@@ -133,10 +116,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.16
-signing_key: 
+signing_key:
 specification_version: 4
-summary: 'Calcpace: calculate time, distance, pace, velocity and convert distances
-  in an easy and precise way.'
+summary: 'Calcpace: calculate total, distance, velocity and convert distances in an
+  easy and precise way.'
 test_files:
 - test/calcpace/test_calculator.rb
 - test/calcpace/test_checker.rb