calendarium-romanum 0.5.0 → 0.9.0

data/lib/calendarium-romanum/sanctoraleloader.rb

@@ -1,122 +0,0 @@
-module CalendariumRomanum
-
-  # understands a plaintext calendar format
-  # and knows how to transform it to Celebrations
-  # and fill them in a Sanctorale
-  #
-  # Format of the file:
-  # 1/31 m : S. Ioannis Bosco, presbyteri
-  #
-  # <month>/<day> <rank shortcut> : <title>
-  # rank shortcut is optional, default value is optional memorial
-  class SanctoraleLoader
-
-    RANK_CODES = {
-      nil => Ranks::MEMORIAL_OPTIONAL,
-      'm' => Ranks::MEMORIAL_GENERAL,
-      'f' => Ranks::FEAST_GENERAL,
-      's' => Ranks::SOLEMNITY_GENERAL
-    }.freeze
-    COLOUR_CODES = {
-      nil => Colours::WHITE,
-      'w' => Colours::WHITE,
-      'v' => Colours::VIOLET,
-      'g' => Colours::GREEN,
-      'r' => Colours::RED
-    }.freeze
-
-    # dest should be a Sanctorale,
-    # src anything with #each_line
-    def load(src, dest = nil)
-      dest ||= Sanctorale.new
-
-      in_front_matter = false
-      month_section = nil
-      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!(/#.*/, '')
-        l.strip!
-        next if l.empty?
-
-        # month section heading
-        n = l.match(/^=\s*(\d+)\s*$/)
-        unless n.nil?
-          month_section = n[1].to_i
-          unless month_section >= 1 && month_section <= 12
-            raise error("Invalid month #{month_section}", line_num)
-          end
-          next
-        end
-
-        # celebration record
-        m = l.match(/^((\d+)\/)?(\d+)\s*(([mfs])?(\d\.\d{1,2})?)?\s*([WVRG])?\s*:(.*)$/i)
-        if m.nil?
-          raise error("Syntax error, line skipped '#{l}'", line_num)
-        end
-
-        month, day, rank_char, rank_num, colour, title = m.values_at(2, 3, 5, 6, 7, 8)
-        month ||= month_section
-        day = day.to_i
-        month = month.to_i
-
-        rank = RANK_CODES[rank_char && rank_char.downcase]
-        if rank.nil?
-          raise error("Invalid celebration rank code #{rank_char}", line_num)
-        end
-
-        if rank_num
-          rank_num = rank_num.to_f
-          rank_by_num = Ranks[rank_num]
-
-          if rank_by_num.nil?
-            raise error("Invalid celebration rank code #{rank_num}", line_num)
-          elsif rank_char && (rank.priority.to_i != rank_by_num.priority.to_i)
-            raise error("Invalid combination of rank letter #{rank_char.inspect} and number #{rank_num}.", line_num)
-          end
-
-          rank = rank_by_num
-        end
-
-        begin
-          dest.add(
-            month,
-            day,
-            Celebration.new(
-              title.strip,
-              rank,
-              COLOUR_CODES[colour && colour.downcase]
-            )
-          )
-        rescue RangeError => err
-          raise error(err.message, line_num)
-        end
-      end
-
-      dest
-    end
-
-    alias load_from_string load
-
-    def load_from_file(filename, dest = nil, encoding = 'utf-8')
-      load File.open(filename, 'r', encoding: encoding), dest
-    end
-
-    private
-
-    def error(message, line_number)
-      InvalidDataError.new("L#{line_number}: #{message}")
-    end
-  end
-end

data/spec/abstract_date_spec.rb

@@ -1,62 +0,0 @@
-require_relative 'spec_helper'
-
-describe CR::AbstractDate do
-  AD = CR::AbstractDate
-
-  describe '.new' do
-    describe 'fails on invalid' do
-      it 'month' do
-        expect do
-          AD.new(13, 1)
-        end.to raise_exception /Invalid month/
-      end
-
-      it 'day' do
-        expect do
-          AD.new(1, 32)
-        end.to raise_exception /Invalid day/
-      end
-
-      it 'day of month' do
-        expect do
-          AD.new(2, 30)
-        end.to raise_exception /Invalid day/
-      end
-    end
-  end
-
-  # test .new through .from_date on a complete leap year
-  describe '.from_date' do
-    YEAR = 2000
-
-    it 'the test year is leap' do
-      expect(Date.new(YEAR)).to be_leap
-    end
-
-    CR::Util::Year.new(YEAR).each do |date|
-      it date.to_s do
-        expect do
-          AD.from_date date
-        end.not_to raise_exception
-      end
-    end
-  end
-
-  describe '#<' do
-    it { expect(AD.new(1, 1)).to be < AD.new(1, 2) }
-    it { expect(AD.new(1, 1)).to be < AD.new(2, 1) }
-    it { expect(AD.new(1, 1)).not_to be < AD.new(1, 1) }
-  end
-
-  describe '#==' do
-    it { expect(AD.new(1, 1)).to be == AD.new(1, 1) }
-    it { expect(AD.new(1, 1)).not_to be == AD.new(1, 2) }
-  end
-
-  describe 'as a Hash key' do
-    it 'different objects with the same values are considered same key' do
-      h = {AD.new(1, 1) => 1}
-      expect(h).to have_key AD.new(1, 1)
-    end
-  end
-end

data/spec/calendar_spec.rb

@@ -1,559 +0,0 @@
-require_relative 'spec_helper'
-
-describe CR::Calendar do
-  before :all 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
-        described_class.new(1968)
-      end.to raise_exception(RangeError, /in use only since 1st January 1970/)
-    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
-
-  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
-
-    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 '#==' 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 '#[]' 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
-        it 'returns a Day' do
-          expect(@c.day(Date.new(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
-        end
-      end
-
-      describe 'three Integers' do
-        it 'returns a Day' do
-          expect(@c.day(2013, 12, 10)).to be_a CR::Day
-        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)
-          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)
-          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
-
-    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 '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
-
-    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 '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 '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
-
-        describe 'Lent' do
-          it 'Ash Wednesday is week 0' do
-            expect(@c.day(2014, 3, 5).season_week).to eq 0
-          end
-        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 '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 '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 '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
-
-            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
-                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
-                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
-                end
-              end
-            end
-          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).freeze
-      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
-
-        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
-
-        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)
-
-        c = described_class.new 2014, san
-
-        celebs = c.day(d).celebrations
-        expect(celebs.size).to eq 1
-        expect(celebs[0].rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
-      end
-
-      it 'suppressed fictive solemnity is transferred' do
-        san = CR::Sanctorale.new
-
-        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
-
-        c = described_class.new 2014, san
-
-        # 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 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 'transfer of suppressed Annunciation (real world example)' do
-        c = described_class.new 2015, @s
-
-        d = Date.new(2016, 3, 25)
-
-        # Good Friday suppresses the solemnity
-        celebs = c.day(d).celebrations
-        expect(celebs.size).to eq 1
-        expect(celebs[0]).to eq celfactory.good_friday
-
-        # 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
-
-      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