fat_core 5.6.1 → 6.0.0

data/spec/lib/range_spec.rb

@@ -4,100 +4,101 @@ require 'fat_core/range'
 describe Range do
   describe 'set operations' do
     it 'knows if it is a subset of another range' do
-      expect((4..8)).to be_subset_of((2..9))
-      expect((4..8)).to be_subset_of((4..8))
-      expect((4..8)).not_to be_subset_of((2..7))
-      expect((4..8)).not_to be_subset_of((5..8))
-      expect((4..8)).not_to be_subset_of((11..20))
+      expect((4..8).subset_of?(2..9)).to be true
+      expect((4..8).subset_of?(4..8)).to be true
+      expect((4..8).subset_of?(2..7)).to be false
+      expect((4..8).subset_of?(5..8)).to be false
+      expect((4..8).subset_of?(11..20)).to be false
     end
 
     it 'knows if it is a proper subset of another range' do
-      expect((4..8)).to be_proper_subset_of((2..9))
-      expect((4..8)).to be_proper_subset_of((4..9))
-      expect((4..8)).not_to be_proper_subset_of((4..8))
-      expect((4..8)).not_to be_proper_subset_of((2..7))
-      expect((4..8)).not_to be_proper_subset_of((5..8))
-      expect((4..8)).not_to be_proper_subset_of((11..20))
+      expect((4..8).proper_subset_of?(2..9)).to be true
+      expect((4..8).proper_subset_of?(4..9)).to be true
+      expect((4..8).proper_subset_of?(4..8)).to be false
+      expect((4..8).proper_subset_of?(2..7)).to be false
+      expect((4..8).proper_subset_of?(5..8)).to be false
+      expect((4..8).proper_subset_of?(11..20)).to be false
     end
 
     it 'knows if it is a superset of another range' do
-      expect((4..8)).to be_superset_of((5..7))
-      expect((4..8)).to be_superset_of((6..8))
-      expect((4..8)).to be_superset_of((4..7))
-      expect((4..8)).to be_superset_of((4..8))
-      expect((4..8)).not_to be_superset_of((2..9))
-      expect((4..8)).not_to be_superset_of((2..8))
-      expect((4..8)).not_to be_superset_of((4..9))
-      expect((4..8)).not_to be_superset_of((8..20))
-      expect((4..8)).not_to be_superset_of((0..4))
-      expect((4..8)).not_to be_superset_of((0..3))
-      expect((4..8)).not_to be_superset_of((9..20))
+      expect((4..8).superset_of?(5..7)).to be true
+      expect((4..8).superset_of?(6..8)).to be true
+      expect((4..8).superset_of?(4..7)).to be true
+      expect((4..8).superset_of?(4..8)).to be true
+      expect((4..8).superset_of?(2..9)).to be false
+      expect((4..8).superset_of?(2..8)).to be false
+      expect((4..8).superset_of?(4..9)).to be false
+      expect((4..8).superset_of?(8..20)).to be false
+      expect((4..8).superset_of?(0..4)).to be false
+      expect((4..8).superset_of?(0..3)).to be false
+      expect((4..8).superset_of?(9..20)).to be false
     end
 
     it 'knows if it is a proper superset of another range' do
-      expect((4..8)).to be_proper_superset_of((5..7))
-      expect((4..8)).to be_proper_superset_of((6..8))
-      expect((4..8)).to be_proper_superset_of((4..7))
-      expect((4..8)).not_to be_proper_superset_of((4..8))
-      expect((4..8)).not_to be_proper_superset_of((2..9))
-      expect((4..8)).not_to be_proper_superset_of((2..8))
-      expect((4..8)).not_to be_proper_superset_of((4..9))
-      expect((4..8)).not_to be_proper_superset_of((8..20))
-      expect((4..8)).not_to be_proper_superset_of((0..4))
-      expect((4..8)).not_to be_proper_superset_of((0..3))
-      expect((4..8)).not_to be_proper_superset_of((9..20))
+      expect((4..8).proper_superset_of?(5..7)).to be true
+      expect((4..8).proper_superset_of?(6..8)).to be true
+      expect((4..8).proper_superset_of?(4..7)).to be true
+      expect((4..8).proper_superset_of?(4..8)).to be false
+      expect((4..8).proper_superset_of?(2..9)).to be false
+      expect((4..8).proper_superset_of?(2..8)).to be false
+      expect((4..8).proper_superset_of?(4..9)).to be false
+      expect((4..8).proper_superset_of?(8..20)).to be false
+      expect((4..8).proper_superset_of?(0..4)).to be false
+      expect((4..8).proper_superset_of?(0..3)).to be false
+      expect((4..8).proper_superset_of?(9..20)).to be false
+      expect((4..8).proper_superset_of?(4..8)).to be false
     end
 
     it 'knows its intersection with another range' do
-      expect(((0..10) & (5..20))).to eq((5..10))
-      expect(((0..10) & (5..20))).to eq((5..20) & (0..10))
-      expect(((0..10) & (10..20))).to eq((10..10))
+      expect((0..10) & (5..20)).to eq(5..10)
+      expect((0..10) & (5..20)).to eq((5..20) & (0..10))
+      expect((0..10) & (10..20)).to eq(10..10)
     end
 
     it 'intersection should return nil if there is no overlap' do
-      expect(((0..10) & (15..20))).to be_nil
+      expect((0..10) & (15..20)).to be_nil
     end
 
     it 'knows its union with another range' do
-      expect(((0..10) + (5..20))).to eq((0..20))
-      expect(((0..10) + (5..20))).to eq((5..20) + (0..10))
-      expect(((0..10) + (10..20))).to eq((0..20))
+      expect((0..10) + (5..20)).to eq(0..20)
+      expect((0..10) + (5..20)).to eq((5..20) + (0..10))
+      expect((0..10) + (10..20)).to eq(0..20)
 
       # For discrete values, union should work on contiguous ranges
-      expect(((0..5) + (6..20))).to eq((0..20))
+      expect((0..5) + (6..20)).to eq(0..20)
     end
 
     it 'union should return nil if there is no overlap' do
-      expect(((0..10) & (15..20))).to be_nil
-      expect(((15..20) & (0..10))).to be_nil
+      expect((0..10) & (15..20)).to be_nil
+      expect((15..20) & (0..10)).to be_nil
     end
 
     it 'knows the difference with another range' do
       # Other is same as self
       # xrubocop:disable Lint/BinaryOperatorWithIdenticalOperands
       expect(((4..10) - (4..10)).size).to eq(0)
-      expect(((4..10) - (4..10))).to be_empty
+      expect((4..10) - (4..10)).to be_empty
       # xrubocop:enable Lint/BinaryOperatorWithIdenticalOperands
 
       # Other is proper subset of self
-      expect(((4..10) - (6..7)).first).to eq((4..5))
-      expect(((4..10) - (6..7)).last).to eq((8..10))
-      expect(((4..10) - (6..10)).first).to eq((4..5))
-      expect(((4..10) - (4..7)).last).to eq((8..10))
+      expect(((4..10) - (6..7)).first).to eq(4..5)
+      expect(((4..10) - (6..7)).last).to eq(8..10)
+      expect(((4..10) - (6..10)).first).to eq(4..5)
+      expect(((4..10) - (4..7)).last).to eq(8..10)
 
       # Other overlaps on the left
       expect(((4..10) - (0..6)).size).to eq(1)
-      expect(((4..10) - (0..6)).first).to eq((7..10))
+      expect(((4..10) - (0..6)).first).to eq(7..10)
 
       expect(((4..10) - (4..6)).size).to eq(1)
-      expect(((4..10) - (4..6)).first).to eq((7..10))
+      expect(((4..10) - (4..6)).first).to eq(7..10)
 
       # Other overlaps on the right
       expect(((4..10) - (7..11)).size).to eq(1)
-      expect(((4..10) - (7..11)).first).to eq((4..6))
+      expect(((4..10) - (7..11)).first).to eq(4..6)
 
       expect(((4..10) - (7..10)).size).to eq(1)
-      expect(((4..10) - (7..10)).last).to eq((4..6))
+      expect(((4..10) - (7..10)).last).to eq(4..6)
 
       # Other does not overlap
       expect((4..10) - (13..20)).to eq([(4..10)])
@@ -107,8 +108,8 @@ describe Range do
 
   describe 'joining' do
     it 'can join contiguous ranges' do
-      expect((0..3).join(4..8)).to eq((0..8))
-      expect((4..8).join(0..3)).to eq((0..8))
+      expect((0..3).join(4..8)).to eq(0..8)
+      expect((4..8).join(0..3)).to eq(0..8)
     end
 
     it 'returns nil on join of non-contiguous ranges' do
@@ -120,51 +121,51 @@ describe Range do
     end
 
     it 'works with Floats, allowing single-point overlap' do
-      expect((0.0..3.0).join(3.0..8.2)).to eq((0.0..8.2))
-      expect((3.0..8.2).join(0.0..3.0)).to eq((0.0..8.2))
+      expect((0.0..3.0).join(3.0..8.2)).to eq(0.0..8.2)
+      expect((3.0..8.2).join(0.0..3.0)).to eq(0.0..8.2)
     end
   end
 
   describe 'spanning' do
     it 'can determine whether it is spanned by a set of ranges' do
-      expect((0..10)).to be_spanned_by([(0..3), (4..6), (7..10)])
+      expect((0..10).spanned_by?([(0..3), (4..6), (7..10)])).to be true
     end
 
     it 'can determine that overlapping ranges do not span' do
-      expect((0..10)).not_to be_spanned_by([(0..3), (3..6), (7..10)])
+      expect((0..10).spanned_by?([(0..3), (3..6), (7..10)])).to be false
     end
 
     it 'allows spanning ranges to be any Enumerable' do
       require 'set'
       set = [(0..3), (4..6), (7..10)].to_set
-      expect((0..10)).to be_spanned_by(set)
+      expect((0..10).spanned_by?(set)).to be true
       set = [(0...3), (4..6), (7..10)].to_set
-      expect((0..10)).not_to be_spanned_by(set)
+      expect((0..10).spanned_by?(set)).to be false
     end
 
     it 'allows the spanning set to be wider than itself' do
       set = [(0..3), (4..6), (7..10)].to_set
-      expect((2..8)).to be_spanned_by(set)
-      expect((5..6)).to be_spanned_by(set)
+      expect((2..8).spanned_by?(set)).to be true
+      expect((5..6).spanned_by?(set)).to be true
     end
   end
 
   describe 'overlapping a single range' do
     it 'knows if another range overlaps it' do
-      expect((0..10)).to be_overlaps(-3..5)
-      expect((0..10)).to be_overlaps(3..5)
-      expect((0..10)).to be_overlaps(8..15)
-      expect((0..10)).to be_overlaps(0..10)
-      expect((0..10)).not_to be_overlaps(11..12)
-      expect((0..10)).not_to be_overlaps(-11..-1)
+      expect((0..10).overlaps?(-3..5)).to be true
+      expect((0..10).overlaps?(3..5)).to be true
+      expect((0..10).overlaps?(8..15)).to be true
+      expect((0..10).overlaps?(0..10)).to be true
+      expect((0..10).overlaps?(11..12)).to be false
+      expect((0..10).overlaps?(-11..-1)).to be false
 
       # Order of operands should not matter
-      expect((-3..5)).to be_overlaps(0..10)
-      expect((3..5)).to be_overlaps(0..10)
-      expect((8..15)).to be_overlaps(0..10)
-      expect((0..10)).to be_overlaps(0..10)
-      expect((11..12)).not_to be_overlaps(0..10)
-      expect((-11..-1)).not_to be_overlaps(0..10)
+      expect((-3..5).overlaps?(0..10)).to be true
+      expect((3..5).overlaps?(0..10)).to be true
+      expect((8..15).overlaps?(0..10)).to be true
+      expect((0..10).overlaps?(0..10)).to be true
+      expect((11..12).overlaps?(0..10)).to be false
+      expect((-11..-1).overlaps?(0..10)).to be false
     end
 
     it 'can determine whether a set contains covered overlaps' do
@@ -201,8 +202,8 @@ describe Range do
 
     it 'returns an array of gaps' do
       gaps = (0..10).gaps([(0..3), (5..6), (9..10)])
-      expect(gaps[0]).to eq((4..4))
-      expect(gaps[1]).to eq((7..8))
+      expect(gaps[0]).to eq(4..4)
+      expect(gaps[1]).to eq(7..8)
     end
 
     it 'allows ranges to extend before and after self' do
@@ -213,30 +214,30 @@ describe Range do
     it 'does not include parts before or after in gaps' do
       gaps = (0..10).gaps([(-10..-8), (-3..3), (7..13), (30..40)])
       expect(gaps.size).to eq(1)
-      expect(gaps[0]).to eq((4..6))
+      expect(gaps[0]).to eq(4..6)
     end
 
     it 'includes gaps at beginning and end' do
       gaps = (0..10).gaps([(2..3), (4..6), (7..8)])
-      expect(gaps[0]).to eq((0..1))
-      expect(gaps[1]).to eq((9..10))
+      expect(gaps[0]).to eq(0..1)
+      expect(gaps[1]).to eq(9..10)
     end
 
     it 'works even if ranges are out of order' do
       gaps = (0..10).gaps([(2..3), (30..40), (7..8), (-10..-8), (4..6)])
-      expect(gaps[0]).to eq((0..1))
-      expect(gaps[1]).to eq((9..10))
+      expect(gaps[0]).to eq(0..1)
+      expect(gaps[1]).to eq(9..10)
     end
 
     it 'notices single point coverage' do
       gaps = (0..10).gaps([(4..4), (5..5), (6..6)])
-      expect(gaps[0]).to eq((0..3))
-      expect(gaps[1]).to eq((7..10))
+      expect(gaps[0]).to eq(0..3)
+      expect(gaps[1]).to eq(7..10)
     end
 
     it 'works for a single-point range' do
       gaps = (3..3).gaps([(0..2), (4..4), (5..5), (6..6)])
-      expect(gaps[0]).to eq((3..3))
+      expect(gaps[0]).to eq(3..3)
     end
 
     it 'works even if ranges overlap' do
@@ -265,22 +266,22 @@ describe Range do
     it 'returns an array of overlaps' do
       overlaps = (0..10).overlaps([(0..3), (2..6), (4..10)])
       expect(overlaps.size).to eq(2)
-      expect(overlaps[0]).to eq((2..3))
-      expect(overlaps[1]).to eq((4..6))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
 
     it 'does not return any overlaps before self' do
       overlaps = (0..10).overlaps([(-5..-3), (-4..-1), (0..3), (2..6), (4..10)])
       expect(overlaps.size).to eq(2)
-      expect(overlaps[0]).to eq((2..3))
-      expect(overlaps[1]).to eq((4..6))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
 
     it 'does not return any overlaps after self' do
       overlaps = (0..10).overlaps([(0..3), (2..6), (4..15), (11..20)])
       expect(overlaps.size).to eq(2)
-      expect(overlaps[0]).to eq((2..3))
-      expect(overlaps[1]).to eq((4..6))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
   end
 end

data/spec/lib/string_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 require 'fat_core/string'
-require 'fat_core/date'
 
 describe String do
   describe 'class methods' do
@@ -144,14 +143,6 @@ the people, for the people, shall not perish from the earth."
       end
     end
 
-    it 'converts a digital date to a Date' do
-      expect('20140521'.as_date.iso).to eq '2014-05-21'
-      expect('2014-05-21'.as_date.iso).to eq '2014-05-21'
-      expect('2014/05/21'.as_date.iso).to eq '2014-05-21'
-      expect('2014/5/21'.as_date.iso).to eq '2014-05-21'
-      expect('201X/5/21'.as_date).to be_nil
-    end
-
     it 'converts a string to a regular expression' do
       # Ignores case by default
       re = "/hello((\s+)(world))?/".as_regexp

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: fat_core
 version: !ruby/object:Gem::Version
-  version: 5.6.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Daniel E. Doherty
 bindir: bin
 cert_chain: []
-date: 2025-03-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -73,8 +73,7 @@ description: |
   iteration, (also for Hash), set operations on Ranges
 email:
 - ded@ddoherty.net
-executables:
-- easter
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -91,14 +90,12 @@ files:
 - Rakefile
 - TODO.org
 - bin/console
-- bin/easter
 - fat_core.gemspec
 - lib/fat_core.rb
 - lib/fat_core/ChangeLog
 - lib/fat_core/all.rb
 - lib/fat_core/array.rb
 - lib/fat_core/bigdecimal.rb
-- lib/fat_core/date.rb
 - lib/fat_core/enumerable.rb
 - lib/fat_core/hash.rb
 - lib/fat_core/kernel.rb
@@ -111,7 +108,6 @@ files:
 - lib/fat_core/version.rb
 - spec/lib/array_spec.rb
 - spec/lib/big_decimal_spec.rb
-- spec/lib/date_spec.rb
 - spec/lib/enumerable_spec.rb
 - spec/lib/hash_spec.rb
 - spec/lib/kernel_spec.rb
@@ -140,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.7
 specification_version: 4
 summary: some useful core extensions
 test_files: []

data/bin/easter

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "debug"
-require 'fat_core/date'
-
-usage = <<~HELP
-  USAGE:
-     easter             -- print the date of Easter for the current year
-     easter year        -- print the date of Easter for the given year
-     easter year1 year2 -- print the dates of Easter from year1 to year2
-
-  Note: if the date of Easter is the earliest possible, it is marked with a '<';
-        if it is the latest date possible, it is marked with a '>'
-HELP
-first, last = *ARGV
-first ||= Date.today.year
-last ||= Date.today.year
-
-if first.to_s.match?(/--help|-h/)
-  puts usage
-  exit(1)
-end
-
-begin
-  first = Integer(first)
-  last = Integer(last)
-rescue ArgumentError
-  warn "!!Error: invalid year number given\n\n"
-  puts usage
-  exit(2)
-end
-
-(first..last).each do |yr|
-  easter = Date.easter(yr)
-  sig =
-    if easter.month == 4 && easter.day >= 25
-      ' >'
-    elsif easter.month == 3 && easter.day <= 22
-      ' <'
-    else
-      ''
-    end
-  puts "Easter #{yr}: #{easter.iso}#{sig}"
-end