edtf 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cc486f565cf7987bbb547f9ddb63a8eb50e0f6cd016a409f3eb60caf7f4544b
-  data.tar.gz: de1c6696854d6c7c58a6bb1f133ebe4cd7d363022617a2fe5cf78d3b2e55722d
+  metadata.gz: e91fb341cfc4a8bc2ba77ed40f51240510578ef0c535b8b7ae44812328d69cdf
+  data.tar.gz: 89af7cf2bdfb4dfdd644d88a4765f2cd7487e479ee8f75bcea75d0da7e42b83d
 SHA512:
-  metadata.gz: 27e4c029c50828e797ab21fe727bc850cb80367f0fe74421158dc32387d21b4424ef1614defc3b86bb9a957d397fc792d6f7152dc0c085d93b41f5c4b3c78055
-  data.tar.gz: 4832debc9c007c0e324b6705fb5346b3755235c5b92b19498d46f50324498ff1673c9559e1242b6abdc8e968267c5a849fbaef08d8cd509ed9ab527bcda6ef49
+  metadata.gz: 48847ec7463218a2fd6b505271da96471b0341e5e88c5cd11ff302fd636040f580dc2a78be5c1c22f33b225e93ffecf6a3dda9d9e4fa5e5ff998636e936c3e0d
+  data.tar.gz: 1fbe3d006b3a72cf21a4c4ca07a5933b888a32c221158f32230f1011e159583c79fea5e8d8d00b1b1b434ecdf36cbc2b59b5e5d02b8b73124f26d3f51d79c11c

data/.github/workflows/ci.yml

@@ -13,16 +13,19 @@ jobs:
 
     strategy:
       matrix:
+        coverage:
+          - false
         ruby-version:
-          - '2.7'
-          - '3.0'
-          - '3.1'
+          - '3.3'
           - '3.2'
           - 'jruby'
+        include:
+          - ruby-version: '4.0'
+            coverage: true
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v7
 
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
@@ -34,8 +37,8 @@ jobs:
         run: bundle exec rake
 
       - name: Upload coverage results
-        if: matrix.ruby-version == '3.1'
+        if: matrix.coverage
         continue-on-error: true
-        uses: coverallsapp/github-action@master
+        uses: coverallsapp/github-action@v2
         with:
           github-token: ${{ github.token }}

data/.gitignore

@@ -1,8 +1,8 @@
 Gemfile.lock
 lib/edtf/parser.output
-*.rbc
 .rbx
 .ruby-version
 *.swp
 .bundle
 coverage
+pkg

data/Gemfile

@@ -1,8 +1,15 @@
 source 'https://rubygems.org'
 gemspec
 
-group :debug do
-  gem 'debug', platform: 'mri'
+group :coverage do
+  platforms :mri do
+    gem 'simplecov'
+    gem 'simplecov-lcov'
+  end
+end
+
+group :debug, optional: true do
+  gem 'debug', '>= 1.0.0', require: false
 end
 
 group :development do
@@ -10,13 +17,4 @@ group :development do
   gem 'racc'
   gem 'cucumber'
   gem 'rspec'
-  gem 'simplecov', platform: 'mri'
-  gem 'simplecov-lcov', platform: 'mri'
 end
-
-group :extra do
-  gem 'ZenTest'
-end
-
-# active_support requires this
-gem 'i18n'

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011-2022 Sylvester Keil. All rights reserved.
+Copyright 2011-2026 Sylvester Keil. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

data/README.md

@@ -28,9 +28,10 @@ overlaps (version 3.x and 4.x are supported).
 
 ### ISO 8601-2
 
-A variation of EDTF will part of the upcoming ISO 8601-2 standard. EDTF-Ruby
+A variation of EDTF has been adopted by the ISO 8601-2 standard. EDTF-Ruby
 does not support this new version of EDTF yet, but if you are curious,
-[EDTF.js](https://github.com/inukshuk/edtf.js), an ES6 implementation is already available.
+[EDTF.js](https://github.com/inukshuk/edtf.js), an ES6 implementation
+is already available.
 
 Quickstart
 ----------

data/Rakefile

@@ -1,21 +1,12 @@
-
-require 'bundler'
-begin
-  Bundler.setup
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
+require 'bundler/gem_tasks'
+require 'rake/clean'
 
 $:.unshift(File.join(File.dirname(__FILE__), './lib'))
 require 'edtf/version'
 
-require 'rake/clean'
-
 task :default => [:spec, :cucumber]
 
-desc 'Run an IRB session with CiteProc loaded'
+desc 'Run an IRB session with EDTF loaded'
 task :console, [:script] do |t,args|
   ARGV.clear
 
@@ -28,12 +19,12 @@ end
 
 desc 'Generates the parser'
 task :racc do
-  system 'bundle exec racc -o lib/edtf/parser.rb lib/edtf/parser.y'
+  sh 'bundle exec racc -o lib/edtf/parser.rb lib/edtf/parser.y'
 end
 
 desc 'Generates the parser with debug information'
 task :racc_debug do
-  system 'bundle exec racc -v -t -o lib/edtf/parser.rb lib/edtf/parser.y'
+  sh 'bundle exec racc -v -t -o lib/edtf/parser.rb lib/edtf/parser.y'
 end
 
 require 'rspec/core'
@@ -45,24 +36,6 @@ end
 require 'cucumber/rake/task'
 Cucumber::Rake::Task.new(:cucumber)
 
-desc 'Builds the gem file'
-task :build => [:check_warnings] do
-  system 'gem build edtf.gemspec'
-end
-
-task :check_warnings do
-  $VERBOSE = true
-  require 'edtf'
-  puts EDTF::VERSION
-end
-
-task :release => [ :build] do
-  system "git tag #{EDTF::VERSION}"
-  system "git push --tags"
-  system "gem push edtf-#{EDTF::VERSION}.gem"
-end
-
 CLEAN.include('lib/edtf/parser.rb')
 CLEAN.include('lib/edtf/parser.output')
-CLEAN.include('*.gem')
-CLEAN.include('**/*.rbc')
+CLOBBER.include('pkg')

data/features/step_definitions/edtf_steps.rb

@@ -1,148 +1,150 @@
-Given /^the date "([^"]*)"(?: with precision set to "([^"]*)")?$/ do |date, precision|
+Given('the date {string}') do |date|
   @date = Date.parse(date)
-	@date.precision = precision unless precision.nil?
 end
 
-When /^I convert the date$/ do
+Given('the date {string} with precision set to {string}') do |date, precision|
+  @date = Date.parse(date)
+  @date.precision = precision
+end
+
+When('I convert the date') do
   @string = @date.edtf
 end
 
-Then /^the EDTF String should be "([^"]*)"$/i do |edtf|
+Then('the EDTF string should be {string}') do |edtf|
   expect(@string).to eq(edtf)
 end
 
-When /^I parse the string "([^"]*)"$/ do |string|
+When('I parse the string {string}') do |string|
   @date = EDTF.parse!(string)
 end
 
-Then /^the year should be "([^"]*)"$/ do |year|
+Then('the year should be {string}') do |year|
   expect(@date.year).to eq(year.to_i)
 end
 
-Then /^the month should be "([^"]*)"$/ do |month|
+Then('the month should be {string}') do |month|
   expect(@date.month).to eq(month.to_i)
 end
 
-Then /^the day should be "([^"]*)"$/ do |day|
+Then('the day should be {string}') do |day|
   expect(@date.day).to eq(day.to_i)
 end
 
-Then /^the hours should be "([^"]*)"$/ do |hours|
+Then('the hours should be {string}') do |hours|
   expect(@date.hour).to eq(hours.to_i)
 end
 
-Then /^the year should be "([^"]*)" UTC$/ do |year|
+Then('the year should be {string} \(UTC)') do |year|
   expect(@date.to_time.utc.year).to eq(year.to_i)
 end
 
-Then /^the month should be "([^"]*)" UTC$/ do |month|
+Then('the month should be {string} \(UTC)') do |month|
   expect(@date.to_time.utc.month).to eq(month.to_i)
 end
 
-Then /^the day should be "([^"]*)" UTC$/ do |day|
+Then('the day should be {string} \(UTC)') do |day|
   expect(@date.to_time.utc.day).to eq(day.to_i)
 end
 
-Then /^the hours should be "([^"]*)" UTC$/ do |hours|
+Then('the hours should be {string} \(UTC)') do |hours|
   expect(@date.to_time.utc.hour).to eq(hours.to_i)
 end
 
-
-Then /^the minutes should be "([^"]*)"$/ do |minutes|
+Then('the minutes should be {string}') do |minutes|
   expect(@date.min).to eq(minutes.to_i)
 end
 
-Then /^the seconds should be "([^"]*)"$/ do |seconds|
+Then('the seconds should be {string}') do |seconds|
   expect(@date.sec).to eq(seconds.to_i)
 end
 
-Then /^the duration should range from "([^"]*)" to "([^"]*)"$/ do |from,to|
-  expect([@date.begin.year.to_s, @date.end.year.to_s]).to eq([from,to])
+Then('the duration should range from {string} to {string}') do |from, to|
+  expect([@date.begin.year.to_s, @date.end.year.to_s]).to eq([from, to])
 end
 
-Then /^the interval should start at "([^"]*)"$/ do |date|
+Then('the interval should start at {string}') do |date|
   expect(@date.begin.to_s).to eq(date)
 end
 
-Then /^the interval should end at "([^"]*)"$/ do |date|
+Then('the interval should end at {string}') do |date|
   expect(@date.end.to_s).to eq(date)
 end
 
-Then /^the interval should include the date "([^"]*)"$/ do |date|
+Then('the interval should include the date {string}') do |date|
   expect(@date).to include(Date.parse(date))
 end
 
-Then /^the interval should cover the date "([^"]*)"$/ do |date|
+Then('the interval should cover the date {string}') do |date|
   expect(@date).to be_cover(Date.parse(date))
 end
 
-
-Then /^the date should be uncertain\? "([^"]*)"$/ do |arg1|
-  expect(@date.uncertain?).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the date should be uncertain? {string}') do |answer|
+  expect(@date.uncertain?).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the year should be uncertain\? "([^"]*)"$/ do |arg1|
-  expect(@date.uncertain?(:year)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the year should be uncertain? {string}') do |answer|
+  expect(@date.uncertain?(:year)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the month should be uncertain\? "([^"]*)"$/ do |arg1|
-  expect(@date.uncertain?(:month)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the month should be uncertain? {string}') do |answer|
+  expect(@date.uncertain?(:month)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the day should be uncertain\? "([^"]*)"$/ do |arg1|
-  expect(@date.uncertain?(:day)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the day should be uncertain? {string}') do |answer|
+  expect(@date.uncertain?(:day)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the date should be approximate\? "([^"]*)"$/ do |arg1|
-  expect(@date.approximate?).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the date should be approximate? {string}') do |answer|
+  expect(@date.approximate?).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the year should be approximate\? "([^"]*)"$/ do |arg1|
-  expect(@date.approximate?(:year)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the year should be approximate? {string}') do |answer|
+  expect(@date.approximate?(:year)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the month should be approximate\? "([^"]*)"$/ do |arg1|
-  expect(@date.approximate?(:month)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the month should be approximate? {string}') do |answer|
+  expect(@date.approximate?(:month)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the day should be approximate\? "([^"]*)"$/ do |arg1|
-  expect(@date.approximate?(:day)).to eq(!!(arg1 =~ /y(es)?/i))
+Then('the day should be approximate? {string}') do |answer|
+  expect(@date.approximate?(:day)).to eq(!!(answer =~ /y(es)?/i))
 end
 
-Then /^the result should be an Unknown$/ do
+Then('the result should be an Unknown') do
   expect(@date).to be_an(EDTF::Unknown)
 end
 
-Then /^the unspecified string code be "([^"]*)"$/ do |arg1|
-  expect(@date.unspecified.to_s).to eq(arg1)
+Then('the unspecified string code be {string}') do |code|
+  expect(@date.unspecified.to_s).to eq(code)
 end
 
-When /^I parse the following strings an error should be raised:$/ do |table|
-	table.raw.each do |row|
-		expect { Date.edtf!(row[0]) }.to raise_error(ArgumentError)
-	end
+When('I parse the following strings an error should be raised:') do |table|
+  table.raw.each do |row|
+    expect { Date.edtf!(row[0]) }.to raise_error(ArgumentError)
+  end
 end
 
-When /^the year is uncertain: "([^"]*)"$/ do |arg1|
-	@date.uncertain!(:year) if arg1 =~ /y(es)?/i
+When('the year is uncertain: {string}') do |answer|
+  @date.uncertain!(:year) if answer =~ /y(es)?/i
 end
 
-When /^the month is uncertain: "([^"]*)"$/ do |arg1|
-	@date.uncertain!(:month) if arg1 =~ /y(es)?/i
+When('the month is uncertain: {string}') do |answer|
+  @date.uncertain!(:month) if answer =~ /y(es)?/i
 end
 
-When /^the day is uncertain: "([^"]*)"$/ do |arg1|
-	@date.uncertain!(:day) if arg1 =~ /y(es)?/i
+When('the day is uncertain: {string}') do |answer|
+  @date.uncertain!(:day) if answer =~ /y(es)?/i
 end
 
-When /^the year is approximate: "([^"]*)"$/ do |arg1|
-	@date.approximate!(:year) if arg1 =~ /y(es)?/i
+When('the year is approximate: {string}') do |answer|
+  @date.approximate!(:year) if answer =~ /y(es)?/i
 end
 
-When /^the month is approximate: "([^"]*)"$/ do |arg1|
-	@date.approximate!(:month) if arg1 =~ /y(es)?/i
+When('the month is approximate: {string}') do |answer|
+  @date.approximate!(:month) if answer =~ /y(es)?/i
 end
 
-When /^the day is approximate "([^"]*)"$/ do |arg1|
-	@date.approximate!(:day) if arg1 =~ /y(es)?/i
+When('the day is approximate {string}') do |answer|
+  @date.approximate!(:day) if answer =~ /y(es)?/i
 end

data/lib/edtf/interval.rb

@@ -37,7 +37,7 @@ module EDTF
 
     def from=(date)
       case date
-      when Date, :unknown
+      when Date, :unknown, :open
         @from = date
       else
         throw ArgumentError.new("Intervals cannot start with: #{date}")
@@ -54,6 +54,15 @@ module EDTF
     end
 
     [:open, :unknown].each do |method_name|
+      define_method("#{method_name}_start!") do
+        @from = method_name
+        self
+      end
+
+      define_method("#{method_name}_start?") do
+        @from == method_name
+      end
+
       define_method("#{method_name}_end!") do
         @to = method_name
         self
@@ -64,16 +73,8 @@ module EDTF
       end
     end
 
-    alias open! open_end!
-    alias open? open_end?
-
-    def unknown_start?
-      from == :unknown
-    end
-
-    def unknown_start!
-      @from = :unknown
-      self
+    def open?
+      open_start? || open_end?
     end
 
     def unknown?
@@ -83,12 +84,12 @@ module EDTF
     # Returns the intervals precision. Mixed precisions are currently not
     # supported; in that case, the start date's precision takes precedence.
     def precision
-      min.precision || max.precision
+      min&.precision || max&.precision
     end
 
     # Returns true if the precisions of start and end date are not the same.
     def mixed_precision?
-      min.precision != max.precision
+      min&.precision != max&.precision
     end
 
     def each(&block)
@@ -170,6 +171,8 @@ module EDTF
         max.day_precision! == other
       when unknown_end?
         min.day_precision! == other
+      when open_start?
+        max.day_precision! >= other
       when open_end?
         min.day_precision! <= other
       else
@@ -216,7 +219,7 @@ module EDTF
         to_a.min(&block)
       else
         case
-        when unknown_start?, !unknown_end? && !open? && to < from
+        when open_start?, unknown_start?, !(open_end? || unknown_end?) && !open? && to < from
           nil
         when from.day_precision?
           from
@@ -249,7 +252,7 @@ module EDTF
         to_a.max(&block)
       else
         case
-        when open_end?, unknown_end?, !unknown_start? && to < from
+        when open_end?, unknown_end?, !(open_start? || unknown_start?) && to < from
           nil
         when to.day_precision?
           to