citeproc-ruby 0.0.1

data/spec/citeproc/name_spec.rb

@@ -0,0 +1,30 @@
+module CiteProc
+  
+  describe Name do
+    Test::Fixtures::Names.keys.each do |feature|
+      describe feature do
+
+        Test::Fixtures::Names[feature].each do |test|
+
+          it test['it'] do
+            names = test['names'].map { |name| Name.new(name) }
+            expected = test['expected']
+            options = test['options']
+        
+            result = case feature
+              when 'sort'
+                names.sort.map(&:to_s)
+              else
+                names.map { |name| name.send(feature, options) }
+              end
+        
+            result.should == expected 
+          end
+        
+        end
+      
+      end
+    end
+  end
+  
+end

data/spec/citeproc/processor_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module CiteProc
+  
+  describe Processor do
+  
+    let(:processor) { Processor.new }
+    let(:item) { Hash['author', [{ 'given' => 'Edgar A.', 'family' => 'Poe' }], 'title', 'The Raven', 'type', 'book', 'issued', { 'date-parts' => [[1996]] }, 'publisher', 'Library of America', 'publisher-place', 'New York' ] }
+
+    describe '.process' do
+      it 'returns an empty string by default' do
+        Processor.process({}).should == ''
+      end
+      
+      it 'returns a formatted citation' do
+        Processor.process(item, :mode => :citation, :style => :apa).should == '(Poe, 1996)'
+        Processor.process(item, :mode => :citation, :style => :mla).should == '(Poe)'
+      end
+
+      it 'returns a formatted bibliographic entry' do
+        Processor.process(item, :mode => :bibliography, :style => :apa).should == 'Poe, E. A. (1996). The Raven. New York: Library of America.'
+      end
+    end
+  
+    describe '#style' do
+      it 'accepts a style name' do
+        processor.style = 'apa'
+        processor.style.should_not be_nil
+      end
+    end
+    
+    describe '#abbreviations' do
+      it 'can be set and records new abbreviations' do
+        expected = { 'default' => { 'container-title' => { 'long' => 'short' } } }
+        processor.abbreviations = expected
+        processor.abbreviations.should == expected
+      
+        alternate = { 'alternate' => { 'container-title' => { 'long' => 'short' } } }
+        processor.add_abbreviations(alternate)
+        processor.abbreviations.should == expected.merge(alternate)
+     
+        result = processor.abbreviate('container-title', 'long')
+        result.should == 'short'
+      
+        result = processor.abbreviate('container-title', 'long', 'alternate')
+        result.should == 'short'
+      
+        result = processor.abbreviate('container-title', 'new')
+        result.should == 'new'
+
+        result = processor.abbreviate('container-title', 'new', 'alternate')
+        result.should == 'new'
+
+        result = processor.abbreviate('hereinafter', 'new')
+        result.should == 'new'
+      end
+    end
+    
+  end
+  
+end

data/spec/citeproc/selector_spec.rb

@@ -0,0 +1,82 @@
+module CiteProc
+  describe Selector do
+    describe '#new' do
+      it { should_not be_nil }
+
+      %w{ all any none select include exclude }.each do |mode|
+        it "accepts string/symbol values (#{mode})" do
+          Selector.new(mode).type.should_not be_nil
+          # Selector.new(mode.to_sym).type.should_not be_nil
+        end
+      end
+      
+      describe 'json API support' do
+      
+        it 'accepts a json object (select)' do
+          Selector.new(
+             "select" => [
+                {
+                   "field" => "type",
+                   "value" => "book"
+                },
+                {  "field" => "categories",
+                    "value" => "1990s"
+                }
+             ]
+          ).select.should have(2).items
+        end
+
+        it 'accepts a json string (select)' do
+          Selector.new('{
+             "select" : [
+                {
+                   "field" : "type",
+                   "value" : "book"
+                },
+                {  "field" : "categories",
+                    "value" : "1990s"
+                }
+             ]
+          }
+          ').select.should have(2).items
+        end
+        
+      end
+    end
+    
+    describe '#conditions' do
+    
+      let(:condition) { {'field' => 'type', 'value' => 'book'} }
+      
+      %w{ select include exclude }.each do |mode|
+        it "returns the conditions (#{mode})" do
+          Selector.new(mode => [condition]).conditions.should == [condition]
+        end
+      end
+    
+    end
+    
+    describe '#to_proc' do
+      
+      let(:books) { Selector.new('select' => [{'field' => 'type', 'value' => 'book'}]) }
+      let(:english_books) { Selector.new('select' => [{'field' => 'type', 'value' => 'book'}, {'field' => 'language', 'value' => 'en'}]) }
+      
+      
+      it 'can be used as a block to Array#select' do
+        [{ 'type' => 'book'}, { 'type' => 'article'}].select(&books).should have(1).item
+      end
+      
+      it 'does not filter out anything by default' do
+        [1,2,3].select(&Selector.new).should == [1,2,3]
+      end
+      
+      describe 'when the type is :select' do
+        it 'selects items that match all conditions' do
+          [{ 'type' => 'book'}, { 'type' => 'article'}, { 'type' => 'book', 'language' => 'en'}].select(&english_books).should have(1).item          
+        end
+      end
+      
+    end
+    
+  end
+end

data/spec/citeproc/variable_spec.rb

@@ -0,0 +1,69 @@
+module CiteProc
+
+  describe Variable do
+    
+    describe '#new' do
+      it { should_not be_nil }
+      
+      it 'accepts a string value' do
+        Variable.new('test').value.should == 'test'
+      end
+      
+      it 'accepts an attributes hash' do
+        Variable.new('value' => 'test').value.should == 'test'
+      end
+      
+      it 'supports self yielding block' do
+        Variable.new { |v| v.value = 'test' }.value.should == 'test'
+      end
+    end
+    
+    describe '#to_s' do
+      it 'displays the value' do
+        Variable.new('test').to_s.should == 'test'
+      end
+    end
+
+    describe '#to_i' do
+      it 'returns zero by default' do
+        Variable.new.to_i.should == 0
+      end
+      
+      context 'when the value is numeric' do
+        %w{ -23 -1 0 1 23 }.each do |value|
+          it "returns the integer value (#{value})" do
+            Variable.new(value).to_i.should == value.to_i
+          end
+        end
+        
+        it 'returns only the first numeric value if there are several' do
+          Variable.new('testing 1, 2, 3...').to_i.should == 1
+        end
+      end
+    end
+
+    
+    describe '#numeric?' do
+      it 'returns false by default' do
+        Variable.new.should_not be_numeric
+      end
+
+      context 'variable contains a number' do
+        it 'returns true (string initialized)' do
+          Variable.new('23').should be_numeric
+          Variable.new('foo 23').should be_numeric
+        end
+        it 'returns true (integer initialized)' do
+          Variable.new(23).should be_numeric
+        end
+      end
+      
+      context 'variable does not contain a number' do
+        it 'returns false for strings' do
+          Variable.new('test').should_not be_numeric
+        end
+      end
+    end
+    
+  end
+end

data/spec/csl/locale_spec.rb

@@ -0,0 +1,208 @@
+# -*- encoding: utf-8 -*-
+
+module CSL
+
+  describe Locale do
+
+    let(:locale) { Locale.new }
+
+    let(:en) { Locale.new('en-US') }
+    let(:de) { Locale.new('de-DE') }
+    let(:fr) { Locale.new('fr-FR') }
+        
+    describe '#new' do
+      it { should_not be_nil }
+      
+      it 'defaults to empty language' do
+        locale.language.should be_nil
+      end
+      
+      it 'defaults to empty region' do
+        locale.region.should be_nil
+      end
+    
+      it 'contains no terms, date, and options content by default' do
+        [:terms, :date, :options].each do |m|
+          locale.send(m).should_not be_nil
+          locale.send(m).should be_empty
+        end
+      end
+
+      it 'parses an XML string' do
+        locale = Locale.new <<-END
+        <locale xml:lang="en">
+          <terms>
+            <term name="editortranslator" form="short">
+              <single>ed. &amp; trans.</single>
+              <multiple>eds. &amp; trans.</multiple>
+            </term>
+          </terms>
+        </locale>
+        END
+
+        locale.language.should == 'en'
+        locale.options.should be_empty
+        locale.terms['editortranslator'].pluralize('form' => 'short').should == 'eds. & trans.'
+      end
+    end
+  
+    describe '#set' do
+      it 'sets a new language' do
+        language = 'de'
+        locale.language = language
+        locale.language.should == language
+        locale.region.should == 'DE'      
+      end
+    
+      it 'sets a new language and region' do
+        language = 'de'
+        region = 'DE'
+      
+        locale.region = region
+        locale.language.should == language
+        locale.region.should == region
+      end
+    
+    end
+  
+    describe '#terms' do
+      it 'contains common terms by default' do
+        en['book'].should_not be_nil
+      end
+    
+      it 'contains variants for form and number' do
+        en['page']['long'].values.should == ['page', 'pages']
+        en['page']['short'].values.should == ['p.', 'pp.']
+      end
+    
+      it 'returns different values for different languages' do
+        [en, de, fr].map do |l|
+          l['editor'].to_s
+        end.uniq.length.should == 3
+      end
+    end
+  
+    describe '#ordinalize' do
+      context 'in English' do
+        it 'works' do
+          result = (1..13).map do |i|
+            en.ordinalize(i)
+          end
+      
+          expected = %w{ 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11th 12th 13th }
+
+          result.should == expected
+      
+          result = [20, 21, 22, 23, 24, 100, 101, 102, 103, 104, 113, 123].map do |i|
+            en.ordinalize(i)
+          end
+
+          expected = %w{ 20th 21st 22nd 23rd 24th 100th 101st 102nd 103rd 104th 113th 123rd }
+
+          result.should == expected
+
+        end
+      
+        it 'long-forms work in English' do
+          result = (1..13).map do |i|
+            en.ordinalize(i, 'form' => 'long-ordinal')
+          end
+      
+          expected = %w{ first second third fourth fifth sixth seventh eighth ninth tenth 11th 12th 13th }
+
+          result.should == expected
+        end
+      end
+
+      context 'in German' do
+        it 'works' do
+          result = (1..13).map do |i|
+            de.ordinalize(i)
+          end
+      
+          expected = %w{ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. }
+
+          result.should == expected
+      
+          result = [20, 21, 22, 23, 24, 100, 101, 102, 103, 104, 113, 123].map do |i|
+            de.ordinalize(i)
+          end
+
+          expected = %w{ 20. 21. 22. 23. 24. 100. 101. 102. 103. 104. 113. 123. }
+
+          result.should == expected
+
+        end
+      
+        it 'long-forms work' do
+          result = (1..13).map do |i|
+            de.ordinalize(i, 'form' => 'long-ordinal')
+          end
+      
+          expected = %w{ erster zweiter dritter vierter fünfter sechster siebter achter neunter zehnter  11. 12. 13. }
+
+          result.should == expected
+        end
+        
+        it 'female long-forms work' do
+          result = (1..13).map do |i|
+            de.ordinalize(i, 'form' => 'long-ordinal', 'gender-form' => 'feminine')
+          end
+      
+          expected = %w{ erste zweite dritte vierte fünfte sechste siebte achte neunte zehnte  11. 12. 13. }
+
+          result.should == expected
+        end
+        
+      end
+      
+    end
+    
+    describe 'sorting' do
+      
+      context 'default priority' do
+        [['da-DK', 'de-DE'],  ['ar-AR', 'el-GR'], ['en-US', 'it-IT'], ['en-US', 'ar-AR'], ['en-US', 'de-DE']].each do |a,b|
+          it "sorts by default and alphabetically by language (#{a} < #{b})" do
+            (Locale.new(a) < Locale.new(b)).should be true
+          end
+        end
+
+        [['de-AT', 'de-CH'],  ['de-DE', 'de-CH'], ['de-DE', 'de-AT'], ['pt-PT', 'pt-BR'], ['zh-CN', 'zh-TW']].each do |a,b|
+          it "sorts by default and alphabetically by region (#{a} < #{b})" do
+            (Locale.new(a) < Locale.new(b)).should be true
+          end
+        end
+        
+        it 'sorts nil languages last' do
+          [Locale.new, Locale.new('de'), Locale.new('sv-SE')].sort.last.language.should be_nil
+        end
+
+        it 'sorts nil regions as default' do
+          %w{ de de-AT de-DE de-CH }.map { |lc| Locale.new(lc) }.sort.map(&:tag).should == %w{ de-DE de-DE de-AT de-CH }
+        end
+      end
+          
+      context 'language priority (de)' do
+        [['de-DE', 'da-DK'],  ['ar-AR', 'el-GR'], ['en-US', 'it-IT'], ['en-US', 'ar-AR'], ['de-DE', 'en-US']].each do |a,b|
+          it "sorts by default and alphabetically by language (#{a} < #{b})" do
+            [Locale.new(a), Locale.new(b)].sort(&Locale.sort('de')).map(&:tag).should == [a,b]
+          end
+        end
+
+        [['de-DE', 'de-AT'],  ['de-AT', 'ar-AR'], ['en-US', 'ar-AR'], ['de-CH', 'en-US']].each do |a,b|
+          it "sorts by default and alphabetically by region (#{a} < #{b})" do
+            [Locale.new(a), Locale.new(b)].sort(&Locale.sort('de')).map(&:tag).should == [a,b]
+          end
+        end
+      end
+      
+      context 'regional priority (CH)' do
+        it 'sorts by default and alphabetically' do
+          %w{ de-AT de-DE de-CH }.map { |lc| Locale.new(lc) }.sort(&Locale.sort(nil, 'CH')).map(&:tag).should == %w{ de-CH de-DE de-AT }          
+        end
+      end
+      
+    end
+    
+  end
+end