edtf-humanize 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 370eca8ed68c9afdd06117f0e584f82f2f48eac108a1113b77ce91355844bcba
-  data.tar.gz: 608b950683ce5117a1bcb9fe63380fc99ce705b53184f8e68c6e6a545527bbf7
+  metadata.gz: 4d1b42abe59756665b608da4635e8766f78fb44ac2e658e14365141bf919eae9
+  data.tar.gz: f7a583e56c886eee461568fd2deacbd4769221b48b1f5e6b6f9b2ed68b08420c
 SHA512:
-  metadata.gz: 4093df048a06504a30c04a8960ed6e253bb39a3d5d0015ac6f791287515ea9d2c800c0d04bf1e2834b5da2757243b47a1ab78589c5b259e7b9a7bd58ad4d2991
-  data.tar.gz: 6946c6594d3149788cbfc4ec50f770d450b3716817d7c8ad4c73c0ad58cd3a3b535436b1e373ccf998528d9ebdd4eb9faed24f42898da2d5de58b9ca9023bd7e
+  metadata.gz: e7d3799ba863355aefa8afd5fdd09f20bc796cea31609d2015979b36f175ccff9a998019b62901c71d0873ca48dc03c0405f47fce7dd049d2ac801fc763d74f3
+  data.tar.gz: 6233da61c4a069e473336c229cd117e479ce1037d10d789506a32565ff4abed04740ce9fa59df1f8be772aaaa62447e58e9b422f6d72ed8778c9e2a6416e0035

data/config/locales/en.edtf.yml

@@ -0,0 +1,44 @@
+en:
+  edtf:
+    terms:
+      approximate_date_prefix_day: "circa "
+      approximate_date_prefix_month: "circa "
+      approximate_date_prefix_year: "circa "
+      approximate_date_suffix_day: ""
+      approximate_date_suffix_month: ""
+      approximate_date_suffix_year: ""
+      century_suffix: "s"
+      decade_prefix: ""
+      decade_suffix: "s"
+      interval_prefix_day: ""
+      interval_prefix_month: ""
+      interval_prefix_year: ""
+      interval_connector_approximate: " to "
+      interval_connector_day: " to "
+      interval_connector_open: " to "
+      interval_connector_month: " to "
+      interval_connector_year: " to "
+      interval_unspecified_suffix: "s"
+      open_start_interval_with_day: "until %{date}"
+      open_start_interval_with_month: "until %{date}"
+      open_start_interval_with_year: "until %{date}"
+      open_end_interval_with_day: "since %{date}"
+      open_end_interval_with_month: "since %{date}"
+      open_end_interval_with_year: "since %{date}"
+      set_dates_connector_exclusive: ", "
+      set_dates_connector_inclusive: ", "
+      set_earlier_prefix_exclusive: 'on or before '
+      set_earlier_prefix_inclusive: 'on and before '
+      set_last_date_connector_exclusive: " or "
+      set_last_date_connector_inclusive: " and "
+      set_later_prefix_exclusive: 'on or after '
+      set_later_prefix_inclusive: 'on and after '
+      set_two_dates_connector_exclusive: " or "
+      set_two_dates_connector_inclusive: " and "
+      uncertain_date_suffix: "?"
+      unknown: 'unknown'
+      unspecified_digit_substitute: "x"
+    formats:
+      day_precision_strftime_format: "%B %-d, %Y"
+      month_precision_strftime_format: "%B %Y"
+      year_precision_strftime_format: "%Y"

data/config/locales/fr.edtf.yml

@@ -0,0 +1,55 @@
+fr:
+  date:
+    day_names: [Dimanche, Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi]
+    abbr_day_names: [Dim, Lun, Mar, Mer, Jeu, Ven, Sam]
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, Janvier, Février, Mars, Avril, Mai, Juin, Juillet, Août, Septembre, Octobre, Novembre, Decembre]
+    abbr_month_names: [~, Jan, Fev, Mar, Avr, Mai, Jun, Jul, Aou, Sep, Oct, Nov, Dec]
+    seasons:
+      spring: "printemps"
+      summer: "été"
+      autumn: "automne"
+      winter: "hiver"
+  edtf:
+    terms:
+      approximate_date_prefix_day: ""
+      approximate_date_prefix_month: ""
+      approximate_date_prefix_year: ""
+      approximate_date_suffix_day: " environ"
+      approximate_date_suffix_month: " environ"
+      approximate_date_suffix_year: " environ"
+      decade_prefix: "Les années "
+      decade_suffix: ""
+      century_suffix: ""
+      interval_prefix_day: "Du "
+      interval_prefix_month: "De "
+      interval_prefix_year: "De "
+      interval_connector_approximate: " à "
+      interval_connector_open: " à "
+      interval_connector_day: " au "
+      interval_connector_month: " à "
+      interval_connector_year: " à "
+      interval_unspecified_suffix: "s"
+      open_start_interval_with_day: "Jusqu'au %{date}"
+      open_start_interval_with_month: "Jusqu'en %{date}"
+      open_start_interval_with_year: "Jusqu'en %{date}"
+      open_end_interval_with_day: "Depuis le %{date}"
+      open_end_interval_with_month: "Depuis %{date}"
+      open_end_interval_with_year: "Depuis %{date}"
+      set_dates_connector_exclusive: ", "
+      set_dates_connector_inclusive: ", "
+      set_earlier_prefix_exclusive: 'Le ou avant '
+      set_earlier_prefix_inclusive: 'Le et avant '
+      set_last_date_connector_exclusive: " ou "
+      set_last_date_connector_inclusive: " et "
+      set_later_prefix_exclusive: 'Le ou après '
+      set_later_prefix_inclusive: 'Le et après '
+      set_two_dates_connector_exclusive: " ou "
+      set_two_dates_connector_inclusive: " et "
+      uncertain_date_suffix: "?"
+      unknown: 'Inconnue'
+      unspecified_digit_substitute: "x"
+    formats:
+      day_precision_strftime_format: "%-d %B %Y"
+      month_precision_strftime_format: "%B %Y"
+      year_precision_strftime_format: "%Y"

data/config/locales/it.edtf.yml

@@ -0,0 +1,55 @@
+it:
+  date:
+    day_names: [domenica, lunedì, martedì, mercoledì, giovedì, venerdì, sabato]
+    abbr_day_names: [dom, lun, mar, mer, gio, ven, sab]
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, gennaio, febbraio, marzo, aprile, maggio, giugno, luglio, agosto, settembre, ottobre, novembre, dicembre]
+    abbr_month_names: [~, gen, feb, mar, apr, mag, giu, lug, ago, set, ott, nov, dic]
+    seasons:
+      spring: "primavera"
+      summer: "estate"
+      autumn: "autunno"
+      winter: "inverno"
+  edtf:
+    terms:
+      approximate_date_prefix_day: "circa "
+      approximate_date_prefix_month: "circa "
+      approximate_date_prefix_year: "circa "
+      approximate_date_suffix_day: ""
+      approximate_date_suffix_month: ""
+      approximate_date_suffix_year: ""
+      decade_prefix: "anni "
+      decade_suffix: ""
+      century_suffix: ""
+      interval_prefix_day: ""
+      interval_prefix_month: ""
+      interval_prefix_year: ""
+      interval_connector_approximate: " - "
+      interval_connector_open: " - "
+      interval_connector_day: " - "
+      interval_connector_month: " - "
+      interval_connector_year: " - "
+      interval_unspecified_suffix: ""
+      open_start_interval_with_day: "fino a %{date}"
+      open_start_interval_with_month: "fino a %{date}"
+      open_start_interval_with_year: "fino a %{date}"
+      open_end_interval_with_day: "%{date} - "
+      open_end_interval_with_month: "%{date} - "
+      open_end_interval_with_year: "%{date} - "
+      set_dates_connector_exclusive: ", "
+      set_dates_connector_inclusive: ", "
+      set_earlier_prefix_exclusive: "prima di "
+      set_earlier_prefix_inclusive: "prima di "
+      set_last_date_connector_exclusive: " o "
+      set_last_date_connector_inclusive: " e "
+      set_later_prefix_exclusive: "dopo "
+      set_later_prefix_inclusive: "dopo "
+      set_two_dates_connector_exclusive: " o "
+      set_two_dates_connector_inclusive: " e "
+      uncertain_date_suffix: " ?"
+      unknown: "data sconosciuta"
+      unspecified_digit_substitute: "x"
+    formats:
+      day_precision_strftime_format: "%-d %B %Y"
+      month_precision_strftime_format: "%B %Y"
+      year_precision_strftime_format: "%Y"

data/lib/edtf/humanize/century.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module Century
-
-      include Edtf::Humanize::Formats
+      include Edtf::Humanize::Language
 
       def humanize
-        "#{self.begin.year}#{Edtf::Humanize.configuration.century_suffix}"
+        language_strategy::Century.humanizer(self)
       end
-
     end
   end
 end

data/lib/edtf/humanize/decade.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module Decade
-
-      include Edtf::Humanize::Formats
+      include Edtf::Humanize::Language
 
       def humanize
-        "#{self.begin.year}#{Edtf::Humanize.configuration.decade_suffix}"
+        language_strategy::Decade.humanizer(self)
       end
-
     end
   end
 end

data/lib/edtf/humanize/interval.rb

@@ -1,30 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module Interval
-
-      include Edtf::Humanize::Formats
+      include Edtf::Humanize::Language
 
       def humanize
-        "#{apply_if_approximate(self.from)}"\
-        "#{simple_date_format(self.from)}"\
-        "#{Edtf::Humanize.configuration.interval_connector}"\
-        "#{apply_if_approximate(self.to)}"\
-        "#{simple_date_format(self.to)}"
-      end
-
-      private
-
-      # '198u/199u' => 1980s to 1990s
-      def apply_if_unspecified_year date
-        display = date_precision(date)
-        if date.respond_to? :unspecified?
-          if date.unspecified? :year
-            display << Edtf::Humanize.configuration.interval_unspecified_suffix
-          end
-        end
-        display
+        language_strategy::Interval.humanizer(self)
       end
-
     end
   end
 end

data/lib/edtf/humanize/iso_date.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module IsoDate
-
-      include Edtf::Humanize::Formats
+      include Edtf::Humanize::Language
 
       def humanize
-        "#{apply_if_approximate(self)}#{simple_date_format(self)}"
+        language_strategy::IsoDate.humanizer(self)
       end
-
     end
   end
 end

data/lib/edtf/humanize/language/default/century.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Century
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            "#{date.begin.year}" \
+            "#{I18n.t('edtf.terms.century_suffix', default: 's')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/decade.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Decade
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            "#{I18n.t('edtf.terms.decade_prefix', default: '')}" \
+            "#{date.begin.year}" \
+            "#{I18n.t('edtf.terms.decade_suffix', default: 's')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/formats.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Formats
+          extend self
+
+          private
+
+          def date_format(date)
+            "#{apply_if_unspecified_year(date)}#{apply_if_uncertain(date)}"
+          end
+
+          def date_precision(date)
+            if date.respond_to? :precision
+              case date.precision
+              when :day # 2010-10-25
+                day_precision_format(date)
+              when :month # 2010-10
+                month_precision_format(date)
+              when :year # 2010
+                year_precision_format(date)
+              end
+            else
+              date
+            end
+          end
+
+          # October 5, 1995
+          def day_precision_format(date)
+            I18n.localize(
+              date,
+              format: I18n.t('edtf.formats.day_precision_strftime_format',
+                             default: '%B %-d, %Y')
+            )
+          end
+
+          # October 1995
+          def month_precision_format(date)
+            I18n.localize(
+              date,
+              format: I18n.t('edtf.formats.month_precision_strftime_format',
+                             default: '%B %Y')
+            )
+          end
+
+          # 1995
+          def year_precision_format(date)
+            date.strftime(I18n.t('edtf.formats.year_precision_strftime_format',
+                                 default: '%Y'))
+          end
+
+          # '1990~' => circa 1990
+          def apply_prefix_if_approximate(date)
+            return unless date.respond_to?(:approximate?) && date.approximate?
+
+            case date.precision
+            when :year
+              I18n.t('edtf.terms.approximate_date_prefix_year',
+                     default: 'circa ')
+            when :month
+              I18n.t('edtf.terms.approximate_date_prefix_month',
+                     default: 'circa ')
+            when :day
+              I18n.t('edtf.terms.approximate_date_prefix_day',
+                     default: 'circa ')
+            end
+          end
+
+          # '1990~' => 1990 environ
+          def apply_suffix_if_approximate(date)
+            return '' unless date.respond_to?(:approximate?) &&
+                             date.approximate?
+
+            case date.precision
+            when :year
+              I18n.t('edtf.terms.approximate_date_suffix_year', default: '')
+            when :month
+              I18n.t('edtf.terms.approximate_date_suffix_month', default: '')
+            when :day
+              I18n.t('edtf.terms.approximate_date_suffix_day', default: '')
+            end
+          end
+
+          # '1990?' => 1990?
+          def apply_if_uncertain(date)
+            return '' unless date.respond_to?(:uncertain?) && date.uncertain?
+
+            I18n.t('edtf.terms.uncertain_date_suffix', default: '?')
+          end
+
+          # '198u' => 198x
+          def apply_if_unspecified_year(date)
+            display = date_precision(date)
+            if date.respond_to?(:unspecified?) && date.unspecified?(:year)
+              year_substitute =
+                date.year_precision.edtf.gsub(
+                  /u/,
+                  I18n.t('edtf.terms.unspecified_digit_substitute',
+                         default: 'x')
+                )
+              display.gsub!(date.year.to_s, year_substitute)
+            end
+            display
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/interval.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Interval
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            if date.from == :open || date.to == :open
+              open_interval(date)
+            else
+              "#{interval_prefix(date)}" \
+              "#{formatted_date(date.from)}" \
+              "#{interval_connector(date)}" \
+              "#{formatted_date(date.to)}"
+            end
+          end
+
+          private
+
+          def open_interval(date)
+            if date.from == :open
+              open_start_interval(formatted_date: formatted_date(date.to),
+                                  precision: date.to.precision)
+            elsif date.to == :open
+              open_end_interval(formatted_date: formatted_date(date.from),
+                                precision: date.from.precision)
+            end
+          end
+
+          # open/1980 => Jusqu'en 1980
+          def open_start_interval(formatted_date:, precision:)
+            case precision
+            when :year
+              I18n.t('edtf.terms.open_start_interval_with_year',
+                     date: formatted_date,
+                     default: "until #{formatted_date}")
+            when :month
+              I18n.t('edtf.terms.open_start_interval_with_month',
+                     date: formatted_date,
+                     default: "until #{formatted_date}")
+            when :day
+              I18n.t('edtf.terms.open_start_interval_with_day',
+                     date: formatted_date,
+                     default: "until #{formatted_date}")
+            end
+          end
+
+          # 1980/open => Depuis 1980
+          def open_end_interval(formatted_date:, precision:)
+            case precision
+            when :year
+              I18n.t('edtf.terms.open_end_interval_with_year',
+                     date: formatted_date,
+                     default: "since #{formatted_date}")
+            when :month
+              I18n.t('edtf.terms.open_end_interval_with_month',
+                     date: formatted_date,
+                     default: "since #{formatted_date}")
+            when :day
+              I18n.t('edtf.terms.open_end_interval_with_day',
+                     date: formatted_date,
+                     default: "since #{formatted_date}")
+            end
+          end
+
+          def formatted_date(date)
+            "#{apply_prefix_if_approximate(date)}" \
+            "#{date_format(date)}" \
+            "#{apply_suffix_if_approximate(date)}"
+          end
+
+          def interval_prefix(date)
+            case date.from.precision
+            when :year
+              I18n.t('edtf.terms.interval_prefix_year', default: '')
+            when :month
+              I18n.t('edtf.terms.interval_prefix_month', default: '')
+            when :day
+              I18n.t('edtf.terms.interval_prefix_day', default: '')
+            end
+          end
+
+          def interval_connector(date)
+            return interval_connector_open if date.to == :open
+
+            return interval_connector_approx if date.to.approximate.day ||
+                                                date.to.approximate.month ||
+                                                date.to.approximate.year
+
+            interval_connector_other(date)
+          end
+
+          def interval_connector_open
+            I18n.t('edtf.terms.interval_connector_open')
+          end
+
+          def interval_connector_approx
+            I18n.t('edtf.terms.interval_connector_approximate',
+                   default: ' to ')
+          end
+
+          def interval_connector_other(date)
+            case date.to.precision
+            when :year
+              I18n.t('edtf.terms.interval_connector_year', default: ' to ')
+            when :month
+              I18n.t('edtf.terms.interval_connector_month', default: ' to ')
+            when :day
+              I18n.t('edtf.terms.interval_connector_day', default: ' to ')
+            end
+          end
+
+          # '198u/199u' => 1980s to 1990s
+          def apply_if_unspecified_year(date)
+            if date.respond_to?(:unspecified?) && date.unspecified?(:year)
+              return "#{date_precision(date)}" \
+                     "#{I18n.t('edtf.terms.interval_unspecified_suffix',
+                               default: 's')}"
+            end
+
+            date_precision(date)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/iso_date.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module IsoDate
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            "#{apply_prefix_if_approximate(date)}" \
+            "#{date_format(date)}" \
+            "#{apply_suffix_if_approximate(date)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/season.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Season
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            "#{apply_prefix_if_approximate(date)}"\
+            "#{translate_season(date.season)} #{date.year}"\
+            "#{apply_suffix_if_approximate(date)}"\
+            "#{apply_if_uncertain(date)}"
+          end
+
+          private
+
+          def translate_season(season)
+            I18n.translate!("date.seasons.#{season}")
+          rescue I18n::MissingTranslationData
+            season
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/default/set.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Set
+          include Edtf::Humanize::Language::Default::Formats
+
+          extend self
+
+          def humanizer(date)
+            format_set_entries(date).to_sentence(
+              words_connector:
+                I18n.t("edtf.terms.set_dates_connector_#{mode(date)}",
+                       default: ', '),
+              last_word_connector:
+                I18n.t("edtf.terms.set_last_date_connector_#{mode(date)}",
+                       default: default_word_connector(date)),
+              two_words_connector:
+                I18n.t("edtf.terms.set_two_dates_connector_#{mode(date)}",
+                       default: default_word_connector(date))
+            )
+          end
+
+          private
+
+          def default_word_connector(date)
+            mode(date) == 'inclusive' ? ' and ' : ' or '
+          end
+
+          def format_set_entries(dates)
+            dates.entries.map.with_index do |date, index|
+              "#{apply_if_earlier(dates, index)}"\
+              "#{apply_if_later(dates, index)}"\
+              "#{apply_prefix_if_approximate(date)}"\
+              "#{date_format(date)}"\
+              "#{apply_suffix_if_approximate(date)}"\
+            end
+          end
+
+          # '[..1760-12-03]' => on or before December 3, 1760
+          def apply_if_earlier(dates, index)
+            return earlier_prefix(dates) if dates.earlier? && index.zero?
+          end
+
+          def earlier_prefix(dates)
+            I18n.t("edtf.terms.set_earlier_prefix_#{mode(dates)}",
+                   default: earlier_prefix_default(dates))
+          end
+
+          def earlier_prefix_default(dates)
+            mode(dates) == 'inclusive' ? 'on and before ' : 'on or before '
+          end
+
+          # '[1760-12..]' => on or after December 1760
+          def apply_if_later(dates, index)
+            return later_prefix(dates) if dates.later? &&
+                                          (index + 1) == dates.size
+          end
+
+          def later_prefix(dates)
+            I18n.t("edtf.terms.set_later_prefix_#{mode(dates)}",
+                   default: later_prefix_default(dates))
+          end
+
+          def later_prefix_default(dates)
+            mode(dates) == 'inclusive' ? 'on and after ' : 'on or after '
+          end
+
+          def mode(date)
+            date.choice? ? 'exclusive' : 'inclusive'
+          end
+        end
+      end
+    end
+  end
+end