calendarium-romanum 0.4.0 → 0.5.0

data/lib/calendarium-romanum/temporale/celebration_factory.rb

@@ -0,0 +1,48 @@
+module CalendariumRomanum
+  class Temporale
+    # builds temporale Celebrations
+    class CelebrationFactory
+      class << self
+        def first_advent_sunday
+          Celebration.new(
+            I18n.t('temporale.advent.sunday', week: Ordinalizer.ordinal(1)),
+            Ranks::PRIMARY,
+            Colours::VIOLET
+          )
+        end
+
+        private
+
+        def celebration(symbol, rank, colour = Colours::WHITE)
+          define_singleton_method(symbol) do
+            Celebration.new(
+              proc { I18n.t("temporale.solemnity.#{symbol}") },
+              rank,
+              colour,
+              symbol
+            )
+          end
+        end
+      end
+
+      # define factory methods
+      celebration(:nativity, Ranks::PRIMARY)
+      celebration(:holy_family, Ranks::FEAST_LORD_GENERAL)
+      celebration(:mother_of_god, Ranks::SOLEMNITY_GENERAL)
+      celebration(:epiphany, Ranks::PRIMARY)
+      celebration(:baptism_of_lord, Ranks::FEAST_LORD_GENERAL)
+      celebration(:ash_wednesday, Ranks::PRIMARY, Colours::VIOLET)
+      celebration(:good_friday, Ranks::TRIDUUM, Colours::RED)
+      celebration(:holy_saturday, Ranks::TRIDUUM, Colours::VIOLET)
+      celebration(:palm_sunday, Ranks::PRIMARY, Colours::RED)
+      celebration(:easter_sunday, Ranks::TRIDUUM)
+      celebration(:ascension, Ranks::PRIMARY)
+      celebration(:pentecost, Ranks::PRIMARY, Colours::RED)
+      celebration(:holy_trinity, Ranks::SOLEMNITY_GENERAL)
+      celebration(:corpus_christi, Ranks::SOLEMNITY_GENERAL)
+      celebration(:sacred_heart, Ranks::SOLEMNITY_GENERAL)
+      celebration(:christ_king, Ranks::SOLEMNITY_GENERAL)
+      celebration(:immaculate_heart, Ranks::MEMORIAL_GENERAL)
+    end
+  end
+end

data/lib/calendarium-romanum/temporale/dates.rb

@@ -29,7 +29,7 @@ module CalendariumRomanum
           return sunday_after(Date.new(year + 1, 1, 1))
         end
 
-        Date.new(year+1, 1, 6)
+        Date.new(year + 1, 1, 6)
       end
 
       def self.baptism_of_lord(year, epiphany_on_sunday: false)
@@ -58,16 +58,16 @@ module CalendariumRomanum
         paschal_full_moon = (3 - 11 * golden_number + solar_correction - lunar_correction) % 30
         dominical_number += 7 until dominical_number > 0
         paschal_full_moon += 30 until paschal_full_moon > 0
-        paschal_full_moon -= 1 if paschal_full_moon == 29 or (paschal_full_moon == 28 and golden_number > 11)
+        paschal_full_moon -= 1 if (paschal_full_moon == 29) || ((paschal_full_moon == 28) && golden_number > 11)
         difference = (4 - paschal_full_moon - dominical_number) % 7
         difference += 7 if difference < 0
         day_easter = paschal_full_moon + difference + 1
-        if day_easter < 11 then
+        if day_easter < 11
           # Easter occurs in March.
-          return Date.new(y=year, m=3, d=day_easter + 21)
+          return Date.new(year, 3, day_easter + 21)
         else
           # Easter occurs in April.
-          return Date.new(y=year, m=4, d=day_easter - 10)
+          return Date.new(year, 4, day_easter - 10)
         end
       end
 
@@ -124,22 +124,22 @@ module CalendariumRomanum
       # utility methods
 
       def self.weekday_before(weekday, date)
-        if date.wday == weekday then
-          return date - WEEK
+        if date.wday == weekday
+          date - WEEK
         elsif weekday < date.wday
-          return date - (date.wday - weekday)
+          date - (date.wday - weekday)
         else
-          return date - (date.wday + WEEK - weekday)
+          date - (date.wday + WEEK - weekday)
         end
       end
 
       def self.weekday_after(weekday, date)
-        if date.wday == weekday then
-          return date + WEEK
+        if date.wday == weekday
+          date + WEEK
         elsif weekday > date.wday
-          return date + (weekday - date.wday)
+          date + (weekday - date.wday)
         else
-          return date + (WEEK - date.wday + weekday)
+          date + (WEEK - date.wday + weekday)
         end
       end
 
@@ -148,7 +148,7 @@ module CalendariumRomanum
       end
 
       class << self
-        WEEKDAYS = %w{sunday monday tuesday wednesday thursday friday saturday}
+        WEEKDAYS = %w(sunday monday tuesday wednesday thursday friday saturday).freeze
         WEEKDAYS.each_with_index do |weekday, weekday_i|
           define_method "#{weekday}_before" do |date|
             send('weekday_before', weekday_i, date)

data/lib/calendarium-romanum/util.rb

@@ -18,7 +18,7 @@ module CalendariumRomanum
         @start.send(@prop) != date.send(@prop)
       end
 
-      alias_method :each_day, :each
+      alias each_day each
     end
 
     # enumerates days of a year
@@ -36,5 +36,26 @@ module CalendariumRomanum
         @prop = :month
       end
     end
+
+    class DateParser
+      attr_reader :date_range
+      def initialize(date_str)
+        if date_str =~ /((\d{4})(\/|-)?(\d{0,2})(\/|-)?(\d{0,2}))\z/ # Accepts YYYY-MM-DD, YYYY/MM/DD where both day and month are optional
+          year = Regexp.last_match(2).to_i
+          month = Regexp.last_match(4).to_i
+          day = Regexp.last_match(6).to_i
+          @date_range = if (day == 0) && (month == 0) # Only year is given
+                          Year.new(year)
+                        elsif day == 0 # Year and month are given
+                          Month.new(year, month)
+                        else
+                          Date.new(year, month, day)..Date.new(year, month, day)
+                        end
+        else
+          raise ArgumentError, 'Unparseable date'
+        end
+      end
+    end
+
   end
 end

data/lib/calendarium-romanum/version.rb

@@ -1,3 +1,6 @@
+require 'date'
+
 module CalendariumRomanum
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'.freeze
+  RELEASE_DATE = Date.new(2017, 11, 1).freeze
 end

data/spec/calendar_spec.rb

@@ -5,6 +5,8 @@ describe CR::Calendar do
     @c = described_class.new(2013).freeze
   end
 
+  let(:celfactory) { CR::Temporale::CelebrationFactory }
+
   describe '.new' do
     it 'throws RangeError on invalid year' do
       expect do
@@ -56,6 +58,24 @@ describe CR::Calendar do
     end
   end
 
+  describe '#[]' do 
+    describe 'received arguments' do
+      describe 'Date' do 
+        it 'returns a Day' do
+          expect(@c[Date.new(2013, 12, 10)]).to be_a CR::Day
+        end
+      end
+
+      describe 'Date range' do 
+        it 'returns an array of Days' do
+          array = @c[Date.new(2013, 12, 10)..Date.new(2014, 4, 10)]
+          expect(array).to be_a Array
+          array.each{|day| expect(day).to be_a CR::Day}
+        end
+      end
+    end
+  end
+
   describe '#day' do
     describe 'received arguments' do
       describe 'Date' do
@@ -206,7 +226,7 @@ describe CR::Calendar do
                 end
               end
 
-              describe 'second last'  do
+              describe 'second last' do
                 Date.new(2014, 11, 16).upto(Date.new(2014, 11, 22)) do |date|
                   it date do
                     expect(@c.day(date).season_week).to eq 33
@@ -316,8 +336,7 @@ describe CR::Calendar do
         # Good Friday suppresses the solemnity
         celebs = c.day(d).celebrations
         expect(celebs.size).to eq 1
-        expect(celebs[0].rank).to eq CR::Ranks::TRIDUUM
-        expect(celebs[0].title).to have_translation 'Friday of the Passion of the Lord'
+        expect(celebs[0]).to eq celfactory.good_friday
 
         # it is transferred on a day after the Easter octave
         d = c.temporale.easter_sunday + 8
@@ -325,6 +344,216 @@ describe CR::Calendar do
         expect(celebs.size).to eq 1
         expect(celebs[0].title).to eq 'Annunciation of the Lord'
       end
+
+      describe 'collision of Immaculate Heart with another obligatory memorial' do
+        let(:year) { 2002 }
+        let(:c) { described_class.new year, @s }
+        let(:date) { Date.new(2003, 6, 28) }
+
+        it 'makes both optional memorials' do
+          # make sure
+          expect(c.sanctorale.get(date).first.rank).to eq CR::Ranks::MEMORIAL_GENERAL
+          expect(c.temporale.get(date).rank).to eq CR::Ranks::MEMORIAL_GENERAL
+
+          celebrations = c.day(date).celebrations
+          expect(celebrations.size).to eq 3
+
+          expect(celebrations[0].rank).to eq CR::Ranks::FERIAL
+          expect(celebrations[1..-1].collect(&:rank).uniq)
+            .to eq([CR::Ranks::MEMORIAL_OPTIONAL])
+        end
+      end
+    end
+
+    describe 'Vespers' do
+      let(:saturday) { Date.new(2014, 1, 4) }
+      let(:year) { 2013 }
+      let(:calendar) { described_class.new(year) }
+
+      describe 'not opted in' do
+        it 'does not fill Vespers' do
+          day = calendar.day saturday
+          expect(day.vespers).to be nil
+        end
+      end
+
+      describe 'opted in by constructor argument' do
+        let(:calendar) { described_class.new(year, nil, nil, vespers: true) }
+
+        it 'fills Vespers' do
+          day = calendar.day saturday
+          expect(day.vespers).to be_a CR::Celebration
+        end
+
+        describe 'but the day has not Vespers from following' do
+          it 'does not fill Vespers' do
+            friday = saturday - 1
+            day = calendar.day friday
+            expect(day.vespers).to be nil
+          end
+        end
+      end
+
+      describe 'opted in by argument' do
+        it 'fills Vespers' do
+          day = calendar.day saturday, vespers: true
+          expect(day.vespers).to be_a CR::Celebration
+        end
+      end
+
+      describe 'first Vespers of' do
+        let(:sanctorale) { CR::Data::GENERAL_ROMAN_ENGLISH.load }
+        let(:calendar) { described_class.new(year, sanctorale, nil, vespers: true) }
+
+        describe 'a Sunday' do
+          it 'has first Vespers' do
+            day = calendar.day saturday
+            expect(day.vespers.rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
+          end
+        end
+
+        describe 'a solemnity' do
+          let(:testing_solemnity) do
+            CR::Celebration.new(
+              'Testing solemnity',
+              CR::Ranks::SOLEMNITY_GENERAL,
+              CR::Colours::WHITE,
+              :test
+            )
+          end
+
+          it 'has first Vespers' do
+            day = calendar.day(Date.new(2014, 11, 1) - 1)
+            expect(day.vespers.rank).to be CR::Ranks::SOLEMNITY_GENERAL
+          end
+
+          describe 'clash with Sunday Vespers' do
+            it 'wins over Sunday' do
+              sunday = Date.new(2014, 8, 17)
+              expect(sunday).to be_sunday # make sure
+              sanctorale.replace(8, 17, [testing_solemnity])
+
+              day = calendar.day(sunday - 1)
+              expect(day.vespers.symbol).to eq :test
+            end
+          end
+
+          describe 'clash with second Vespers of another solemnity' do
+            it "the day's Vespers win" do
+              assumption = Date.new(2014, 8, 15)
+              sanctorale.replace(8, 16, [testing_solemnity])
+
+              day = calendar.day(assumption)
+              expect(day.celebrations.first.rank).to be CR::Ranks::SOLEMNITY_GENERAL
+              expect(day.vespers).to be nil
+
+              # make sure
+              next_day = calendar.day(assumption + 1)
+              expect(next_day.celebrations.first).to be testing_solemnity
+            end
+          end
+        end
+
+        describe 'feast of the Lord' do
+          describe 'not falling on a Sunday' do
+            it 'does not have first Vespers' do
+              calendar = described_class.new(2015, sanctorale, nil, vespers: true)
+              presentation = Date.new(2016, 2, 2)
+              expect(presentation).not_to be_sunday # make sure
+
+              day = calendar.day(presentation - 1)
+              expect(day.vespers).to be nil
+            end
+          end
+
+          describe 'falling on a Sunday' do
+            it 'has first Vespers' do
+              presentation = Date.new(2014, 2, 2)
+              expect(presentation).to be_sunday # make sure
+
+              day = calendar.day(presentation - 1)
+              expect(day.vespers.rank).to be CR::Ranks::FEAST_LORD_GENERAL
+            end
+          end
+        end
+
+        # this group contains both days having and days not having
+        # first Vespers: special care must be taken
+        describe 'primary liturgical days' do
+          describe 'Ash Wednesday' do
+            it 'does not have first Vespers' do
+              aw = CR::Temporale::Dates.ash_wednesday year
+              day = calendar.day(aw - 1)
+              expect(day.vespers).to be nil
+            end
+          end
+
+          describe 'Nativity' do
+            it 'has first Vespers' do
+              day = calendar.day Date.new(2013, 12, 24)
+              expect(day.vespers).to eq celfactory.nativity
+            end
+          end
+
+          describe 'Epiphany' do
+            it 'has first Vespers' do
+              day = calendar.day Date.new(2014, 1, 5)
+              expect(day.vespers.rank).to be CR::Ranks::PRIMARY
+              expect(day.vespers.symbol).to be :epiphany
+            end
+          end
+
+          describe 'Palm Sunday' do
+            it 'has first Vespers' do
+              ps = CR::Temporale::Dates.palm_sunday year
+              day = calendar.day(ps - 1)
+              expect(day.vespers).to eq celfactory.palm_sunday
+            end
+          end
+
+          describe 'day in the Holy week' do
+            it 'does not have first Vespers' do
+              tuesday = CR::Temporale::Dates.palm_sunday(year) + 2
+              day = calendar.day(tuesday - 1)
+              expect(day.vespers).to be nil
+            end
+          end
+
+          describe 'Good Friday' do
+            it 'does not have first Vespers' do
+              gf = CR::Temporale::Dates.good_friday(year)
+              day = calendar.day(gf - 1)
+              expect(day.vespers).to be nil
+            end
+          end
+
+          describe 'Easter' do
+            it 'has first Vespers' do
+              es = CR::Temporale::Dates.easter_sunday year
+              day = calendar.day(es - 1)
+              expect(day.vespers).to eq celfactory.easter_sunday
+            end
+          end
+
+          describe 'day in Easter octave' do
+            it 'does not have first Vespers' do
+              tuesday = CR::Temporale::Dates.easter_sunday(year) + 2
+              day = calendar.day(tuesday - 1)
+              expect(day.vespers).to be nil
+            end
+          end
+        end
+
+        describe 'edge cases' do
+          describe 'First Sunday of Advent' do
+            it 'has first Vespers (and does not cause an exception)' do
+              sunday = CR::Temporale::Dates.first_advent_sunday(year + 1)
+              day = calendar.day(sunday - 1)
+              expect(day.vespers).to eq celfactory.first_advent_sunday
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/celebration_factory_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe CR::Temporale::CelebrationFactory do
+  describe '.first_advent_sunday' do
+    it 'returns Celebration equal to the one returned by Temporale' do
+      year = 2000
+      temporale = CR::Temporale.new(year)
+      date = CR::Temporale::Dates.first_advent_sunday(year)
+
+      c = temporale.get(date)
+      c2 = described_class.first_advent_sunday
+
+      expect(c2).to eq c
+    end
+  end
+end