calendarium-romanum 0.5.0 → 0.9.0

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,58 +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 of the Resurrection of the Lord'
-      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
-    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
-    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,36 +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
-  end
-end

data/spec/perpetual_calendar_spec.rb

@@ -1,91 +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 }
-
-  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(epiphany_date).not_to eq CR::Temporale::Dates.epiphany(y) # make sure
-
-        expect(calendar.day(epiphany_date).celebrations[0].title).to have_translation 'The Epiphany of the Lord'
-      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| temporale_subcls.new 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 '#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

data/spec/rank_spec.rb

@@ -1,57 +0,0 @@
-require_relative 'spec_helper'
-
-describe CR::Rank do
-  describe 'comparison' do
-    it 'memorial x ferial' do
-      expect(CR::Ranks::MEMORIAL_GENERAL).to be > CR::Ranks::FERIAL
-    end
-  end
-
-  describe '[]' do
-    it 'has all existing instances indexed by rank number' do
-      expect(CR::Ranks[1.1]).to eq CR::Ranks::TRIDUUM
-    end
-  end
-
-  describe '#<' do
-    it { expect(CR::Ranks[1.2]).to be < CR::Ranks[1.1] }
-    it { expect(CR::Ranks[1.1]).not_to be < CR::Ranks[1.2] }
-  end
-
-  describe '#>' do
-    it { expect(CR::Ranks[1.1]).to be > CR::Ranks[1.2] }
-    it { expect(CR::Ranks[1.2]).not_to be > CR::Ranks[1.1] }
-  end
-
-  describe '#==' do
-    it { expect(CR::Ranks[1.2]).to be == CR::Ranks[1.2] }
-    it { expect(CR::Ranks[1.2]).not_to be == CR::Ranks[1.1] }
-  end
-
-  describe 'descriptions' do
-    CR::Ranks.each do |rank|
-      describe "#{rank.priority} #{rank.short_desc}" do
-        it 'has #desc translated' do
-          expect(rank.desc).to have_translation
-        end
-
-        it 'is has #short_desc translated' do
-          if rank.short_desc # not set for some ranks
-            expect(rank.short_desc).to have_translation
-          end
-        end
-      end
-    end
-
-    describe '#short_desc' do
-      it 'is not always set' do
-        expect(CR::Ranks[1.1].short_desc).to be_nil
-      end
-    end
-  end
-
-  describe '#memorial?' do
-    it { expect(CR::Ranks::MEMORIAL_OPTIONAL.memorial?).to be true }
-    it { expect(CR::Ranks::FERIAL.memorial?).to be false }
-  end
-end

data/spec/readme_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-class MarkdownDocument
-  def initialize(str)
-    @str = str
-  end
-
-  def each_ruby_example
-    example = nil
-    line = nil
-    @str.each_line.with_index(1) do |l, i|
-      if example.nil?
-        if example_beginning?(l)
-          example = ''
-          line = i + 1
-        end
-      elsif example_end?(l)
-        yield example, line
-        example = nil
-      else
-        example += l
-      end
-    end
-  end
-
-  protected
-
-  def example_beginning?(line)
-    line =~ /^```ruby/
-  end
-
-  def example_end?(line)
-    line =~ /```/
-  end
-end
-
-%w(README.md data/README.md).each do |path|
-  describe path do
-    before :each do
-      STDERR.stub(:puts)
-    end
-
-    readme_path = File.expand_path('../../' + path, __FILE__)
-    readme = File.read readme_path
-    doc = MarkdownDocument.new readme
-
-    doc.each_ruby_example do |code, line|
-      describe "example L#{line}" do
-        it 'executes without failure' do
-          cls = Class.new
-          cls.class_eval(code, readme_path, line)
-        end
-      end
-    end
-  end
-end

data/spec/sanctorale_factory_spec.rb

@@ -1,42 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe CR::SanctoraleFactory do
-  describe '.create_layered'
-
-  describe '.load_layered_from_files' do
-    before :each do
-      files = %w(czech-cs.txt czech-cechy-cs.txt czech-budejovice-cs.txt).collect do |f|
-        File.join(File.expand_path('../data', File.dirname(__FILE__)), f)
-      end
-      @s = described_class.load_layered_from_files(*files)
-    end
-
-    it 'has celebrations from the first file' do
-      dd = @s.get 9, 28
-      expect(dd.size).to eq 1
-
-      d = dd.first
-      expect(d.rank).to eq CR::Ranks::SOLEMNITY_PROPER
-      expect(d.title).to eq 'Sv. Václava, mučedníka, hlavního patrona českého národa'
-    end
-
-    it 'has celebrations from the second file' do
-      dd = @s.get 7, 4
-      expect(dd.size).to eq 1
-
-      d = dd.first
-      expect(d.rank).to eq CR::Ranks::MEMORIAL_PROPER
-      expect(d.title).to eq 'Sv. Prokopa, opata'
-    end
-
-    it 'celebrations from the last file win' do
-      dd = @s.get 12, 22
-      expect(dd.size).to eq 1
-
-      d = dd.first
-      expect(d.rank).to eq CR::Ranks::FEAST_PROPER
-      expect(d.title).to eq 'Výročí posvěcení katedrály sv. Mikuláše'
-    end
-  end
-end

data/spec/sanctorale_spec.rb

@@ -1,191 +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) }
-  let(:opt_memorial) { CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_OPTIONAL) }
-  let(:opt_memorial_2) { CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_OPTIONAL) }
-  let(:solemnity) { CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_PROPER) }
-
-  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
-
-    describe 'multiple celebrations on a single day' do
-      it 'succeeds for any number of optional memorials' do
-        expect do
-          s.add 1, 13, opt_memorial
-          s.add 1, 13, opt_memorial_2
-        end.not_to raise_exception
-      end
-
-      it 'fails when adding a non-optional memorial' do
-        expect do
-          s.add 1, 13, opt_memorial
-          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
-        expect do
-          s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_GENERAL)
-          s.add 1, 13, opt_memorial_2
-        end.to raise_exception ArgumentError
-      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
-  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
-    it 'yields each date and corresponding CR::Celebrations' do
-      s.add 1, 17, antonius
-
-      expect {|block| s.each_day(&block) }.to yield_with_args(CR::AbstractDate.new(1, 17), [antonius])
-    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
-end