citeproc-ruby 0.0.6 → 1.0.0

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module CiteProc
+  module Ruby
+
+    describe 'Renderer#render_layout' do
+      let(:renderer) { Renderer.new }
+
+      let(:node) { CSL::Style::Layout.new }
+
+      let(:item) {
+        i = CiteProc::CitationItem.new(:id => 'ID-1')
+        i.data = CiteProc::Item.new(:id => 'ID-1')
+        i
+      }
+
+      it 'returns an empty string when empty' do
+        renderer.render(item, node).should == ''
+      end
+
+      describe 'with child nodes' do
+        before(:each) do
+          node << CSL::Style::Text.new(:value => 'foo')
+          node << CSL::Style::Text.new(:value => 'bar')
+        end
+
+        it 'renders each child' do
+          renderer.render(item, node).should == 'foobar'
+        end
+
+        it 'uses the delimiters if specified' do
+          node[:delimiter] = '-'
+          renderer.render(item, node).should == 'foo-bar'
+        end
+      end
+
+    end
+
+  end
+end
+

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module CiteProc
+  module Ruby
+
+    describe 'Renderer#render_macro' do
+      let(:renderer) { Renderer.new }
+
+      let(:node) { CSL::Style::Macro.new }
+
+      let(:item) {
+        i = CiteProc::CitationItem.new(:id => 'ID-1')
+        i.data = CiteProc::Item.new(:id => 'ID-1')
+        i
+      }
+
+      it 'returns an empty string when empty' do
+        renderer.render(item, node).should == ''
+      end
+
+      it 'renders each child' do
+        node << CSL::Style::Text.new(:value => 'foo')
+        node << CSL::Style::Text.new(:value => 'bar')
+
+        renderer.render(item, node).should == 'foobar'
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+
+module CiteProc
+  module Ruby
+
+    describe "Renderer#render_names" do
+      let(:renderer) { Renderer.new }
+
+      let(:node) { CSL::Style::Names.new }
+
+      let(:item) {
+        i = CiteProc::CitationItem.new(:id => 'ID-1')
+        i.data = CiteProc::Item.new(:id => 'ID-1')
+        i
+      }
+
+      let(:poe) { people(:poe) }
+      let(:philosophers) { CiteProc::Names.new('Plato and Socrates and Aristotle') }
+
+      describe 'given an empty node' do
+        it 'returns an empty string for an empty item' do
+          renderer.render(item, node).should == ''
+        end
+
+        it 'returns an empty string for an item with variables' do
+          item.data.edition = 'foo'
+          renderer.render_names(item, node).should == ''
+        end
+      end
+
+      describe 'given a single name for the variable' do
+        before do
+          item.data.author = poe
+          node[:variable] = 'author'
+        end
+
+        it 'formats it in long form' do
+          renderer.render_names(item, node).should == 'Edgar Allen Poe'
+        end
+
+        it 'supports nested name node options' do
+          node << CSL::Style::Name.new(:form => 'short')
+          renderer.render_names(item, node).should == 'Poe'
+        end
+
+        it 'supports nested label node' do
+          node << CSL::Style::Label.new(:prefix => ' [', :suffix => ']')
+          renderer.render_names(item, node).should == 'Edgar Allen Poe [author]'
+        end
+      end
+
+      describe 'given multiple names for a single variable' do
+        before do
+          item.data.editor = philosophers
+          node[:variable] = 'editor'
+        end
+
+        it 'formats them as a list' do
+          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle'
+        end
+
+        it 'supports nested name node options' do
+          node << CSL::Style::Name.new(:and => 'symbol')
+          renderer.render_names(item, node).should == 'Plato, Socrates, & Aristotle'
+        end
+
+        it 'supports nested label node' do
+          node << CSL::Style::Label.new(:prefix => ' (', :suffix => ')')
+          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle (editors)'
+        end
+      end
+
+      describe 'given multiple variables' do
+        before do
+          node[:variable] = 'author editor'
+          node[:delimiter] = '; '
+        end
+
+        it 'renders all matching lists combinded using default delimiter' do
+          renderer.render_names(item, node).should == ''
+
+          item.data.author = poe
+          renderer.render_names(item, node).should == 'Edgar Allen Poe'
+
+          item.data.editor = philosophers
+          renderer.render_names(item, node).should == 'Edgar Allen Poe; Plato, Socrates, Aristotle'
+        end
+
+        it 'keeps the variable order' do
+          item.data.author = poe
+          item.data.editor = philosophers
+
+          node[:variable] = 'editor author'
+          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle; Edgar Allen Poe'
+        end
+
+        it 'supports labels' do
+          item.data.author = poe
+          item.data.editor = philosophers
+
+          node << CSL::Style::Label.new(:prefix => ' (', :suffix => ')')
+
+          renderer.render_names(item, node).should == 'Edgar Allen Poe (author); Plato, Socrates, Aristotle (editors)'
+        end
+
+        it 'resolves the editor translator special case' do
+          renderer.format = :text
+
+          node[:variable] = 'translator author editor'
+
+          item.data.editor = 'Patrick F. Quinn and G. R. Thompson'
+          item.data.author = poe
+
+          node.name = { :and => 'symbol', :form => 'short' }
+          node.label = { :prefix => ' (', :suffix => ')' }
+
+          renderer.render_names(item, node).should == 'Poe (author); Quinn & Thompson (editors)'
+
+          item.data.translator = poe
+          renderer.render_names(item, node).should == 'Poe (translator); Poe (author); Quinn & Thompson (editors)'
+
+          item.data.translator = 'Patrick F. Quinn and G. R. Thompson'
+
+          renderer.render(item, node).should == 'Quinn & Thompson (editors & translators); Poe (author)'
+        end
+      end
+    end
+
+    describe "Renderer#render_name" do
+      let(:renderer) { Renderer.new }
+
+      let(:node) { CSL::Style::Name.new }
+
+      let(:poe) { people(:poe) }
+      let(:philosophers) { CiteProc::Names.new('Plato and Socrates and Aristotle') }
+
+      describe 'given an empty node' do
+        it 'returns an empty string given no names' do
+          renderer.render_name(CiteProc::Names.new, node).should == ''
+        end
+
+        it 'formats the given name in long form' do
+          renderer.render_name(poe, node).should == 'Edgar Allen Poe'
+        end
+
+        it 'formats multiple names delimitted by commas' do
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+        end
+      end
+
+      describe 'given a node with and "and" attribute' do
+        it 'inserts a delimited connector' do
+          node[:and] = 'symbol'
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, & Aristotle'
+
+          node[:and] = 'text'
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+        end
+      end
+
+      describe 'given a node with delimier-precedes-last' do
+        it 'inserts final delimiter only for three or more names when set to "contextual"' do
+          node.delimiter_contextually_precedes_last!
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+
+          node[:and] = 'text'
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+
+          renderer.render_name(philosophers.take(2), node).should == 'Plato and Socrates'
+
+          node[:and] = nil
+          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+        end
+
+        it 'inserts final delimiter when set to "always"' do
+          node.delimiter_always_precedes_last!
+
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+
+          node[:and] = 'text'
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+
+          renderer.render_name(philosophers.take(2), node).should == 'Plato, and Socrates'
+
+          node[:and] = nil
+          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+        end
+
+        it 'never inserts final delimiter when set to "never" (unless there is no "and")' do
+          node.delimiter_never_precedes_last!
+
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+
+          node[:and] = 'text'
+          renderer.render_name(philosophers, node).should == 'Plato, Socrates and Aristotle'
+          renderer.render_name(philosophers.take(2), node).should == 'Plato and Socrates'
+        end
+
+        it 'supports only-after-inverted-name rule' do
+          names = CiteProc::Names.new('Doe, J. and Smith, S. and Williams, T.')
+          node.delimiter_precedes_last_after_inverted_name!
+
+          # always delimit when there is no and!
+          renderer.render_name(names, node).should == 'J. Doe, S. Smith, T. Williams'
+          renderer.render_name(names.take(2), node).should == 'J. Doe, S. Smith'
+
+          node[:and] = 'text'
+          renderer.render_name(names, node).should == 'J. Doe, S. Smith and T. Williams'
+          renderer.render_name(names.take(2), node).should == 'J. Doe and S. Smith'
+
+          node[:'name-as-sort-order'] = 'first'
+          renderer.render_name(names, node).should == 'Doe, J., S. Smith and T. Williams'
+          renderer.render_name(names.take(2), node).should == 'Doe, J., and S. Smith'
+
+          node[:'name-as-sort-order'] = 'all'
+          renderer.render_name(names, node).should == 'Doe, J., Smith, S., and Williams, T.'
+          renderer.render_name(names.take(2), node).should == 'Doe, J., and Smith, S.'
+        end
+      end
+
+      describe 'truncation of name lists' do
+        let(:names) { CiteProc::Names.new('Doe, J. and Smith, S. and Williams, T.') }
+
+        it 'supports et-al formatting via an et-al node' do
+          node[:'et-al-min'] = 3
+          node[:'et-al-use-first'] = 2
+
+          others = CSL::Style::EtAl.new(:prefix => '!!')
+          node.stub(:et_al).and_return(others)
+
+          renderer.render_name(names, node).should == 'J. Doe, S. Smith, !!et al.'
+
+          others[:term] = 'and others'
+          renderer.render_name(names, node).should == 'J. Doe, S. Smith, !!and others'
+        end
+
+        it 'supports et-al-use-last' do
+          node[:'et-al-min'] = 3
+          node[:'et-al-use-first'] = 2
+          node[:'et-al-use-last'] = true
+
+          # truncated list must be at least two names short!
+          renderer.render_name(names, node).should == 'J. Doe, S. Smith, et al.'
+
+          node[:'et-al-use-first'] = 1
+          renderer.render_name(names, node).should == 'J. Doe, … T. Williams'
+        end
+
+        describe 'with default delimiter settings' do
+          it 'truncates the list if it matches or exceeds et-al-min' do
+            node[:'et-al-min'] = 3
+            node[:'et-al-use-first'] = 2
+
+            renderer.render_name(names, node).should == 'J. Doe, S. Smith, et al.'
+
+            node[:'et-al-use-first'] = 1
+            renderer.render_name(names, node).should == 'J. Doe et al.'
+          end
+
+          it 'does not truncate the list if it is less than et-al-min' do
+            node[:'et-al-min'] = 4
+            node[:'et-al-use-first'] = 2
+
+            renderer.render_name(names, node).should == 'J. Doe, S. Smith, T. Williams'
+          end
+        end
+
+        describe 'with delimiter-precedes-et-al set' do
+          it 'inserts delimiter only for two or more names when set to "contextual" or nil' do
+            node.truncate_when! 3
+            node.truncate_at! 2
+
+            # default behaviour should match contextual!
+            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+
+            node.truncate_at! 1
+            renderer.render_name(philosophers, node).should == 'Plato et al.'
+
+            # set contextual explicitly
+            node.delimiter_contextually_precedes_et_al!
+            renderer.render_name(philosophers, node).should == 'Plato et al.'
+
+            node.truncate_at! 2
+            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+          end
+
+          it 'inserts delimiter when set to "always"' do
+            node.truncate_when! 3
+            node.truncate_at! 2
+
+            node.delimiter_always_precedes_et_al!
+            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+
+            node.truncate_at! 1
+            renderer.render_name(philosophers, node).should == 'Plato, et al.'
+          end
+
+          it 'never inserts delimiter when set to "never"' do
+            node.truncate_when! 3
+            node.truncate_at! 2
+
+            node.delimiter_never_precedes_et_al!
+            renderer.render_name(philosophers, node).should == 'Plato, Socrates et al.'
+
+            node.truncate_at! 1
+            renderer.render_name(philosophers, node).should == 'Plato et al.'
+          end
+
+          it 'supports only-after-inverted-name rule' do
+            node.truncate_when! 3
+            node.truncate_at! 2
+
+            node.delimiter_precedes_et_al_after_inverted_name!
+
+            renderer.render_name(names, node).should == 'J. Doe, S. Smith et al.'
+
+            node[:'name-as-sort-order'] = 'first'
+            renderer.render_name(names, node).should == 'Doe, J., S. Smith et al.'
+
+            node.truncate_at! 1
+            renderer.render_name(names, node).should == 'Doe, J., et al.'
+
+            node[:'name-as-sort-order'] = 'all'
+            renderer.render_name(names, node).should == 'Doe, J., et al.'
+
+            node.truncate_at! 2
+            renderer.render_name(names, node).should == 'Doe, J., Smith, S., et al.'
+          end
+        end
+      end
+
+      describe 'name-part formatting' do
+        let(:part) { CSL::Style::NamePart.new(:'text-case' => 'uppercase') }
+        before { node.parts << part }
+
+        it 'supports family name formatting' do
+          part[:name] = 'family'
+          renderer.render_name(poe, node).should == 'Edgar Allen POE'
+        end
+
+        it 'family part includes non-demoted particles' do
+          part[:name] = 'family'
+
+          renderer.render_name(people(:la_fontaine), node).should == 'Jean de LA FONTAINE'
+          renderer.render_name(people(:humboldt), node).should == 'Alexander von HUMBOLDT'
+          renderer.render_name(people(:van_gogh), node).should == 'Vincent VAN GOGH'
+        end
+
+        it 'family part affixes includes name suffix for non-inverted names' do
+          part.merge! :name => 'family', :prefix => '(', :suffix => ')'
+
+          la_fontaine = people(:la_fontaine)
+          la_fontaine[0].suffix = 'Jr.'
+
+          renderer.render_name(la_fontaine, node).should == 'Jean de (LA FONTAINE Jr.)'
+        end
+
+        it 'supports given name formatting' do
+          part[:name] = 'given'
+          renderer.render_name(poe, node).should == 'EDGAR ALLEN Poe'
+        end
+
+        it 'given part includes particles' do
+          part[:name] = 'given'
+
+          renderer.render_name(people(:la_fontaine), node).should == 'JEAN DE La Fontaine'
+          renderer.render_name(people(:humboldt), node).should == 'ALEXANDER VON Humboldt'
+          renderer.render_name(people(:van_gogh), node).should == 'VINCENT van Gogh'
+        end
+
+        it 'given part affixes enclose demoted particles' do
+          part.merge! :name => 'given', :prefix => '(', :suffix => ')'
+
+          la_fontaine = people(:la_fontaine)
+
+          renderer.render_name(la_fontaine, node).should == '(JEAN DE) La Fontaine'
+
+          node.all_names_as_sort_order!
+          renderer.render_name(la_fontaine, node).should == 'La Fontaine, (JEAN DE)'
+
+          la_fontaine[0].always_demote_particle!
+          renderer.render_name(la_fontaine, node).should == 'Fontaine, (JEAN DE La)'
+        end
+
+        it 'does not alter the passed-in name object' do
+          part[:name] = 'family'
+          renderer.render_name(poe, node).should == 'Edgar Allen POE'
+          poe.to_s.should == 'Edgar Allen Poe'
+        end
+      end
+    end
+  end
+end