citeproc-ruby 1.1.7 → 1.1.13

data/spec/citeproc/ruby/renderer/date_spec.rb

@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-    describe 'Renderer#render_date' do
-      let(:renderer) { Renderer.new }
-
-      let(:item) {
-        i = CiteProc::CitationItem.new(:id => 'ID-1')
-        i.data = CiteProc::Item.new(:id => 'ID-1')
-        i
-      }
-
-      describe 'localized rendering' do
-        let(:node) { CSL::Style::Date.new(:variable => 'issued', :form => 'numeric') }
-
-        describe 'given an item issued on January 27th, 2012' do
-          before(:each) { item.data[:issued] = '2012-01-27' }
-
-          it "uses the locale's date parts to render the date" do
-            expect(renderer.render(item, node)).to eq('01/27/2012')
-          end
-        end
-      end
-
-      describe 'static rendering' do
-        let(:node) { CSL::Style::Date.new(:variable => 'issued') }
-
-        describe 'given an item issued on January 27th, 2012' do
-          before(:each) { item.data[:issued] = '2012-01-27' }
-
-          it 'returns an empty string by default' do
-            expect(renderer.render_date(item, node)).to eq('')
-          end
-
-          describe 'and given a node with a year part' do
-            before(:each) { node << CSL::Style::DatePart.new(:name => 'year') }
-
-            it 'returns the year as "2012"' do
-              expect(renderer.render_date(item, node)).to eq('2012')
-            end
-
-            describe 'and a day part' do
-              before(:each) { node << CSL::Style::DatePart.new(:name => 'day') }
-
-              it 'returns "201227"' do
-                expect(renderer.render_date(item, node)).to eq('201227')
-              end
-
-              it 'applies delimiters when set on the node' do
-                node[:delimiter] = '/'
-                expect(renderer.render_date(item, node)).to eq('2012/27')
-              end
-
-              describe 'and a month part' do
-                before(:each) { node << CSL::Style::DatePart.new(:name => 'month') }
-
-                it 'returns "201227January"' do
-                  expect(renderer.render_date(item, node)).to eq('201227January')
-                end
-
-                it 'returns "2012/27/01" when the month form set to "numeric-leading-zeros" and the node has a delimiter "/"' do
-                  node.parts.last[:form] = 'numeric-leading-zeros'
-                  node[:delimiter] = '/'
-                  expect(renderer.render_date(item, node)).to eq('2012/27/01')
-                end
-              end
-            end
-          end
-        end
-      end
-
-    end
-
-    describe 'Renderer#render_date_part' do
-      let(:renderer) { Renderer.new }
-      let(:node) { CSL::Style::DatePart.new }
-
-      let(:today) { CiteProc::Date.today }
-
-      let(:january) { CiteProc::Date.new([2012, 1]) }
-      let(:december) { CiteProc::Date.new([2012, 12]) }
-      let(:independence) { CiteProc::Date.new([1776, 7, 4]) }
-
-      it 'returns an empty string by default' do
-        expect(renderer.render_date_part(CiteProc::Date.today, node)).to eq('')
-      end
-
-      describe 'when the name is set to "day"' do
-        before(:each) { node[:name] = 'day' }
-
-        it 'renders the day as number by default' do
-          expect(renderer.render_date_part(today, node)).to eq(today.day.to_s)
-        end
-
-        it 'renders the day as an ordinal number when the form is set to "ordinal"' do
-          node[:form] = 'ordinal'
-          expect(renderer.render_date_part(independence, node)).to eq('4th')
-
-          renderer.locale.limit_day_ordinals!
-          expect(renderer.render_date_part(independence, node)).to eq('4')
-
-          independence.day = 1
-          expect(renderer.render_date_part(independence, node)).to eq('1st')
-        end
-      end
-
-      describe 'when the name is set to "month"' do
-        before(:each) { node[:name] = 'month' }
-
-        it "renders the month's full name by default" do
-          expect(renderer.render_date_part(january, node)).to eq('January')
-          expect(renderer.render_date_part(december, node)).to eq('December')
-        end
-
-        it "renders the month's full name as the long form" do
-          node[:form] = 'long'
-          expect(renderer.render_date_part(january, node)).to eq('January')
-        end
-
-        it "renders the month's short name as the short form" do
-          node[:form] = 'short'
-          expect(renderer.render_date_part(january, node)).to eq('Jan.')
-        end
-
-        it 'renders the month as number as the numeric form' do
-          node[:form] = 'numeric'
-          expect(renderer.render_date_part(january, node)).to eq('1')
-        end
-
-        it 'renders the month as number with a leading zero when form is set to numeric-leading-zeros' do
-          node[:form] = 'numeric-leading-zeros'
-          expect(renderer.render_date_part(january, node)).to eq('01')
-          expect(renderer.render_date_part(december, node)).to eq('12')
-        end
-
-        it 'renders the name of the season when a season is set' do
-          january.season = 4
-          expect(renderer.render_date_part(january, node)).to eq('Winter')
-        end
-      end
-
-      describe 'when the name is set to "year"' do
-        before(:each) { node[:name] = 'year' }
-
-        it 'renders the full year by default' do
-          expect(renderer.render_date_part(today, node)).to eq(today.year.to_s)
-        end
-
-        it 'renders the full year when form is set to long' do
-          node[:form] = 'long'
-          expect(renderer.render_date_part(january, node)).to eq('2012')
-        end
-
-        it 'renders the short year when form is set to short' do
-          node[:form] = 'short'
-          expect(renderer.render_date_part(january, node)).to eq('12')
-        end
-
-        it 'adds AD if applicable' do
-          renderer.render_date_part(CiteProc::Date.new([200]), node) == '200AD'
-        end
-
-        it 'adds BC if applicable' do
-          renderer.render_date_part(CiteProc::Date.new([-200]), node) == '200BC'
-        end
-      end
-
-    end
-
-  end
-end

data/spec/citeproc/ruby/renderer/group_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-    describe 'Renderer#render_group' do
-      let(:renderer) { Renderer.new }
-
-      let(:item) {
-        i = CiteProc::CitationItem.new(:id => 'ID-1')
-        i.data = CiteProc::Item.new(:id => 'ID-1')
-        i
-      }
-
-      let(:node) { CSL::Style::Group.new }
-
-      it 'returns an empty string by default' do
-        expect(renderer.render(item, node)).to eq('')
-
-        node[:prefix] = '!'
-        expect(renderer.render(item, node)).to eq('')
-      end
-
-      describe 'when there is a text node in the group' do
-        before(:each) { node << CSL::Style::Text.new( :term => 'retrieved') }
-
-        it 'returns the content of the nested node' do
-          expect(renderer.render_group(item, node)).to eq('retrieved')
-        end
-
-        it 'applies formatting options to the nested node' do
-          node[:'text-case'] = 'uppercase'
-          expect(renderer.render(item, node)).to eq('RETRIEVED')
-        end
-
-        describe 'when there is a second text node in the group' do
-          before(:each) { node << CSL::Style::Text.new( :term => 'from') }
-
-          it 'returns the content of both nested nodes' do
-            expect(renderer.render_group(item, node)).to eq('retrievedfrom')
-          end
-
-          describe 'when there is a delimter set on the group node' do
-            before(:each) { node[:delimiter] = ' ' }
-
-            it 'applies the delimiter to the output' do
-              expect(renderer.render_group(item, node)).to eq('retrieved from')
-            end
-
-            it 'applies formatting options to the nested nodes only' do
-              node[:'text-case'] = 'uppercase'
-              node[:delimiter] = ' foo '
-              node[:prefix] = '('
-              node[:suffix] = ')'
-              expect(renderer.render(item, node)).to eq('(RETRIEVED FOO FROM)')
-            end
-
-            describe 'when a nested node produces no output' do
-              before(:each) do
-                node << CSL::Style::Text.new( :term => 'fooo')
-                node << CSL::Style::Text.new( :term => 'from')
-              end
-
-              it 'the delimiter does not apply to it' do
-                expect(renderer.render_group(item, node)).to eq('retrieved from from')
-              end
-            end
-
-            describe 'when there is a variable-based node in the group' do
-              before(:each) { node << CSL::Style::Text.new( :variable => 'URL') }
-
-              it 'returns the empty string when the variable is not present in the item' do
-                expect(renderer.render_group(item, node)).to eq('')
-              end
-
-              describe 'when the variable is present' do
-                before(:each) { item.data[:URL] = 'http://example.org' };
-
-                it 'returns all nested renditions' do
-                  expect(renderer.render_group(item, node)).to eq('retrieved from http://example.org')
-                end
-              end
-            end
-          end
-        end
-      end
-
-      describe 'when there is a names node with substitute in the group' do
-
-        before(:each) do
-          subst = CSL::Style::Substitute.new()
-          subst << CSL::Style::Text.new( :value => 'Anonymous') 
-          names = CSL::Style::Names.new( :variable => 'author')
-          names << subst
-          node << names
-        end
-
-        describe 'when the variable is set' do
-          before(:each) { item.data.author = 'Some Author' }
-
-          it 'returns the content of the nested node' do
-            expect(renderer.render_group(item, node)).to eq('Some Author')
-          end
-        end
-
-        describe 'when the variable is not set' do
-          it 'returns the substitution of the nested node' do
-            expect(renderer.render_group(item, node)).to eq('Anonymous')
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/citeproc/ruby/renderer/history_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-    describe Renderer::History do
-      let(:state) { Renderer::State.new }
-      let(:history) { state.history }
-
-      it 'has an empty citation history' do
-        expect(history.memory['citation']).to eq([])
-      end
-
-      it 'has an empty bibliography history' do
-        expect(history.memory['bibliogrpahy']).to eq([])
-      end
-
-      describe '#update' do
-        it 'saves the passed in items for :store!' do
-          expect {
-            history.update :store!, 'citation', { :x => 1 }
-          }.to change { history.citation }.to([{ :x => 1 }])
-        end
-
-        it 'drops remembered items when they are too old' do
-          expect {
-            history.update :store!, 'citation', { :x => 1 }
-            history.update :store!, 'citation', { :x => 2 }
-            history.update :store!, 'citation', { :x => 3 }
-            history.update :store!, 'citation', { :x => 4 }
-            history.update :store!, 'citation', { :x => 5 }
-          }.to change { history.citation.length }.to(3)
-        end
-      end
-
-      describe '#discard' do
-        it 'clears the history' do
-          history.update :store!, 'bibliography', { :x => 1 }
-          expect(history.memory).not_to be_empty
-          history.discard
-          expect(history.memory).to be_empty
-        end
-      end
-    end
-
-  end
-end

data/spec/citeproc/ruby/renderer/label_spec.rb

@@ -1,225 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-    describe "Renderer#render_label" do
-      let(:renderer) { Renderer.new }
-
-      let(:node) { CSL::Style::Label.new }
-
-      let(:item) {
-        i = CiteProc::CitationItem.new(:id => 'ID-1')
-        i.data = CiteProc::Item.new(:id => 'ID-1')
-        i
-      }
-
-      describe 'given an empty node' do
-        it 'returns an empty string for an empty item' do
-          expect(renderer.render_label(item, node)).to eq('')
-        end
-
-        it 'returns an empty string for an item with variables' do
-          item.data.edition = 'foo'
-          expect(renderer.render_label(item, node)).to eq('')
-        end
-      end
-
-
-      # page
-
-      describe "when the node's variable is set to :page" do
-        before(:each) { node[:variable] = :page }
-
-        describe "for an item with no page value" do
-          it 'returns an empty string' do
-            expect(renderer.render_label(item, node)).to eq('')
-          end
-        end
-
-        describe 'for an item with a page value' do
-          it 'returns the singular label for a number' do
-            item.write_attribute :page, '23'
-            expect(renderer.render_label(item, node)).to eq('page')
-          end
-
-          it 'returns the plural label for a page-range' do
-            item.write_attribute :page, '23-24'
-            expect(renderer.render_label(item, node)).to eq('pages')
-          end
-
-          it 'returns the plural label for multiple pages' do
-            item.write_attribute :page, '23 & 24'
-            expect(renderer.render_label(item, node)).to eq('pages')
-
-            item.write_attribute :page, '23, 24, 25'
-            expect(renderer.render_label(item, node)).to eq('pages')
-          end
-
-          describe 'when pluralization is contextual' do
-            before(:each) { node[:plural] = 'contextual' }
-
-            it 'returns the singular label for a number' do
-              item.write_attribute :page, '23'
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-
-            it 'returns the plural label for a page-range' do
-              item.write_attribute :page, '23-24'
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-          end
-
-          describe 'when pluralization is set to "always"' do
-            before(:each) { node[:plural] = 'always' }
-
-            it 'returns the singular label for a number' do
-              item.write_attribute :page, '1'
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-
-            it 'returns the plural label for a page-range' do
-              item.write_attribute :page, '1-3'
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-          end
-
-          describe 'when pluralization is set to "never"' do
-            before(:each) { node[:plural] = 'never' }
-
-            it 'returns the singular label for a number' do
-              item.write_attribute :page, '1'
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-
-            it 'returns the plural label for a page-range' do
-              item.write_attribute :page, '1-3'
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-          end
-        end
-      end
-
-
-      # number-of-pages variable
-
-      describe "when the node's variable is set to :'number-of-pages'" do
-        before(:each) { node[:variable] = 'number-of-pages' }
-
-        describe "for an item with no 'number-of-pages' value" do
-          it 'returns an empty string' do
-            expect(renderer.render_label(item, node)).to eq('')
-          end
-        end
-
-        describe "for an item with a 'number-of-pages' value" do
-          it 'returns the singular label for number 1' do
-            item.data[:'number-of-pages'] = 1
-            expect(renderer.render_label(item, node)).to eq('page')
-          end
-
-          it 'returns the plural label for numbers higher than 1' do
-            item.data[:'number-of-pages'] = '2'
-            expect(renderer.render_label(item, node)).to eq('pages')
-
-            item.data[:'number-of-pages'] = 42
-            expect(renderer.render_label(item, node)).to eq('pages')
-          end
-
-          describe 'when pluralization is set to "contextual"' do
-            before(:each) { node[:plural] = 'contextual' }
-
-            it 'returns the singular label for number 1' do
-              item.data[:'number-of-pages'] = '1'
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-
-            it 'returns the plural label for numbers higher than 1' do
-              item.data[:'number-of-pages'] = '2'
-              expect(renderer.render_label(item, node)).to eq('pages')
-
-              item.data[:'number-of-pages'] = 42
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-          end
-
-          describe 'when pluralization is set to "always"' do
-            before(:each) { node[:plural] = 'always' }
-
-            it 'returns the singular label for number 1' do
-              item.data[:'number-of-pages'] = 1
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-
-            it 'returns the plural label for numbers higher than 1' do
-              item.data[:'number-of-pages'] = '2'
-              expect(renderer.render_label(item, node)).to eq('pages')
-
-              item.data[:'number-of-pages'] = 42
-              expect(renderer.render_label(item, node)).to eq('pages')
-            end
-          end
-
-          describe 'when pluralization is set to "never"' do
-            before(:each) { node[:plural] = 'never' }
-
-            it 'returns the singular label for number 1' do
-              item.data[:'number-of-pages'] = 1
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-
-            it 'returns the plural label for numbers higher than 1' do
-              item.data[:'number-of-pages'] = '2'
-              expect(renderer.render_label(item, node)).to eq('page')
-
-              item.data[:'number-of-pages'] = 42
-              expect(renderer.render_label(item, node)).to eq('page')
-            end
-          end
-        end
-      end
-
-      # number-of-volumes variable
-
-      describe "when the node's variable is set to :'number-of-volumes'" do
-        before(:each) { node[:variable] = 'number-of-volumes' }
-
-        describe "for an item with a 'number-of-volumes' value" do
-          it 'returns the singular label for number 1' do
-            item.data[:'number-of-volumes'] = 1
-            expect(renderer.render_label(item, node)).to eq('volume')
-          end
-
-          it 'returns the plural label for numbers higher than 1' do
-            item.data[:'number-of-volumes'] = '2'
-            expect(renderer.render_label(item, node)).to eq('volumes')
-
-            item.data[:'number-of-volumes'] = 42
-            expect(renderer.render_label(item, node)).to eq('volumes')
-          end
-        end
-      end
-
-      # locators
-
-      describe "when the node's variable is set to another locator" do
-        before(:each) { node[:variable] = 'locator' }
-
-        describe "for an item with a locator and label" do
-          it "returns the singular label for a single number" do
-            item.locator = 2
-            item.label = 'book'
-            expect(renderer.render_label(item, node)).to eq('book')
-          end
-
-          it "returns the plural label for multiple numbers" do
-            item.locator = '23 & 4'
-            item.label = 'book'
-            expect(renderer.render_label(item, node)).to eq('books')
-          end
-        end
-      end
-
-    end # render_label
-  end
-end