calendarium-romanum 0.3.0 → 0.4.0

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

@@ -3,7 +3,7 @@ module CalendariumRomanum
     # dates of movable feasts
     module Dates
       def self.first_advent_sunday(year)
-        sunday_before(nativity(year)) - 3 * Temporale::WEEK
+        sunday_before(nativity(year)) - 3 * WEEK
       end
 
       def self.nativity(year)
@@ -23,16 +23,26 @@ module CalendariumRomanum
         octave_of(nativity(year))
       end
 
-      def self.epiphany(year)
+      def self.epiphany(year, sunday: false)
+        if sunday
+          # GNLYC 7 a)
+          return sunday_after(Date.new(year + 1, 1, 1))
+        end
+
         Date.new(year+1, 1, 6)
       end
 
-      def self.baptism_of_lord(year)
-        sunday_after epiphany(year)
+      def self.baptism_of_lord(year, epiphany_on_sunday: false)
+        e = epiphany(year, sunday: epiphany_on_sunday)
+        if epiphany_on_sunday
+          e + 1
+        else
+          sunday_after e
+        end
       end
 
       def self.ash_wednesday(year)
-        easter_sunday(year) - (6 * Temporale::WEEK + 4)
+        easter_sunday(year) - (6 * WEEK + 4)
       end
 
       def self.easter_sunday(year)
@@ -42,17 +52,10 @@ module CalendariumRomanum
         # https://github.com/jrobertson/easter
 
         golden_number = (year % 19) + 1
-        if year <= 1752 then
-          # Julian calendar
-          dominical_number = (year + (year / 4) + 5) % 7
-          paschal_full_moon = (3 - (11 * golden_number) - 7) % 30
-        else
-          # Gregorian calendar
-          dominical_number = (year + (year / 4) - (year / 100) + (year / 400)) % 7
-          solar_correction = (year - 1600) / 100 - (year - 1600) / 400
-          lunar_correction = (((year - 1400) / 100) * 8) / 25
-          paschal_full_moon = (3 - 11 * golden_number + solar_correction - lunar_correction) % 30
-        end
+        dominical_number = (year + (year / 4) - (year / 100) + (year / 400)) % 7
+        solar_correction = (year - 1600) / 100 - (year - 1600) / 400
+        lunar_correction = (((year - 1400) / 100) * 8) / 25
+        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)
@@ -80,24 +83,34 @@ module CalendariumRomanum
         easter_sunday(year) - 1
       end
 
-      def self.ascension(year)
+      def self.ascension(year, sunday: false)
+        if sunday
+          # GNLYC 7 b)
+          return easter_sunday(year) + 6 * WEEK
+        end
+
         pentecost(year) - 10
       end
 
       def self.pentecost(year)
-        easter_sunday(year) + 7 * Temporale::WEEK
+        easter_sunday(year) + 7 * WEEK
       end
 
       def self.holy_trinity(year)
         octave_of(pentecost(year))
       end
 
-      def self.body_blood(year)
+      def self.corpus_christi(year, sunday: false)
+        if sunday
+          # GNLYC 7 c)
+          return holy_trinity(year) + WEEK
+        end
+
         holy_trinity(year) + 4
       end
 
       def self.sacred_heart(year)
-        body_blood(year) + 8
+        corpus_christi(year) + 8
       end
 
       def self.immaculate_heart(year)
@@ -112,26 +125,26 @@ module CalendariumRomanum
 
       def self.weekday_before(weekday, date)
         if date.wday == weekday then
-          return date - Temporale::WEEK
+          return date - WEEK
         elsif weekday < date.wday
           return date - (date.wday - weekday)
         else
-          return date - (date.wday + Temporale::WEEK - weekday)
+          return date - (date.wday + WEEK - weekday)
         end
       end
 
       def self.weekday_after(weekday, date)
         if date.wday == weekday then
-          return date + Temporale::WEEK
+          return date + WEEK
         elsif weekday > date.wday
           return date + (weekday - date.wday)
         else
-          return date + (Temporale::WEEK - date.wday + weekday)
+          return date + (WEEK - date.wday + weekday)
         end
       end
 
       def self.octave_of(date)
-        date + Temporale::WEEK
+        date + WEEK
       end
 
       class << self

data/lib/calendarium-romanum/temporale/extensions/christ_eternal_priest.rb

@@ -4,8 +4,8 @@ module CalendariumRomanum
       # Temporale extension adding feast of Christ Eternal Priests,
       # included in some local calendars
       module ChristEternalPriest
-        def self.included(mod)
-          mod.add_celebration(
+        def self.each_celebration
+          yield(
             :christ_eternal_priest,
             Celebration.new(
               proc { I18n.t('temporale.extension.christ_eternal_priest') },
@@ -16,8 +16,8 @@ module CalendariumRomanum
         end
 
         # method computing date
-        def christ_eternal_priest
-          pentecost + 4
+        def self.christ_eternal_priest(year)
+          Dates.pentecost(year) + 4
         end
       end
     end

data/lib/calendarium-romanum/version.rb

@@ -1,3 +1,3 @@
 module CalendariumRomanum
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/calendar_spec.rb

@@ -1,201 +1,223 @@
 require_relative 'spec_helper'
 
 describe CR::Calendar do
+  before :all do
+    @c = described_class.new(2013).freeze
+  end
 
-  describe 'core functions' do
-    before :all do
-      @c = described_class.new 2013
+  describe '.new' do
+    it 'throws RangeError on invalid year' do
+      expect do
+        described_class.new(1968)
+      end.to raise_exception(RangeError, /in use only since 1st January 1970/)
     end
 
-    describe '#==' do
-      it 'considers calendars with the same year same' do
-        expect(described_class.new(2014) == described_class.new(2014)).to be true
-      end
+    it 'throws ArgumentError when Temporale year does not match' do
+      year = 2000
+      temporale = CR::Temporale.new year
+      expect do
+        CR::Calendar.new(year + 1, nil, temporale)
+      end.to raise_exception ArgumentError
+    end
+  end
 
-      it 'considers calendars with different year different' do
-        expect(described_class.new(2014) == described_class.new(2010)).to be false
-      end
+  describe '.for_day' do
+    it 'continues the previous year\'s calendar in summer' do
+      expect(described_class.for_day(Date.new(2014, 6, 9))).to eq described_class.new(2013)
     end
 
-    describe '#lectionary' do
-      it 'detects correctly' do
-        expect(described_class.new(2014).lectionary).to eq :B
-        expect(described_class.new(2013).lectionary).to eq :A
-        expect(described_class.new(2012).lectionary).to eq :C
-      end
+    it 'provides the current year\'s calendar in December' do
+      expect(described_class.for_day(Date.new(2014, 12, 20))).to eq described_class.new(2014)
     end
+  end
 
-    describe '#ferial_lectionary' do
-      it 'detects correctly' do
-        expect(described_class.new(2014).ferial_lectionary).to eq 1
-        expect(described_class.new(2013).ferial_lectionary).to eq 2
-      end
+  describe '#==' do
+    it 'considers calendars with the same year same' do
+      expect(described_class.new(2014) == described_class.new(2014)).to be true
+    end
+
+    it 'considers calendars with different year different' do
+      expect(described_class.new(2014) == described_class.new(2010)).to be false
+    end
+  end
+
+  describe '#lectionary' do
+    it 'detects correctly' do
+      expect(described_class.new(2014).lectionary).to eq :B
+      expect(described_class.new(2013).lectionary).to eq :A
+      expect(described_class.new(2012).lectionary).to eq :C
+    end
+  end
+
+  describe '#ferial_lectionary' do
+    it 'detects correctly' do
+      expect(described_class.new(2014).ferial_lectionary).to eq 1
+      expect(described_class.new(2013).ferial_lectionary).to eq 2
     end
+  end
 
-    describe '.for_day' do
-      it 'continues the previous year\'s calendar in summer' do
-        expect(described_class.for_day(Date.new(2014, 6, 9))).to eq described_class.new(2013)
+  describe '#day' do
+    describe 'received arguments' do
+      describe 'Date' do
+        it 'returns a Day' do
+          expect(@c.day(Date.new(2013, 12, 10))).to be_a CR::Day
+        end
       end
 
-      it 'provides the current year\'s calendar in December' do
-        expect(described_class.for_day(Date.new(2014, 12, 20))).to eq described_class.new(2014)
+      describe 'DateTime' do
+        it 'returns a Day' do
+          expect(@c.day(DateTime.new(2013, 12, 10, 12, 10, 0))).to be_a CR::Day
+        end
       end
-    end
 
-    describe '#day' do
-      describe 'received arguments' do
-        describe 'Date' do
-          it 'returns a Day' do
-            expect(@c.day(Date.new(2013, 12, 10))).to be_a CR::Day
-          end
+      describe 'three Integers' do
+        it 'returns a Day' do
+          expect(@c.day(2013, 12, 10)).to be_a CR::Day
         end
+      end
 
-        describe 'DateTime' do
-          it 'returns a Day' do
-            expect(@c.day(DateTime.new(2013, 12, 10, 12, 10, 0))).to be_a CR::Day
+      describe 'two integers' do
+        describe 'autumn' do
+          it 'supplies year' do
+            day = @c.day(12, 10)
+            expect(day).to be_a CR::Day
+            expect(day.date).to eq Date.new(2013, 12, 10)
           end
         end
 
-        describe 'three Integers' do
-          it 'returns a Day' do
-            expect(@c.day(2013, 12, 10)).to be_a CR::Day
+        describe 'spring' do
+          it 'supplies year' do
+            day = @c.day(4, 10)
+            expect(day).to be_a CR::Day
+            expect(day.date).to eq Date.new(2014, 4, 10)
           end
         end
 
-        describe 'two integers' do
-          describe 'autumn' do
-            it 'supplies year' do
-              day = @c.day(12, 10)
-              expect(day).to be_a CR::Day
-              expect(day.date).to eq Date.new(2013, 12, 10)
+        describe 'invalid' do
+          describe 'absolutely' do
+            it 'fails' do
+              expect do
+                day = @c.day(0, 34)
+              end.to raise_exception(ArgumentError, 'invalid date')
             end
           end
 
-          describe 'spring' do
-            it 'supplies year' do
-              day = @c.day(4, 10)
-              expect(day).to be_a CR::Day
-              expect(day.date).to eq Date.new(2014, 4, 10)
+          describe 'for the given year' do
+            it 'fails' do
+              expect do
+                day = @c.day(2, 29)
+              end.to raise_exception(ArgumentError, 'invalid date')
             end
           end
+        end
+      end
+    end
 
-          describe 'invalid' do
-            describe 'absolutely' do
-              it 'fails' do
-                expect do
-                  day = @c.day(0, 34)
-                end.to raise_exception(ArgumentError, 'invalid date')
-              end
-            end
+    describe "date not included in the calendar's year" do
+      it 'throws RangeError' do
+        expect { @c.day(2000, 1, 1) }.to raise_exception RangeError
+      end
+    end
 
-            describe 'for the given year' do
-              it 'fails' do
-                expect do
-                  day = @c.day(2, 29)
-                end.to raise_exception(ArgumentError, 'invalid date')
-              end
-            end
-          end
-        end
+    describe 'date before system effectiveness' do
+      it 'throws RangeError' do
+        c = described_class.new 1969
+        expect { c.day(1969, 12, 20) }.to raise_exception RangeError
       end
+    end
 
-      it 'throws RangeError if given date not included in the year' do
-        expect { @c.day(2000, 1, 1) }.to raise_error RangeError
+    describe 'temporale features' do
+      describe 'season' do
+        it 'detects Advent correctly' do
+          expect(@c.day(2013, 12, 10).season).to eq CR::Seasons::ADVENT
+        end
       end
 
-      describe 'temporale features' do
-        describe 'season' do
-          it 'detects Advent correctly' do
-            expect(@c.day(2013, 12, 10).season).to eq CR::Seasons::ADVENT
+      describe 'week of the season' do
+        describe 'Advent' do
+          it 'sets Advent week correctly' do
+            expect(@c.day(2013, 12, 10).season_week).to eq 2
+            expect(@c.day(2013, 12, 15).season_week).to eq 3
           end
         end
 
-        describe 'week of the season' do
-          describe 'Advent' do
-            it 'sets Advent week correctly' do
-              expect(@c.day(2013, 12, 10).season_week).to eq 2
-              expect(@c.day(2013, 12, 15).season_week).to eq 3
-            end
+        describe 'Christmas' do
+          it 'days before the first Sunday are week 0' do
+            expect(@c.day(2013, 12, 25).season_week).to eq 0
           end
 
-          describe 'Christmas' do
-            it 'days before the first Sunday are week 0' do
-              expect(@c.day(2013, 12, 25).season_week).to eq 0
-            end
+          it 'first Sunday starts week 1' do
+            expect(@c.day(2013, 12, 29).season_week).to eq 1
+          end
+        end
 
-            it 'first Sunday starts week 1' do
-              expect(@c.day(2013, 12, 29).season_week).to eq 1
-            end
+        describe 'Lent' do
+          it 'Ash Wednesday is week 0' do
+            expect(@c.day(2014, 3, 5).season_week).to eq 0
           end
+        end
 
-          describe 'Lent' do
-            it 'Ash Wednesday is week 0' do
-              expect(@c.day(2014, 3, 5).season_week).to eq 0
-            end
+        describe 'Easter' do
+          it 'Easter Sunday opens week 1' do
+            expect(@c.day(2014, 4, 20).season_week).to eq 1
           end
+        end
 
-          describe 'Easter' do
-            it 'Easter Sunday opens week 1' do
-              expect(@c.day(2014, 4, 20).season_week).to eq 1
-            end
+        describe 'Ordinary time' do
+          it 'Monday after Baptism of the Lord is week 1' do
+            expect(@c.day(2014, 1, 13).season_week).to eq 1
           end
 
-          describe 'Ordinary time' do
-            it 'Monday after Baptism of the Lord is week 1' do
-              expect(@c.day(2014, 1, 13).season_week).to eq 1
+          describe 'after Pentecost' do
+            it '2014' do
+              c = described_class.new(2013)
+              expect(c.day(2014, 6, 9).season_week).to eq 10
             end
 
-            describe 'after Pentecost' do
-              it '2014' do
-                c = described_class.new(2013)
-                expect(c.day(2014, 6, 9).season_week).to eq 10
-              end
-
-              it '2015' do
-                c = described_class.new(2014)
-                expect(c.day(2015, 5, 25).season_week).to eq 8
-              end
+            it '2015' do
+              c = described_class.new(2014)
+              expect(c.day(2015, 5, 25).season_week).to eq 8
+            end
 
-              it '2016' do
-                c = described_class.new(2015)
-                expect(c.day(2016, 5, 16).season_week).to eq 7
-              end
+            it '2016' do
+              c = described_class.new(2015)
+              expect(c.day(2016, 5, 16).season_week).to eq 7
+            end
 
-              it '2017' do
-                c = described_class.new(2016)
-                expect(c.day(2017, 6, 5).season_week).to eq 9
-              end
+            it '2017' do
+              c = described_class.new(2016)
+              expect(c.day(2017, 6, 5).season_week).to eq 9
+            end
 
-              describe 'works correctly for the whole week' do
-                describe 'first' do
-                  Date.new(2014, 6, 9).upto(Date.new(2014, 6, 14)) do |date|
-                    it date do
-                      expect(@c.day(date).season_week).to eq 10
-                    end
+            describe 'works correctly for the whole week' do
+              describe 'first' do
+                Date.new(2014, 6, 9).upto(Date.new(2014, 6, 14)) do |date|
+                  it date do
+                    expect(@c.day(date).season_week).to eq 10
                   end
                 end
+              end
 
-                describe 'second' do
-                  Date.new(2014, 6, 15).upto(Date.new(2014, 6, 21)) do |date|
-                    it date do
-                      expect(@c.day(date).season_week).to eq 11
-                    end
+              describe 'second' do
+                Date.new(2014, 6, 15).upto(Date.new(2014, 6, 21)) do |date|
+                  it date do
+                    expect(@c.day(date).season_week).to eq 11
                   end
                 end
+              end
 
-                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
-                    end
+              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
                   end
                 end
+              end
 
-                describe 'last' do
-                  Date.new(2014, 11, 23).upto(Date.new(2014, 11, 29)) do |date|
-                    it date do
-                      expect(@c.day(date).season_week).to eq 34
-                    end
+              describe 'last' do
+                Date.new(2014, 11, 23).upto(Date.new(2014, 11, 29)) do |date|
+                  it date do
+                    expect(@c.day(date).season_week).to eq 34
                   end
                 end
               end
@@ -203,149 +225,105 @@ describe CR::Calendar do
           end
         end
       end
+    end
 
-      describe 'Temporale x Sanctorale resolution' do
-        before :all do
-          @s = CR::Data::GENERAL_ROMAN_ENGLISH.load
-          @c = described_class.new 2013, @s
-        end
-
-        it '"empty" day results in a ferial' do
-          d = @c.day(7, 2)
-          expect(d.celebrations.size).to eq 1
-          expect(d.celebrations[0].rank).to eq CR::Ranks::FERIAL
-        end
-
-        it 'sanctorale feast' do
-          d = @c.day(7, 3)
-          expect(d.celebrations.size).to eq 1
-          expect(d.celebrations[0].rank).to eq CR::Ranks::FEAST_GENERAL
-          expect(d.celebrations[0].title).to include 'Thomas'
-        end
-
-        it 'optional memorial does not suppress ferial' do
-          d = @c.day(7, 14)
-          expect(d.celebrations.size).to eq 2
-
-          expect(d.celebrations[0].rank).to eq CR::Ranks::FERIAL
-
-          expect(d.celebrations[1].rank).to eq CR::Ranks::MEMORIAL_OPTIONAL
-          expect(d.celebrations[1].title).to include 'Lellis'
-        end
-
-        it 'obligatory memorial does suppress ferial' do
-          d = @c.day(1, 17)
-          expect(d.celebrations.size).to eq 1
+    describe 'Temporale x Sanctorale resolution' do
+      before :all do
+        @s = CR::Data::GENERAL_ROMAN_ENGLISH.load
+        @c = described_class.new(2013, @s).freeze
+      end
 
-          expect(d.celebrations[0].rank).to eq CR::Ranks::MEMORIAL_GENERAL
-        end
+      it '"empty" day results in a ferial' do
+        d = @c.day(7, 2)
+        expect(d.celebrations.size).to eq 1
+        expect(d.celebrations[0].rank).to eq CR::Ranks::FERIAL
+      end
 
-        it 'memorial in Lent becomes mere commemoration' do
-          d = @c.day(4, 2)
-          expect(d.celebrations.size).to eq 2
+      it 'sanctorale feast' do
+        d = @c.day(7, 3)
+        expect(d.celebrations.size).to eq 1
+        expect(d.celebrations[0].rank).to eq CR::Ranks::FEAST_GENERAL
+        expect(d.celebrations[0].title).to include 'Thomas'
+      end
 
-          comm = d.celebrations[1]
-          expect(comm.rank).to eq CR::Ranks::COMMEMORATION
-          expect(comm.title).to eq 'Saint Francis of Paola, hermit'
-        end
+      it 'optional memorial does not suppress ferial' do
+        d = @c.day(7, 14)
+        expect(d.celebrations.size).to eq 2
 
-        it 'Sunday suppresses feast' do
-          san = CR::Sanctorale.new
+        expect(d.celebrations[0].rank).to eq CR::Ranks::FERIAL
 
-          d = Date.new 2015, 6, 28
-          expect(d).to be_sunday # ensure
-          san.add d.month, d.day, CR::Celebration.new('St. None, programmer', CR::Ranks::FEAST_GENERAL)
+        expect(d.celebrations[1].rank).to eq CR::Ranks::MEMORIAL_OPTIONAL
+        expect(d.celebrations[1].title).to include 'Lellis'
+      end
 
-          c = described_class.new 2014, san
+      it 'obligatory memorial does suppress ferial' do
+        d = @c.day(1, 17)
+        expect(d.celebrations.size).to eq 1
 
-          celebs = c.day(d).celebrations
-          expect(celebs.size).to eq 1
-          expect(celebs[0].rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
-        end
+        expect(d.celebrations[0].rank).to eq CR::Ranks::MEMORIAL_GENERAL
+      end
 
-        it 'suppressed fictive solemnity is transferred' do
-          san = CR::Sanctorale.new
+      it 'memorial in Lent becomes mere commemoration' do
+        d = @c.day(4, 2)
+        expect(d.celebrations.size).to eq 2
 
-          d = CR::Temporale.new(2014).good_friday
-          st_none = CR::Celebration.new('St. None, abbot, founder of the Order of Programmers (OProg)', CR::Ranks::SOLEMNITY_PROPER)
-          san.add d.month, d.day, st_none
+        comm = d.celebrations[1]
+        expect(comm.rank).to eq CR::Ranks::COMMEMORATION
+        expect(comm.title).to eq 'Saint Francis of Paola, hermit'
+      end
 
-          c = described_class.new 2014, san
+      it 'Sunday suppresses feast' do
+        san = CR::Sanctorale.new
 
-          # 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'
+        d = Date.new 2015, 6, 28
+        expect(d).to be_sunday # ensure
+        san.add d.month, d.day, CR::Celebration.new('St. None, programmer', CR::Ranks::FEAST_GENERAL)
 
-          # it is transferred on a day after the Easter octave
-          d = c.temporale.easter_sunday + 8
-          celebs = c.day(d).celebrations
-          expect(celebs.size).to eq 1
-          expect(celebs[0]).to eq st_none
-        end
+        c = described_class.new 2014, san
 
-        it 'transfer of suppressed Annunciation (real world example)' do
-          c = described_class.new 2015, @s
+        celebs = c.day(d).celebrations
+        expect(celebs.size).to eq 1
+        expect(celebs[0].rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
+      end
 
-          d = Date.new(2016, 3, 25)
+      it 'suppressed fictive solemnity is transferred' do
+        san = CR::Sanctorale.new
 
-          # 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'
+        d = CR::Temporale.new(2014).good_friday
+        st_none = CR::Celebration.new('St. None, abbot, founder of the Order of Programmers (OProg)', CR::Ranks::SOLEMNITY_PROPER)
+        san.add d.month, d.day, st_none
 
-          # it is transferred on a day after the Easter octave
-          d = c.temporale.easter_sunday + 8
-          celebs = c.day(d).celebrations
-          expect(celebs.size).to eq 1
-          expect(celebs[0].title).to eq 'Annunciation of the Lord'
-        end
-      end
-    end
+        c = described_class.new 2014, san
 
-    describe '#pred' do
-      it 'returns a calendar for the previous year' do
-        new_cal = @c.pred
-        expect(new_cal.year).to eq(@c.year - 1)
-        expect(new_cal.sanctorale).to eq (@c.sanctorale)
-      end
+        # 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'
 
-      it 'preserves sanctorale' do
-        sanctorale = CR::Sanctorale.new
-        cal = described_class.new(2000, sanctorale)
-        new_cal = cal.pred
-        expect(new_cal.sanctorale).to be sanctorale
+        # it is transferred on a day after the Easter octave
+        d = c.temporale.easter_sunday + 8
+        celebs = c.day(d).celebrations
+        expect(celebs.size).to eq 1
+        expect(celebs[0]).to eq st_none
       end
 
-      it 'preserves temporale class' do
-        t_class = Class.new(CR::Temporale)
-        cal = described_class.new(2000, nil, t_class)
-        new_cal = cal.pred
-        expect(new_cal.temporale).to be_a t_class
-      end
-    end
+      it 'transfer of suppressed Annunciation (real world example)' do
+        c = described_class.new 2015, @s
 
-    describe '#succ' do
-      it 'returns a calendar for the subsequent year' do
-        new_cal = @c.succ
-        expect(new_cal.year).to eq(@c.year + 1)
-        expect(new_cal.sanctorale).to eq (@c.sanctorale)
-      end
+        d = Date.new(2016, 3, 25)
 
-      it 'preserves sanctorale' do
-        sanctorale = CR::Sanctorale.new
-        cal = described_class.new(2000, sanctorale)
-        new_cal = cal.succ
-        expect(new_cal.sanctorale).to be sanctorale
-      end
+        # 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'
 
-      it 'preserves temporale class' do
-        t_class = Class.new(CR::Temporale)
-        cal = described_class.new(2000, nil, t_class)
-        new_cal = cal.succ
-        expect(new_cal.temporale).to be_a t_class
+        # it is transferred on a day after the Easter octave
+        d = c.temporale.easter_sunday + 8
+        celebs = c.day(d).celebrations
+        expect(celebs.size).to eq 1
+        expect(celebs[0].title).to eq 'Annunciation of the Lord'
       end
     end
   end