calcpace 1.5.2 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1bc217d0029f20e144635be812ef1b066fff104893544e053b9dda9db8c8e56
-  data.tar.gz: fffcb173e7b4e93682f24841f13ef82dd88c9b11d3183aec637d643707373f21
+  metadata.gz: 522046fd25c06347010dd5eaafafead682c8f112b559e0d6932cad8131170441
+  data.tar.gz: 20b0c9a3a1fb855bedfcac50463ef223ae200466404901207a9c082b4e54eb8c
 SHA512:
-  metadata.gz: 1dd3e2ecabae55b31d08cf43a4ab562043947dbf00ed957e3801f7375df737f629f98d17469a0fc08864df48e4e06b2bd95d453f96df13adfdee02048413ee43
-  data.tar.gz: 53f464b531373402629a67ee9b415a26fcd0a51a64224fe60c25c82164c657d9efadd2df2bc2421cd9b466329eb1dc9ccfb8886c6a65ce1f6f77e8473dfa8d10
+  metadata.gz: 1b4bf0d96394bff3711b5691499e4719e8f57fec6850ad96a87376bd339e5b478b645e827acda80be8cc1aa48b40b642e53aa8cdc050f308dda2a5c7b0d38a29
+  data.tar.gz: be6fd9bd85c4b20c479f57d2637342dce116bc24c2fc0a5f867b5cd0a014e4534875e4d1ef29fd29aacb3cf0e06d564bc81f06171ced58a3aa9a850ef6e55b7f

data/.github/workflows/tests.yml

@@ -0,0 +1,28 @@
+name: Tests
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4']
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Install Bundler
+      run: gem install bundler
+    - name: Build Gem
+      run: gem build calcpace.gemspec
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,2 @@
+calcpace-*
+calcpace.*

data/.ruby-version

@@ -0,0 +1 @@
+3.4.2

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'minitest', '~> 5.25'
+gem 'rake', '~> 13.2'
+gem 'rake-compiler', '~> 1.0'
+gem 'rdoc', '~> 6.2'
+gem 'rubocop', '~> 1.69'

data/Gemfile.lock

@@ -0,0 +1,55 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    date (3.4.1)
+    json (2.10.2)
+    language_server-protocol (3.17.0.4)
+    lint_roller (1.1.0)
+    minitest (5.25.4)
+    parallel (1.26.3)
+    parser (3.3.7.1)
+      ast (~> 2.4.1)
+      racc
+    psych (5.2.3)
+      date
+      stringio
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    rake-compiler (1.2.9)
+      rake
+    rdoc (6.12.0)
+      psych (>= 4.0.0)
+    regexp_parser (2.10.0)
+    rubocop (1.73.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.38.1)
+      parser (>= 3.3.1.0)
+    ruby-progressbar (1.13.0)
+    stringio (3.1.5)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.25)
+  rake (~> 13.2)
+  rake-compiler (~> 1.0)
+  rdoc (~> 6.2)
+  rubocop (~> 1.69)
+
+BUNDLED WITH
+   2.4.22

data/README.md

@@ -0,0 +1,182 @@
+# Calcpace [![Gem Version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=rb&r=r&ts=1683906897&type=6e&v=1.5.4&x2=0)](https://badge.fury.io/rb/calcpace)
+
+Calcpace is a Ruby gem designed for calculations and conversions related to distance and time. It can calculate velocity, pace, total time, and distance, accepting time in various formats, including HH:MM:SS. The gem supports conversion to 42 different units, including kilometers, miles, meters, and feet. It also provides methods to validate input.
+
+## Installation
+
+### Add to your Gemfile
+
+```ruby
+gem 'calcpace', '~> 1.5.4'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+### Install the gem manually
+
+```bash
+gem install calcpace
+```
+
+## Usage
+
+Before performing any calculations or conversions, create a new instance of Calcpace:
+
+```ruby
+require 'calcpace'
+
+calculate = Calcpace.new
+```
+
+### Calculate using Integers or Floats
+
+Calcpace provides methods to calculate velocity, pace, total time, and distance. The methods are unit-agnostic, and the return value is a float. Here are some examples:
+
+```ruby
+calculate.velocity(3625, 12275) # => 3.386206896551724
+calculate.pace(3665, 12) # => 305.4166666666667
+calculate.time(210, 12) # => 2520.0
+calculate.distance(9660, 120) # => 80.5
+```
+
+Tip: Use the `round` method to round a float. For example:
+
+```ruby
+calculate.velocity(3625, 12275).round(3) # => 3.386
+```
+
+Remember:
+
+- Velocity is the distance divided by the time (e.g., m/s or km/h).
+- Pace is the time divided by the distance (e.g., minutes/km or minutes/miles).
+- Total time is the distance divided by the velocity.
+- Distance is the velocity multiplied by the time.
+
+### Calculate using Clocktime
+
+Calcpace also provides methods to calculate using clocktime (HH:MM:SS or MM:SS format string). The return value will be in seconds or clocktime, depending on the method called, except for `checked_distance`. Here are some examples:
+
+```ruby
+# The return will be in the unit you input/seconds or seconds/unit you input
+calculate.checked_velocity('01:00:00', 12275) # => 3.4097222222222223
+calculate.checked_pace('01:21:32', 10) # => 489.2
+calculate.checked_time('00:05:31', 12.6) # => 4170.599999999999
+
+calculate.checked_distance('01:21:32', '00:06:27') # => 12.640826873385013
+
+# The return will be in clocktime
+calculate.clock_pace('01:21:32', 10) # => "00:08:09"
+calculate.clock_velocity('01:00:00', 10317) # => "00:00:02"
+calculate.clock_time('00:05:31', 12.6) # => "01:09:30"
+```
+
+Note: Using the `clock` methods may be less precise than using other methods due to conversions.
+
+You can also use BigDecimal for more precise calculations. For example:
+
+```ruby
+require 'bigdecimal'
+calculate.checked_velocity('10:00:00', 10317).to_d # => #<BigDecimal:7f9f1b8b1d08,'0.2865833333 333333E1',27(36)>
+```
+
+To learn more about BigDecimal, check the [documentation](https://ruby-doc.org/stdlib-2.7.1/libdoc/bigdecimal/rdoc/BigDecimal.html).
+
+### Convert Distances and Velocities
+
+Use the `convert` method to convert a distance or velocity. The first parameter is the value to be converted, and the second parameter is the unit to which the value will be converted. The unit must be a string with the abbreviation of the unit. The gem supports 26 different units, including kilometers, miles, meters, knots, and feet.
+
+Here are some examples:
+
+```ruby
+converter.convert(10, :km_to_meters) # => 1000
+converter.convert(10, :mi_to_km) # => 16.0934
+converter.convert(1, :nautical_mi_to_km) # => 1.852
+converter.convert(1, :km_h_to_m_s) # => 0.277778
+converter.convert(1, :m_s_to_mi_h) # => 2.23694
+```
+
+| Conversion Unit      | Description                 |
+|----------------------|-----------------------------|
+| :km_to_mi            | Kilometers to Miles         |
+| :mi_to_km            | Miles to Kilometers         |
+| :nautical_mi_to_km   | Nautical Miles to Kilometers |
+| :km_to_nautical_mi   | Kilometers to Nautical Miles |
+| :meters_to_km        | Meters to Kilometers        |
+| :km_to_meters        | Kilometers to Meters        |
+| :meters_to_mi        | Meters to Miles             |
+| :mi_to_meters        | Miles to Meters             |
+| :m_s_to_km_h         | Meters per Second to Kilometers per Hour    |
+| :km_h_to_m_s         | Kilometers per Hour to Meters per Second    |
+| :m_s_to_mi_h         | Meters per Second to Miles per Hour    |
+| :mi_h_to_m_s         | Miles per Hour to Meters per Second    |
+| :m_s_to_feet_s       | Meters per Second to Feet per Second    |
+| :feet_s_to_m_s       | Feet per Second to Meters per Second    |
+| :km_h_to_mi_h        | Kilometers per Hour to Miles per Hour    |
+| :mi_h_to_km_h        | Miles per Hour to Kilometers per Hour    |
+
+You can list all the available units [here](/lib/calcpace/converter.rb), or using `list` methods:
+
+```ruby
+converter.list_all
+converter.list_distance
+converter.list_speed
+```
+
+### Other Useful Methods
+
+Calcpace also provides other useful methods:
+
+```ruby
+converter = Calcpace.new
+converter.convert_to_seconds('01:00:00') # => 3600
+converter.convert_to_clocktime(3600) # => '01:00:00'
+converter.converto_to_clocktime(100000) # => '1 03:46:40'
+converter.check_time('01:00:00') # => nil
+```
+
+### Errors
+
+The gem now raises specific custom error classes for invalid inputs, allowing for more precise error handling. These errors inherit from `Calcpace::Error`.
+
+- `Calcpace::NonPositiveInputError`: Raised when a numeric input is not positive.
+- `Calcpace::InvalidTimeFormatError`: Raised when a time string is not in the expected `HH:MM:SS` or `MM:SS` format.
+
+For example:
+
+```ruby
+begin
+  calculate.pace(945, -1)
+rescue Calcpace::NonPositiveInputError => e
+  puts e.message # => "Input must be a positive number"
+end
+
+begin
+  calculate.checked_time('string', 10)
+rescue Calcpace::InvalidTimeFormatError => e
+  puts e.message # => "It must be a valid time in the XX:XX:XX or XX:XX format"
+end
+```
+
+### Testing
+
+To run the tests, clone the repository and run:
+
+```bash
+bundle exec rake
+```
+
+### Supported Ruby Versions
+
+The tests are run using Ruby versions from 2.7.8 to 3.4.2, as specified in the `.github/workflows/test.yml` file.
+
+## Contributing
+
+We welcome contributions to Calcpace! To contribute, clone this repository and submit a pull request. Please ensure that your code adheres to our style and includes tests where appropriate.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'minitest/test_task'
+
+Minitest::TestTask.create(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.warning = false
+end
+
+task default: :test

data/lib/calcpace/calculator.rb

@@ -1,68 +1,68 @@
-# frozen_string_literal: true
-
-# Module to calculate time, distance, pace and velocity
-module Calculator
-  def velocity(time, distance)
-    validate_positive(time, distance)
-    distance.to_f / time
-  end
-
-  def checked_velocity(time, distance)
-    seconds = convert_to_seconds(validate_time(time))
-    velocity(seconds, distance)
-  end
-
-  def clock_velocity(time, distance)
-    convert_to_clocktime(checked_velocity(time, distance))
-  end
-
-  def pace(time, distance)
-    validate_positive(time, distance)
-    time.to_f / distance
-  end
-
-  def checked_pace(time, distance)
-    seconds = convert_to_seconds(validate_time(time))
-    pace(seconds, distance)
-  end
-
-  def clock_pace(time, distance)
-    convert_to_clocktime(checked_pace(time, distance))
-  end
-
-  def time(velocity, distance)
-    validate_positive(velocity, distance)
-    velocity * distance
-  end
-
-  def checked_time(velocity, distance)
-    velocity_seconds = convert_to_seconds(validate_time(velocity))
-    time(velocity_seconds, distance)
-  end
-
-  def clock_time(velocity, distance)
-    convert_to_clocktime(checked_time(velocity, distance))
-  end
-
-  def distance(time, velocity)
-    validate_positive(time, velocity)
-    time.to_f / velocity
-  end
-
-  def checked_distance(time, velocity)
-    time_seconds = convert_to_seconds(validate_time(time))
-    velocity_seconds = convert_to_seconds(validate_time(velocity))
-    distance(time_seconds, velocity_seconds)
-  end
-
-  private
-
-  def validate_positive(*values)
-    values.each { |value| check_positive(value) }
-  end
-
-  def validate_time(time)
-    check_time(time)
-    time
-  end
-end
+# frozen_string_literal: true
+
+# Module to calculate time, distance, pace and velocity
+module Calculator
+  def velocity(time, distance)
+    validate_positive(time, distance)
+    distance.to_f / time
+  end
+
+  def checked_velocity(time, distance)
+    seconds = convert_to_seconds(validate_time(time))
+    velocity(seconds, distance)
+  end
+
+  def clock_velocity(time, distance)
+    convert_to_clocktime(checked_velocity(time, distance))
+  end
+
+  def pace(time, distance)
+    validate_positive(time, distance)
+    time.to_f / distance
+  end
+
+  def checked_pace(time, distance)
+    seconds = convert_to_seconds(validate_time(time))
+    pace(seconds, distance)
+  end
+
+  def clock_pace(time, distance)
+    convert_to_clocktime(checked_pace(time, distance))
+  end
+
+  def time(velocity, distance)
+    validate_positive(velocity, distance)
+    velocity * distance
+  end
+
+  def checked_time(velocity, distance)
+    velocity_seconds = convert_to_seconds(validate_time(velocity))
+    time(velocity_seconds, distance)
+  end
+
+  def clock_time(velocity, distance)
+    convert_to_clocktime(checked_time(velocity, distance))
+  end
+
+  def distance(time, velocity)
+    validate_positive(time, velocity)
+    time.to_f / velocity
+  end
+
+  def checked_distance(time, velocity)
+    time_seconds = convert_to_seconds(validate_time(time))
+    velocity_seconds = convert_to_seconds(validate_time(velocity))
+    distance(time_seconds, velocity_seconds)
+  end
+
+  private
+
+  def validate_positive(*values)
+    values.each { |value| check_positive(value) }
+  end
+
+  def validate_time(time)
+    check_time(time)
+    time
+  end
+end

data/lib/calcpace/checker.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
+require_relative 'errors'
+
 # Module to check if the input is valid or of the correct type
 module Checker
   def check_positive(number)
-    raise ArgumentError, 'It must be a positive number' unless number.is_a?(Numeric) && number.positive?
+    return if number.is_a?(Numeric) && number.positive?
+
+    raise Calcpace::NonPositiveInputError,
+          'It must be a positive number'
   end
 
   def check_time(time_string)
-    return if time_string =~ /\A\d{1,2}:\d{2}:\d{2}\z/
+    return if time_string =~ /\A\d{1,2}:\d{2}:\d{2}\z/ ||
+              time_string =~ /\A\d{1,2}:\d{2}\z/
 
-    raise ArgumentError,
-          'It must be a valid time in the format XX:XX:XX'
+    raise Calcpace::InvalidTimeFormatError, 'It must be a valid time in the XX:XX:XX or XX:XX format'
   end
 end

data/lib/calcpace/converter.rb

@@ -1,87 +1,93 @@
-# frozen_string_literal: true
-
-# Module to convert units
-module Converter
-  module Distance
-    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
-    KM_TO_YARDS = 1093.61
-    YARDS_TO_KM = 0.0009144
-    KM_TO_FEET = 3280.84
-    FEET_TO_KM = 0.0003048
-    KM_TO_INCHES = 39_370.1
-    INCHES_TO_KM = 0.0000254
-    MI_TO_YARDS = 1760
-    YARDS_TO_MI = 0.000568182
-    MI_TO_FEET = 5280
-    FEET_TO_MI = 0.000189394
-    MI_TO_INCHES = 63_360
-    INCHES_TO_MI = 0.0000157828
-  end
-
-  module Speed
-    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
-    KM_H_TO_NAUTICAL_MI_H = 0.539957
-    NAUTICAL_MI_H_TO_KM_H = 1.852
-    MI_H_TO_NAUTICAL_MI_H = 0.868976
-    NAUTICAL_MI_H_TO_MI_H = 1.15078
-  end
-
-  def convert(value, unit)
-    check_positive(value)
-    unit_constant = constant(unit)
-    value * unit_constant
-  end
-
-  def convert_to_seconds(time)
-    hour, minute, seconds = time.split(':').map(&:to_i)
-    (hour * 3600) + (minute * 60) + seconds
-  end
-
-  def convert_to_clocktime(seconds)
-    days = seconds / 86_400
-    format = days.to_i > 0 ? "#{days} %H:%M:%S" : '%H:%M:%S'
-    Time.at(seconds).utc.strftime(format)
-  end
-
-  def constant(symbol)
-    Distance.const_get(symbol.to_s.upcase)
-  rescue NameError
-    Speed.const_get(symbol.to_s.upcase)
-  end
-
-  def list_all
-    (Distance.constants + Speed.constants).map { |c| c.downcase.to_sym }
-  end
-
-  def list_speed
-    Speed.constants.map { |c| c.downcase.to_sym }
-  end
-
-  def list_distance
-    Distance.constants.map { |c| c.downcase.to_sym }
-  end
-end
+# frozen_string_literal: true
+
+# Module to convert units
+module Converter
+  module Distance
+    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
+    KM_TO_YARDS = 1093.61
+    YARDS_TO_KM = 0.0009144
+    KM_TO_FEET = 3280.84
+    FEET_TO_KM = 0.0003048
+    KM_TO_INCHES = 39_370.1
+    INCHES_TO_KM = 0.0000254
+    MI_TO_YARDS = 1760
+    YARDS_TO_MI = 0.000568182
+    MI_TO_FEET = 5280
+    FEET_TO_MI = 0.000189394
+    MI_TO_INCHES = 63_360
+    INCHES_TO_MI = 0.0000157828
+  end
+
+  module Speed
+    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
+    KM_H_TO_NAUTICAL_MI_H = 0.539957
+    NAUTICAL_MI_H_TO_KM_H = 1.852
+    MI_H_TO_NAUTICAL_MI_H = 0.868976
+    NAUTICAL_MI_H_TO_MI_H = 1.15078
+  end
+
+  def convert(value, unit)
+    check_positive(value)
+    unit_constant = constant(unit)
+    value * unit_constant
+  end
+
+  def convert_to_seconds(time)
+    parts = time.split(':').map(&:to_i)
+    if parts.length == 2
+      minute, seconds = parts
+      (minute * 60) + seconds
+    else
+      hour, minute, seconds = parts
+      (hour * 3600) + (minute * 60) + seconds
+    end
+  end
+
+  def convert_to_clocktime(seconds)
+    days = seconds / 86_400
+    format = days.to_i.positive? ? "#{days} %H:%M:%S" : '%H:%M:%S'
+    Time.at(seconds).utc.strftime(format)
+  end
+
+  def constant(symbol)
+    Distance.const_get(symbol.to_s.upcase)
+  rescue NameError
+    Speed.const_get(symbol.to_s.upcase)
+  end
+
+  def list_all
+    (Distance.constants + Speed.constants).map { |c| c.downcase.to_sym }
+  end
+
+  def list_speed
+    Speed.constants.map { |c| c.downcase.to_sym }
+  end
+
+  def list_distance
+    Distance.constants.map { |c| c.downcase.to_sym }
+  end
+end

data/lib/calcpace/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Calcpace
+  class Error < StandardError; end
+
+  class InvalidTimeFormatError < Error; end
+
+  class NonPositiveInputError < Error; end
+end

data/lib/calcpace/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Calcpace
+  VERSION = '1.5.4'
+end

data/lib/calcpace.rb

@@ -1,14 +1,15 @@
-# frozen_string_literal: true
-
-require_relative 'calcpace/calculator'
-require_relative 'calcpace/checker'
-require_relative 'calcpace/converter'
-
-# Main class to calculate velocity, pace, time, distance and velocity
-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'
+require_relative 'calcpace/errors'
+
+# Main class to calculate velocity, pace, time, distance and velocity
+class Calcpace
+  include Calculator
+  include Checker
+  include Converter
+
+  def initialize; end
+end

metadata

@@ -1,105 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: calcpace
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.5.4
 platform: ruby
 authors:
-- Joao Gilberto Saraiva
-bindir: bin
+- João Gilberto Saraiva
+bindir: exe
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.25'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.25'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.69'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.69'
-description: It is designed for calculations related to distance, speed and time.
-  The gem also supports conversion to 42 different units of distance and velocity,
-  including metric, nautical and imperial units.
-email: joaogilberto@tuta.io
+date: 2025-06-28 00:00:00.000000000 Z
+dependencies: []
+description: Calcpace provides methods to calculate and convert values related to
+  pace, distance, time, and speed. It supports various time formats and unit conversions.
+email:
+- joaogilberto@tuta.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/tests.yml"
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile.rb
 - lib/calcpace.rb
 - lib/calcpace/calculator.rb
 - lib/calcpace/checker.rb
 - lib/calcpace/converter.rb
-- test/calcpace/test_calculator.rb
-- test/calcpace/test_checker.rb
-- test/calcpace/test_converter.rb
-homepage: https://github.com/0jonjo/calcpace
+- lib/calcpace/errors.rb
+- lib/calcpace/version.rb
+homepage: https://github.com/jonjo/calcpace
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/0jonjo/calcpace
-post_install_message: It's time to calculate! Thank you for installing Calcpace.
+  source_code_uri: https://github.com/jonjo/calcpace
+  changelog_uri: https://github.com/jonjo/calcpace/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -116,9 +52,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: 'Calcpace: calculate total, distance, speed, and convert distances and velocity
-  in an easy way.'
-test_files:
-- test/calcpace/test_calculator.rb
-- test/calcpace/test_checker.rb
-- test/calcpace/test_converter.rb
+summary: A Ruby gem for pace, distance, and time calculations.
+test_files: []

data/test/calcpace/test_calculator.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'bigdecimal'
-require_relative '../../lib/calcpace'
-
-class TestCalculator < Minitest::Test
-  def setup
-    @checker = Calcpace.new
-  end
-
-  def test_velocity
-    assert_equal 3.333, @checker.velocity(3600, 12_000).round(3)
-    assert_equal 12.3, @checker.velocity(5841, 71_844.3)
-    assert_equal 3.6, @checker.velocity(10_000, 36_000.0)
-    assert_raises(ArgumentError) { @checker.velocity(0, 10) }
-    assert_raises(ArgumentError) { @checker.velocity(10, -1) }
-  end
-
-  def test_checked_velocity
-    assert_raises(ArgumentError) { @checker.checked_velocity('', 10) }
-    assert_raises(ArgumentError) { @checker.checked_velocity('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.checked_velocity('00:00:00', 0) }
-    assert_raises(ArgumentError) { @checker.checked_velocity('00:00:00', -1) }
-    assert_equal 2.778, @checker.checked_velocity('01:00:00', 10_000).round(3)
-    assert_equal 10, @checker.checked_velocity('00:00:01', 10)
-    assert_equal 12.3, @checker.checked_velocity('01:37:21', 71_844.3)
-  end
-
-  def test_clock_velocity
-    assert_raises(ArgumentError) { @checker.clock_velocity('', 10) }
-    assert_raises(ArgumentError) { @checker.clock_velocity('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.clock_velocity('00:00:00', 0) }
-    assert_raises(ArgumentError) { @checker.clock_velocity('00:00:00', -1) }
-    assert_equal '00:00:02', @checker.clock_velocity('01:00:00', 10_000)
-    assert_equal '00:00:12', @checker.clock_velocity('01:37:21', 71_844.3)
-  end
-
-  def test_pace
-    assert_equal 300, @checker.pace(3600, 12)
-    assert_equal 122.81076923076924, @checker.pace(71_844.3, 585.0)
-    assert_raises(ArgumentError) { @checker.pace(0, 10) }
-    assert_raises(ArgumentError) { @checker.pace(10, -1) }
-  end
-
-  def test_checked_pace
-    assert_raises(ArgumentError) { @checker.checked_pace('', 10) }
-    assert_raises(ArgumentError) { @checker.checked_pace('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.checked_pace('00:00:00', 0) }
-    assert_raises(ArgumentError) { @checker.checked_pace('00:00:00', -1) }
-    assert_equal 360, @checker.checked_pace('01:00:00', 10)
-    assert_equal 474.8780487804878, @checker.checked_pace('01:37:21', 12.3)
-  end
-
-  def test_clock_pace
-    assert_raises(ArgumentError) { @checker.clock_pace('', 10) }
-    assert_raises(ArgumentError) { @checker.clock_pace('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.clock_pace('00:00:00', 0) }
-    assert_raises(ArgumentError) { @checker.clock_pace('00:00:00', -1) }
-    assert_equal '00:06:00', @checker.clock_pace('01:00:00', 10)
-    assert_equal '00:07:54', @checker.clock_pace('01:37:21', 12.3)
-  end
-
-  def test_time
-    assert_equal 43_200, @checker.time(3600, 12)
-    assert_equal 5841.0, @checker.time(12.3, 474.8780487804878)
-    assert_raises(ArgumentError) { @checker.time(0, 10) }
-    assert_raises(ArgumentError) { @checker.time(10, -1) }
-  end
-
-  def test_checked_time
-    assert_raises(ArgumentError) { @checker.checked_time('', 10) }
-    assert_raises(ArgumentError) { @checker.checked_time('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.checked_time('00:00:00', 0) }
-    assert_raises(ArgumentError) { @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_clock_time
-    assert_raises(ArgumentError) { @checker.clock_time('', 10) }
-    assert_raises(ArgumentError) { @checker.clock_time('invalid', 10) }
-    assert_raises(ArgumentError) { @checker.clock_time('00:00:00', 0) }
-    assert_raises(ArgumentError) { @checker.clock_time('00:00:00', -1) }
-    assert_equal '01:00:00', @checker.clock_time('00:05:00', 12)
-  end
-
-  def test_distance
-    assert_equal 30, @checker.distance(3600, 120)
-    assert_equal 12.3, @checker.distance(5841.0, 474.8780487804878)
-    assert_raises(ArgumentError) { @checker.distance(0, 10) }
-    assert_raises(ArgumentError) { @checker.distance(10, -1) }
-  end
-
-  def test_checked_distance
-    assert_raises(ArgumentError) { @checker.checked_distance('', '00:05:00') }
-    assert_raises(ArgumentError) { @checker.checked_distance('01:00:00', '') }
-    assert_equal 18.0, @checker.checked_distance('01:30:00', '00:05:00')
-    assert_equal 15.493, @checker.checked_distance('01:37:21', '00:06:17').round(3)
-  end
-
-  def test_readme_examples_one
-    assert_equal 3.386206896551724, @checker.velocity(3625, 12_275)
-    assert_equal 305.4166666666667, @checker.pace(3665, 12)
-    assert_equal 2520.0, @checker.time(210, 12)
-    assert_equal 80.5, @checker.distance(9660, 120)
-  end
-
-  def test_readme_examples_two
-    assert_equal 2.8658333333333332, @checker.checked_velocity('01:00:00', 10_317)
-    assert_equal '00:00:02', @checker.clock_velocity('01:00:00', 10_317)
-    assert_equal 489.2, @checker.checked_pace('01:21:32', 10)
-    assert_equal '00:08:09', @checker.clock_pace('01:21:32', 10)
-    assert_equal 4170.599999999999, @checker.checked_time('00:05:31', 12.6)
-    assert_equal '01:09:30', @checker.clock_time('00:05:31', 12.6)
-    assert_equal 12.640826873385013, @checker.checked_distance('01:21:32', '00:06:27')
-  end
-end

data/test/calcpace/test_checker.rb

@@ -1,21 +0,0 @@
-# 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(ArgumentError) { @checker.check_positive(-1) }
-    assert_raises(ArgumentError) { @checker.check_positive(0) }
-    assert_nil @checker.check_positive(1)
-  end
-
-  def test_check_time
-    assert_raises(ArgumentError) { @checker.check_time('') }
-    assert_nil @checker.check_time('00:00:00')
-  end
-end

data/test/calcpace/test_converter.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require_relative '../../lib/calcpace'
-
-class TestConverter < Minitest::Test
-  def setup
-    @checker = Calcpace.new
-  end
-
-  def test_convert_to_seconds
-    assert_equal 4262, @checker.convert_to_seconds('01:11:02')
-  end
-
-  def test_convert_to_clocktime
-    assert_equal '01:11:02', @checker.convert_to_clocktime(4262)
-  end
-
-  def test_convert_to_clocktime_more_than_24_hours
-    assert_equal '1 03:46:40', @checker.convert_to_clocktime(100_000)
-  end
-
-  def test_convert_distance_one
-    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)
-  end
-
-  def test_convert_distance_two
-    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)
-  end
-
-  def test_convert_distance_three
-    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_one
-    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)
-  end
-
-  def test_convert_velocity_two
-    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_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_list_all
-    assert_equal 42, @checker.list_all.size
-  end
-
-  def test_list_speed
-    assert_equal 16, @checker.list_speed.size
-  end
-
-  def test_list_distance_constants
-    assert_equal 26, @checker.list_distance.size
-  end
-end