calendarium-romanum 0.2.1 → 0.3.0

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

@@ -0,0 +1,151 @@
+module CalendariumRomanum
+  class Temporale
+    # dates of movable feasts
+    module Dates
+      def self.first_advent_sunday(year)
+        sunday_before(nativity(year)) - 3 * Temporale::WEEK
+      end
+
+      def self.nativity(year)
+        Date.new(year, 12, 25)
+      end
+
+      def self.holy_family(year)
+        xmas = nativity(year)
+        if xmas.sunday?
+          return Date.new(year, 12, 30)
+        else
+          sunday_after(xmas)
+        end
+      end
+
+      def self.mother_of_god(year)
+        octave_of(nativity(year))
+      end
+
+      def self.epiphany(year)
+        Date.new(year+1, 1, 6)
+      end
+
+      def self.baptism_of_lord(year)
+        sunday_after epiphany(year)
+      end
+
+      def self.ash_wednesday(year)
+        easter_sunday(year) - (6 * Temporale::WEEK + 4)
+      end
+
+      def self.easter_sunday(year)
+        year += 1
+
+        # algorithm below taken from the 'easter' gem:
+        # 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 += 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)
+        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
+          # Easter occurs in March.
+          return Date.new(y=year, m=3, d=day_easter + 21)
+        else
+          # Easter occurs in April.
+          return Date.new(y=year, m=4, d=day_easter - 10)
+        end
+      end
+
+      def self.palm_sunday(year)
+        easter_sunday(year) - 7
+      end
+
+      def self.good_friday(year)
+        easter_sunday(year) - 2
+      end
+
+      def self.holy_saturday(year)
+        easter_sunday(year) - 1
+      end
+
+      def self.ascension(year)
+        pentecost(year) - 10
+      end
+
+      def self.pentecost(year)
+        easter_sunday(year) + 7 * Temporale::WEEK
+      end
+
+      def self.holy_trinity(year)
+        octave_of(pentecost(year))
+      end
+
+      def self.body_blood(year)
+        holy_trinity(year) + 4
+      end
+
+      def self.sacred_heart(year)
+        body_blood(year) + 8
+      end
+
+      def self.immaculate_heart(year)
+        pentecost(year) + 20
+      end
+
+      def self.christ_king(year)
+        first_advent_sunday(year + 1) - 7
+      end
+
+      # utility methods
+
+      def self.weekday_before(weekday, date)
+        if date.wday == weekday then
+          return date - Temporale::WEEK
+        elsif weekday < date.wday
+          return date - (date.wday - weekday)
+        else
+          return date - (date.wday + Temporale::WEEK - weekday)
+        end
+      end
+
+      def self.weekday_after(weekday, date)
+        if date.wday == weekday then
+          return date + Temporale::WEEK
+        elsif weekday > date.wday
+          return date + (weekday - date.wday)
+        else
+          return date + (Temporale::WEEK - date.wday + weekday)
+        end
+      end
+
+      def self.octave_of(date)
+        date + Temporale::WEEK
+      end
+
+      class << self
+        WEEKDAYS = %w{sunday monday tuesday wednesday thursday friday saturday}
+        WEEKDAYS.each_with_index do |weekday, weekday_i|
+          define_method "#{weekday}_before" do |date|
+            send('weekday_before', weekday_i, date)
+          end
+
+          define_method "#{weekday}_after" do |date|
+            send('weekday_after', weekday_i, date)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module CalendariumRomanum
+  class Temporale
+    module Extensions
+      # Temporale extension adding feast of Christ Eternal Priests,
+      # included in some local calendars
+      module ChristEternalPriest
+        def self.included(mod)
+          mod.add_celebration(
+            :christ_eternal_priest,
+            Celebration.new(
+              proc { I18n.t('temporale.extension.christ_eternal_priest') },
+              Ranks::FEAST_PROPER,
+              Colours::WHITE
+            )
+          )
+        end
+
+        # method computing date
+        def christ_eternal_priest
+          pentecost + 4
+        end
+      end
+    end
+  end
+end

data/lib/calendarium-romanum/transfers.rb

@@ -4,9 +4,11 @@ module CalendariumRomanum
   class Transfers
     def initialize(temporale, sanctorale)
       @transferred = {}
+      @temporale = temporale
+      @sanctorale = sanctorale
 
       dates = sanctorale.solemnities.keys.collect do |abstract_date|
-        temporale.concretize_abstract_date abstract_date
+        concretize_abstract_date abstract_date
       end.sort
 
       dates.each do |date|
@@ -21,7 +23,7 @@ module CalendariumRomanum
         transfer_to = date
         begin
           transfer_to = transfer_to.succ
-        end until valid_destination?(transfer_to, temporale, sanctorale)
+        end until valid_destination?(transfer_to)
         @transferred[transfer_to] = loser
       end
     end
@@ -32,13 +34,29 @@ module CalendariumRomanum
 
     private
 
-    def valid_destination?(day, temporale, sanctorale)
-      return false if temporale.get(day).rank >= Ranks::FEAST_PROPER
+    def valid_destination?(day)
+      return false if @temporale.get(day).rank >= Ranks::FEAST_PROPER
 
-      sc = sanctorale.get(day)
+      sc = @sanctorale.get(day)
       return false if sc.size > 0 && sc.first.rank >= Ranks::FEAST_PROPER
 
       true
     end
+
+    # Converts an AbstractDate to a Date in the given
+    # liturgical year.
+    # It isn't guaranteed to work well (and probably doesn't work well)
+    # for the grey zone of dates between earliest and latest
+    # possible date of the first Advent Sunday, but that's no problem
+    # as long as there are no sanctorale solemnities in this
+    # date range.
+    def concretize_abstract_date(abstract_date)
+      d = abstract_date.concretize(@temporale.year + 1)
+      if @temporale.date_range.include? d
+        d
+      else
+        abstract_date.concretize(@temporale.year)
+      end
+    end
   end
 end

data/lib/calendarium-romanum/version.rb

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

data/spec/calendar_spec.rb

@@ -9,36 +9,36 @@ describe CR::Calendar do
 
     describe '#==' do
       it 'considers calendars with the same year same' do
-        described_class.new(2014).should == described_class.new(2014)
+        expect(described_class.new(2014) == described_class.new(2014)).to be true
       end
 
       it 'considers calendars with different year different' do
-        described_class.new(2014).should_not == described_class.new(2010)
+        expect(described_class.new(2014) == described_class.new(2010)).to be false
       end
     end
 
     describe '#lectionary' do
       it 'detects correctly' do
-        described_class.new(2014).lectionary.should eq :B
-        described_class.new(2013).lectionary.should eq :A
-        described_class.new(2012).lectionary.should eq :C
+        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
-        described_class.new(2014).ferial_lectionary.should eq 1
-        described_class.new(2013).ferial_lectionary.should eq 2
+        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
-        described_class.for_day(Date.new(2014, 6, 9)).should eq described_class.new(2013)
+        expect(described_class.for_day(Date.new(2014, 6, 9))).to eq described_class.new(2013)
       end
 
       it 'provides the current year\'s calendar in December' do
-        described_class.for_day(Date.new(2014, 12, 20)).should eq described_class.new(2014)
+        expect(described_class.for_day(Date.new(2014, 12, 20))).to eq described_class.new(2014)
       end
     end
 
@@ -46,19 +46,19 @@ describe CR::Calendar do
       describe 'received arguments' do
         describe 'Date' do
           it 'returns a Day' do
-            @c.day(Date.new(2013, 12, 10)).should be_a CR::Day
+            expect(@c.day(Date.new(2013, 12, 10))).to be_a CR::Day
           end
         end
 
         describe 'DateTime' do
           it 'returns a Day' do
-            @c.day(DateTime.new(2013, 12, 10, 12, 10, 0)).should be_a CR::Day
+            expect(@c.day(DateTime.new(2013, 12, 10, 12, 10, 0))).to be_a CR::Day
           end
         end
 
         describe 'three Integers' do
           it 'returns a Day' do
-            @c.day(2013, 12, 10).should be_a CR::Day
+            expect(@c.day(2013, 12, 10)).to be_a CR::Day
           end
         end
 
@@ -78,6 +78,24 @@ describe CR::Calendar do
               expect(day.date).to eq Date.new(2014, 4, 10)
             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 '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
 
@@ -88,7 +106,7 @@ describe CR::Calendar do
       describe 'temporale features' do
         describe 'season' do
           it 'detects Advent correctly' do
-            @c.day(2013, 12, 10).season.should eq :advent
+            expect(@c.day(2013, 12, 10).season).to eq CR::Seasons::ADVENT
           end
         end
 
@@ -188,9 +206,7 @@ describe CR::Calendar do
 
       describe 'Temporale x Sanctorale resolution' do
         before :all do
-          @s = CR::Sanctorale.new
-          loader = CR::SanctoraleLoader.new
-          loader.load_from_file(File.join(File.dirname(__FILE__), '..', 'data', 'universal-en.txt'), @s)
+          @s = CR::Data::GENERAL_ROMAN_ENGLISH.load
           @c = described_class.new 2013, @s
         end
 
@@ -217,13 +233,22 @@ describe CR::Calendar do
           expect(d.celebrations[1].title).to include 'Lellis'
         end
 
-        it 'obligate memorial does suppress ferial' do
+        it 'obligatory memorial does suppress ferial' do
           d = @c.day(1, 17)
           expect(d.celebrations.size).to eq 1
 
           expect(d.celebrations[0].rank).to eq CR::Ranks::MEMORIAL_GENERAL
         end
 
+        it 'memorial in Lent becomes mere commemoration' do
+          d = @c.day(4, 2)
+          expect(d.celebrations.size).to eq 2
+
+          comm = d.celebrations[1]
+          expect(comm.rank).to eq CR::Ranks::COMMEMORATION
+          expect(comm.title).to eq 'Saint Francis of Paola, hermit'
+        end
+
         it 'Sunday suppresses feast' do
           san = CR::Sanctorale.new
 
@@ -251,7 +276,7 @@ describe CR::Calendar do
           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 eq 'Friday of the Passion of the Lord'
+          expect(celebs[0].title).to have_translation 'Friday of the Passion of the Lord'
 
           # it is transferred on a day after the Easter octave
           d = c.temporale.easter_sunday + 8
@@ -269,7 +294,7 @@ describe CR::Calendar do
           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 eq 'Friday of the Passion of the Lord'
+          expect(celebs[0].title).to have_translation 'Friday of the Passion of the Lord'
 
           # it is transferred on a day after the Easter octave
           d = c.temporale.easter_sunday + 8
@@ -286,6 +311,20 @@ describe CR::Calendar do
         expect(new_cal.year).to eq(@c.year - 1)
         expect(new_cal.sanctorale).to eq (@c.sanctorale)
       end
+
+      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
+      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
 
     describe '#succ' do
@@ -294,6 +333,20 @@ describe CR::Calendar do
         expect(new_cal.year).to eq(@c.year + 1)
         expect(new_cal.sanctorale).to eq (@c.sanctorale)
       end
+
+      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
+
+      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
+      end
     end
   end
 end

data/spec/dates_spec.rb

@@ -0,0 +1,45 @@
+require_relative 'spec_helper'
+
+describe CR::Temporale::Dates do
+  let(:today) { Date.new 2014, 3, 16 }
+
+  describe '#weekday_before' do
+    describe 'works well for all 7 weekdays' do
+      [
+        [0, Date.new(2014, 3, 9)],
+        [1, Date.new(2014, 3, 10)],
+        [2, Date.new(2014, 3, 11)],
+        [3, Date.new(2014, 3, 12)],
+        [4, Date.new(2014, 3, 13)],
+        [5, Date.new(2014, 3, 14)],
+        [6, Date.new(2014, 3, 15)],
+      ].each do |e|
+        day_num, expected = e
+        it day_num do
+          actual = described_class.weekday_before(day_num, today)
+          expect(actual).to eq expected
+        end
+      end
+    end
+  end
+
+  describe '#weekday_after aliases' do
+    describe 'works well for all 7 weekdays' do
+      [
+        [:monday_after, Date.new(2014, 3, 17)],
+        [:tuesday_after, Date.new(2014, 3, 18)],
+        [:wednesday_after, Date.new(2014, 3, 19)],
+        [:thursday_after, Date.new(2014, 3, 20)],
+        [:friday_after, Date.new(2014, 3, 21)],
+        [:saturday_after, Date.new(2014, 3, 22)],
+        [:sunday_after, Date.new(2014, 3, 23)],
+      ].each do |e|
+        method, expected = e
+        it method do
+          actual = described_class.public_send(method, today)
+          expect(actual).to eq expected
+        end
+      end
+    end
+  end
+end