edtf-humanize 0.0.4 → 2.0.0

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module Default
+        module Unknown
+          extend self
+
+          def humanizer(_date)
+            I18n.t('edtf.terms.unknown', default: 'unknown')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/english.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module English
+        include Default
+      end
+    end
+  end
+end

data/lib/edtf/humanize/language/french.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Edtf
+  module Humanize
+    module Language
+      module French
+        include Default
+
+        module Century
+          extend self
+
+          def humanizer(date)
+            require 'roman'
+            "#{(date.year.abs / 100 + 1).to_roman}" \
+            "#{century_number_suffix(date)}" \
+            "#{century_sign_suffix(date)}"
+          end
+
+          private
+
+          def century_number_suffix(date)
+            return 'er siècle' if (date.year.abs / 100).zero?
+
+            'e siècle'
+          end
+
+          def century_sign_suffix(date)
+            return ' avant J.C.' if date.year.negative?
+
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edtf/humanize/season.rb

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

data/lib/edtf/humanize/set.rb

@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module Set
-
-      include Edtf::Humanize::Formats
+      include Edtf::Humanize::Language
 
       def humanize
-        display = []
-        self.entries.each do |date|
-          display << "#{apply_if_approximate(date)}#{simple_date_format(date)}"
-        end
-        display.to_sentence(
-          words_connector: Edtf::Humanize.configuration.set_dates_connector,
-          last_word_connector: Edtf::Humanize.configuration.set_last_date_connector,
-          two_words_connector: Edtf::Humanize.configuration.set_two_dates_connector
-          )
+        language_strategy::Set.humanizer(self)
       end
-
     end
   end
 end

data/lib/edtf/humanize/unknown.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
     module Unknown
+      include Edtf::Humanize::Language
 
       def humanize
-        Edtf::Humanize.configuration.unknown
+        language_strategy::Unknown.humanizer(self)
       end
-
     end
   end
-end
+end

data/lib/edtf/humanize/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Edtf
   module Humanize
-    VERSION = "0.0.4"
+    VERSION = '2.0.0'
   end
 end

data/spec/edtf_humanize_en_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'edtf-humanize'
+
+RSpec.describe Edtf::Humanize do
+  before do
+    I18n.locale = :en
+  end
+
+  it { is_expected.to be_a(Module) }
+
+  context 'with a decade' do
+    it 'returns a humanized decade string' do
+      expect(Date.edtf('199x').humanize).to eq('1990s')
+    end
+  end
+
+  context 'with a century' do
+    it 'returns a humanized century string' do
+      expect(Date.edtf('19xx').humanize).to eq('1900s')
+    end
+  end
+
+  context 'with an interval' do
+    it 'returns a humanized interval string' do
+      expect(Date.edtf('1970/1980').humanize).to eq('1970 to 1980')
+    end
+  end
+
+  context 'with an open interval' do
+    it 'returns a humanized interval string' do
+      expect(Date.edtf('1970/open').humanize).to eq('since 1970')
+    end
+  end
+
+  context 'with an appoximate interval'
+  it 'returns a humanized approximate interval string' do
+    expect(Date.edtf('1970~/1980~').humanize).to(
+      eq('circa 1970 to circa 1980')
+    )
+  end
+
+  context 'with an iso date' do
+    it 'returns a humanized ISO date string' do
+      expect(Date.edtf('1975-07-01').humanize).to eq('July 1, 1975')
+    end
+  end
+
+  context 'with an uncertain iso date' do
+    it 'returns a humanized uncertain ISO date string' do
+      expect(Date.edtf('1975?').humanize).to eq('1975?')
+    end
+  end
+
+  context 'with an unspecfic year iso date' do
+    it 'returns a humanized unspecified year ISO date string' do
+      expect(Date.edtf('197u').humanize).to eq('197x')
+    end
+  end
+
+  context 'with a season' do
+    it 'returns a humanized season string' do
+      expect(Date.edtf('1975-22').humanize).to eq('summer 1975')
+    end
+  end
+
+  context 'with a set' do
+    it 'returns a humanized exclusive set string' do
+      expect(Date.edtf('[1980, 1981, 1983]').humanize).to(
+        eq('1980, 1981 or 1983')
+      )
+    end
+
+    it 'returns a humanized inclusive set string' do
+      expect(Date.edtf('{1980, 1981, 1983}').humanize).to(
+        eq('1980, 1981 and 1983')
+      )
+    end
+
+    it 'returns a humanized open (before) exclusive set string' do
+      expect(Date.edtf('[..1980]').humanize).to eq('on or before 1980')
+    end
+
+    it 'returns a humanized open (after) exclusive set string' do
+      expect(Date.edtf('[1980..]').humanize).to eq('on or after 1980')
+    end
+
+    it 'returns a humanized open (before) inclusive set string' do
+      expect(Date.edtf('{..1980}').humanize).to eq('on and before 1980')
+    end
+
+    it 'returns a humanized open (after) inclusive set string' do
+      expect(Date.edtf('{1980..}').humanize).to eq('on and after 1980')
+    end
+  end
+
+  context 'with an unknown value' do
+    it 'returns a humanized unknown string' do
+      expect(Date.edtf('uuuu').humanize).to eq('unknown')
+    end
+  end
+end