calendarium-romanum 0.7.0 → 0.7.1

data/spec/sanctorale_spec.rb

@@ -1,281 +0,0 @@
-require 'spec_helper'
-
-describe CR::Sanctorale do
-  let(:s) { described_class.new }
-
-  # example celebrations
-  let(:antonius) { CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL, CR::Colours::WHITE, :antonius) }
-  let(:nullus) { CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_OPTIONAL, CR::Colours::WHITE, :nullus) }
-  let(:ignotus) { CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_OPTIONAL, CR::Colours::WHITE, :ignotus) }
-  let(:opt_memorial) { nullus }
-  let(:opt_memorial_2) { ignotus }
-  let(:solemnity) { CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_PROPER, CR::Colours::WHITE, :nullus_solemnity) }
-
-  describe '#get' do
-    describe 'for an empty day' do
-      it 'returns an Array' do
-        expect(s.get(1, 3)).to be_an Array
-      end
-    end
-
-    describe 'for an unempty day' do
-      before :each do
-        s.add 1, 17, antonius
-      end
-
-      it 'get by month, day' do
-        expect(s.get(1, 17)).to eq [antonius]
-      end
-
-      it 'get by Date' do
-        expect(s.get(Date.new(2014, 1, 17))).to eq [antonius]
-      end
-
-      it 'may have more CR::Celebrations for a day' do
-        [
-          'S. Fabiani, papae et martyris',
-          'S. Sebastiani, martyris'
-        ].each {|t| s.add 1, 20, CR::Celebration.new(t, CR::Ranks::MEMORIAL_OPTIONAL) }
-        expect(s.get(1, 20).size).to eq 2
-      end
-    end
-  end
-
-  describe '#add' do
-    it 'adds a CR::Celebration to one month only' do
-      s.add 1, 17, antonius
-      expect(s.get(2, 17)).to be_empty
-    end
-
-    it 'does not allow month 0' do
-      expect { s.add 0, 1, opt_memorial }.to raise_exception RangeError
-    end
-
-    it 'does not allow month higher than 12' do
-      expect { s.add 13, 1, opt_memorial }.to raise_exception RangeError
-    end
-
-    it 'adds solemnity to a dedicated container' do
-      expect { s.add 1, 13, solemnity }.to change { s.solemnities.size }.by 1
-    end
-
-    it 'does not add non-solemnity to solemnities' do
-      expect { s.add 1, 13, opt_memorial }.not_to change { s.solemnities.size }
-    end
-
-    it 'fails when adding second celebration with the same symbol' do
-      s.add 1, 13, antonius
-
-      expect do
-        s.add 1, 14, antonius
-      end.to raise_exception ArgumentError, /duplicate symbol :antonius/
-    end
-
-    describe 'multiple celebrations on a single day' do
-      it 'succeeds for any number of optional memorials' do
-        s.add 1, 13, opt_memorial
-
-        expect do
-          s.add 1, 13, opt_memorial_2
-        end.not_to raise_exception
-      end
-
-      it 'fails when adding a non-optional memorial' do
-        s.add 1, 13, opt_memorial
-
-        expect do
-          s.add 1, 13, CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_GENERAL)
-        end.to raise_exception ArgumentError
-      end
-
-      it 'fails when adding to a non-optional memorial' do
-        s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_GENERAL)
-
-        expect do
-          s.add 1, 13, opt_memorial_2
-        end.to raise_exception ArgumentError
-      end
-
-      # there used to be a bug, registering a solemnity *before*
-      # checking if it can be added at all
-      it 'does not modify internal state when it fails' do
-        s.add 1, 13, opt_memorial
-
-        expect do
-          begin
-            s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_GENERAL)
-          rescue ArgumentError
-          end
-        end.not_to change { s.solemnities.size }
-      end
-    end
-  end
-
-  describe '#replace' do
-    it 'replaces the original celebration(s)' do
-      s.add 1, 13, opt_memorial_2
-      s.replace 1, 13, [solemnity]
-
-      expect(s.get(1, 13)).to eq [solemnity]
-    end
-
-    it 'adds solemnity to a dedicated container' do
-      expect do
-        s.replace 1, 13, [solemnity]
-      end.to change { s.solemnities.size }.by 1
-    end
-
-    it 'removes solemnity' do
-      s.add 1, 13, solemnity
-      expect do
-        s.replace 1, 13, [opt_memorial_2]
-      end.to change { s.solemnities.size }.by(-1)
-    end
-
-    it 'does not simply save the passed Array' do
-      array = [opt_memorial]
-      s.replace 1, 13, array
-
-      array << nil
-
-      expect(s.get(1, 13)).not_to include nil
-    end
-
-    describe 'duplicate symbol handling' do
-      it 'fails when adding second celebration with the same symbol' do
-        s.replace 1, 13, [nullus]
-
-        expect do
-          s.replace 1, 14, [nullus]
-        end.to raise_exception ArgumentError, /duplicate symbols \[:nullus\]/
-      end
-
-      it 'failed attempts do not modify state of the internal symbol set' do
-        s.replace 1, 14, [nullus]
-        s.replace 1, 15, [ignotus]
-
-        expect do
-          s.replace 1, 14, [ignotus]
-        end.to raise_exception ArgumentError, /duplicate symbols \[:ignotus\]/
-
-        expect do
-          s.replace 1, 15, [nullus]
-        end.to raise_exception ArgumentError, /duplicate symbols \[:nullus\]/
-      end
-
-      it 'succeeds when celebration with the same symbol is being replaced' do
-        s.replace 1, 13, [nullus]
-
-        expect do
-          s.replace 1, 13, [nullus]
-        end.not_to raise_exception
-      end
-    end
-  end
-
-  describe '#update' do
-    let(:s2) { described_class.new }
-
-    it 'adds entries from the argument to receiver' do
-      s2.add 1, 17, antonius
-
-      expect(s).to be_empty
-      s.update s2
-      expect(s.size).to eq 1
-    end
-
-    it 'overwrites eventual previous content of the day' do
-      s.add 1, 17, antonius
-      s2.add 1, 17, opt_memorial
-
-      s.update s2
-      expect(s.get(1, 17)).to eq [opt_memorial]
-    end
-
-    it 'does not overwrite content of days for which it does not have any' do
-      s.add 1, 17, antonius
-
-      s.update s2
-      expect(s.get(1, 17)).to eq [antonius]
-    end
-  end
-
-  describe '#size' do
-    it 'knows when the Sanctorale is empty' do
-      expect(s.size).to eq 0
-    end
-
-    it 'knows when there is something' do
-      s.add 1, 17, antonius
-      expect(s.size).to eq 1
-    end
-  end
-
-  describe '#empty?' do
-    it 'is empty at the beginning' do
-      expect(s).to be_empty
-    end
-
-    it 'is never more empty once a record is entered' do
-      s.add 1, 17, antonius
-      expect(s).not_to be_empty
-    end
-  end
-
-  describe '#each_day' do
-    before :each do
-      s.add 1, 17, antonius
-    end
-
-    it 'yields each date and corresponding CR::Celebrations' do
-      expect {|block| s.each_day(&block) }.to yield_with_args(CR::AbstractDate.new(1, 17), [antonius])
-    end
-
-    it 'can be called without a block' do
-      expect(s.each_day).to be_an Enumerator
-    end
-  end
-
-  describe '#freeze' do
-    it 'makes the instance frozen' do
-      expect(s).not_to be_frozen # make sure
-      s.freeze
-      expect(s).to be_frozen
-    end
-
-    it 'prevents modification' do
-      s.freeze
-
-      expect do
-        s.add 1, 17, antonius
-      end.to raise_exception(RuntimeError, /can't modify frozen/)
-    end
-  end
-
-  describe '#==' do
-    describe 'empty' do
-      it 'is equal' do
-        expect(described_class.new).to be == described_class.new
-      end
-    end
-
-    describe 'with content' do
-      let(:a) do
-        s = described_class.new
-        s.add 1, 17, antonius
-        s
-      end
-
-      it 'different' do
-        expect(a).not_to be == described_class.new
-      end
-
-      it 'same' do
-        b = described_class.new
-        b.add 1, 17, antonius
-
-        expect(a).to be == b
-      end
-    end
-  end
-end

data/spec/season_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe CR::Season do
-  CR::Seasons.each do |season|
-    describe season do
-      describe '#name' do
-        it { expect(season.name).to have_translation }
-      end
-    end
-  end
-
-  describe 'indexing' do
-    it 'is indexed by symbol' do
-      expect(CR::Seasons[:lent]).to be CR::Seasons::LENT
-    end
-  end
-
-  describe '#to_s' do
-    it { expect(CR::Seasons::LENT.to_s)
-         .to eq '#<CalendariumRomanum::Season lent>' }
-  end
-end

data/spec/spec_helper.rb

@@ -1,46 +0,0 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter 'lib/calendarium-romanum/cli.rb'
-end
-
-require 'aruba/rspec'
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end
-
-RSpec::Matchers.define :have_translation do |expected, locale|
-  match do |actual|
-    locale ||= :en
-    if expected && I18n.locale == locale
-      actual == expected
-    else
-      # with locale different from the one the spec is written for
-      # just test that the string isn't left untranslated
-      !(actual.nil? || actual.empty? || actual.include?('translation missing'))
-    end
-  end
-end
-
-require 'calendarium-romanum'
-CR = CalendariumRomanum
-
-I18n.enforce_available_locales = true
-I18n.locale = ENV['LOCALE'] || :en
-
-# make the gem's executable(s) easily available for aruba
-gem_bin = File.expand_path('../../bin', __FILE__)
-ENV['PATH'] = "#{gem_bin}:#{ENV['PATH']}"

data/spec/temporale_spec.rb

@@ -1,693 +0,0 @@
-# coding: utf-8
-require_relative 'spec_helper'
-
-describe CR::Temporale do
-  let(:t12) { described_class.new 2012 }
-  let(:t13) { described_class.new 2013 }
-  let(:t) { t12 }
-
-  let(:factory) { CR::Temporale::CelebrationFactory }
-
-  describe '.liturgical_year' do
-    it 'returns liturgical year for the given date' do
-      [
-        [Date.new(2014, 11, 1), 2013],
-        [Date.new(2014, 12, 1), 2014]
-      ].each do |date, year|
-        expect(described_class.liturgical_year(date)).to eq year
-      end
-    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
-    let(:year) { 2012 }
-    let(:b) { described_class.new year }
-
-    describe 'year' do
-      let(:a) { described_class.new year }
-
-      it 'same' do
-        expect(a).to be == described_class.new(year)
-      end
-
-      it 'different' do
-        expect(a).not_to be == described_class.new(year + 1)
-      end
-    end
-
-    describe 'transfers' do
-      let(:transfers) { [:epiphany, :ascension] }
-      let(:a) { described_class.new year, transfer_to_sunday: transfers }
-
-      it 'same' do
-        reversed_transfers = transfers.reverse # order doesn't matter
-        expect(a)
-          .to be == described_class.new(year, transfer_to_sunday: reversed_transfers)
-      end
-
-      it 'different' do
-        expect(a).not_to be == b
-      end
-    end
-
-    describe 'extensions' do
-      let(:empty_enumerator) do
-        o = Object.new
-        def o.each_celebration; end
-        o
-      end
-
-      let(:extensions) do
-        [
-          CR::Temporale::Extensions::ChristEternalPriest,
-          empty_enumerator
-        ]
-      end
-
-      let(:a) { described_class.new year, extensions: extensions }
-
-      it 'same' do
-        reversed_extensions = extensions.reverse # order doesn't matter
-        expect(a)
-          .to be == described_class.new(year, extensions: reversed_extensions)
-      end
-
-      it 'different' do
-        expect(a).not_to be == b
-      end
-    end
-  end
-
-  describe '#first_advent_sunday determines first Sunday of Advent' do
-    [
-      [2004, [11, 28]],
-      [2010, [11, 28]],
-      [2011, [11, 27]],
-      [2012, [12, 2]],
-      [2013, [12, 1]]
-    ].each do |d|
-      year, date = d
-      it year do
-        temporale = described_class.new(year)
-        expect(temporale.first_advent_sunday).to eq Date.new(year, *date)
-      end
-    end
-  end
-
-  describe '#easter_sunday determines Easter Sunday' do
-    [
-      [2003, [2004, 4, 11]],
-      [2004, [2005, 3, 27]],
-      [2005, [2006, 4, 16]],
-      [2006, [2007, 4, 8]],
-      [2014, [2015, 4, 5]]
-    ].each do |d|
-      year, date = d
-      it year do
-        temporale = described_class.new(year)
-        expect(temporale.easter_sunday).to eq Date.new(*date)
-      end
-    end
-  end
-
-  describe '#date_range' do
-    it 'includes days of the year' do
-      expect(t.date_range).to include Date.new(2012, 12, 3)
-      expect(t.date_range).to include Date.new(2013, 11, 5)
-    end
-  end
-
-  describe '#season' do
-    shared_examples 'season determination' do |year_beginning, year_end|
-      if year_beginning
-        it { expect { t13.season(date_beginning - 1) }.to raise_exception RangeError }
-      else
-        it { expect(t13.season(date_beginning - 1)).not_to be season }
-      end
-
-      it { expect(t13.season(date_beginning)).to be season }
-      it { expect(t13.season(date_end)).to be season }
-
-      if year_end
-        it { expect { t13.season(date_end + 1) }.to raise_exception RangeError }
-      else
-        it { expect(t13.season(date_end + 1)).not_to be season }
-      end
-    end
-
-    describe 'Advent' do
-      let(:season) { CR::Seasons::ADVENT }
-      let(:date_beginning) { Date.new(2013, 12, 1) }
-      let(:date_end) { Date.new(2013, 12, 24) }
-      include_examples 'season determination', true
-    end
-
-    describe 'Christmas' do
-      let(:season) { CR::Seasons::CHRISTMAS }
-      let(:date_beginning) { Date.new(2013, 12, 25) }
-      let(:date_end) { Date.new(2014, 1, 12) }
-      include_examples 'season determination'
-    end
-
-    describe 'Ordinary Time #1' do
-      let(:season) { CR::Seasons::ORDINARY }
-      let(:date_beginning) { Date.new(2014, 1, 13) }
-      let(:date_end) { Date.new(2014, 3, 4) }
-      include_examples 'season determination'
-    end
-
-    describe 'Lent' do
-      let(:season) { CR::Seasons::LENT }
-      let(:date_beginning) { Date.new(2014, 3, 5) }
-      let(:date_end) { Date.new(2014, 4, 19) }
-      include_examples 'season determination'
-    end
-
-    describe 'Easter time' do
-      let(:season) { CR::Seasons::EASTER }
-      let(:date_beginning) { Date.new(2014, 4, 20) }
-      let(:date_end) { Date.new(2014, 6, 8) }
-      include_examples 'season determination'
-    end
-
-    describe 'Ordinary Time #2' do
-      let(:season) { CR::Seasons::ORDINARY }
-      let(:date_beginning) { Date.new(2014, 6, 9) }
-      let(:date_end) { Date.new(2014, 11, 29) }
-      include_examples 'season determination', nil, true
-    end
-  end
-
-  describe '#season_beginning' do
-    let(:year) { 2016 }
-    let(:options) { {} }
-    let(:t) { described_class.new(year, **options) }
-
-    describe 'unsupported season' do
-      it 'fails' do
-        season = CR::Season.new(:strawberry_season, CR::Colours::RED)
-        expect do
-          t.season_beginning season
-        end.to raise_exception(ArgumentError, /unsupported season/)
-      end
-    end
-
-    describe 'Ordinary Time' do
-      describe 'Epiphany not transferred' do
-        it do
-          expect(t.season_beginning(CR::Seasons::ORDINARY))
-            .to eq Date.new(2017, 1, 9)
-        end
-      end
-
-      describe 'Epiphany transferred' do
-        let(:t) { described_class.new(year, transfer_to_sunday: [:epiphany]) }
-
-        it do
-          expect(t.season_beginning(CR::Seasons::ORDINARY))
-            .to eq Date.new(2017, 1, 10)
-        end
-      end
-    end
-  end
-
-  describe '#get' do
-    it 'returns a Celebration' do
-      expect(t13.get(8, 12)).to be_a CR::Celebration
-    end
-
-    describe 'for' do
-      describe 'ferial' do
-        it 'in Ordinary Time' do
-          c = t13.get(8, 12)
-          expect(c.rank).to eq CR::Ranks::FERIAL
-          expect(c.color).to eq CR::Colours::GREEN
-        end
-
-        it 'in Advent' do
-          c = t13.get(12, 12)
-          expect(c.rank).to eq CR::Ranks::FERIAL
-          expect(c.color).to eq CR::Colours::VIOLET
-        end
-
-        it 'in the last week of Advent' do
-          c = t13.get(12, 23)
-          expect(c.rank).to eq CR::Ranks::FERIAL_PRIVILEGED
-          expect(c.color).to eq CR::Colours::VIOLET
-        end
-
-        it 'in Christmas time' do
-          c = t13.get(1, 3)
-          expect(c.rank).to eq CR::Ranks::FERIAL
-          expect(c.color).to eq CR::Colours::WHITE
-        end
-
-        it 'in Lent' do
-          c = t13.get(3, 18)
-          expect(c.rank).to eq CR::Ranks::FERIAL_PRIVILEGED
-          expect(c.color).to eq CR::Colours::VIOLET
-        end
-
-        it 'in Easter Time' do
-          c = t13.get(5, 5)
-          expect(c.rank).to eq CR::Ranks::FERIAL
-          expect(c.color).to eq CR::Colours::WHITE
-        end
-      end
-
-      describe 'Sunday' do
-        it 'in Ordinary Time' do
-          c = t13.get(8, 10)
-          expect(c.rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
-          expect(c.color).to eq CR::Colours::GREEN
-        end
-
-        it 'in Advent' do
-          c = t13.get(12, 15)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.color).to eq CR::Colours::VIOLET
-        end
-
-        it 'in Christmas time' do
-          c = t13.get(1, 5)
-          expect(c.rank).to eq CR::Ranks::SUNDAY_UNPRIVILEGED
-          expect(c.color).to eq CR::Colours::WHITE
-        end
-
-        it 'in Lent' do
-          c = t13.get(3, 23)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.color).to eq CR::Colours::VIOLET
-        end
-
-        it 'in Easter Time' do
-          c = t13.get(5, 11)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.color).to eq CR::Colours::WHITE
-        end
-      end
-
-      describe 'solemnities and their cycles - ' do
-        it 'end of Advent time' do
-          c = t13.get(12, 17)
-          expect(c.rank).to eq CR::Ranks::FERIAL_PRIVILEGED
-          expect(c.colour).to eq CR::Colours::VIOLET
-        end
-
-        it 'Nativity' do
-          c = t13.get(12, 25)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'Christmas'
-          expect(c.colour).to eq CR::Colours::WHITE
-          expect(c.symbol).to eq :nativity
-          expect(c.date).to eq CR::AbstractDate.new(12, 25)
-        end
-
-        it 'day in the octave of Nativity' do
-          c = t13.get(12, 27)
-          expect(c.rank).to eq CR::Ranks::FERIAL_PRIVILEGED
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Holy Family' do
-          c = t13.get(12, 29)
-          expect(c.rank).to eq CR::Ranks::FEAST_LORD_GENERAL
-          expect(c.title).to have_translation 'The Holy Family'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        context 'when a Sunday does not occur between Dec 25 and Jan 1' do
-          it 'is Holy Family on Friday Dec 30' do
-            t16 = described_class.new 2016
-            c = t16.get(12, 30)
-            expect(c.title).to have_translation 'The Holy Family'
-          end
-        end
-
-        it 'Epiphany' do
-          c = t13.get(1, 6)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'The Epiphany'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Baptism of the Lord' do
-          c = t13.get(1, 12)
-          expect(c.rank).to eq CR::Ranks::FEAST_LORD_GENERAL
-          expect(c.title).to have_translation 'The Baptism of the Lord'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Ash Wednesday' do
-          c = t13.get(3, 5)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'Ash Wednesday'
-          expect(c.colour).to eq CR::Colours::VIOLET
-        end
-
-        it 'Palm Sunday' do
-          c = t13.get(4, 13)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'Passion Sunday (Palm Sunday)'
-          expect(c.colour).to eq CR::Colours::RED
-        end
-
-        it 'Good Friday' do
-          c = t13.get(4, 18)
-          expect(c.rank).to eq CR::Ranks::TRIDUUM
-          expect(c.title).to have_translation 'Good Friday'
-          expect(c.colour).to eq CR::Colours::RED
-        end
-
-        it 'Holy Saturday' do
-          c = t13.get(4, 19)
-          expect(c.rank).to eq CR::Ranks::TRIDUUM
-          expect(c.title).to have_translation 'Holy Saturday'
-          expect(c.colour).to eq CR::Colours::VIOLET
-        end
-
-        it 'Resurrection' do
-          c = t13.get(4, 20)
-          expect(c.rank).to eq CR::Ranks::TRIDUUM
-          expect(c.title).to have_translation 'Easter Sunday'
-          expect(c.colour).to eq CR::Colours::WHITE
-          expect(c.symbol).to eq :easter_sunday
-        end
-
-        it 'Ascension' do
-          c = t13.get(5, 29)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'The Ascension'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Pentecost' do
-          c = t13.get(6, 8)
-          expect(c.rank).to eq CR::Ranks::PRIMARY
-          expect(c.title).to have_translation 'Pentecost'
-          expect(c.colour).to eq CR::Colours::RED
-          expect(c.symbol).to eq :pentecost
-        end
-
-        it 'Trinity' do
-          c = t13.get(6, 15)
-          expect(c.rank).to eq CR::Ranks::SOLEMNITY_GENERAL
-          expect(c.title).to have_translation 'Trinity Sunday'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Body of Christ' do
-          c = t13.get(6, 19)
-          expect(c.rank).to eq CR::Ranks::SOLEMNITY_GENERAL
-          expect(c.title).to have_translation 'Corpus Christi (The Body and Blood of Christ)'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Sacred Heart' do
-          c = t13.get(6, 27)
-          expect(c.rank).to eq CR::Ranks::SOLEMNITY_GENERAL
-          expect(c.title).to have_translation 'The Sacred Heart of Jesus'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        it 'Christ the King' do
-          c = t13.get(11, 23)
-          expect(c.rank).to eq CR::Ranks::SOLEMNITY_GENERAL
-          expect(c.title).to have_translation 'Christ The King'
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-
-        describe 'other locales' do
-          it 'Latin' do
-            I18n.with_locale(:la) do
-              c = t13.get(11, 23)
-              expect(c.title).to eq 'Domini nostri Iesu Christi universorum regis'
-            end
-          end
-
-          it 'Czech' do
-            I18n.with_locale(:cs) do
-              c = t13.get(11, 23)
-              expect(c.title).to eq 'Ježíše Krista krále'
-            end
-          end
-
-          it 'Italian' do
-            I18n.with_locale(:it) do
-              c = t13.get(11, 23)
-              expect(c.title).to eq "Nostro Signore Gesù Cristo Re dell'universo"
-            end
-          end
-        end
-      end
-
-      # movable sanctorale feasts don't really belong in Temporale, but ...
-      describe 'movable sanctorale feasts' do
-        it 'Immaculate Heart' do
-          c = t13.get(6, 28)
-          expect(c.title).to have_translation 'The Immaculate Heart of Mary'
-          expect(c.rank).to eq CR::Ranks::MEMORIAL_GENERAL
-        end
-
-        it 'Mary, Mother of the Church' do
-          # it would be an anachronism to retrieve this celebration
-          # from t13
-          t17 = described_class.new 2017
-          c = t17.get(5, 21)
-          expect(c.title).to have_translation 'Mary, Mother of the Church'
-          expect(c.rank).to eq CR::Ranks::MEMORIAL_GENERAL
-        end
-      end
-    end
-
-    describe 'titles of Sundays and ferials' do
-      def title_for(month, day)
-        t13.get(month, day).title
-      end
-
-      describe 'Ordinary time' do
-        it 'Sunday' do
-          expect(title_for(1, 19)).to have_translation '2nd Sunday in Ordinary Time'
-        end
-
-        it 'ferial' do
-          expect(title_for(1, 13)).to have_translation 'Monday, 1st week in Ordinary Time'
-        end
-      end
-
-      describe 'Advent' do
-        it 'Sunday' do
-          expect(title_for(12, 1)).to have_translation '1st Sunday of Advent'
-        end
-
-        it 'ferial' do
-          expect(title_for(12, 2)).to have_translation 'Monday, 1st week of Advent'
-        end
-
-        it 'ferial before Christmas' do
-          expect(title_for(12, 17)).to have_translation '17th December'
-        end
-      end
-
-      describe 'Christmas time' do
-        describe 'Octave of Christmas' do
-          it 'ferial' do
-            day = t13.get(12, 30)
-            expect(day.rank).to eq CR::Ranks::FERIAL_PRIVILEGED
-            expect(day.title).to have_translation '6th day of Christmas Octave'
-          end
-        end
-
-        describe 'after Octave of Christmas' do
-          it 'ferial' do
-            expect(title_for(1, 2)).to have_translation 'Thursday after Christmas Octave'
-          end
-
-          it 'Sunday' do
-            expect(title_for(1, 5)).to have_translation '2nd Sunday after the Nativity of the Lord'
-          end
-        end
-
-        describe 'after Epiphany' do
-          it 'ferial' do
-            expect(title_for(1, 7)).to have_translation 'Tuesday after Epiphany'
-          end
-        end
-      end
-
-      describe 'Lent' do
-        describe 'before first Sunday' do
-          it 'ferial' do
-            expect(title_for(3, 6)).to have_translation 'Thursday after Ash Wednesday'
-          end
-        end
-
-        it 'Sunday' do
-          expect(title_for(3, 9)).to have_translation '1st Sunday of Lent'
-        end
-
-        it 'ferial' do
-          expect(title_for(3, 10)).to have_translation 'Monday, 1st week of Lent'
-        end
-
-        describe 'Holy Week' do
-          it 'ferial' do
-            day = t13.get(4, 14)
-            expect(day.rank).to eq CR::Ranks::PRIMARY
-            expect(day.title).to have_translation 'Monday of Holy Week'
-          end
-        end
-      end
-
-      describe 'Easter' do
-        describe 'Easter Octave' do
-          it 'ferial' do
-            c = t13.get(4, 22)
-            expect(c.rank).to eq CR::Ranks::PRIMARY
-            expect(c.title).to have_translation 'Easter Tuesday'
-          end
-
-          it 'Sunday (the octave day)' do
-            c = t13.get(4, 27)
-            expect(c.rank).to eq CR::Ranks::PRIMARY
-            expect(c.title).to have_translation '2nd Sunday of Easter'
-          end
-        end
-
-        it 'Sunday' do
-          expect(title_for(5, 4)).to have_translation '3rd Sunday of Easter'
-        end
-
-        it 'ferial' do
-          expect(title_for(5, 5)).to have_translation 'Monday, 3rd week of Easter'
-        end
-      end
-
-      describe 'other locales' do
-        it 'Latin' do
-          I18n.with_locale(:la) do
-            expect(title_for(5, 5)).to eq 'Feria secunda, hebdomada III temporis paschalis'
-          end
-        end
-
-        it 'Czech' do
-          I18n.with_locale(:cs) do
-            expect(title_for(5, 5)).to eq 'Pondělí po 3. neděli velikonoční'
-          end
-        end
-
-        it 'French' do
-          I18n.with_locale(:fr) do
-            expect(title_for(5, 5)).to eq 'Lundi, 3ème semaine de Pâques'
-          end
-        end
-
-        it 'Italian' do
-          I18n.with_locale(:it) do
-            expect(title_for(5, 5)).to eq 'Lunedì, III di Pasqua'
-          end
-        end
-      end
-    end
-  end
-
-  describe 'packaged extensions' do
-    describe 'ChristEternalPriest' do
-      let(:t) { described_class.new(2016, extensions: [CR::Temporale::Extensions::ChristEternalPriest]) }
-
-      it 'adds the feast' do
-        I18n.with_locale(:cs) do
-          c = t.get(6, 8)
-          expect(c.title).to eq 'Ježíše Krista, nejvyššího a věčného kněze'
-          expect(c.rank).to eq CR::Ranks::FEAST_PROPER
-          expect(c.colour).to eq CR::Colours::WHITE
-        end
-      end
-    end
-  end
-
-  describe 'Solemnities transferred to a Sunday' do
-    let(:year) { 2016 }
-    let(:transferred) { [:epiphany, :ascension, :corpus_christi] }
-    let(:t) { described_class.new(year, transfer_to_sunday: transferred) }
-    let(:t_notransfer) { described_class.new(year) }
-
-    it 'Epiphany' do
-      date = Date.new(2017, 1, 8)
-      expect(date).to be_sunday # make sure
-
-      expect(t.epiphany).to eq date
-
-      c = t.get(date)
-      expect(c).to eq factory.epiphany
-    end
-
-    it 'Baptism of the Lord after transferred Epiphany' do
-      date = Date.new(2017, 1, 9)
-      expect(date).to be_monday # make sure
-
-      expect(t.baptism_of_lord).to eq date
-
-      c = t.get(date)
-      expect(c).to eq factory.baptism_of_lord
-    end
-
-    describe 'Ordinary Time numbering after transferred Epiphany' do
-      it 'ferials correct' do
-        first_ot_tuesday = Date.new(2017, 1, 10)
-        expect(t.get(first_ot_tuesday)).to eq t_notransfer.get(first_ot_tuesday)
-      end
-
-      it 'Sundays correct' do
-        second_ot_sunday = Date.new(2017, 1, 15)
-        expect(t.get(second_ot_sunday)).to eq t_notransfer.get(second_ot_sunday)
-      end
-    end
-
-    it 'Ascension' do
-      date = Date.new(2017, 5, 28)
-      expect(date).to be_sunday # make sure
-
-      expect(t.ascension).to eq date
-
-      c = t.get(date)
-      expect(c).to eq factory.ascension
-    end
-
-    it 'Corpus Christi' do
-      date = Date.new(2017, 6, 18)
-      expect(date).to be_sunday # make sure
-
-      expect(t.corpus_christi).to eq date
-
-      c = t.get(date)
-      expect(c).to eq factory.corpus_christi
-    end
-
-    it 'fails on an unsupported solemnity' do
-      expect do
-        described_class.new(2016, transfer_to_sunday: [:sacred_heart])
-      end.to raise_exception(RuntimeError, /not supported/)
-    end
-  end
-
-  describe 'properly setting cycle' do
-    t = CR::Temporale.new(2013)
-    t.date_range.each do |date|
-      it date do
-        c = t.get date
-        expect(c.cycle).to be :temporale
-      end
-    end
-  end
-end