calendarium-romanum 0.2.1 → 0.3.0

data/data/czech-plzen-cs.txt

@@ -1,5 +1,13 @@
-# Czech Republic
-# diocese of Plzeň
+---
+title: kalendář plzeňské diecéze
+description: Calendar for diocese of Plzeň, Czech Republic
+locale: cs
+country: cz
+diocese: Plzeň
+extends:
+  - czech-cs.txt
+  - czech-cechy-cs.txt
+---
 
 7/14 f2.8 R : Bl. Hroznaty, mučedníka, hlavního patrona diecéze
 

data/data/czech-praha-cs.txt

@@ -1,4 +1,12 @@
-# Czech Republic
-# archdiocese of Prague
+---
+title: kalendář pražské arcidiecéze
+description: Calendar for archdiocese of Prague, Czech Republic
+locale: cs
+country: cz
+diocese: Praha
+extends:
+  - czech-cs.txt
+  - czech-cechy-cs.txt
+---
 
 5/12 f2.8 : Výročí posvěcení katedrály sv. Víta, Václava a Vojtěcha

data/data/universal-en.txt

@@ -1,5 +1,8 @@
-# General Roman Calendar in English
+---
+title: General Roman Calendar
+locale: en
 # source: https://en.wikipedia.org/wiki/General_Roman_Calendar
+---
 
 = 1
 2 m : Saints Basil the Great and Gregory Nazianzen, bishops and doctors

data/data/universal-it.txt

@@ -1,4 +1,7 @@
-# Calendario Romano Generale
+---
+title: Calendario Romano Generale
+locale: it
+---
 
 = 1
 2 m : Santi Basilio Magno e Gregorio Nazianzeno, vescovi e dottori della Chiesa

data/data/universal-la.txt

@@ -1,5 +1,8 @@
-# General Roman Calendar in Latin
+---
+title: Calendarium Romanum Generale
+locale: la
 # source: http://www.binetti.ru/collectio/liturgia/missale_files/crg.htm
+---
 
 = 1
 2 m : Ss. Basilii et Gregorii Nazianzeni, episcoporum et Ecclesiae doctorum

data/lib/calendarium-romanum.rb

@@ -7,6 +7,8 @@ enums
 data
 calendar
 temporale
+temporale/dates
+temporale/extensions/christ_eternal_priest
 sanctorale
 sanctoraleloader
 sanctorale_factory
@@ -14,6 +16,7 @@ transfers
 day
 abstract_date
 util
+ordinalizer
 }.each do |f| 
   require_relative File.join('calendarium-romanum', f) 
 end

data/lib/calendarium-romanum/calendar.rb

@@ -12,10 +12,11 @@ module CalendariumRomanum
     # year: Integer
     # returns a calendar for the liturgical year beginning with
     # Advent of the specified civil year.
-    def initialize(year, sanctorale=nil)
+    def initialize(year, sanctorale=nil, temporale_class=nil)
       @year = year
-      @temporale = Temporale.new(year)
       @sanctorale = sanctorale || Sanctorale.new
+      @temporale_class = temporale_class || Temporale
+      @temporale = @temporale_class.new(year)
       @transferred = Transfers.new(@temporale, @sanctorale)
     end
 
@@ -45,8 +46,8 @@ module CalendariumRomanum
 
       # creates a Calendar for the liturgical year including given
       # date
-      def for_day(date, sanctorale=nil)
-        return new(Temporale.liturgical_year(date), sanctorale)
+      def for_day(date, *constructor_args)
+        return new(Temporale.liturgical_year(date), *constructor_args)
       end
     end # class << self
 
@@ -57,13 +58,13 @@ module CalendariumRomanum
 
     # returns a Calendar for the subsequent year
     def succ
-      c = Calendar.new @year + 1, @sanctorale
+      c = Calendar.new @year + 1, @sanctorale, @temporale_class
       return c
     end
 
     # returns a Calendar for the previous year
     def pred
-      c = Calendar.new @year - 1, @sanctorale
+      c = Calendar.new @year - 1, @sanctorale, @temporale_class
       return c
     end
 
@@ -124,6 +125,12 @@ module CalendariumRomanum
           else
             return st
           end
+        elsif t.rank == Ranks::FERIAL_PRIVILEGED && st.first.rank.memorial?
+          st = st.collect do |c|
+            Celebration.new(c.title, Ranks::COMMEMORATION, t.colour)
+          end
+          st.unshift t
+          return st
         end
       end
 

data/lib/calendarium-romanum/data.rb

@@ -1,5 +1,5 @@
 module CalendariumRomanum
-  # allows easy access to the bundled data files
+  # allows easy access to bundled data files
   class Data < Enum
 
     class SanctoraleFile

data/lib/calendarium-romanum/day.rb

@@ -30,9 +30,6 @@ module CalendariumRomanum
 
     # an Array of Celebrations, possibly empty
     attr_reader :celebrations
-
-    # Celebration of the following day if it has first vespers
-    attr_reader :vespers
   end
 
   # information on one particular celebration of the liturgical year

data/lib/calendarium-romanum/enums.rb

@@ -1,15 +1,45 @@
 module CalendariumRomanum
 
+  class Colour
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+    attr_reader :symbol
+    alias to_sym symbol
+  end
+
+  class Colours < Enum
+    values do
+      [
+        GREEN = Colour.new(:green),
+        VIOLET = Colour.new(:violet),
+        WHITE = Colour.new(:white),
+        RED = Colour.new(:red)
+      ]
+    end
+  end
+
+  Colors = Colours
+
+  class Season
+    def initialize(symbol, colour)
+      @symbol = symbol
+      @colour = colour
+    end
+
+    attr_reader :symbol, :colour
+    alias to_sym symbol
+  end
+
   class Seasons < Enum
     values do
       [
-        ADVENT = :advent,
-        CHRISTMAS = :christmas,
-        LENT = :lent,
-        EASTER = :easter,
-        ORDINARY = :ordinary,
-        # is Triduum Sacrum a special season? For now I count Friday and Saturday
-        # to the Lent, Sunday to the Easter time
+        ADVENT = Season.new(:advent, Colours::VIOLET),
+        CHRISTMAS = Season.new(:christmas, Colours::WHITE),
+        LENT = Season.new(:lent, Colours::VIOLET),
+        EASTER = Season.new(:easter, Colours::WHITE),
+        ORDINARY = Season.new(:ordinary, Colours::GREEN)
       ]
     end
   end
@@ -37,21 +67,11 @@ module CalendariumRomanum
         MEMORIAL_GENERAL  = Rank.new(3.10, 'rank.3_10', 'rank.short.memorial'),
         MEMORIAL_PROPER   = Rank.new(3.11, 'rank.3_11', 'rank.short.memorial'),
         MEMORIAL_OPTIONAL = Rank.new(3.12, 'rank.3_12', 'rank.short.memorial_opt'),
-        FERIAL            = Rank.new(3.13, 'rank.3_13', 'rank.short.ferial')
+        FERIAL            = Rank.new(3.13, 'rank.3_13', 'rank.short.ferial'),
+        # not included as a celebration rank on it's own
+        # in the Table of Liturgical Days
+        COMMEMORATION     = Rank.new(4.0,  'rank.4_0', 'rank.short.commemoration')
       ]
     end
   end
-
-  class Colours < Enum
-    values do
-      [
-        GREEN = :green,
-        VIOLET = :violet,
-        WHITE = :white,
-        RED = :red
-      ]
-    end
-  end
-
-  Colors = Colours
 end

data/lib/calendarium-romanum/ordinalizer.rb

@@ -0,0 +1,37 @@
+require 'roman-numerals'
+
+module CalendariumRomanum
+  # Knows how to produce localized ordinals
+  class Ordinalizer
+    class << self
+      def ordinal(number, locale: nil)
+        locale ||= I18n.locale
+
+        case locale
+        when :cs
+          "#{number}."
+        when :en
+          english_ordinal(number)
+        # when :it # TODO
+        when :la, :it
+          RomanNumerals.to_roman number
+        else
+          number
+        end
+      end
+
+      def english_ordinal(number)
+        case number
+        when 1
+          '1st'
+        when 2
+          '2nd'
+        when 3
+          '3rd'
+        else
+          "#{number}th"
+        end
+      end
+    end
+  end
+end

data/lib/calendarium-romanum/sanctoraleloader.rb

@@ -30,9 +30,20 @@ module CalendariumRomanum
     def load(src, dest=nil)
       dest ||= Sanctorale.new
 
+      in_front_matter = false
       month_section = nil
-      src.each_line.each_with_index do |l, li|
-        line_num = li + 1
+      src.each_line.with_index(1) do |l, line_num|
+        # skip YAML front matter
+        if line_num == 1 && l.start_with?('---')
+          in_front_matter = true
+          next
+        elsif in_front_matter
+          if l.start_with?('---')
+            in_front_matter = false
+          end
+
+          next
+        end
 
         # strip whitespace and comments
         l.sub!(/#.*/, '')

data/lib/calendarium-romanum/temporale.rb

@@ -7,21 +7,22 @@ module CalendariumRomanum
 
     WEEK = 7
 
-    SEASON_COLOUR = {
-                     Seasons::ADVENT => Colours::VIOLET,
-                     Seasons::CHRISTMAS => Colours::WHITE,
-                     Seasons::ORDINARY => Colours::GREEN,
-                     Seasons::LENT => Colours::VIOLET,
-                     Seasons::EASTER => Colours::WHITE,
-                    }
-
     # year is Integer - the civil year when the liturgical year begins
-    def initialize(year=nil)
+    def initialize(year)
       @year = year
-      prepare_solemnities unless @year.nil?
+      prepare_solemnities
     end
 
+    attr_reader :year
+
     class << self
+      # Creates a subclass with specified extension modules included
+      def with_extensions(*extensions)
+        Class.new(self) do
+          extensions.each {|e| include e }
+        end
+      end
+
       # Determines liturgical year for the given date
       def liturgical_year(date)
         year = date.year
@@ -39,197 +40,106 @@ module CalendariumRomanum
       def for_day(date)
         return new(liturgical_year(date))
       end
-    end
-
-    def start_date(year=nil)
-      first_advent_sunday(year)
-    end
-
-    def end_date(year=nil)
-      year ||= @year
-      first_advent_sunday(year+1) - 1
-    end
-
-    def date_range(year=nil)
-      start_date(year) .. end_date(year)
-    end
 
-    def range_check(date)
-      # necessary in order to handle Date correctly
-      date = date.to_date if date.class != Date
-
-      unless date_range.include? date
-        raise RangeError.new "Date out of range #{date}"
+      C = Struct.new(:date_method, :celebration)
+      private_constant :C
+
+      # implementation detail, not to be touched by client code
+      def celebrations
+        @celebrations ||=
+          begin
+            [
+              c(:nativity, Ranks::PRIMARY),
+              c(:holy_family, Ranks::FEAST_LORD_GENERAL),
+              c(:mother_of_god, Ranks::SOLEMNITY_GENERAL),
+              c(:epiphany, Ranks::PRIMARY),
+              c(:baptism_of_lord, Ranks::FEAST_LORD_GENERAL),
+              c(:ash_wednesday, Ranks::PRIMARY, Colours::VIOLET),
+              c(:good_friday, Ranks::TRIDUUM, Colours::RED),
+              c(:holy_saturday, Ranks::TRIDUUM, Colours::VIOLET),
+              c(:palm_sunday, Ranks::PRIMARY, Colours::RED),
+              c(:easter_sunday, Ranks::TRIDUUM),
+              c(:ascension, Ranks::PRIMARY),
+              c(:pentecost, Ranks::PRIMARY, Colours::RED),
+              c(:holy_trinity, Ranks::SOLEMNITY_GENERAL),
+              c(:body_blood, Ranks::SOLEMNITY_GENERAL),
+              c(:sacred_heart, Ranks::SOLEMNITY_GENERAL),
+              c(:christ_king, Ranks::SOLEMNITY_GENERAL),
+
+              # Immaculate Heart of Mary is actually (currently the only one)
+              # movable *sanctorale* feast, but as it would make little sense
+              # to add support for movable sanctorale feasts because of
+              # a single one, we cheat a bit and handle it in temporale.
+              c(:immaculate_heart, Ranks::MEMORIAL_GENERAL),
+            ]
+          end
       end
-    end
-
-    # converts an AbstractDate to a Date in the given
-    # liturgical year
-    def concretize_abstract_date(abstract_date)
-      d = abstract_date.concretize(@year + 1)
-      if date_range.include? d
-        d
-      else
-        abstract_date.concretize(@year)
-      end
-    end
 
-    def weekday_before(weekday, date)
-      if date.wday == weekday then
-        return date - WEEK
-      elsif weekday < date.wday
-        return date - (date.wday - weekday)
-      else
-        return date - (date.wday + WEEK - weekday)
-      end
-    end
-
-    def weekday_after(weekday, date)
-      if date.wday == weekday then
-        return date + WEEK
-      elsif weekday > date.wday
-        return date + (weekday - date.wday)
-      else
-        return date + (WEEK - date.wday + weekday)
-      end
-    end
-
-    def octave_of(date)
-      date + WEEK
-    end
-
-    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
-
-    # first_advent_sunday -> advent_sunday(1)
-    %w{first second third fourth}.each_with_index do |word,i|
-      define_method "#{word}_advent_sunday" do |year=nil|
-        send("advent_sunday", i + 1, year)
-      end
-    end
+      # Hook point for extensions to add new celebrations
+      def add_celebration(date_method, celebration)
+        if self == Temporale
+          raise RuntimeError.new("Don't add celebrations to Temporale itself, subclass it and modify the subclass.")
+        end
 
-    def advent_sunday(num, year=nil)
-      advent_sundays_total = 4
-      unless (1..advent_sundays_total).include? num
-        raise ArgumentError.new "Invalid Advent Sunday #{num}"
+        celebrations << C.new(date_method, celebration)
       end
 
-      year ||= @year
-      return sunday_before(nativity(year)) - ((advent_sundays_total - num) * WEEK)
-    end
+      private
 
-    def nativity(year=nil)
-      year ||= @year
-      return Date.new(year, 12, 25)
-    end
+      def c(date_method, rank, colour=Colours::WHITE)
+        title = proc { I18n.t("temporale.solemnity.#{date_method}") }
 
-    def holy_family(year=nil)
-      year ||= @year
-      xmas = nativity(year)
-      if xmas.sunday?
-        return Date.new(year, 12, 30)
-      else
-        sunday_after(xmas)
+        C.new(
+          date_method,
+          Celebration.new(title, rank, colour)
+        )
       end
     end
 
-    def mother_of_god(year=nil)
-      octave_of(nativity(year))
+    def start_date
+      first_advent_sunday
     end
 
-    def epiphany(year=nil)
-      year ||= @year
-      return Date.new(year+1, 1, 6)
+    def end_date
+      Dates.first_advent_sunday(year+1) - 1
     end
 
-    def baptism_of_lord(year=nil)
-      year ||= @year
-      return sunday_after epiphany(year)
+    def date_range
+      start_date .. end_date
     end
 
-    def ash_wednesday(year=nil)
-      year ||= @year
-      return easter_sunday(year) - (6 * WEEK + 4)
-    end
-
-    def easter_sunday(year=nil)
-      year ||= @year
-      year += 1
-
-      # algorithm below taken from the 'easter' gem:
-      # https://github.com/jrobertson/easter
+    def range_check(date)
+      # necessary in order to handle Date correctly
+      date = date.to_date if date.class != Date
 
-      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)
+      unless date_range.include? date
+        raise RangeError.new "Date out of range #{date}"
       end
     end
 
-    def palm_sunday(year=nil)
-      return easter_sunday(year) - 7
-    end
-
-    def good_friday(year=nil)
-      return easter_sunday(year) - 2
-    end
-
-    def holy_saturday(year=nil)
-      return easter_sunday(year) - 1
-    end
-
-    def ascension(year=nil)
-      return pentecost(year) - 10
-    end
-
-    def pentecost(year=nil)
-      year ||= @year
-      return easter_sunday(year) + 7 * WEEK
-    end
-
-    def holy_trinity(year=nil)
-      sunday_after(pentecost(year))
-    end
-
-    def body_blood(year=nil)
-      thursday_after(holy_trinity(year))
-    end
-
-    def sacred_heart(year=nil)
-      friday_after(sunday_after(body_blood(year)))
-    end
-
-    def christ_king(year=nil)
-      year ||= @year
-      sunday_before(first_advent_sunday(year + 1))
+    %i(
+    first_advent_sunday
+    nativity
+    holy_family
+    mother_of_god
+    epiphany
+    baptism_of_lord
+    ash_wednesday
+    palm_sunday
+    good_friday
+    holy_saturday
+    easter_sunday
+    ascension
+    pentecost
+    holy_trinity
+    body_blood
+    sacred_heart
+    immaculate_heart
+    christ_king
+    ).each do |feast|
+      define_method feast do
+        Dates.public_send feast, year
+      end
     end
 
     # which liturgical season is it?
@@ -268,14 +178,14 @@ module CalendariumRomanum
       when Seasons::EASTER
         easter_sunday
       else # ordinary time
-        monday_after(baptism_of_lord)
+        Dates.monday_after(baptism_of_lord)
       end
     end
 
     def season_week(seasonn, date)
       week1_beginning = season_beginning = season_beginning(seasonn)
       unless season_beginning.sunday?
-        week1_beginning = sunday_after(season_beginning)
+        week1_beginning = Dates.sunday_after(season_beginning)
       end
 
       week = date_difference(date, week1_beginning) / Temporale::WEEK + 1
@@ -286,7 +196,7 @@ module CalendariumRomanum
         week += 1
 
         if date > pentecost
-          weeks_after_date = date_difference(first_advent_sunday(@year + 1), date) / 7
+          weeks_after_date = date_difference(Dates.first_advent_sunday(@year + 1), date) / 7
           week = 34 - weeks_after_date
           week += 1 if date.sunday?
         end
@@ -310,44 +220,34 @@ module CalendariumRomanum
         end
       end
 
-      return solemnity(date) || sunday(date) || ferial(date)
+      return @solemnities[date] || @feasts[date] || sunday(date) || @memorials[date] || ferial(date)
     end
 
     private
 
-    # the celebration determination split in methods:
-
-    def solemnity(date)
-      if @solemnities.has_key?(date)
-        return @solemnities[date]
-      end
-
-      seas = season(date)
-      case seas
-      when Seasons::EASTER
-        if date <= sunday_after(easter_sunday)
-          return Celebration.new '', Ranks::PRIMARY, SEASON_COLOUR[seas]
-        end
-      end
-
-      return nil
-    end
+    # seasons when Sundays have higher rank
+    SEASONS_SUNDAY_PRIMARY = [Seasons::ADVENT, Seasons::LENT, Seasons::EASTER].freeze
 
     def sunday(date)
       return nil unless date.sunday?
 
       seas = season date
       rank = Ranks::SUNDAY_UNPRIVILEGED
-      if [Seasons::ADVENT, Seasons::LENT, Seasons::EASTER].include?(seas)
+      if SEASONS_SUNDAY_PRIMARY.include?(seas)
         rank = Ranks::PRIMARY
       end
 
-      return Celebration.new '', rank, SEASON_COLOUR[seas]
+      week = Ordinalizer.ordinal season_week(seas, date)
+      title = I18n.t "temporale.#{seas.to_sym}.sunday", week: week
+
+      return Celebration.new title, rank, seas.colour
     end
 
     def ferial(date)
       seas = season date
+      week = season_week(seas, date)
       rank = Ranks::FERIAL
+      title = nil
       case seas
       when Seasons::ADVENT
         if date >= Date.new(@year, 12, 17)
@@ -356,12 +256,31 @@ module CalendariumRomanum
       when Seasons::CHRISTMAS
         if date < mother_of_god
           rank = Ranks::FERIAL_PRIVILEGED
+
+          nth = Ordinalizer.ordinal(date.day - nativity.day + 1) # 1-based counting
+          title = I18n.t 'temporale.christmas.nativity_octave.ferial', day: nth
+        elsif date > epiphany
+          title = I18n.t "temporale.christmas.after_epiphany.ferial", weekday: I18n.t("weekday.#{date.wday}")
         end
       when Seasons::LENT
-        rank = Ranks::FERIAL_PRIVILEGED
+        if week == 0
+          title = I18n.t "temporale.lent.after_ashes.ferial", weekday: I18n.t("weekday.#{date.wday}")
+        elsif date > palm_sunday
+          rank = Ranks::PRIMARY
+          title = I18n.t "temporale.lent.holy_week.ferial", weekday: I18n.t("weekday.#{date.wday}")
+        end
+        rank = Ranks::FERIAL_PRIVILEGED unless rank > Ranks::FERIAL_PRIVILEGED
+      when Seasons::EASTER
+        if week == 1
+          rank = Ranks::PRIMARY
+          title = I18n.t "temporale.easter.octave.ferial", weekday: I18n.t("weekday.#{date.wday}")
+        end
       end
 
-      return Celebration.new '', rank, SEASON_COLOUR[seas]
+      week_ord = Ordinalizer.ordinal week
+      title ||= I18n.t "temporale.#{seas.to_sym}.ferial", week: week_ord, weekday: I18n.t("weekday.#{date.wday}")
+
+      return Celebration.new title, rank, seas.colour
     end
 
     # helper: difference between two Dates in days
@@ -369,35 +288,29 @@ module CalendariumRomanum
       return (d1 - d2).numerator
     end
 
-    # prepare dates of temporale solemnities and their octaves
+    # prepare dates of temporale solemnities
     def prepare_solemnities
       @solemnities = {}
-
-      {
-        nativity: [Ranks::PRIMARY, nil],
-        holy_family: [Ranks::FEAST_LORD_GENERAL, nil],
-        mother_of_god: [Ranks::SOLEMNITY_GENERAL],
-        epiphany: [Ranks::PRIMARY, nil],
-        baptism_of_lord: [Ranks::FEAST_LORD_GENERAL, nil],
-        ash_wednesday: [Ranks::PRIMARY, nil],
-        good_friday: [Ranks::TRIDUUM, Colours::RED],
-        holy_saturday: [Ranks::TRIDUUM, nil],
-        palm_sunday: [Ranks::PRIMARY, Colours::RED],
-        easter_sunday: [Ranks::TRIDUUM, nil],
-        ascension: [Ranks::PRIMARY, Colours::WHITE],
-        pentecost: [Ranks::PRIMARY, Colours::RED],
-        holy_trinity: [Ranks::SOLEMNITY_GENERAL, Colours::WHITE],
-        body_blood: [Ranks::SOLEMNITY_GENERAL, Colours::WHITE],
-        sacred_heart: [Ranks::SOLEMNITY_GENERAL, Colours::WHITE],
-        christ_king: [Ranks::SOLEMNITY_GENERAL, Colours::WHITE],
-      }.each_pair do |method_name, data|
-        date = send(method_name)
-        rank, colour = data
-        @solemnities[date] = Celebration.new(
-                                             proc { I18n.t("temporale.solemnity.#{method_name}") },
-                                             rank,
-                                             colour || SEASON_COLOUR[season(date)]
-                                            )
+      @feasts = {}
+      @memorials = {}
+
+      self.class.celebrations.each do |c|
+        if c.date_method.is_a? Proc
+          date = instance_eval &c.date_method
+        else
+          date = public_send(c.date_method)
+        end
+        celebration = c.celebration
+
+        add_to =
+          if celebration.feast?
+            @feasts
+          elsif celebration.memorial?
+            @memorials
+          else
+            @solemnities
+          end
+        add_to[date] = celebration
       end
     end
   end