calcpace 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08aafc87c8fa3b75db3dfac8e186f803cbfec584991945e9849648a0d91c7341'
-  data.tar.gz: 886d0b4b83bc2bbc07b3f2dc5d4b3b605459cc15df13a51c22e4ba87f2620ff4
+  metadata.gz: 3f95d90f68ffe230e0f84e3d16b4221de5ffe61004e76ad2f2d2a18260ad9c30
+  data.tar.gz: fe206da9ac7d89e6df053fa0b6c6aff02227d06da7e81f48e6955cba183a720d
 SHA512:
-  metadata.gz: 0e3b69e165c445f5c2885c91a8b866020095ba3de87431817eed0d75df2f6f3e65da15cb73205904cff8c3844d590ce3b3edeabdf91cd74f31bbeafe84ac085c
-  data.tar.gz: 311f84fa56b4f5d3bec6e0c16cac2d6650a488828058f169c8bf1f12c410bff8a91c9be667ffd30ed6dcf40a856f5c64a63aa4b9386095f9a0fdbd7c83548844
+  metadata.gz: 8e93948a4751a908473f92cf526c09b6c8dc084978cb9c99a3e2a1977bd2ae7da7a14548631c689da95a0e10dcc361a512d1967f610f60cf38297e51fb7cdad6
+  data.tar.gz: bbf563ced661d193b79d5c90dd77ce63262488ceaf42fba06033b0154cebb0139a2f63f1749d1ed400985e854b1d716e54872a5a7b83756fabd2be16e081f7c8

data/lib/calcpace/calculator.rb

@@ -3,31 +3,31 @@
 require 'bigdecimal'
 
 module Calculator
-  def pace(time, distance, bigdecimal = false)
-    pace_in_seconds = pace_seconds(time, distance, bigdecimal)
+  def pace(time, distance)
+    pace_in_seconds = pace_seconds(time, distance)
     convert_to_clocktime(pace_in_seconds)
   end
 
-  def pace_seconds(time, distance, bigdecimal = false)
+  def pace_seconds(time, distance)
     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)
+  def total_time(pace, distance)
+    total_time_in_seconds = total_time_seconds(pace, distance)
     convert_to_clocktime(total_time_in_seconds)
   end
 
-  def total_time_seconds(pace, distance, bigdecimal = false)
+  def total_time_seconds(pace, distance)
     check_time(pace)
     check_distance(distance)
     pace_seconds = convert_to_seconds(pace)
-    bigdecimal ? pace_seconds * BigDecimal(distance.to_s) : pace_seconds * distance
+    @bigdecimal ? pace_seconds * BigDecimal(distance.to_s) : pace_seconds * distance
   end
 
-  def distance(time, pace, bigdecimal = false)
+  def distance(time, pace)
     check_time(time)
     check_time(pace)
     if bigdecimal

data/lib/calcpace/converter.rb

@@ -1,44 +1,55 @@
-# frozen_string_literal: true
-
-require 'bigdecimal'
-
-module Converter
-  KM_TO_MI = BigDecimal('0.621371')
-  MI_TO_KM = BigDecimal('1.60934')
-
-  def to_seconds(time)
-    check_time(time)
-    convert_to_seconds(time)
-  end
-
-  def to_clocktime(seconds)
-    check_integer(seconds)
-    convert_to_clocktime(seconds)
-  end
-
-  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)
-  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)
-    format = seconds >= 86_400 ? '%d %H:%M:%S' : '%H:%M:%S'
-    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
-  end
-end
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Converter
+  KM_TO_MI_BIGDECIMAL = BigDecimal('0.621371')
+  KM_TO_MI = 0.621371
+  MI_TO_KM_BIGDECIMAL = BigDecimal('1.60934')
+  MI_TO_KM = 1.60934
+
+  def to_seconds(time)
+    check_time(time)
+    convert_to_seconds(time)
+  end
+
+  def to_clocktime(seconds)
+    check_integer(seconds)
+    convert_to_clocktime(seconds)
+  end
+
+  def convert_to_miles(distance)
+    convert(distance, 'mi')
+  end
+
+  def convert_to_km(distance)
+    convert(distance, 'km')
+  end
+
+  def convert(distance, unit)
+    check_distance(distance)
+    bigdecimal ? distance_to_convert = BigDecimal(distance.to_s) : distance_to_convert = distance
+    convert_the_distance(distance_to_convert, unit)
+  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)
+    format = seconds >= 86_400 ? '%d %H:%M:%S' : '%H:%M:%S'
+    Time.at(seconds.to_i).utc.strftime(format)
+  end
+
+  def convert_the_distance(distance, unit)
+    case unit
+    when 'mi'
+      bigdecimal ? km_to_mi = KM_TO_MI_BIGDECIMAL : km_to_mi = KM_TO_MI
+      (distance * km_to_mi)
+    when 'km'
+      bigdecimal ? mi_to_km = MI_TO_KM_BIGDECIMAL : mi_to_km = MI_TO_KM
+      (distance * mi_to_km)
+    end
+  end
+end

data/lib/calcpace.rb

@@ -9,5 +9,9 @@ class Calcpace
   include Checker
   include Converter
 
-  def initialize; end
+  attr_reader :bigdecimal
+
+  def initialize(bigdecimal = false)
+    @bigdecimal = bigdecimal
+  end
 end

data/test/calcpace/test_calculator.rb

@@ -1,68 +1,73 @@
-# 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_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)
-  end
-
-  def test_pace_without_bigdecimal_precision
-    assert_equal '00:07:54', @checker.pace('01:37:21', 12.3, false)
-  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)
-  end
-
-  def test_pace_seconds_with_bigdecimal_precision
-    assert_equal BigDecimal('0.474878048780487804878048780487804878049e3'), @checker.pace_seconds('01:37:21', 12.3, true)
-  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)
-  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)
-  end
-
-  def test_total_time_seconds_with_bigdecimal_precision
-    assert_equal BigDecimal('0.718443e5'), @checker.total_time_seconds('01:37:21', 12.3, true)
-  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')
-  end
-
-  def test_distance_with_bigdecimal_precision
-    assert_equal BigDecimal('0.15493368700265251989389920424403183024e2'), @checker.distance('01:37:21', '00:06:17', true)
-  end
-end
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'bigdecimal'
+require_relative '../../lib/calcpace'
+
+class TestCalculator < Minitest::Test
+  def setup
+    @checker = Calcpace.new
+    @checker_bigdecimal = Calcpace.new(bigdecimal = 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)
+  end
+
+  def test_pace_with_bigdecimal_precision
+    assert_equal '00:07:54', @checker_bigdecimal.pace('01:37:21', 12.3)
+  end
+
+  def test_pace_without_bigdecimal_precision
+    assert_equal '00:07:54', @checker.pace('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 474.8780487804878, @checker.pace_seconds('01:37:21', 12.3)
+  end
+
+  def test_pace_seconds_with_bigdecimal_precision
+    assert_equal BigDecimal('0.474878048780487804878048780487804878049e3'), @checker_bigdecimal.pace_seconds('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)
+  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)
+  end
+
+  def test_total_time_seconds_with_bigdecimal_precision
+    assert_equal BigDecimal('0.718443e5'), @checker_bigdecimal.total_time_seconds('01:37:21', 12.3)
+  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')
+  end
+
+  def test_distance_with_bigdecimal_precision
+    assert_equal BigDecimal('0.15493368700265251989389920424403183024e2'), @checker_bigdecimal.distance('01:37:21', '00:06:17')
+  end
+end

data/test/calcpace/test_converter.rb

@@ -1,49 +1,58 @@
-# 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_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') }
-  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')
-  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') }
-  end
-end
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../lib/calcpace'
+
+class TestConverter < Minitest::Test
+  def setup
+    @checker = Calcpace.new
+    @checker_bigdecimal = Calcpace.new(bigdecimal = 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') }
+  end
+
+  def test_convert_the_distance
+    assert_equal 6.21, @checker.convert_the_distance(10, 'mi').round(2)
+    assert_equal 6.2, @checker.convert_the_distance(10, 'mi').round(1)
+    assert_equal 6.214, @checker.convert_the_distance(10, 'mi').round(3)
+    assert_equal 16.09, @checker.convert_the_distance(10, 'km').round(2)
+  end
+
+  def test_convert_the_distance_with_bigdecimal_precision
+    assert_equal BigDecimal('6.21371'), @checker_bigdecimal.convert_the_distance(10, 'mi')
+  end
+
+  def test_convert
+    assert_equal 6.21, @checker.convert(10, 'mi').round(2)
+    assert_equal 16.09, @checker.convert(10, 'km').round(2)
+    assert_equal 6.2, @checker.convert(10, 'mi').round(1)
+    assert_raises(RuntimeError) { @checker.convert(-1, 'km') }
+  end
+
+  def test_convert_to_miles
+    assert_equal 6.21, @checker.convert_to_miles(10).round(2)
+  end
+
+  def test_convert_to_km
+    assert_equal 16.09, @checker.convert_to_km(10).round(2)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calcpace
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Joao Gilberto Saraiva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-21 00:00:00.000000000 Z
+date: 2024-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -94,12 +94,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
-description: 'Calcpace is a Ruby gem that helps with calculations related to running/cycling
+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, '
+  gem supports BigDecimal to handle the calculations with more precision.
 email: joaogilberto@tuta.io
 executables: []
 extensions: []