gitlab_chronic_duration 0.10.6.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31c85bafdeb76ec821dee3705c00a9755f41a82f49a3226b0955b40b6c6093be
-  data.tar.gz: e6c7a5ee5f8ed8e8668ae09891b3b21c6770bb2a8cd2639c4ea7dbe2635be46f
+  metadata.gz: 90ed911722678aa8c57973bd8cf733877d32bd06b0e313764502100bd0e36bf7
+  data.tar.gz: 5a5afd28caceefa29332d8774a161b811a1340344fdff23a33cd33f7d91aaaea
 SHA512:
-  metadata.gz: 4ee3b0723ac970588440c226025a1fbd026ffe7304e203304bfee1445794dae1f9d660d49653c94b2b714dcf2f04d899ec0bc0554c683c8cf2e67860cc3db740
-  data.tar.gz: e7950ea62b28e6c6cfe2f3a877b46a80b7a5281d5196557e8a86f91093f4c5f15fdb94d1afe26b248b391972c2e033dae2c15f94c2eb71aba784d63fd55783f9
+  metadata.gz: '085d3ef7649df9ff93e215b41cea7d77739c415c9295f201a5e005da90c52309d395459bf0543512e729c0feb73a4520d4123d7250191888212f6c12f7f2c0d8'
+  data.tar.gz: 374eaf5cfee394c835a28bad82214de21a921a4cbc11a99f58844e43b7f240c804f757b941294924927a7b88a33e3925a44c86e6f8defc893c0533e00bc969e2

data/.gitlab-ci.yml

@@ -1,12 +1,17 @@
-image: "ruby:2.5"
-
-before_script:
-  - ruby -v
-  - which ruby
-  - gem install bundler
-  - bundle install --jobs $(nproc)  "${FLAGS[@]}"
+.default:
+  image: "ruby:${RUBY_VERSION}"
+  before_script:
+    - ruby -v
+    - which ruby
+    - gem install bundler
+    - bundle install --jobs $(nproc)  "${FLAGS[@]}"
 
 rspec:
+  extends:
+    - .default
   stage: test
   script:
     - bundle exec rspec
+  parallel:
+    matrix:
+      - RUBY_VERSION: ['2.7', '3.0', '3.1', '3.2']

data/README.md

@@ -8,7 +8,7 @@ The reverse can also be accomplished with the output method. So pass in seconds
 
 ## Usage
 
-    >> require 'chronic_duration'
+    >> require 'gitlab_chronic_duration'
     => true
     >> ChronicDuration.parse('4 minutes and 30 seconds')
     => 270

data/gitlab_chronic_duration.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["henry@poydar.com"]
   gem.description   = %q{A simple Ruby natural language parser for elapsed time. (For example, 4 hours and 30 minutes, 6 minutes 4 seconds, 3 days, etc.) Returns all results in seconds. Will return an integer unless you get tricky and need a float. (4 minutes and 13.47 seconds, for example.) The reverse can also be performed via the output method.}
   gem.summary       = %q{A simple Ruby natural language parser for elapsed time}
-  gem.homepage      = "https://gitlab.com/gitlab-org/gitlab-chronic-duration"
+  gem.homepage      = "https://gitlab.com/gitlab-org/ruby/gems/gitlab-chronic-duration"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
@@ -22,7 +22,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "numerizer", "~> 0.2"
 
   gem.add_development_dependency "rake", "~> 10.0.3"
-  gem.add_development_dependency "rspec", "~> 2.12.0"
+  gem.add_development_dependency "rspec", "~> 3.12"
 
 
 end

data/lib/chronic_duration/version.rb

@@ -1,5 +1,3 @@
 module ChronicDuration
-  # '0.10.6' is the versioning used in 'https://github.com/henrypoydar/chronic_duration',
-  # we are adding revision part to highlight GitLab changes, e.g. '0.10.6.N'
-  VERSION = '0.10.6.2'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/lib/gitlab_chronic_duration.rb

@@ -1,3 +1,7 @@
+# NOTE:
+# Changes to this file should be kept in sync with
+# https://gitlab.com/gitlab-org/gitlab/-/blob/master/app/assets/javascripts/chronic_duration.js.
+
 require 'numerizer' unless defined?(Numerizer)
 
 module ChronicDuration
@@ -42,7 +46,8 @@ module ChronicDuration
   # return an integer (or float, if fractions of a
   # second are input)
   def parse(string, opts = {})
-    result = calculate_from_words(cleanup(string), opts)
+    use_complete_matcher = opts.fetch(:use_complete_matcher, false)
+    result = calculate_from_words(cleanup(string, use_complete_matcher), opts)
     (!opts[:keep_zero] and result == 0) ? nil : result
   end
 
@@ -184,9 +189,9 @@ private
     val
   end
 
-  def cleanup(string)
+  def cleanup(string, use_complete_matcher = false)
     res = string.downcase
-    res = filter_by_type(Numerizer.numerize(res))
+    res = filter_by_type(Numerizer.numerize(res), use_complete_matcher)
     res = res.gsub(float_matcher) {|n| " #{n} "}.squeeze(' ').strip
     res = filter_through_white_list(res)
   end
@@ -218,9 +223,11 @@ private
   end
 
   # Parse 3:41:59 and return 3 hours 41 minutes 59 seconds
-  def filter_by_type(string)
+  def filter_by_type(string, use_complete_matcher = false)
     chrono_units_list = duration_units_list.reject {|v| v == "weeks"}
-    if string.gsub(' ', '') =~ /#{float_matcher}(:#{float_matcher})+/
+    matcher = use_complete_matcher ? time_matcher : /#{float_matcher}(:#{float_matcher})+/
+
+    if string.gsub(' ', '') =~ matcher
       res = []
       string.gsub(' ', '').split(':').reverse.each_with_index do |v,k|
         return unless chrono_units_list[k]
@@ -233,6 +240,10 @@ private
     res
   end
 
+  def time_matcher
+    /^[0-9]+:[0-9]+(:[0-9]+){0,4}(\.[0-9]*)?$/
+  end
+
   def float_matcher
     /[0-9]*\.?[0-9]+/
   end

data/spec/lib/chronic_duration_spec.rb

@@ -1,3 +1,7 @@
+# NOTE:
+# Changes to this file should be kept in sync with
+# https://gitlab.com/gitlab-org/gitlab/-/blob/master/spec/frontend/chronic_duration_spec.js.
+
 require 'spec_helper'
 
 describe ChronicDuration do
@@ -34,11 +38,11 @@ describe ChronicDuration do
     context "when string can't be parsed" do
 
       it "returns nil" do
-        ChronicDuration.parse('gobblygoo').should be_nil
+        expect(ChronicDuration.parse('gobblygoo')).to be_nil
       end
 
       it "cannot parse zero" do
-        ChronicDuration.parse('0').should be_nil
+        expect(ChronicDuration.parse('0')).to be_nil
       end
 
       context "when @@raise_exceptions set to true" do
@@ -54,47 +58,47 @@ describe ChronicDuration do
     end
 
     it "should return zero if the string parses as zero and the keep_zero option is true" do
-      ChronicDuration.parse('0', :keep_zero => true).should == 0
+      expect(ChronicDuration.parse('0', :keep_zero => true)).to eq(0)
     end
 
     it "should return a float if seconds are in decimals" do
-      ChronicDuration.parse('12 mins 3.141 seconds').is_a?(Float).should be_true
+      expect(ChronicDuration.parse('12 mins 3.141 seconds')).to be_a(Float)
     end
 
     it "should return an integer unless the seconds are in decimals" do
-      ChronicDuration.parse('12 mins 3 seconds').is_a?(Integer).should be_true
+      expect(ChronicDuration.parse('12 mins 3 seconds')).to be_a(Integer)
     end
 
     it "should be able to parse minutes by default" do
-      ChronicDuration.parse('5', :default_unit => "minutes").should == 300
+      expect(ChronicDuration.parse('5', :default_unit => "minutes")).to eq(300)
     end
 
     @exemplars.each do |k, v|
       it "parses a duration like #{k}" do
-        ChronicDuration.parse(k).should == v
+        expect(ChronicDuration.parse(k)).to eq(v)
       end
     end
 
     context 'with :hours_per_day and :days_per_month params' do
       it 'uses provided :hours_per_day' do
-        ChronicDuration.parse('1d', hours_per_day: 24).should == 24 * 60 * 60
-        ChronicDuration.parse('1d', hours_per_day: 8).should == 8 * 60 * 60
+        expect(ChronicDuration.parse('1d', hours_per_day: 24)).to eq(24 * 60 * 60)
+        expect(ChronicDuration.parse('1d', hours_per_day: 8)).to eq(8 * 60 * 60)
       end
 
       it 'uses provided :days_per_month' do
-        ChronicDuration.parse('1mo', days_per_month: 30).should == 30 * 24 * 60 * 60
-        ChronicDuration.parse('1mo', days_per_month: 20).should == 20 * 24 * 60 * 60
+        expect(ChronicDuration.parse('1mo', days_per_month: 30)).to eq(30 * 24 * 60 * 60)
+        expect(ChronicDuration.parse('1mo', days_per_month: 20)).to eq(20 * 24 * 60 * 60)
 
-        ChronicDuration.parse('1w', days_per_month: 30).should == 7 * 24 * 60 * 60
-        ChronicDuration.parse('1w', days_per_month: 20).should == 5 * 24 * 60 * 60
+        expect(ChronicDuration.parse('1w', days_per_month: 30)).to eq(7 * 24 * 60 * 60)
+        expect(ChronicDuration.parse('1w', days_per_month: 20)).to eq(5 * 24 * 60 * 60)
       end
 
       it 'uses provided both :hours_per_day and :days_per_month' do
-        ChronicDuration.parse('1mo', days_per_month: 30, hours_per_day: 24).should == 30 * 24 * 60 * 60
-        ChronicDuration.parse('1mo', days_per_month: 20, hours_per_day: 8).should == 20 * 8 * 60 * 60
+        expect(ChronicDuration.parse('1mo', days_per_month: 30, hours_per_day: 24)).to eq(30 * 24 * 60 * 60)
+        expect(ChronicDuration.parse('1mo', days_per_month: 20, hours_per_day: 8)).to eq(20 * 8 * 60 * 60)
 
-        ChronicDuration.parse('1w', days_per_month: 30, hours_per_day: 24).should == 7 * 24 * 60 * 60
-        ChronicDuration.parse('1w', days_per_month: 20, hours_per_day: 8).should == 5 * 8 * 60 * 60
+        expect(ChronicDuration.parse('1w', days_per_month: 30, hours_per_day: 24)).to eq(7 * 24 * 60 * 60)
+        expect(ChronicDuration.parse('1w', days_per_month: 20, hours_per_day: 8)).to eq(5 * 8 * 60 * 60)
       end
     end
   end
@@ -187,7 +191,7 @@ describe ChronicDuration do
     @exemplars.each do |k, v|
       v.each do |key, val|
         it "properly outputs a duration of #{k} seconds as #{val} using the #{key.to_s} format option" do
-          ChronicDuration.output(k, :format => key).should == val
+          expect(ChronicDuration.output(k, :format => key)).to eq(val)
         end
       end
     end
@@ -214,83 +218,94 @@ describe ChronicDuration do
     @keep_zero_exemplars.each do |k, v|
       v.each do |key, val|
         it "should properly output a duration of 0 seconds as #{val.nil? ? "nil" : val} using the #{key.to_s} format option, if the keep_zero option is #{k.to_s}" do
-          ChronicDuration.output(0, :format => key, :keep_zero => k).should == val
+          expect(ChronicDuration.output(0, :format => key, :keep_zero => k)).to eq(val)
         end
       end
     end
 
     it "returns weeks when needed" do
-      ChronicDuration.output(45*24*60*60, :weeks => true).should =~ /.*wk.*/
+      expect(ChronicDuration.output(45*24*60*60, :weeks => true)).to match(/.*wk.*/)
     end
 
     it "returns hours and minutes only when :hours_only option specified" do
-      ChronicDuration.output(395*24*60*60 + 15*60, :limit_to_hours => true).should == '9480 hrs 15 mins'
+      expect(ChronicDuration.output(395*24*60*60 + 15*60, :limit_to_hours => true)).to eq('9480 hrs 15 mins')
     end
 
     context 'with :hours_per_day and :days_per_month params' do
       it 'uses provided :hours_per_day' do
-        ChronicDuration.output(24 * 60 * 60, hours_per_day: 24).should == '1 day'
-        ChronicDuration.output(24 * 60 * 60, hours_per_day: 8).should == '3 days'
+        expect(ChronicDuration.output(24 * 60 * 60, hours_per_day: 24)).to eq('1 day')
+        expect(ChronicDuration.output(24 * 60 * 60, hours_per_day: 8)).to eq('3 days')
       end
 
       it 'uses provided :days_per_month' do
-        ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 30).should == '1 wk'
-        ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 20).should == '1 wk 2 days'
+        expect(ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 30)).to eq('1 wk')
+        expect(ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 20)).to eq('1 wk 2 days')
       end
 
       it 'uses provided both :hours_per_day and :days_per_month' do
-        ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 30, hours_per_day: 24).should == '1 wk'
-        ChronicDuration.output(5 * 8 * 60 * 60, weeks: true, days_per_month: 20, hours_per_day: 8).should == '1 wk'
+        expect(ChronicDuration.output(7 * 24 * 60 * 60, weeks: true, days_per_month: 30, hours_per_day: 24)).to eq('1 wk')
+        expect(ChronicDuration.output(5 * 8 * 60 * 60, weeks: true, days_per_month: 20, hours_per_day: 8)).to eq('1 wk')
       end
 
       it 'uses provided params alonside with :weeks when converting to months' do
-        ChronicDuration.output(30 * 24 * 60 * 60, days_per_month: 30, hours_per_day: 24).should == '1 mo'
-        ChronicDuration.output(30 * 24 * 60 * 60, days_per_month: 30, hours_per_day: 24, weeks: true).should == '1 mo 2 days'
+        expect(ChronicDuration.output(30 * 24 * 60 * 60, days_per_month: 30, hours_per_day: 24)).to eq('1 mo')
+        expect(ChronicDuration.output(30 * 24 * 60 * 60, days_per_month: 30, hours_per_day: 24, weeks: true)).to eq('1 mo 2 days')
 
-        ChronicDuration.output(20 * 8 * 60 * 60, days_per_month: 20, hours_per_day: 8).should == '1 mo'
-        ChronicDuration.output(20 * 8 * 60 * 60, days_per_month: 20, hours_per_day: 8, weeks: true).should == '1 mo'
+        expect(ChronicDuration.output(20 * 8 * 60 * 60, days_per_month: 20, hours_per_day: 8)).to eq('1 mo')
+        expect(ChronicDuration.output(20 * 8 * 60 * 60, days_per_month: 20, hours_per_day: 8, weeks: true)).to eq('1 mo')
       end
     end
 
     it "returns the specified number of units if provided" do
-      ChronicDuration.output(4 * 3600 + 60 + 1, units: 2).should == '4 hrs 1 min'
-      ChronicDuration.output(6 * 30 * 24 * 3600 + 24 * 3600 + 3600 + 60 + 1, units: 3, format: :long).should == '6 months 1 day 1 hour'
+      expect(ChronicDuration.output(4 * 3600 + 60 + 1, units: 2)).to eq('4 hrs 1 min')
+      expect(ChronicDuration.output(6 * 30 * 24 * 3600 + 24 * 3600 + 3600 + 60 + 1, units: 3, format: :long)).to eq('6 months 1 day 1 hour')
     end
 
     context "when the format is not specified" do
 
       it "uses the default format" do
-        ChronicDuration.output(2 * 3600 + 20 * 60).should == '2 hrs 20 mins'
+        expect(ChronicDuration.output(2 * 3600 + 20 * 60)).to eq('2 hrs 20 mins')
       end
 
     end
 
     @exemplars.each do |seconds, format_spec|
       format_spec.each do |format, _|
-        it "outputs a duration for #{seconds} that parses back to the same thing when using the #{format.to_s} format" do
-          ChronicDuration.parse(ChronicDuration.output(seconds, :format => format)).should == seconds
+        context 'when using the legacy time matcher' do
+          it "outputs a duration for #{seconds} that parses back to the same thing when using the #{format} format" do
+            expect(ChronicDuration.parse(
+              ChronicDuration.output(seconds, format: format, use_complete_matcher: false)
+            )).to eq(seconds)
+          end
+        end
+
+        context 'when using the new time matcher' do
+          it "outputs a duration for #{seconds} that parses back to the same thing when using the #{format} format" do
+            expect(ChronicDuration.parse(
+              ChronicDuration.output(seconds, format: format, use_complete_matcher: true)
+            )).to eq(seconds)
+          end
         end
       end
     end
 
     it "uses user-specified joiner if provided" do
-      ChronicDuration.output(2 * 3600 + 20 * 60, joiner: ', ').should == '2 hrs, 20 mins'
+      expect(ChronicDuration.output(2 * 3600 + 20 * 60, joiner: ', ')).to eq('2 hrs, 20 mins')
     end
-
   end
 
   describe ".filter_by_type" do
 
     it "receives a chrono-formatted time like 3:14 and return a human time like 3 minutes 14 seconds" do
-      ChronicDuration.instance_eval("filter_by_type('3:14')").should == '3 minutes 14 seconds'
+      expect(ChronicDuration.instance_eval("filter_by_type('3:14')")).to eq('3 minutes 14 seconds')
     end
 
     it "receives chrono-formatted time like 12:10:14 and return a human time like 12 hours 10 minutes 14 seconds" do
-      ChronicDuration.instance_eval("filter_by_type('12:10:14')").should == '12 hours 10 minutes 14 seconds'
+      expect(ChronicDuration.instance_eval("filter_by_type('12:10:14')")).to eq('12 hours 10 minutes 14 seconds')
     end
 
     it "returns the input if it's not a chrono-formatted time" do
-      ChronicDuration.instance_eval("filter_by_type('4 hours')").should == '4 hours'
+      expect(ChronicDuration.instance_eval("filter_by_type('4 hours')")).to eq('4 hours')
     end
 
   end
@@ -298,15 +313,15 @@ describe ChronicDuration do
   describe ".cleanup" do
 
     it "cleans up extraneous words" do
-      ChronicDuration.instance_eval("cleanup('4 days and 11 hours')").should == '4 days 11 hours'
+      expect(ChronicDuration.instance_eval("cleanup('4 days and 11 hours')")).to eq('4 days 11 hours')
     end
 
     it "cleans up extraneous spaces" do
-      ChronicDuration.instance_eval("cleanup('  4 days and 11     hours')").should == '4 days 11 hours'
+      expect(ChronicDuration.instance_eval("cleanup('  4 days and 11     hours')")).to eq('4 days 11 hours')
     end
 
     it "inserts spaces where there aren't any" do
-      ChronicDuration.instance_eval("cleanup('4m11.5s')").should == '4 minutes 11.5 seconds'
+      expect(ChronicDuration.instance_eval("cleanup('4m11.5s')")).to eq('4 minutes 11.5 seconds')
     end
 
   end
@@ -324,8 +339,8 @@ describe ChronicDuration do
 
     it "should parse knowing the work week" do
       week = ChronicDuration.parse('5d')
-      ChronicDuration.parse('40h').should == week
-      ChronicDuration.parse('1w').should == week
+      expect(ChronicDuration.parse('40h')).to eq(week)
+      expect(ChronicDuration.parse('1w')).to eq(week)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_chronic_duration
 version: !ruby/object:Gem::Version
-  version: 0.10.6.2
+  version: 0.11.0
 platform: ruby
 authors:
 - hpoydar
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-24 00:00:00.000000000 Z
+date: 2023-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numerizer
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.12'
 description: A simple Ruby natural language parser for elapsed time. (For example,
   4 hours and 30 minutes, 6 minutes 4 seconds, 3 days, etc.) Returns all results in
   seconds. Will return an integer unless you get tricky and need a float. (4 minutes
@@ -75,11 +75,11 @@ files:
 - lib/gitlab_chronic_duration.rb
 - spec/lib/chronic_duration_spec.rb
 - spec/spec_helper.rb
-homepage: https://gitlab.com/gitlab-org/gitlab-chronic-duration
+homepage: https://gitlab.com/gitlab-org/ruby/gems/gitlab-chronic-duration
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -94,8 +94,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: A simple Ruby natural language parser for elapsed time
 test_files: