fat_period 1.0.3 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a2fde65d6d14d1a0c94d09b2097528ef2f23826388b1f3291ac7e7d0b3312af
-  data.tar.gz: c14e872d1fb6abf9015a4acf3a3b5c21c23afe28e05f8f15ba7df6db921751d2
+  metadata.gz: 609274b0338a91caf02d5fbf0ed37b4d2621dea51e93a393f9bde86e5287b0ad
+  data.tar.gz: cddf0aa8c7087d0705917319090dab8fea710579b697cc79d231f0257a80271d
 SHA512:
-  metadata.gz: 23ab6b2bc98abfc6d7609df56f93b7acf8683d29fdd13a54c7377b321ffc0a29d29c5498c327054ef5c970c5650b129757fca7a0b71db4132c4d5328a9b31c24
-  data.tar.gz: d266e75e1c4caaecbd14952cad1ffbc6cea36e65c6d6b5264b353edc7c3b5604aa04709489c5f3ffa058f3d0d9a236ce1ca2d228283e907092166c19351ddc72
+  metadata.gz: 3da42e489a2dc3a1d8b42191e589e675a71466048a70b1b2d04f430b2f3f34685f0c137194952a7c4ec33c117cf227b1143670409353351af9b8531492efc93b
+  data.tar.gz: e91123fa17ff8a9f47553652a302316418aaf2f5fe5eee587b45ecb9b27799ad20b39b9e1af350e4453ee69f19f4a8cd6a595ed82df2247c5bc8084c664768de

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
 rvm:
-  - 2.3.0
-  - 2.4
   - 2.5
   - 2.6
   - 2.7
-  - ruby-head
+  - 3.0

data/fat_period.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry-doc'
   spec.add_development_dependency 'pry-byebug'
 
-  spec.add_runtime_dependency 'fat_core'
+  spec.add_runtime_dependency 'fat_core', '>= 4.8.3'
 end

data/lib/fat_period/period.rb

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 require 'fat_core/date'
 require 'fat_core/range'
 require 'fat_core/string'
@@ -29,37 +27,10 @@ class Period
   # @raise [ArgumentError] if first date is later than last date
   # @return [Period]
   def initialize(first, last)
-    if first.is_a?(Date)
-      @first = first
-    elsif first.respond_to?(:to_s)
-      begin
-        @first = Date.parse(first.to_s)
-      rescue ArgumentError => e
-        if e.message =~ /invalid date/
-          raise ArgumentError, "invalid date '#{first}'"
-        end
-
-        raise
-      end
-    else
-      raise ArgumentError, 'use Date or String to initialize Period'
-    end
+    @first = Date.ensure_date(first).freeze
+    @last = Date.ensure_date(last).freeze
+    freeze
 
-    if last.is_a?(Date)
-      @last = last
-    elsif last.respond_to?(:to_s)
-      begin
-        @last = Date.parse(last.to_s)
-      rescue ArgumentError => e
-        if e.message =~ /invalid date/
-          raise ArgumentError, "you gave an invalid date '#{last}'"
-        end
-
-        raise
-      end
-    else
-      raise ArgumentError, 'use Date or String to initialize Period'
-    end
     return unless @first > @last
 
     raise ArgumentError, "Period's first date is later than its last date"
@@ -116,14 +87,13 @@ class Period
   # @return [Period] translated from phrase
   def self.parse_phrase(phrase)
     phrase = phrase.clean
-    if phrase =~ /\Afrom (.*) to (.*)\z/
+    case phrase
+    when /\Afrom (.*) to (.*)\z/
       from_phrase = $1
       to_phrase = $2
-    elsif phrase =~ /\Afrom (.*)\z/
+    when /\Afrom (.*)\z/, /\Ato (.*)\z/
       from_phrase = $1
       to_phrase = nil
-    elsif phrase =~ /\Ato (.*)\z/
-      from_phrase = $1
     else
       from_phrase = phrase
       to_phrase = nil
@@ -208,6 +178,20 @@ class Period
     !(self == other)
   end
 
+  # Return the hash value for this Period.  Make Period's with identical
+  # values test eql? so that they may be used as hash keys.
+  #
+  # @return [Integer]
+  def hash
+    (first.hash | last.hash)
+  end
+
+  def eql?(other)
+    return nil unless other.is_a?(Period)
+
+    hash == other.hash
+  end
+
   # Return whether this Period contains the given date.
   #
   # @param date [Date] date to test
@@ -297,6 +281,12 @@ class Period
   CHUNKS = %i[day week biweek semimonth month bimonth quarter
               half year irregular].freeze
 
+  CHUNK_ORDER = {}
+  CHUNKS.each_with_index do |c, i|
+    CHUNK_ORDER[c] = i
+  end
+  CHUNK_ORDER.freeze
+
   # An Array of Ranges for the number of days that can be covered by each chunk.
   CHUNK_RANGE = {
     day: (1..1), week: (7..7), biweek: (14..14), semimonth: (15..16),
@@ -304,6 +294,10 @@ class Period
     half: (180..183), year: (365..366)
   }.freeze
 
+  def self.chunk_cmp(chunk1, chunk2)
+    CHUNK_ORDER[chunk1] <=> CHUNK_ORDER[chunk2]
+  end
+
   # Return a period representing a chunk containing a given Date.
   def self.day_containing(date)
     Period.new(date, date)
@@ -341,6 +335,17 @@ class Period
     Period.new(date.beginning_of_year, date.end_of_year)
   end
 
+  def self.chunk_containing(date, chunk)
+    raise ArgumentError, 'chunk is nil' unless chunk
+
+    chunk = chunk.to_sym
+    raise ArgumentError, "unknown chunk name: #{chunk}" unless CHUNKS.include?(chunk)
+
+    date = Date.ensure_date(date)
+    method = "#{chunk}_containing".to_sym
+    send(method, date)
+  end
+
   # Return a Period representing a chunk containing today.
   def self.this_day
     day_containing(Date.current)
@@ -461,20 +466,20 @@ class Period
     end
   end
 
-  # Return the chunk symbol represented by the number of days given, but allow a
-  # deviation from the minimum and maximum number of days for periods larger
-  # than bimonths. The default tolerance is +/-10%, but that can be adjusted. The
-  # reason for allowing a bit of tolerance for the larger periods is that
-  # financial statements meant to cover a given calendar period are often short
-  # or long by a few days due to such things as weekends, holidays, or
-  # accounting convenience. For example, a bank might issuer "monthly"
-  # statements approximately every 30 days, but issue them earlier or later to
-  # avoid having the closing date fall on a weekend or holiday. We still want to
-  # be able to recognize them as "monthly", even though the period covered might
-  # be a few days shorter or longer than any possible calendar month.  You can
-  # eliminate this "fudge factor" by setting the `tolerance_pct` to zero.  If
-  # the number of days corresponds to none of the defined calendar periods,
-  # return the symbol `:irregular`.
+  # Return the chunk symbol represented by the number of days given, but allow
+  # a deviation from the minimum and maximum number of days for periods larger
+  # than bimonths. The default tolerance is +/-10%, but that can be
+  # adjusted. The reason for allowing a bit of tolerance for the larger
+  # periods is that financial statements meant to cover a given calendar
+  # period are often short or long by a few days due to such things as
+  # weekends, holidays, or accounting convenience. For example, a bank might
+  # issuer "monthly" statements approximately every 30 days, but issue them
+  # earlier or later to avoid having the closing date fall on a weekend or
+  # holiday. We still want to be able to recognize them as "monthly", even
+  # though the period covered might be a few days shorter or longer than any
+  # possible calendar month.  You can eliminate this "fudge factor" by setting
+  # the `tolerance_pct` to zero.  If the number of days corresponds to none of
+  # the defined calendar periods, return the symbol `:irregular`.
   #
   # @example
   #   Period.days_to_chunk(360)    #=> :year
@@ -483,12 +488,12 @@ class Period
   #   Period.days_to_chunk(88, 0)  #=> :irregular
   #
   # @param days [Integer] the number of days in the period under test
-  # @param tolerance_pct [Numberic] the percent deviation allowed, e.g. 10 => 10%
+  # @param tolerance_pct [Numeric] the percent deviation allowed, e.g. 10 => 10%
   # @return [Symbol] symbol for the period corresponding to days number of days
   def self.days_to_chunk(days, tolerance_pct = 10)
     result = :irregular
     CHUNK_RANGE.each_pair do |chunk, rng|
-      if [:semimonth, :biweek, :week, :day].include?(chunk)
+      if %i[semimonth biweek week day].include?(chunk)
         # Be strict for shorter periods.
         if rng.cover?(days)
           result = chunk
@@ -578,77 +583,59 @@ class Period
   # @return [Array<Period>] periods that subdivide self into chunks of size, `size`
   def chunks(size: :month, partial_first: false, partial_last: false,
              round_up_last: false)
-    size = size.to_sym
-    unless CHUNKS.include?(size)
-      raise ArgumentError, "unknown chunk size '#{size}'"
-    end
+    chunk_size = size.to_sym
+    raise ArgumentError, "unknown chunk size '#{chunk_size}'" unless CHUNKS.include?(chunk_size)
 
-    if CHUNK_RANGE[size].first > length
-      return [self] if partial_first || partial_last
+    containing_period = Period.chunk_containing(first, chunk_size)
+    return [dup] if self == containing_period
 
-      msg = "any #{size} is longer than this period's #{length} days"
-      raise ArgumentError, msg
+    # Period too small for even a single chunk and is wholly-contained by a
+    # single chunk.
+    result = []
+    if proper_subset_of?(containing_period)
+      result =
+        if partial_first || partial_last
+          if round_up_last
+            [containing_period]
+          else
+            [dup]
+          end
+        else
+          []
+        end
+      return result
     end
 
-    result = []
     chunk_start = first.dup
-    while chunk_start <= last
-      case size
-      when :year
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_year?
-        end
-        chunk_end = chunk_start.end_of_year
-      when :half
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_half?
-        end
-        chunk_end = chunk_start.end_of_half
-      when :quarter
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_quarter?
-        end
-        chunk_end = chunk_start.end_of_quarter
-      when :bimonth
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_bimonth?
-        end
-        chunk_end = (chunk_start.end_of_month + 1.day).end_of_month
-      when :month
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_month?
-        end
-        chunk_end = chunk_start.end_of_month
-      when :semimonth
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_semimonth?
-        end
-        chunk_end = chunk_start.end_of_semimonth
-      when :biweek
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_biweek?
-        end
-        chunk_end = chunk_start.end_of_biweek
-      when :week
-        unless partial_first
-          chunk_start += 1.day until chunk_start.beginning_of_week?
-        end
-        chunk_end = chunk_start.end_of_week
-      when :day
-        chunk_end = chunk_start
-      else
-        raise ArgumentError, "invalid chunk size '#{size}'"
-      end
-      if chunk_end <= last
-        result << Period.new(chunk_start, chunk_end)
-      elsif round_up_last
+    chunk_end = chunk_start.end_of_chunk(chunk_size)
+    if chunk_start.beginning_of_chunk?(chunk_size) || partial_first
+      # Keep the first chunk if it's whole or partials allowed
+      result << Period.new(chunk_start, chunk_end)
+    end
+    chunk_start = chunk_end + 1.day
+    chunk_end = chunk_start.end_of_chunk(chunk_size)
+    # Add Whole chunks
+    while chunk_end <= last
+      result << Period.new(chunk_start, chunk_end)
+      chunk_start = chunk_end + 1.day
+      chunk_end = chunk_start.end_of_chunk(chunk_size)
+    end
+    # Possibly append the final chunk to result
+    if chunk_start < last
+      if round_up_last
         result << Period.new(chunk_start, chunk_end)
       elsif partial_last
         result << Period.new(chunk_start, last)
       else
-        break
+        result
       end
-      chunk_start = result.last.last + 1.day
+    end
+    if partial_last && !partial_first && result.empty?
+      # Catch the case where the period is too small to make a whole chunk and
+      # partial_first is false, so it did not get included as the initial
+      # partial chunk, yet a partial_last is allowed, so include the whole
+      # period as a partial chunk.
+      result << Period.new(first, last)
     end
     result
   end
@@ -694,7 +681,7 @@ class Period
     to_range.superset_of?(other.to_range)
   end
 
-  # Does this period wholly contain but not coincident with `other`?
+  # Does this period wholly contain but is not coincident with `other`?
   #
   # @example
   #   Period.parse('2015').proper_superset_of?(Period.parse('2015-2Q'))    #=> true

data/lib/fat_period/version.rb

@@ -1,3 +1,3 @@
 module FatPeriod
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.2.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_period
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.2.1
 platform: ruby
 authors:
 - Daniel E. Doherty
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-23 00:00:00.000000000 Z
+date: 2021-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,15 +100,15 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-description: 
+        version: 4.8.3
+description:
 email:
 - ded-law@ddoherty.net
 executables: []
@@ -132,7 +132,7 @@ files:
 homepage: https://github.com/ddoherty03/fat_period
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -147,8 +147,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.3.3
+signing_key:
 specification_version: 4
 summary: Implements a Period class as a Range of Dates.
 test_files: []