citeproc 1.0.0.pre12 → 1.0.0

data/spec/citeproc/names_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 module CiteProc
-  
+
   describe 'CiteProc Names' do
 
     let(:poe) { Name.new(:family => 'Poe', :given => 'Edgar Allen') }
@@ -11,7 +11,7 @@ module CiteProc
     let(:plato) { Name.new(:given => 'Plato') }
     let(:aristotle) { Name.new(:given => 'Ἀριστοτέλης') }
     let(:dostoyevksy) { Name.new(:given => 'Фёдор Михайлович', :family => 'Достоевский') }
-    
+
     let(:utf) { Name.new(
       :given => 'Gérard',
       :'dropping-particle' => 'de',
@@ -60,20 +60,20 @@ module CiteProc
       "suffix" => "Jr.",
       "comma-suffix" => "true")
     }
-    
+
     let(:ramses) { Name.new(
       :family => 'Ramses',
       :given => 'Horatio',
       :suffix => 'III')
     }
-        
+
     describe Name do
 
 
       it { should_not be_nil }
 
       describe 'formatting options' do
-      
+
         it 'does not always demote particle by default' do
           Name.new.always_demote_particle?.should be false
           Name.new.always_demote_non_dropping_particle?.should be false
@@ -97,262 +97,301 @@ module CiteProc
         it 'demotes particle in sort order if option is set to sort-only' do
           Name.new({}, :'demote-non-dropping-particle' => 'display-and-sort').sort_order!.demote_particle?.should be true
         end
-      
+
         it 'never demotes particle by default' do
           Name.new.never_demote_particle?.should be true
           Name.new.never_demote_non_dropping_particle?.should be true
         end
-      
+
         it 'is not in sort order by default' do
           Name.new.sort_order?.should be false
         end
-      
+
         it 'uses the long form by default' do
           Name.new.should be_long_form
         end
-      
+
         it 'does not use short form by default' do
           Name.new.should_not be_short_form
         end
-      
+
+      end
+
+      describe '#initials' do
+        let(:name) { Name.new(nil, :'initialize-with' => '. ') }
+
+        it 'returns the given name initials' do
+          name.given = 'Edgar A'
+          name.initials.should == 'E. A.'
+
+          name.options[:initialize] = 'false'
+          name.initials.should == 'Edgar A.'
+        end
+
+        describe 'private helpers' do
+          it '#initials_of initializes the given string' do
+            name.send(:initials_of, 'James T.').should == 'J. T.'
+            name.send(:initials_of, 'JT').should == 'J. T.'
+            name.send(:initials_of, 'James T').should == 'J. T.'
+            name.send(:initials_of, 'Jean-Luc').should == 'J.-L.'
+            name.send(:initials_of, 'Vérité Äpfel').should == 'V. Ä.'
+
+            name.initialize_without_hyphen!
+            name.send(:initials_of, 'Jean-Luc').should == 'J. L.'
+
+            name.options[:'initialize-with'] = '.'
+            name.send(:initials_of, 'James T.').should == 'J.T.'
+            name.send(:initials_of, 'James T').should == 'J.T.'
+            name.send(:initials_of, 'Jean-Luc').should == 'J.L.'
+
+            name.options[:'initialize-with-hyphen'] = true
+            name.send(:initials_of, 'Jean-Luc').should == 'J.-L.'
+          end
+
+          it '#initialize_existing_only initializes only current initials' do
+            name.send(:existing_initials_of, 'James T. Kirk').should == 'James T. Kirk'
+            name.send(:existing_initials_of, 'James T.Kirk').should == 'James T. Kirk'
+            name.send(:existing_initials_of, 'James T').should == 'James T.'
+            name.send(:existing_initials_of, 'Jean-Luc').should == 'Jean-Luc'
+            name.send(:existing_initials_of, 'J.-L.M.').should == 'J.-L. M.'
+            name.send(:existing_initials_of, 'J-L').should == 'J.-L.'
+            name.send(:existing_initials_of, 'J-LM').should == 'J.-L. M.'
+            name.send(:existing_initials_of, 'JT').should == 'J. T.'
+          end
+        end
       end
 
       describe 'constructing' do
-      
+
         describe '.new' do
-        
+
           it 'accepts a symbolized hash' do
-            Name.new(:family => 'Doe').to_s.should == 'Doe'
+            Name.new(:family => 'Doe').format.should == 'Doe'
           end
 
           it 'accepts a stringified hash' do
-            Name.new('family' => 'Doe').to_s.should == 'Doe'
+            Name.new('family' => 'Doe').format.should == 'Doe'
           end
-        
-        
+
         end
-      
+
       end
 
       describe '#dup' do
-        
+
         it 'returns a new name copied by value' do
-          poe.dup.upcase!.to_s.should_not == poe.to_s
+          poe.dup.upcase!.format.should_not == poe.format
         end
-        
+
       end
-      
+
       describe 'script awareness' do
-      
+
         it 'english names are romanesque' do
           frank.should be_romanesque
         end
-      
-        if CiteProc.oniguruma?
-          it 'ancient greek names are romanesque' do
-            aristotle.should be_romanesque
-          end
-       
-          it 'russian names are romanesque' do
-            dostoyevksy.should be_romanesque
-          end
+
+        it 'ancient greek names are romanesque' do
+          aristotle.should be_romanesque
         end
-        
+
+        it 'russian names are romanesque' do
+          dostoyevksy.should be_romanesque
+        end
+
         it 'japanese names are not romanesque' do
           japanese.should_not be_romanesque
         end
-      
+
         it 'german names are romanesque' do
-          Name.new(:given => 'Firedrich', :family => 'Hölderlin').should be_romanesque
+          Name.new(:given => 'Friedrich', :family => 'Hölderlin').should be_romanesque
         end
-      
+
         it 'french names are romanesque' do
           utf.should be_romanesque
         end
-      
+
         it 'markup does not interfere with romanesque test' do
           markup.should be_romanesque
         end
-        
+
       end
-    
+
       describe 'literals' do
-      
+
         it 'is a literal if the literal attribute is set' do
           Name.new(:literal => 'GNU/Linux').should be_literal
         end
-      
+
         it 'is not literal by default' do
           Name.new.should_not be_literal
         end
-        
+
         it 'is literal even if other name parts are set' do
           Name.new(:family => 'Tux', :literal => 'GNU/Linux').should be_literal
         end
-      
+
       end
-    
+
       describe 'in-place manipulation (bang! methods)' do
-      
+
         it 'delegates to string for family name' do
-          plato.swapcase!.to_s.should == 'pLATO'
+          plato.swapcase!.format.should == 'pLATO'
         end
-      
+
         it 'delegates to string for given name' do
-          humboldt.gsub!(/^Alex\w*/, 'Wilhelm').to_s.should == 'Wilhelm von Humboldt'
+          humboldt.gsub!(/^Alex\w*/, 'Wilhelm').format.should == 'Wilhelm von Humboldt'
         end
-      
+
         it 'delegates to string for dropping particle' do
           humboldt.upcase!.dropping_particle.should == 'VON'
         end
-      
+
         it 'delegates to string for non dropping particle' do
           van_gogh.upcase!.non_dropping_particle.should == 'VAN'
         end
-        
+
         it 'delegates to string for suffix' do
-          frank.sub!(/jr./i, 'Sr.').to_s.should == 'Frank G. Bennett, Sr.'
+          frank.sub!(/jr./i, 'Sr.').format.should == 'Frank G. Bennett, Sr.'
         end
-      
+
         it 'returns the name object' do
           poe.upcase!.should be_a(Name)
         end
-      
+
       end
-    
-      
-      describe '#to_s' do
+
+
+      describe '#format' do
 
         it 'returns an empty string by default' do
-          Name.new.to_s.should be_empty
+          Name.new.format.should be_empty
         end
 
         it 'returns the last name if only last name is set' do
-          Name.new(:family => 'Doe').to_s.should == 'Doe'
+          Name.new(:family => 'Doe').format.should == 'Doe'
         end
 
         it 'returns the first name if only the first name is set' do
-          Name.new(:given => 'John').to_s.should == 'John'
+          Name.new(:given => 'John').format.should == 'John'
         end
 
         it 'prints japanese names using static ordering' do
-          japanese.to_s.should == '穂積 陳重'
+          japanese.format.should == '穂積 陳重'
         end
 
         it 'returns the literal if the name is a literal' do
-          Name.new(:literal => 'GNU/Linux').to_s == 'GNU/Linux'
+          Name.new(:literal => 'GNU/Linux').format == 'GNU/Linux'
         end
 
         it 'returns the name in display order by default' do
-          Name.new(:family => 'Doe', :given => 'John').to_s.should == 'John Doe'
+          Name.new(:family => 'Doe', :given => 'John').format.should == 'John Doe'
         end
 
         it 'returns the name in sort order if the sort order option is active' do
-          Name.new(:family => 'Doe', :given => 'John').sort_order!.to_s.should == 'Doe, John'
+          Name.new(:family => 'Doe', :given => 'John').sort_order!.format.should == 'Doe, John'
         end
 
         it 'returns the full given name' do
-          saunders.to_s.should == 'John Bertrand de Cusance Morant Saunders'
+          saunders.format.should == 'John Bertrand de Cusance Morant Saunders'
         end
 
         it 'includes dropping particles' do
-          humboldt.to_s.should == 'Alexander von Humboldt'
+          humboldt.format.should == 'Alexander von Humboldt'
         end
 
         it 'includes non dropping particles' do
-          van_gogh.to_s.should == 'Vincent van Gogh'
+          van_gogh.format.should == 'Vincent van Gogh'
         end
 
         it 'includes suffices' do
-          jr.to_s.should == 'James Stephens Jr.'
+          jr.format.should == 'James Stephens Jr.'
         end
 
         it 'uses the comma suffix option' do
-          frank.to_s.should == 'Frank G. Bennett, Jr.'
+          frank.format.should == 'Frank G. Bennett, Jr.'
         end
 
         it 'prints unicode characters' do
-          utf.to_s.should == "Gérard de la Martinière III"
+          utf.format.should == "Gérard de la Martinière III"
         end
 
-        if CiteProc.oniguruma?
-          it 'prints russian names normally' do
-            dostoyevksy.to_s.should == 'Фёдор Михайлович Достоевский'
-          end
+        it 'prints russian names normally' do
+          dostoyevksy.format.should == 'Фёдор Михайлович Достоевский'
         end
 
         describe 'when static ordering is active' do
-        
+
           it 'always prints the family name first' do
-            poe.static_order!.to_s.should == 'Poe Edgar Allen'
+            poe.static_order!.format.should == 'Poe Edgar Allen'
           end
-        
+
         end
-       
+
         describe 'when the sort order option is active' do
 
           it 'returns an empty string by default' do
-            Name.new.sort_order!.to_s.should be_empty
+            Name.new.sort_order!.format.should be_empty
           end
 
           it 'returns the last name if only last name is set' do
-            Name.new({:family => 'Doe'}, { :'name-as-sort-order' => true }).to_s.should == 'Doe'
+            Name.new({:family => 'Doe'}, { :'name-as-sort-order' => true }).format.should == 'Doe'
           end
 
           it 'returns the first name if only the first name is set' do
-            Name.new(:given => 'John').sort_order!.to_s.should == 'John'
+            Name.new(:given => 'John').sort_order!.format.should == 'John'
           end
 
           it 'prints japanese names using static ordering' do
-            japanese.sort_order!.to_s.should == '穂積 陳重'
+            japanese.sort_order!.format.should == '穂積 陳重'
           end
 
           it 'returns the literal if the name is a literal' do
-            Name.new(:literal => 'GNU/Linux').sort_order!.to_s == 'GNU/Linux'
+            Name.new(:literal => 'GNU/Linux').sort_order!.format == 'GNU/Linux'
           end
 
           it 'uses comma for suffix if comma suffix is set' do
-            frank.sort_order!.to_s.should == 'Bennett, Frank G., Jr.'
+            frank.sort_order!.format.should == 'Bennett, Frank G., Jr.'
           end
-        
+
           it 'also uses comma for suffix if comma suffix is *not* set' do
-            jr.sort_order!.to_s.should == 'Stephens, James, Jr.'
+            jr.sort_order!.format.should == 'Stephens, James, Jr.'
           end
 
           it 'for normal names it prints them as "family, given"' do
-            poe.sort_order!.to_s.should == 'Poe, Edgar Allen'
+            poe.sort_order!.format.should == 'Poe, Edgar Allen'
           end
-      
+
           it 'particles come after given name by default' do
-            van_gogh.sort_order!.to_s.should == 'van Gogh, Vincent'
+            van_gogh.sort_order!.format.should == 'van Gogh, Vincent'
           end
 
           it 'particles come after given name if demote option is active' do
-            van_gogh.sort_order!.demote_particle!.to_s.should == 'Gogh, Vincent van'
+            van_gogh.sort_order!.demote_particle!.format.should == 'Gogh, Vincent van'
           end
-        
+
           it 'dropping particles come after given name' do
-            humboldt.sort_order!.to_s.should == 'Humboldt, Alexander von'
+            humboldt.sort_order!.format.should == 'Humboldt, Alexander von'
           end
-        
+
           it 'by default if all parts are set they are returned as "particle family, first dropping-particle, suffix"' do
-            utf.sort_order!.to_s.should == 'la Martinière, Gérard de, III'
+            utf.sort_order!.format.should == 'la Martinière, Gérard de, III'
           end
-        
+
         end
-      
+
       end
-      
+
       describe '#sort_order' do
-      
+
         it 'returns only a single token for literal names' do
           Name.new(:literal => 'ACME Corp.').sort_order.should have(1).element
         end
-      
+
         it 'strips leading "the" off literal names' do
           Name.new(:literal => 'The ACME Corp.').sort_order[0].should == 'ACME Corp.'
         end
-      
+
         it 'strips leading "a" off literal names' do
           Name.new(:literal => 'A Company').sort_order[0].should == 'Company'
         end
@@ -360,11 +399,11 @@ module CiteProc
         it 'strips leading "an" off literal names' do
           Name.new(:literal => 'an ACME Corp.').sort_order[0].should == 'ACME Corp.'
         end
-        
+
         it 'strips leading "l\'" off literal names' do
           Name.new(:literal => "L'Augustine").sort_order[0].should == 'Augustine'
         end
-      
+
         it 'always returns four tokens for non literal names' do
           poe.sort_order.should have(4).elements
           joe.sort_order.should have(4).elements
@@ -373,7 +412,7 @@ module CiteProc
           frank.sort_order.should have(4).elements
           japanese.sort_order.should have(4).elements
         end
-      
+
         it 'demotes non dropping particles if option is set' do
           van_gogh.demote_particle!.sort_order.should == ['Gogh', 'van', 'Vincent', '']
         end
@@ -389,35 +428,35 @@ module CiteProc
         it 'demotes dropping particles' do
           humboldt.sort_order.should == ['Humboldt', 'von', 'Alexander', '']
         end
-      
+
         it 'combines non dropping particles with family name if option demote-non-dropping-particles is not active' do
           van_gogh.never_demote_particle!.sort_order.should == ['van Gogh', '', 'Vincent', '']
         end
-      
+
       end
-    
+
       describe 'sorting' do
-      
+
         it 'sorts by sort order by default' do
           [poe, utf, joe, plato].sort.should == [joe, plato, utf, poe]
         end
-      
+
       end
-    
-    
+
+
     end
-  
+
     describe Names do
-    
+
       let(:gang_of_four) {
         Names.parse!('Erich Gamma and Richard Helm and Ralph Johnson and John Vlissides')
       }
-      
+
       it { should_not be nil }
       it { should_not be_numeric }
-    
+
       describe 'constructing' do
-        
+
         it 'accepts a single name' do
           lambda { Names.new(joe) }.should_not raise_error
         end
@@ -425,7 +464,7 @@ module CiteProc
         it 'accepts a single name as hash' do
           Names.new(:given => 'Jim').should have(1).names
         end
-        
+
         it 'accepts two names' do
           Names.new(joe, poe).should have(2).names
         end
@@ -437,7 +476,7 @@ module CiteProc
         it 'accepts an array of names' do
           Names.new([joe, poe]).should have(2).names
         end
-        
+
       end
 
       describe 'parsing' do
@@ -453,47 +492,47 @@ module CiteProc
           Names.parse('Edgar A. Poe and Hawthorne, Nathaniel and Herman Melville').map { |n|
             n.values_at(:family) }.flatten.should == %w{ Poe Hawthorne Melville }
         end
-        
+
         it '#parse returns nil on error' do
           Names.parse(23).should be_nil
         end
-        
+
         it '#parse! raises an error on bad input' do
           expect { Names.parse!('23') }.to raise_error(ParseError)
         end
-        
+
       end
-      
+
       describe '#strip_markup' do
-        
+
         it 'strips markup off string representation' do
           Names.new(markup).strip_markup.should == utf.to_s
         end
-        
+
         it 'when using the bang! version, strips markup off each name part' do
           Names.new(markup).strip_markup![0].should == utf
         end
-        
-        
+
+
       end
-      
+
       describe 'bang! methods' do
         it 'delegate to the individual names and return self' do
           Names.new(poe, plato, joe).upcase!.map(&:given).should == ['EDGAR ALLEN', 'PLATO', 'JOE']
-        end        
+        end
       end
-      
+
       [:never, :always, :contextually].each do |setting|
         setter = "delimiter_#{setting}_precedes_last!"
         predicate = "delimiter_#{setting}_precedes_last?"
-        
+
         describe "##{setter}" do
           it 'sets the delimiter precedes last option accordingly' do
             Names.new.send(setter).send(predicate).should == true
           end
         end
       end
-      
+
       describe '#delimiter_precedes_last' do
         it 'returns false by default' do
           Names.new(joe).should_not be_delimiter_precedes_last
@@ -519,41 +558,41 @@ module CiteProc
           Names.new(joe, poe, plato).delimiter_never_precedes_last!.should_not be_delimiter_precedes_last
         end
       end
-      
+
       describe '#to_bibtex' do
-        
+
         describe 'when there is only a single name' do
           it 'prints the name in sort order' do
             Names.new(poe).to_bibtex.should == 'Poe, Edgar Allen'
           end
         end
-        
+
         describe 'when there are two or more names' do
           it 'prints the names in sort order connected with the word "and"' do
             Names.new(poe, plato, humboldt).to_bibtex.should == 'Poe, Edgar Allen and Plato and Humboldt, Alexander von'
           end
         end
-        
+
       end
-      
+
       describe '#to_s' do
-      
+
         describe 'when the number of names exceeds the et-al-min option' do
           before do
             gang_of_four.options[:'et-al-min'] = 3
             gang_of_four.options[:'et-al-use-first'] = 2
             gang_of_four.options[:'et-al'] = 'FOO'
           end
-          
+
           it 'prints only the et-al-use-first names' do
             gang_of_four.to_s.should match(/gamma.+helm/i)
             gang_of_four.to_s.should_not match(/johnson|vlissides/i)
           end
-          
+
           it 'adds et-al at the end' do
             gang_of_four.to_s.should end_with('FOO')
           end
-          
+
           it 'adds the delimiter before et-al when multiple names are printed' do
             gang_of_four.to_s.should end_with(', FOO')
           end
@@ -562,26 +601,26 @@ module CiteProc
             gang_of_four.options[:'et-al-use-first'] = 1
             gang_of_four.to_s.should_not end_with(', FOO')
           end
-          
+
         end
-        
+
         it 'squeezes multiple whitespace between delimiter and connector' do
           Names.new(poe, humboldt, van_gogh, joe).to_s.should_not match(/\s{2}/)
-        end 
+        end
       end
-      
+
       describe '#each' do
         it 'returns an enumerator when no block given' do
           gang_of_four.each.should respond_to(:each)
         end
       end
-      
+
       describe '#to_citeproc' do
         it 'returns a list of hashes' do
           gang_of_four.to_citeproc.map(&:class).uniq.should == [Hash]
         end
       end
-      
+
       describe 'sorting' do
         it 'accepts other Names instance' do
           (Names.new(poe, plato) <=> Names.new(plato)).should equal(1)
@@ -599,9 +638,9 @@ module CiteProc
           gang_of_four.inspect.should be_a(String)
         end
       end
-      
+
     end
-    
+
   end
-  
-end
+
+end