active_period 7.0.0 → 7.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f52b743020890ffb49224e7b0dd129901233a4d1cdd639d412a88872c66b97d0
-  data.tar.gz: 0eb862ce0e5aa128ce81fd93e28dd887c64f0f70ec000c9dd7988e281288be39
+  metadata.gz: e197dc4558fd215fc7090f5a14ad074e769457abfa7665b4b2393e5ba2a23d52
+  data.tar.gz: 54c3de6172706d0f08e2885b6401b3f1c964526498193a63c13af4fbfab6eb99
 SHA512:
-  metadata.gz: bce08f3f5b1b10347469b43a832d525bec3a470b09e798539f84bc80b4aca768898734565acadf5600670fcbb9e7a3e6a427b9c4fcbccc402e5b5c0109a05a62
-  data.tar.gz: 5e3dcdb1f0328b1baf28ad298e951d893c9e9102faa703890ba47f3c6983947c666dad61e810364ff2bb2b4648542be859d7bfee5f081472da4bb7d3293da07a
+  metadata.gz: a228d61ffcb56d1f9206127e22775e2a3ec109822ce0b8242e6e778d8edb08531dd9b2834cc7def80cb42ec7cf148b2abc8776059228c5fb7b7d9cb90ec68562
+  data.tar.gz: 25550cbd55706774bfd34e68690be5d39b2e01b6681f33b3134d3c7169949c9e1d017ac40cadd24d041eef2c85d3ce6c05dbb8fe76761d6a2fabebe501230e24

data/Gemfile.lock

@@ -1,20 +1,20 @@
 PATH
   remote: .
   specs:
-    active_period (7.0.0)
-      activesupport (~> 7, >= 5)
+    active_period (7.1.1)
+      activesupport (>= 5, < 8)
       i18n (~> 1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.2)
+    activesupport (7.0.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     builder (3.2.4)
-    concurrent-ruby (1.1.9)
+    concurrent-ruby (1.1.10)
     cucumber (7.0.0)
       builder (~> 3.2, >= 3.2.4)
       cucumber-core (~> 10.0, >= 10.0.1)
@@ -48,17 +48,17 @@ GEM
       cucumber-messages (~> 17.0, >= 17.0.1)
     diff-lcs (1.4.4)
     ffi (1.15.3)
-    i18n (1.10.0)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
     mime-types-data (3.2021.0704)
-    minitest (5.15.0)
+    minitest (5.16.3)
     multi_test (0.1.2)
     rake (10.5.0)
     sys-uname (1.2.2)
       ffi (~> 1.1)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
 
 PLATFORMS

data/README.md

@@ -82,6 +82,9 @@ Period.new(params[:start_date]..params[:end_date])
 
 # or from a range
 ('01/01/2000'...'01/02/2000').to_period
+
+# you can also use [] if .new is too long for you
+Period['01/01/2000'...'01/02/2000']
 ```
 
 **Note** : `to_period` will always return a **FreePeriod**
@@ -204,6 +207,41 @@ These methods return a **StandardPeriod** who include the current period
 Period.this_year.months.second.weeks.last.days.third
 ```
 
+## Period Combination with `&` and `|`
+
+You can use `&` to combine overlapping periods     
+And `|` to combine overlapping and tail to head periods     
+If the given periods cannot combine, then `nil` will be return       
+The period we take the ending date from, determine if the ending date is included or excluded
+
+#### Example for `&`
+```ruby
+# Overlapping periods
+(Period['01/01/2021'..'20/01/2021'] & Period['10/01/2021'...'30/01/2021']).to_s
+=> "From the 10 January 2021 to the 20 January 2021 included"
+
+# Theses period cannot combine
+Period.this_month & Period.next_month
+=> nil
+```
+
+#### Example for `|`
+```ruby
+# Overlapping periods
+(Period['01/01/2021'..'20/01/2021'] | Period['10/01/2021'...'30/01/2021']).to_s
+=> "From the 01 January 2021 to the 30 January 2021 excluded"
+
+# Example with tail to head
+(Period.this_month | Period.next_month).to_s
+=> "From the 01 September 2022 to the 31 October 2022 included"
+(Period['01/01/2021'..'09/01/2021']  | Period['10/01/2021'..'20/01/2021']).to_s
+=> "From the 01 January 2021 to the 20 January 2021 included"
+
+# Theses period cannot combine
+Period['01/01/2021'...'09/01/2021'] | Period['10/01/2021'..'20/01/2021']
+=> nil
+```
+
 ## Boundless Period
 
 Boundless period are fully supported and work as you expect them to do    

data/active_period.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.7'
 
-  spec.add_runtime_dependency 'activesupport', '>= 5', '~> 7'
+  spec.add_runtime_dependency 'activesupport', '>= 5', '< 8'
   spec.add_runtime_dependency 'i18n', '~> 1'
 
   spec.add_development_dependency 'bundler', '~> 2.0'

data/config/locales/fr.yml

@@ -5,7 +5,7 @@ fr:
     comparable:
       incomparable_error:               Les arguments ne sont pas comparables
     collection:
-      param_period_must_be_a_period:          Le paramètre doit hériter de la class Period
+      param_period_must_be_a_period:    Le paramètre doit hériter de la class Period
     period:
       base_class_is_abstract:           Period est une class abstraite qui ne doit pas être utiliser directement
       begin_date_is_invalid:            Date de début invalide
@@ -15,8 +15,8 @@ fr:
       param_must_be_a_range:            Le paramètre doit hériter de la class Range
     free_period:
       default_format:                   Du %{from} au %{to} %{ending}
-      beginless_format:                 Jusqu'au %{from} %{ending}
-      endless_format:                   Depuis le %{to}
+      beginless_format:                 Jusqu'au %{to} %{ending}
+      endless_format:                   Depuis le %{from}
       boundless_format:                 Sans limite de temps
     standard_period:
       base_class_is_abstract:     StandardPeriod est une class abstraite qui ne doit pas être utiliser directement

data/lib/active_period/comparable.rb

@@ -16,12 +16,14 @@ module ActivePeriod
     end
 
     def <=>(other)
+      raise ArgumentError, I18n.t(:incomparable_error, scope: %i[active_period comparable]) unless other.is_a?(ActiveSupport::Duration)
+
       if other.is_a?(ActiveSupport::Duration) || other.is_a?(Numeric)
         to_i <=> other.to_i
       elsif self.class != other.class
         raise ArgumentError, I18n.t(:incomparable_error, scope: %i[active_period comparable])
       else
-        (from <=> other)
+        (self.begin <=> other)
       end
     end
 

data/lib/active_period/period.rb

@@ -9,7 +9,7 @@ class ActivePeriod::Period < Range
   # @param range [Range] A valid range
   # @param allow_beginless [Boolean] Is it allow to creat a beginless range
   # @param allow_endless [Boolean] Is it allow to creat an endless range
-  # @return [self] A new instance of ActivePeriod::FreePeriod
+  # @return [self] A new instance of ActivePeriod::Period
   # @raise ArgumentError if the params range is not a Range
   # @raise ArgumentError if the params range is invalid
   def initialize(range, allow_beginless: true, allow_endless: true)
@@ -25,8 +25,6 @@ class ActivePeriod::Period < Range
     raise ::ArgumentError, I18n.t(:end_date_is_invalid, scope: %i[active_period period]) if !allow_endless && to.nil?
     to = to.try(:end_of_day) || to
 
-    # raise ::ArgumentError, I18n.t(:endless_excluded_end_is_forbiden, scope: %i[active_period period]) if to.nil? && range.exclude_end?
-    # to = to.prev_day if range.exclude_end?
     if range.exclude_end? && from && to && from.to_date == to.to_date
       raise ::ArgumentError, I18n.t(:start_is_equal_to_end_excluded, scope: %i[active_period period])
     end
@@ -70,19 +68,79 @@ class ActivePeriod::Period < Range
     raise NotImplementedError
   end
 
-  # @param other [ActivePeriod::FreePeriod] Any kind of ActivePeriod::FreePeriod object
+  # @param other [ActivePeriod::Period, ActiveSupport::Duration, Numeric] Any kind of ActivePeriod::Period, ActiveSupport::Duration or Numeric (in seconds)
   # @return [Boolean] true if period are equals, false otherwise
-  # @raise ArgumentError if params other is not a ActivePeriod::FreePeriod of some kind
+  # @raise ArgumentError if params other is not a ActivePeriod::Period of some kind
   def ==(other)
     if other.class.ancestors.include?(ActivePeriod::Period)
       from == other.from && self.calculated_end == other.calculated_end
-    elsif other.is_a?(ActiveSupport::Duration) || other.is_a?(Numeric)
+    elsif other.is_a?(ActiveSupport::Duration)
       super(other)
+    elsif other.is_a?(Numeric)
+      super(other.seconds)
     else
       raise ArgumentError
     end
   end
 
+  # @param other [ActivePeriod::Period] Any kind of ActivePeriod::Period object
+  # @return [Boolean] true if period and class are the same, false otherwise
+  # @raise ArgumentError if params other is not a ActivePeriod::Period of some kind
+  def ===(other)
+    self == other && self.class == other.class
+  end
+
+  # @param other [ActivePeriod::Period] Any kind of ActivePeriod::Period object
+  # @return [ActivePeriod::Period, nil] Any kind of ActivePeriod::FreePeriod if period overlap, nil otherwise
+  # @raise ArgumentError if params other is not a ActivePeriod::Period of some kind
+  def &(other)
+    raise ArgumentError, I18n.t(:incomparable_error, scope: %i[active_period comparable]) unless other.class.ancestors.include?(ActivePeriod::Period)
+
+    # self            9------12
+    # other  1-----------10
+    if self.begin.in?(other) && !calculated_end.in?(other)
+      Period.new( Range.new(self.begin, other.to, other.exclude_end?) )
+    # self    1-----------10
+    # other            9------12
+    elsif !self.begin.in?(other) && calculated_end.in?(other)
+      Period.new( Range.new(other.begin, to, exclude_end?) )
+    # self      5-----8
+    # other  1-----------10
+    elsif other.include?(self)
+      other
+    # self   1-----------10
+    # other      5-----8
+    elsif self.include?(other)
+      self
+    else
+      nil
+    end
+  end
+
+  # @param other [ActivePeriod::Period] Any kind of ActivePeriod::Period object
+  # @return [ActivePeriod::Period, nil] Any kind of ActivePeriod::FreePeriod if period overlap, nil otherwise
+  # @raise ArgumentError if params other is not a ActivePeriod::Period of some kind
+  def |(other)
+    raise ArgumentError, I18n.t(:incomparable_error, scope: %i[active_period comparable]) unless other.class.ancestors.include?(ActivePeriod::Period)
+
+    # overlapping or tail to head
+    if self.begin.in?(other) || self.calculated_end.in?(other) || (
+        ((self.calculated_end+1.day).beginning_of_day == other.from) ^
+        ((other.calculated_end+1.day).beginning_of_day == self.from)
+      )
+      Period.new(
+        Range.new(
+          [self.begin, other.begin].min,
+          [self.to, other.to].max,
+          self.calculated_end > other.calculated_end ? self.exclude_end? : other.exclude_end?
+        )
+      )
+    # no overlapping
+    else
+      nil
+    end
+  end
+
   # @raise NotImplementedError This method should be implemented in daughter class
   def strftime
     raise NotImplementedError

data/lib/active_period/version.rb

@@ -1,5 +1,5 @@
 module ActivePeriod
 
-  VERSION = '7.0.0'.freeze
+  VERSION = '7.1.2'.freeze
 
 end

data/lib/period.rb

@@ -12,6 +12,11 @@ module Period
     ActivePeriod::FreePeriod.new(range, allow_beginless: false, allow_endless: false)
   end
 
+  # Shorthand to Period.new
+  def self.[](range)
+    Period.new(range)
+  end
+
   # env_time provide a Fallback if the project dont specify any Time.zone
   def self.env_time
     (Time.zone || Time)
@@ -45,32 +50,56 @@ module Period
     alias tomorrow next_day
     alias today this_day
 
-    # Experimental non-documented feature
+    LAST_OR_NEXT_REGEX = /^(:?last|next)_(\d+)_(day|week|month|quarter|year)s?(_from_now)?$/
+    LAST_AND_NEXT_REGEX = /^last_(\d+)_(day|week|month|quarter|year)s?_to_next_(\d+)_(day|week|month|quarter|year)s?$/
+
+    # Experimenta l non-documented feature
     # Inpired form ActiveRecord dynamic find_by_x like User.find_by_name
     # Example: Period.last_3_weeks_from_now == Period.mew(2.weeks.ago.beginning_of_week..Time.now.end_of_week)
-    # Note : Maybe it should return a collection of StandardPeriod
     def method_missing(method_name, *arguments, &block)
-      super unless method_name.match?(/(last|next)_\d+_(day|week|month|quarter|year)s?(_from_now)?/)
-      last_next, count, klass = method_name.to_s.split('_')
+      if method_name.match? LAST_OR_NEXT_REGEX
+        missing_last_or_next(method_name)
+      elsif method_name.match? LAST_AND_NEXT_REGEX
+        missing_last_and_next(method_name)
+      else
+        super
+      end
+    end
+
+    def missing_last_or_next(method_name)
+      last_next, count, klass, from_now = method_name.to_s.scan(LAST_OR_NEXT_REGEX).flatten
       klass = klass.singularize
 
       case last_next
       when 'last'
         from = count.to_i.send(klass).ago.send("beginning_of_#{klass}")
         to = env_time.now
-        to -= 1.send(klass) unless method_name.match?(/from_now$/)
+        to -= 1.send(klass) unless from_now
         to = to.send("end_of_#{klass}")
       when 'next'
         from = env_time.now
-        from += 1.send(klass) unless method_name.match?(/from_now$/)
+        from += 1.send(klass) unless from_now
         from = from.send("beginning_of_#{klass}")
         to = count.to_i.send(klass).from_now.send("end_of_#{klass}")
       end
       self.new(from..to)
     end
 
+    def missing_last_and_next(method_name)
+      last_count, last_klass, next_count, next_klass = method_name.to_s.scan(LAST_AND_NEXT_REGEX).flatten
+      last_klass = last_klass.singularize
+      next_klass = next_klass.singularize
+
+      from = last_count.to_i.send(last_klass).ago.send("beginning_of_#{last_klass}")
+      to = next_count.to_i.send(next_klass).from_now.send("end_of_#{next_klass}")
+
+      self.new(from..to)
+    end
+
     def respond_to_missing?(method_name, include_private = false)
-      method_name.match?(/(last|next)_\d+_(day|week|month|quarter|year)s?(_from_now)?/) || super
+      method_name.match?(/(last|next)_\d+_(day|week|month|quarter|year)s?(_from_now)?/) ||
+      method_name.match?(/(last)_\d+_(day|week|month|quarter|year)s?_to_next_\d+_(day|week|month|quarter|year)s?/ ) ||
+      super
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_period
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.2
 platform: ruby
 authors:
 - billau_l
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-22 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,9 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -159,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.22
 signing_key:
 specification_version: 4
 summary: Manage time ranges without brain damage.