csl 1.4.5 → 1.5.0

data/spec/csl/locale/date_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-module CSL
-
-  describe Locale::Date do
-
-    let(:date) { Locale::Date.new }
-
-    it { is_expected.not_to be_nil }
-
-    it { is_expected.to be_text }
-    it { is_expected.not_to be_numeric }
-
-    describe '#parts' do
-
-      it 'returns nil by default' do
-        expect(date.parts).to be_empty
-      end
-
-    end
-
-    describe '#to_xml' do
-
-      it 'returns <date/> by default' do
-        expect(Locale::Date.new.to_xml).to eq('<date/>')
-      end
-
-      it 'returns <date form="numeric"/> for an empty numeric date' do
-        expect(Locale::Date.new(:form => 'numeric').to_xml).to eq('<date form="numeric"/>')
-      end
-
-    end
-
-  end
-
-  describe Locale::DatePart do
-
-    it { is_expected.not_to be_nil }
-
-    it { is_expected.not_to be_day }
-    it { is_expected.not_to be_month }
-    it { is_expected.not_to be_year }
-
-    describe '#to_xml' do
-
-      it 'returns <date-part/> by default' do
-        expect(Locale::DatePart.new.to_xml).to eq("<date-part/>")
-      end
-
-      it 'returns <date-part name="year"/> when the name is "year"' do
-        expect(Locale::DatePart.new(:name => 'year').to_xml).to eq('<date-part name="year"/>')
-      end
-
-      it 'returns <date-part name="month" form="numeric" prefix="-"/> for a numeric month with prefix "-"' do
-        expect(Locale::DatePart.new(:name => 'month', :form => 'numeric', :prefix => '-').to_xml).to match(/(\s(name|form|prefix)="[^"]+"){3}/)
-      end
-
-    end
-
-  end
-
-
-end

data/spec/csl/locale/style_options_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module CSL  
-  describe Locale::StyleOptions do
-  
-    it { is_expected.not_to be nil }
-    
-    it 'punctuation-in-quote is false by default' do
-      expect(subject[:'punctuation-in-quote']).to be false
-    end
-    
-    describe '#to_xml' do
-      it 'returns <style-options punctuation-in-quote="false"/> by default' do
-        expect(subject.to_xml).to match(/<style-options\/>/)
-      end
-    end
-    
-  end
-end

data/spec/csl/locale/term_spec.rb

@@ -1,255 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-module CSL
-  describe Locale::Terms do
-
-    it { is_expected.not_to be nil }
-
-    describe '#to_xml' do
-      it 'returns <terms/> by default' do
-        expect(subject.to_xml).to eq('<terms/>')
-      end
-    end
-
-    describe '.specialize' do
-      it 'filters the passed in hash to contain only match-able entries' do
-        expect(Locale::Term.specialize({ :form => 'short', :foo => 'bar' })).to eq({ :form => 'short' })
-      end
-    end
-
-    describe '#ordinalize' do
-
-      describe "given standard English terms" do
-        let(:en) do
-          Locale::Terms.parse <<-EOS
-          <terms>
-            <term name="ordinal">th</term>
-            <term name="ordinal-01">st</term>
-            <term name="ordinal-02">nd</term>
-            <term name="ordinal-03">rd</term>
-            <term name="ordinal-11">th</term>
-            <term name="ordinal-12">th</term>
-            <term name="ordinal-13">th</term>
-          </terms>
-          EOS
-        end
-
-        %w{
-          ordinal ordinal-01 ordinal-02 ordinal-03 ordinal
-        }.each_with_index do |ordinal, number|
-          it "returns #{ordinal.inspect} for #{number}" do
-            expect(en.ordinalize(number)[:name]).to eq(ordinal)
-          end
-        end
-      end
-
-    end
-
-    describe '#lookup' do
-
-      describe "given standard English terms" do
-        let(:en) do
-          Locale::Terms.parse <<-EOS
-          <terms>
-            <term name="page" form="short">
-              <single>p.</single>
-              <multiple>pp.</multiple>
-            </term>
-            <term name="page">
-              <single>page</single>
-              <multiple>pages</multiple>
-            </term>
-            <term name="section">
-              <single>section</single>
-              <multiple>sections</multiple>
-            </term>
-            <term name="section" form="short">sec.</term>
-            <term name="section" form="symbol">
-              <single>§</single>
-              <multiple>§§</multiple>
-            </term>
-            <term name="editor">
-              <single>editor</single>
-              <multiple>editors</multiple>
-            </term>
-            <term name="editor" form="short">
-              <single>ed.</single>
-              <multiple>eds.</multiple>
-            </term>
-            <term name="editor" form="verb">edited by</term>
-            <term name="editor" form="verb-short">ed.</term>
-          </terms>
-          EOS
-        end
-
-        it 'returns nil if there is no matching term' do
-          expect(en.lookup(:foo)).to be_nil
-        end
-
-        it 'returns the long form by default' do
-          expect(en.lookup(:page)).to be_long
-        end
-
-        it 'returns the term in the passed-in form if available' do
-          expect(en.lookup(:section, :form => 'long')).to be_long
-          expect(en.lookup(:section, :form => 'short')).to be_short
-          expect(en.lookup(:section, :form => 'symbol')).to be_symbol
-
-          expect(en.lookup(:editor)).to be_long
-          expect(en.lookup(:editor, :form => 'long')).to be_long
-          expect(en.lookup(:editor, :form => 'verb')).to be_verb
-          expect(en.lookup(:editor, :form => 'verb-short')).to be_verb_short
-        end
-
-        it 'returns the right fallback form if the passed-in form is not available' do
-          expect(en.lookup(:page, :form => 'verb')).to be_long
-          expect(en.lookup(:page, :form => 'verb-short')).to be_long
-          expect(en.lookup(:page, :form => 'symbol')).to be_short
-        end
-
-        it 'ignores irrelevant options' do
-          expect(en.lookup(:page, :plural => true)).not_to be_nil
-        end
-      end
-
-    end
-  end
-
-  describe Locale::Term do
-
-    it { is_expected.not_to be_nil }
-
-    it { is_expected.not_to be_gendered }
-    it { is_expected.to be_neutral }
-
-    it { is_expected.to be_long }
-
-    it { is_expected.not_to be_ordinal }
-    it { is_expected.not_to be_short_ordinal }
-    it { is_expected.not_to be_long_ordinal }
-
-    it 'is not a textnode by default' do
-      expect(subject).not_to be_textnode
-    end
-
-    it 'is a textnode when the text is "foo"' do
-      expect(Locale::Term.new { |t| t.text = 'foo' }).to be_textnode
-    end
-
-    describe 'gender attribute is set' do
-      let(:m) { Locale::Term.new(:name => 'month-05') { |t| t.masculine!; t.text = 'Mai' } }
-      let(:f) { Locale::Term.new(:name => 'edition') { |t| t.feminine!; t.text = 'Ausgabe' } }
-
-      it 'is gendered' do
-        expect(m).to be_gendered
-        expect(f).to be_gendered
-      end
-
-      it 'is feminine or masculine' do
-        expect(m).to be_masculine
-        expect(f).to be_feminine
-      end
-
-      it 'is not neutral' do
-        expect(m).not_to be_neutral
-        expect(f).not_to be_neutral
-      end
-
-      describe '#to_xml' do
-        it 'contains the correct gender' do
-          expect(m.to_xml).to match(/gender="masculine"/)
-          expect(f.to_xml).to match(/gender="feminine"/)
-        end
-      end
-
-      describe '#match?' do
-        it 'matches the name when passed a string' do
-          expect(m).to be_match(:name => 'month-05')
-        end
-
-        it 'matches the name when passed a pattern' do
-          expect(m).to be_match(:name => /month-\d\d/)
-        end
-
-        it 'matches when passed a matching hash without gender' do
-          expect(f).to be_match(:name => 'edition')
-        end
-
-        it 'does not match when passed a matching hash with wrong gender' do
-          expect(f.matches?(:name => 'edition', :gender => 'masculine')).not_to be_truthy
-        end
-
-        it 'matches when passed a matching hash with matching gender' do
-          expect(f.matches?(:name => 'edition', :gender => 'feminine')).to be_truthy
-        end
-      end
-
-      describe '#exact_match?' do
-        it 'does not match when passed a matching hash without gender' do
-          expect(f).not_to be_exact_match(:name => 'edition')
-        end
-      end
-
-      describe 'attributes#to_a' do
-        it 'returns an array of all attribute values of underlying struct' do
-          expect(f.attributes.to_a).to eq(['edition', 'long', 'feminine', nil, nil])
-        end
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns an empty string by default' do
-        expect(Locale::Term.new.to_s).to eq('')
-      end
-
-      describe 'given a simple term' do
-        let(:node) { Locale::Term.new { |t| t.text = 'foo' } }
-
-        it "returns the term's text" do
-          expect(node.to_s).to eq(node.text)
-        end
-      end
-
-      describe 'given a compound term' do
-        let(:node) { Locale::Term.new { |t| t.single = 'shoe'; t.multiple = 'shoes' } }
-
-        it "returns the term's singular form by default" do
-          expect(node.to_s).to eq(node.singularize)
-        end
-
-        it "returns the term's plural form when passed :number => :plural" do
-          expect(node.to_s(:number => :plural)).to eq(node.pluralize)
-        end
-
-        it "returns the term's plural form when passed :number => 2" do
-          expect(node.to_s(:number => 2)).to eq(node.pluralize)
-        end
-
-        it "returns the term's singular form when passed :number => 1" do
-          expect(node.to_s(:number => 1)).to eq(node.singularize)
-        end
-
-        it "returns the term's plural form when passed :plural => true" do
-          expect(node.to_s(:plural => true)).to eq(node.pluralize)
-        end
-
-      end
-    end
-
-    describe '#to_xml' do
-      it 'returns <term/> by default' do
-        expect(subject.to_xml).to eq('<term/>')
-      end
-
-      it 'returns <term>foo</term> when the text is "foo"' do
-        expect(Locale::Term.new { |t| t.text = 'foo' }.to_xml).to eq('<term>foo</term>')
-      end
-
-      it 'returns <term><multiple>foo</multiple></term> when multiple is "foo"' do
-        expect(Locale::Term.new { |t| t.multiple = 'foo' }.to_xml).to eq('<term><multiple>foo</multiple></term>')
-      end
-
-    end
-  end
-end

data/spec/csl/locale_spec.rb

@@ -1,245 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-module CSL
-
-  describe Locale do
-
-    let(:locale) { Locale.new }
-
-    let(:en) { Locale.new('en-US') }
-    let(:gb) { Locale.new('en-GB') }
-    let(:de) { Locale.new('de-DE') }
-
-    describe '.regions' do
-
-      it 'returns the default region when passed a language symbol' do
-        expect(Locale.regions[:en]).to eq(:US)
-      end
-
-    end
-
-    describe '.languages' do
-
-      describe 'the language hash' do
-        it 'returns the default language when passed a region string' do
-          %w{ US en GB en AT de DE de }.map(&:to_sym).each_slice(2) do |region, language|
-            expect(Locale.languages[region]).to eq(language)
-          end
-        end
-      end
-
-    end
-
-    describe '.normalize' do
-      {
-        'en' => 'en-US',
-        '-GB' => 'en-GB',
-        '-BR' => 'pt-BR',
-        'de-AT' => 'de-AT'
-      }.each_pair do |tag, expected|
-        it "converts #{tag.inspect} to #{expected.inspect}" do
-          expect(Locale.normalize(tag)).to eq(expected)
-        end
-      end
-    end
-
-    describe '.new' do
-      it { is_expected.not_to be_nil }
-
-      it 'has no language' do
-        expect(Locale.new.language).to be_nil
-      end
-
-      it 'has no region' do
-        expect(Locale.new.region).to be_nil
-      end
-
-      it 'contains no dates by default' do
-        expect(Locale.new.dates).to be_nil
-      end
-
-      it 'contains no terms by default' do
-        expect(Locale.new.terms).to be_nil
-      end
-
-    end
-
-    describe '.load' do
-
-      describe 'when called with "en-GB" ' do
-        let(:locale) { Locale.load('en-GB') }
-
-        it 'the returned locale has the correct IETF tag' do
-          expect(locale.to_s).to eq('en-GB')
-        end
-
-        it 'the locale has language :en' do
-          expect(locale.language).to eq(:en)
-        end
-
-        it 'the locale has region :GB' do
-          expect(locale.region).to eq(:GB)
-        end
-
-      end
-
-    end
-
-    describe '.parse' do
-      it 'does not set a default language' do
-        expect(Locale.parse('<locale/>').language).to be_nil
-      end
-    end
-
-    describe '#set' do
-
-      it 'when passed "en-GB" sets language to :en and region to :GB' do
-        locale.set('en-GB')
-        expect([locale.language, locale.region]).to eq([:en, :GB])
-      end
-
-      it 'when passed "de" sets language to :de and region to :DE' do
-        locale.set('de')
-        expect([locale.language, locale.region]).to eq([:de, :DE])
-      end
-
-      it 'when passed "-AT" sets language to :de and region to :AT' do
-        locale.set('-AT')
-        expect([locale.language, locale.region]).to eq([:de, :AT])
-      end
-
-    end
-
-    describe '#merge!' do
-      let(:locale_with_options) { Locale.new('en', :foo => 'bar') }
-
-      describe 'style options' do
-        it 'does not change the options if none are set on either locale' do
-          expect { locale.merge!(en) }.not_to change { locale.options }
-        end
-
-        it 'creates a duplicate option element if the first locale has no options' do
-          expect(locale).not_to have_options
-          locale.merge!(locale_with_options)
-          expect(locale).to have_options
-          expect(locale.options[:foo]).to eq('bar')
-          expect(locale.options).not_to equal(locale_with_options.options)
-        end
-
-        it 'merges the options if both locales have options' do
-          locale << Locale::StyleOptions.new(:bar => 'foo')
-
-          expect { locale.merge!(locale_with_options) }.not_to change { locale.options.object_id }
-
-          expect(locale.options[:foo]).to eq('bar')
-          expect(locale.options[:bar]).to eq('foo')
-        end
-
-        it 'overrides the options with those in the other locale' do
-          locale << Locale::StyleOptions.new(:bar => 'foo', :foo => 'foo')
-          locale.merge!(locale_with_options)
-          expect(locale.options[:foo]).to eq('bar')
-          expect(locale.options[:bar]).to eq('foo')
-        end
-      end
-
-      describe 'dates' do
-        it 'does not change the dates if none are set on either locale' do
-          expect { locale.merge!(en) }.not_to change { locale.dates }
-        end
-
-        it 'creates duplicate date elements if the first locale has no options' do
-          locale.merge!(Locale.load('en-US'))
-          expect(locale).to have_dates
-        end
-
-        it 'merges dates of both locales' do
-          locale << Locale::Date.new(:form => 'numeric')
-
-          other = Locale.load('en-US')
-          locale.merge! other
-
-          expect(locale.dates.length).to eq(other.dates.length)
-        end
-      end
-
-      describe 'terms' do
-        let(:us) { Locale.load('en-US') }
-
-        it 'does not change the terms if none are set on either locale' do
-          expect { locale.merge!(Locale.new) }.not_to change { locale.terms.to_s }
-        end
-
-        it 'overrides terms with those of the other locale' do
-          expect(locale).not_to have_terms
-
-          locale.merge! us
-          expect(locale).to have_terms
-        end
-
-        it 'makes copies of the terms' do
-          locale.merge! us
-          expect(locale).to have_terms
-
-          expect(locale.terms.first).to eq(us.terms.first)
-          expect(locale.terms.first).not_to be(us.terms.first)
-        end
-      end
-    end
-
-    describe '#legacy?' do
-      it 'returns false by default' do
-        expect(locale).not_to be_legacy
-      end
-
-      it 'returns true if the version is less than 1.0.1' do
-        locale.version = '0.8'
-        expect(locale).to be_legacy
-      end
-    end
-
-    describe '#quote' do
-
-      it 'quotes the passed-in string' do
-        locale.store 'open-quote', '»'
-        locale.store 'close-quote', '«'
-
-        expect(locale.quote('foo')).to eq('»foo«')
-      end
-
-      it 'does not alter the string if there are no quotes in the locale' do
-        expect(locale.quote('foo')).to eq('foo')
-      end
-
-      it 'adds quotes inside final punctuation if punctuation-in-quote option is set' do
-        locale.store 'open-quote', '»'
-        locale.store 'close-quote', '«'
-
-        expect(locale.quote('foo.')).to eq('»foo«.')
-        expect(locale.quote('foo,')).to eq('»foo«,')
-
-        expect(locale.quote('foo!')).to eq('»foo!«')
-        expect(locale.quote('foo?')).to eq('»foo?«')
-
-        locale.punctuation_in_quotes!
-
-        expect(locale.quote('foo.')).to eq('»foo.«')
-        expect(locale.quote('foo,')).to eq('»foo,«')
-
-        expect(locale.quote('foo!')).to eq('»foo!«')
-        expect(locale.quote('foo?')).to eq('»foo?«')
-      end
-
-      it 'replaces existing quotes with inner quotes' do
-        locale.store 'open-quote', '“'
-        locale.store 'close-quote', '”'
-        locale.store 'open-inner-quote', '‘'
-        locale.store 'close-inner-quote', '’'
-
-        expect(locale.quote('“foo”')).to eq('“‘foo’”')
-      end
-    end
-  end
-end