active_period 6.1.1

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'active_period'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/locales/en.yml

@@ -0,0 +1,36 @@
+en:
+  active_period:
+    included: included
+    excluded: excluded
+    comparable:
+      incomparable_error:               Cannot compare Arguments
+    collection:
+      param_period_must_be_a_period:    The parameter perod must inherit from the Period class
+    period:
+      base_class_is_abstract:           Period is not intended to be used directly
+      begin_date_is_invalid:            The beginning date is invalid
+      end_date_is_invalid:              The ending date is invalid
+      start_is_equal_to_end_excluded:   The beginning date and ending date cannot be equal when the ending date is excluded
+      start_is_greater_than_end:        The beginning date is greater than the ending date
+      param_must_be_a_range:            The parameter must inherit from the Range class
+    free_period:
+      default_format:                   From the %{from} to the %{to} %{ending}
+      beginless_format:                 Until the %{to} %{ending}
+      endless_format:                   From the %{from}
+      boundless_format:                 Limitless time range
+    standard_period:
+      base_class_is_abstract:     StandardPeriod is not intended to be used directly
+      date_is_invalid:            The date is invalid
+      day:
+        default_format: '%{wday} %{day} %{month} %{year}'
+      week:
+        default_format: Week %{week} of %{year}
+      month:
+        default_format: '%{month} %{year}'
+      quarter:
+        default_format: '%{quarter_nb} quarter %{year}'
+      year:
+        default_format: '%{year}'
+    holiday_period:
+      gem_require: 'The gem "holidays" is needed for this feature to work'
+      default_format: '%{name} - %{wday} %{day} %{month} %{year}'

data/config/locales/fr.yml

@@ -0,0 +1,59 @@
+fr:
+  active_period:
+    included: inclus
+    excluded: exclue
+    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
+    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
+      end_date_is_invalid:              Date de fin invalide
+      start_is_equal_to_end_excluded:   La date de début et de fin ne peuvent pas être égale quand la date de fin est exclue
+      start_is_greater_than_end:        Date de début supérieur à la date de fin
+      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}
+      boundless_format:                 Sans limite de temps
+    standard_period:
+      base_class_is_abstract:     StandardPeriod est une class abstraite qui ne doit pas être utiliser directement
+      date_is_invalid:            La date est invalide
+      day:
+        default_format: '%{wday} %{day} %{month} %{year}'
+      week:
+        default_format: Semaine %{week} de l'année %{year}
+      month:
+        default_format: '%{month} %{year}'
+      quarter:
+        default_format: '%{quarter_nb} semestre %{year}'
+      year:
+        default_format: '%{year}'
+    holiday_period:
+      gem_require: 'La gem "holidays" est requise pour activer cette fonctionnalitée'
+      default_format: '%{name} - %{wday} %{day} %{month} %{year}'
+  date:
+    month_names:
+    -
+    - janvier
+    - février
+    - mars
+    - avril
+    - mai
+    - juin
+    - juillet
+    - août
+    - septembre
+    - octobre
+    - novembre
+    - décembre
+    day_names:
+    - dimanche
+    - lundi
+    - mardi
+    - mercredi
+    - jeudi
+    - vendredi
+    - samedi

data/lib/active_period/belongs_to/month.rb

@@ -0,0 +1,12 @@
+module ActivePeriod
+  module BelongsTo
+    # @author Lucas Billaudot <billau_l@modulotech.fr>
+    # @note when include this module provide access to the month of the
+    # FreePeriod
+    module Month
+      def month
+        ActivePeriod::Month.new(self.begin)
+      end
+    end
+  end
+end

data/lib/active_period/belongs_to/quarter.rb

@@ -0,0 +1,12 @@
+module ActivePeriod
+  module BelongsTo
+    # @author Lucas Billaudot <billau_l@modulotech.fr>
+    # @note when include this module provide access to the quarter of the
+    # FreePeriod
+    module Quarter
+      def quarter
+        ActivePeriod::Quarter.new(self.begin)
+      end
+    end
+  end
+end

data/lib/active_period/belongs_to/week.rb

@@ -0,0 +1,12 @@
+module ActivePeriod
+  module BelongsTo
+    # @author Lucas Billaudot <billau_l@modulotech.fr>
+    # @note when include this module provide access to the week of the
+    # FreePeriod
+    module Week
+      def week
+        ActivePeriod::Week.new(self.begin)
+      end
+    end
+  end
+end

data/lib/active_period/belongs_to/year.rb

@@ -0,0 +1,12 @@
+module ActivePeriod
+  module BelongsTo
+    # @author Lucas Billaudot <billau_l@modulotech.fr>
+    # @note when include this module provide access to the year of the
+    # FreePeriod
+    module Year
+      def year
+        ActivePeriod::Year.new(self.begin)
+      end
+    end
+  end
+end

data/lib/active_period/belongs_to.rb

@@ -0,0 +1,7 @@
+# @author Lucas Billaudot <billau_l@modulotech.fr>
+# @note This module define all period of time, who include the current period
+module ActivePeriod
+  module BelongsTo
+
+  end
+end

data/lib/active_period/collection/free_period.rb

@@ -0,0 +1,37 @@
+module ActivePeriod
+  module Collection
+    class FreePeriod
+      include ActivePeriod::Collection
+
+      private
+
+      def enumerator
+        raise RangeError.new "cannot get the first element of beginless range" if period.beginless?
+
+        Enumerator.new do |yielder|
+          current = klass.new(period.begin)
+          while period.calculated_end.nil? || period.include?(current.begin) || period.include?(current.calculated_end)
+            yielder << current
+            current = current.next
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+
+      def reverse_enumerator
+        raise RangeError.new "cannot get the last element of endless range" if period.endless?
+
+        Enumerator.new do |yielder|
+          current = klass.new(period.end)
+          while period.begin.nil? || period.include?(current.begin) || period.include?(current.calculated_end)
+            yielder << current
+            current = current.prev
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_period/collection/holiday_period.rb

@@ -0,0 +1,44 @@
+module ActivePeriod
+  module Collection
+    class HolidayPeriod
+      include ActivePeriod::Collection
+
+      # @!attribute [r] options
+      #   @return [Array] The array of options for Holidays.on
+      attr_reader :options
+
+      def initialize(klass, period, *args)
+        super(klass, period)
+        @options = args
+      end
+
+      private
+
+      def enumerator
+        Enumerator.new do |yielder|
+          days = period.try(:days) || [period]
+          days.each do |day|
+            Holidays.on(day.begin.to_date, *options).each do |hash|
+              yielder << ActivePeriod::Holiday.new(**hash)
+            end
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+
+      def reverse_enumerator
+        Enumerator.new do |yielder|
+          days = period.try(:days) || [period]
+          days.reverse_each do |day|
+            Holidays.on(day.begin.to_date, *options).each do |hash|
+              yielder << ActivePeriod::Holiday.new(**hash)
+            end
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_period/collection/standard_period.rb

@@ -0,0 +1,33 @@
+module ActivePeriod
+  module Collection
+    class StandardPeriod
+      include ActivePeriod::Collection
+
+      private
+
+      def enumerator
+        Enumerator.new do |yielder|
+          current = klass.new(period.begin)
+          while current.end <= period.end || period.include?(current)
+            yielder << current if period.include?(current)
+            current = current.next
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+
+      def reverse_enumerator
+        Enumerator.new do |yielder|
+          current = klass.new(period.end)
+          while current.begin <= period.begin || period.include?(current)
+            yielder << current if period.include?(current)
+            current = current.prev
+          end
+          # At the end (if there is one) the Collection will be return
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_period/collection.rb

@@ -0,0 +1,60 @@
+module ActivePeriod
+  module Collection
+    include Enumerable
+
+    # @!attribute [r] klass
+    #   @return [ActivePeriod::StandardPeriod] Any kind of ActivePeriod::StandardPeriod object
+    attr_reader :klass
+
+    # @!attribute [r] period
+    #   @return [ActivePeriod::FreePeriod] Any kind of ActivePeriod::FreePeriod object
+    attr_reader :period
+
+    def self.new(klass, period)
+      if period.is_a? ActivePeriod::StandardPeriod
+        ActivePeriod::Collection::StandardPeriod.new(klass, period)
+      else
+        ActivePeriod::Collection::FreePeriod.new(klass, period)
+      end
+    end
+
+    def initialize(klass, period)
+      raise I18n.t(:param_period_must_be_a_period, scope: %i[active_period collection]) unless period.class.ancestors.include?(ActivePeriod::Period)
+
+      @klass  = klass
+      @period = period
+    end
+
+    def second
+      find_nth(1)
+    end
+
+    def third
+      find_nth(2)
+    end
+
+    def fourth
+      find_nth(3)
+    end
+
+    def find_nth(limit)
+      each.with_index do |element, index|
+        return element if index == limit
+      end
+      return nil
+    end
+
+    def each(&block)
+      block_given? ? enumerator.each(&block) : enumerator
+    end
+
+    def reverse_each(&block)
+      block_given? ? reverse_enumerator.each(&block) : reverse_enumerator
+    end
+
+    def last
+      reverse_each.first
+    end
+
+  end
+end

data/lib/active_period/comparable.rb

@@ -0,0 +1,51 @@
+module ActivePeriod
+  module Comparable
+    include ::Comparable
+
+    def include?(other)
+      case other
+      when DateTime, Time, ActiveSupport::TimeWithZone
+        include_time?(other)
+      when Date
+        include_period?(ActivePeriod::Day.new(other))
+      when ActivePeriod::Period
+        include_period?(other)
+      else
+        raise ArgumentError, I18n.t(:incomparable_error, scope: %i[active_period comparable])
+      end
+    end
+
+    def <=>(other)
+      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)
+      end
+    end
+
+    private
+
+    def include_period?(other)
+      if self.class.in?([Month, Quarter, Year]) && other.is_a?(Week)
+        self.include_time?(other.include_date)
+      # elsif (other.class.in?([Month, Quarter, Year]) && self.is_a?(Week)
+      #   other.include_time?(self.include_date)
+      else
+        self.include_time?(other.begin) && self.include_time?(other.calculated_end)
+      end
+    end
+
+    # this method could been shorten by chaining condition with ||
+    # yet it would make it less readable
+    def include_time?(other)
+      return true if self.boundless?
+      return true if self.endless? && self.begin <= other
+      return true if self.beginless? && self.calculated_end >= other
+      return true if self.begin.to_i <= other.to_i && other.to_i <= self.calculated_end.to_i
+      false
+    end
+
+  end
+end

data/lib/active_period/day.rb

@@ -0,0 +1,38 @@
+require_relative 'standard_period.rb'
+require_relative 'belongs_to.rb'
+require_relative 'belongs_to/week.rb'
+require_relative 'belongs_to/month.rb'
+require_relative 'belongs_to/quarter.rb'
+require_relative 'belongs_to/year.rb'
+
+class ActivePeriod::Day < ActivePeriod::StandardPeriod
+  include ActivePeriod::BelongsTo::Week
+  include ActivePeriod::BelongsTo::Month
+  include ActivePeriod::BelongsTo::Quarter
+  include ActivePeriod::BelongsTo::Year
+
+  def strftime(format)
+    from.strftime(format)
+  end
+
+  def to_s(format: '%d/%m/%Y')
+    strftime(format)
+  end
+
+  def i18n(&block)
+    return yield(from, to) if block.present?
+
+    I18n.t(:default_format,
+           scope:   i18n_scope,
+           wday:    I18n.l(from, format: '%A').capitalize,
+           day:     from.day,
+           month:   I18n.l(from, format: '%B').capitalize,
+           year:    from.year)
+  end
+
+  def holiday?(...)
+    raise I18n.t(:gem_require, scope: %i[active_period holiday_period]) unless Object.const_defined?('Holidays')
+    holidays(...).first.present?
+  end
+
+end