calendarium-romanum 0.7.0 → 0.7.1

data/spec/dates_spec.rb

@@ -1,73 +0,0 @@
-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
-
-  describe 'transferable solemnities' do
-    # for sake of simplicity a year has been chosen when
-    # none of the transferable solemnities falls on a Sunday
-    let(:year) { 2013 }
-
-    %i(epiphany ascension corpus_christi).each do |solemnity|
-      it solemnity.to_s do
-        transferred =
-          described_class.public_send(solemnity, year, sunday: true)
-        not_transferred =
-          described_class.public_send(solemnity, year)
-
-        expect(transferred).not_to eq not_transferred
-        expect(transferred).to be_sunday
-      end
-    end
-
-    it 'Baptism of the Lord' do
-      transferred =
-          described_class.baptism_of_lord(year, epiphany_on_sunday: true)
-      not_transferred =
-        described_class.baptism_of_lord(year)
-
-      expect(transferred).to be_monday
-      expect(not_transferred).to be_sunday
-    end
-  end
-end

data/spec/day_spec.rb

@@ -1,151 +0,0 @@
-require_relative 'spec_helper'
-
-describe CR::Day do
-  let(:d) do
-    described_class.new(
-      date: Date.today,
-      season: CR::Seasons::ORDINARY,
-      season_week: 1,
-      celebrations: [CR::Celebration.new],
-      vespers: vespers
-    )
-  end
-
-  let(:vespers) { nil }
-
-  describe '.new' do
-    it 'works without arguments' do
-      expect do
-        described_class.new
-      end.not_to raise_exception
-    end
-
-    it 'makes a shallow copy of celebrations' do
-      celebrations = [CR::Celebration.new]
-      day = described_class.new celebrations: celebrations
-
-      expect(day.celebrations).to eq celebrations
-      expect(day.celebrations).not_to be celebrations
-
-      expect(day.celebrations[0]).to be celebrations[0]
-    end
-  end
-
-  describe '#==' do
-    describe 'same content' do
-      let(:d2) do
-        described_class.new(
-          date: Date.today,
-          season: CR::Seasons::ORDINARY,
-          season_week: 1,
-          celebrations: [CR::Celebration.new]
-        )
-      end
-
-      it 'is equal' do
-        expect(d).to eq d2
-      end
-    end
-
-    describe 'different content' do
-      let(:d2) do
-        described_class.new(
-          date: Date.today,
-          season: CR::Seasons::LENT,
-          season_week: 1,
-          celebrations: [CR::Celebration.new]
-        )
-      end
-
-      it 'is different' do
-        expect(d).not_to eq d2
-      end
-    end
-
-    describe 'different celebrations' do
-      let(:d2) do
-        described_class.new(
-          date: Date.today,
-          season: CR::Seasons::ORDINARY,
-          season_week: 1,
-          celebrations: [CR::Celebration.new('another celebration')]
-        )
-      end
-
-      it 'is different' do
-        expect(d).not_to eq d2
-      end
-    end
-
-    describe 'different Vespers' do
-      let(:d2) do
-        described_class.new(
-          date: Date.today,
-          season: CR::Seasons::ORDINARY,
-          season_week: 1,
-          celebrations: [CR::Celebration.new],
-          vespers: CR::Temporale::CelebrationFactory.palm_sunday
-        )
-      end
-
-      it 'is different' do
-        expect(d).not_to eq d2
-      end
-    end
-  end
-
-  describe '#vespers_from_following?' do
-    describe 'vespers not set' do
-      it { expect(d.vespers_from_following?).to be false }
-    end
-
-    describe 'vespers set' do
-      let(:vespers) { CR::Celebration.new }
-
-      it { expect(d.vespers_from_following?).to be true }
-    end
-  end
-
-  describe '#to_s' do
-    it do
-      I18n.with_locale(:en) do
-        day = CR::PerpetualCalendar.new[Date.new(2000, 1, 8)]
-        expect(day.to_s).to eq "#<CalendariumRomanum::Day @date=2000-01-08 @season=#<CalendariumRomanum::Season christmas> @season_week=2 celebrations=[#<CalendariumRomanum::Celebration @title=\"Saturday after Epiphany\" @rank=#<CalendariumRomanum::Rank @priority=3.13 desc=\"Ferials\"> @colour=#<CalendariumRomanum::Colour white> symbol=nil date=nil cycle=:temporale>] vespers=nil>"
-      end
-    end
-  end
-
-  describe '#weekday' do
-    let(:sunday) { Date.new 2018, 5, 20 }
-    let(:saturday) { sunday - 1 }
-
-    it 'Sunday' do
-      expect(sunday).to be_sunday # make sure
-
-      d = described_class.new(date: sunday)
-      expect(d.weekday).to be 0
-    end
-
-    it 'Saturday' do
-      d = described_class.new(date: saturday)
-      expect(d.weekday).to be 6
-    end
-  end
-
-  describe '#weekday_name' do
-    let(:sunday) { Date.new 2018, 5, 20 }
-    let(:saturday) { sunday - 1 }
-
-    it 'Sunday' do
-      expect(sunday).to be_sunday # make sure
-
-      d = described_class.new(date: sunday)
-      expect(d.weekday_name).to eq(I18n.t('0', scope: 'weekday'))
-    end
-
-    it 'Saturday' do
-      d = described_class.new(date: saturday)
-      expect(d.weekday_name).to eq(I18n.t('6', scope: 'weekday'))
-    end
-  end
-end

data/spec/enum_spec.rb

@@ -1,51 +0,0 @@
-require_relative 'spec_helper'
-
-describe CalendariumRomanum::Enum do
-  let(:enum_values) { [:a, :b] }
-
-  let(:test_class) do
-    Class.new(described_class) { values { [:a, :b] } }
-  end
-
-  describe '.all' do
-    it 'returns all values in the original order' do
-      expect(test_class.all).to eq enum_values
-    end
-  end
-
-  describe '.each' do
-    it 'yields all values in the original order' do
-      expect {|b| test_class.each(&b) }.to yield_successive_args(*enum_values)
-    end
-  end
-
-  describe '[]' do
-    describe 'default indexing' do
-      it 'finds first element' do
-        expect(test_class[0]).to be :a
-      end
-
-      it 'finds last element' do
-        expect(test_class[1]).to be :b
-      end
-
-      it 'returns nil for index out of range' do
-        expect(test_class[2]).to be nil
-      end
-    end
-
-    describe 'indexed by a custom property' do
-      let(:test_class) do
-        Class.new(described_class) { values(index_by: :to_s) { [1] } }
-      end
-
-      it 'finds the element' do
-        expect(test_class['1']).to eq 1
-      end
-
-      it 'returns nil for an unknown index' do
-        expect(test_class[1]).to be nil
-      end
-    end
-  end
-end

data/spec/i18n_spec.rb

@@ -1,68 +0,0 @@
-# coding: utf-8
-require_relative 'spec_helper'
-
-describe 'internationalization' do
-  before :all do
-    I18n.backend.load_translations
-  end
-
-  let(:temporale) { CR::Temporale.new(2016) }
-  let(:easter_celebration) { temporale.get Date.new(2017, 4, 16) }
-
-  describe 'supported locales' do
-    before :each do
-      @last_locale = I18n.locale
-      I18n.locale = locale
-    end
-
-    after :each do
-      I18n.locale = @last_locale
-    end
-
-    describe 'English' do
-      let(:locale) { 'en' }
-
-      it 'translates Temporale feast names' do
-        expect(easter_celebration.title).to eq 'Easter Sunday'
-      end
-
-      it 'translates rank names' do
-        rank = CR::Ranks::SUNDAY_UNPRIVILEGED
-        expect(rank.desc).to eq 'Unprivileged Sundays'
-        expect(rank.short_desc).to eq 'Sunday'
-      end
-
-      it 'translates day weekday_names' do
-        sunday = CR::Day.new(date: Date.new(2018, 5, 20))
-        expect(sunday.weekday_name).to eq 'Sunday'
-      end
-    end
-
-    describe 'Czech' do
-      let(:locale) { 'cs' }
-
-      it 'translates Temporale feast names' do
-        expect(easter_celebration.title).to eq 'Zmrtvýchvstání Páně'
-      end
-
-      it 'translates rank names' do
-        rank = CR::Ranks::SUNDAY_UNPRIVILEGED
-        expect(rank.desc).to eq 'Neprivilegované neděle'
-        expect(rank.short_desc).to eq 'neděle'
-      end
-
-      it 'translates day weekday_names' do
-        sunday = CR::Day.new(date: Date.new(2018, 5, 20))
-        expect(sunday.weekday_name).to eq 'Neděle'
-      end
-    end
-  end
-
-  describe 'unsupported locale' do
-    # I will be most happy when this locale one day moves to the 'supported' branch!
-    let(:locale) { 'de' }
-
-    it 'attemt to switch to it fails by default' do
-    end
-  end
-end

data/spec/ordinalizer_spec.rb

@@ -1,44 +0,0 @@
-require_relative 'spec_helper'
-
-describe CalendariumRomanum::Ordinalizer do
-  describe '#ordinal' do
-    describe 'English' do
-      {
-        1 => '1st',
-        2 => '2nd',
-        3 => '3rd',
-        4 => '4th',
-        11 => '11th',
-        12 => '12th',
-        13 => '13th',
-        21 => '21st',
-        22 => '22nd',
-        23 => '23rd',
-      }.each_pair do |number, ordinal|
-        it number do
-          expect(described_class.ordinal(number, locale: :en)).to eq ordinal
-        end
-      end
-    end
-
-    describe 'French' do
-      {
-        1 => '1er',
-        2 => '2ème',
-        3 => '3ème',
-      }.each_pair do |number, ordinal|
-        it number do
-          expect(described_class.ordinal(number, locale: :fr)).to eq ordinal
-        end
-      end
-    end
-
-    describe 'unsupported locale' do
-      [1, 2, 3].each do |number|
-        it number do
-          expect(described_class.ordinal(number, locale: :unsupported)).to eq number
-        end
-      end
-    end
-  end
-end

data/spec/perpetual_calendar_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-describe CR::PerpetualCalendar do
-  let(:pcal) { described_class.new }
-
-  let(:date) { Date.new(2000, 1, 1) }
-  let(:year) { 2000 }
-
-  let(:sanctorale) { CR::Data::GENERAL_ROMAN_ENGLISH.load }
-
-  let(:factory) { CR::Temporale::CelebrationFactory }
-
-  describe '.new' do
-    describe 'with sanctorale' do
-      it 'uses the sanctorale' do
-        pc = described_class.new(sanctorale: sanctorale)
-
-        calendar = pc.calendar_for_year(year)
-        expect(calendar.sanctorale).to be sanctorale
-      end
-    end
-
-    describe 'with temporale options' do
-      it 'applies the options' do
-        pc = described_class.new(temporale_options: {transfer_to_sunday: [:epiphany]})
-
-        y = 2016
-        calendar = pc.calendar_for_year(y)
-        epiphany_date = CR::Temporale::Dates.epiphany(y, sunday: true)
-
-        expect(calendar.day(epiphany_date).celebrations[0]).to eq factory.epiphany
-      end
-    end
-
-    describe 'with temporale factory' do
-      it 'uses the factory' do
-        temporale_subcls = Class.new(CR::Temporale)
-        factory = lambda {|year| temporale_subcls.new year }
-
-        pc = described_class.new(temporale_factory: factory)
-        calendar = pc.calendar_for_year(year)
-        expect(calendar.temporale).to be_a temporale_subcls
-      end
-    end
-
-    describe 'with both temporale factory and options' do
-      it 'fails' do
-        expect do
-          described_class.new(
-            temporale_options: {transfer_to_sunday: [:epiphany]},
-            temporale_factory: lambda {|year| }
-          )
-        end.to raise_exception ArgumentError
-      end
-    end
-
-    describe 'with cache' do
-      it 'uses the supplied object as Calendar instance cache' do
-        cache = {}
-        pc = described_class.new(cache: cache)
-        calendar = pc.calendar_for_year(year)
-        expect(cache[2000]).to be calendar
-      end
-    end
-  end
-
-  describe '#day' do
-    it 'returns a Day' do
-      expect(pcal.day(Date.today)).to be_a CR::Day
-    end
-  end
-
-  describe '#[]' do
-    describe 'arguments' do
-      describe 'single Date' do
-        it 'returns a Day' do
-          expect(pcal[Date.today]).to be_a CR::Day
-        end
-      end
-
-      describe 'Range of Dates' do
-        shared_examples 'range' do
-          it 'returns an Array of Days' do
-            result = pcal[range]
-            expect(result).to be_an Array
-            expect(result[0]).to be_a CR::Day
-          end
-        end
-
-        describe 'of the same liturgical year' do
-          let(:range) { Date.new(2010, 1, 1) .. Date.new(2010, 1, 5) }
-
-          include_examples 'range'
-        end
-
-        describe 'across boundaries of the liturgical year' do
-          let(:first_advent) { CR::Temporale::Dates.first_advent_sunday(2010) }
-          let(:range) { (first_advent - 1) .. (first_advent + 1) }
-
-          include_examples 'range'
-        end
-      end
-    end
-  end
-
-  describe '#calendar_for' do
-    it 'returns a Calendar' do
-      expect(pcal.calendar_for(date)).to be_a CR::Calendar
-    end
-  end
-
-  describe '#calendar_for_year' do
-    it 'returns a Calendar' do
-      expect(pcal.calendar_for_year(year)).to be_a CR::Calendar
-    end
-  end
-
-  describe 'caching' do
-    it 'caches calendar instances' do
-      expect(CR::Calendar).to receive(:new)
-
-      2.times { pcal.calendar_for_year(year) }
-    end
-  end
-end