citeproc-ruby 0.0.6 → 1.0.0

data/spec/citeproc/formatter_spec.rb

@@ -1,101 +0,0 @@
-module CiteProc
-  describe Formatter do
-    
-    it { should_not be_nil }
-    
-    describe '#format' do
-      it 'returns the current format by default' do
-        Formatter.new.format.should be_a_kind_of(Format::Default)
-      end
-      
-      it 'applies the current format if arguments are given' do
-        Formatter.new.format('foo').should == 'foo'
-      end 
-    end
-
-    describe '#apply' do
-      
-      it 'returns an empty string by default' do
-        Formatter.new.apply.should == ''
-      end
-      
-      context 'using the default style' do
-        
-        let(:format) { Formatter.new }
-        
-        it 'returns the given string if there are no attributes' do
-          format.apply('foo') == 'foo'
-        end
-        
-        it 'returns the formatted string (prefix)' do
-          format.apply('foo', 'prefix' => '@').should == '@foo'
-        end
-        
-        it 'returns the formatted string (suffix)' do
-          format.apply('foo', 'suffix' => '@').should == 'foo@'
-        end
-        
-        it 'returns the formatted string (affixes)' do
-          format.apply('foo', 'prefix' => '@', 'suffix' => '@').should == '@foo@'
-        end
-
-        it 'returns the formatted string (display)' do
-          format.apply('foo', 'display' => 'block').should == 'foo'
-          format.apply('foo', 'display' => 'inline').should == 'foo'
-          format.apply('foo', 'display' => 'right-inline').should == 'foo'
-          format.apply('foo', 'display' => 'left-margin').should == 'foo'
-        end
-        
-        it 'returns the formatted string (strip periods)' do
-          format.apply('foo', 'strip-periods' => 'true').should == 'foo'
-          format.apply('foo.', 'strip-periods' => 'true').should == 'foo'
-          format.apply('f.oo.', 'strip-periods' => 'true').should == 'f oo'
-          format.apply('.foo.', 'strip-periods' => 'true').should == 'foo'
-          format.apply('foo...', 'strip-periods' => 'true').should == 'foo'
-        end
-        
-        it 'returns the formatted string (font-style)' do
-          format.apply('foo', 'font-style' => 'normal').should == 'foo'
-          format.apply('foo', 'font-style' => 'italic').should == 'foo'
-          format.apply('foo', 'font-style' => 'italics').should == 'foo'
-          format.apply('foo', 'font-style' => 'oblique').should == 'foo'
-        end
-
-        it 'returns the formatted string (font-variant)' do
-          format.apply('foo', 'font-variant' => 'normal').should == 'foo'
-          format.apply('foo', 'font-variant' => 'small-caps').should == 'foo'
-        end
-
-        it 'returns the formatted string (font-weight)' do
-          format.apply('foo', 'font-weight' => 'normal').should == 'foo'
-          format.apply('foo', 'font-weight' => 'bold').should == 'foo'
-          format.apply('foo', 'font-weight' => 'light').should == 'foo'
-        end
-
-        it 'returns the formatted string (text-decoration)' do
-          format.apply('foo', 'text-decoration' => 'none').should == 'foo'
-          format.apply('foo', 'text-decoration' => 'underline').should == 'foo'
-        end
-
-        it 'returns the formatted string (vertical-align)' do
-          format.apply('foo', 'vertical-align' => 'baseline').should == 'foo'
-          format.apply('foo', 'vertical-align' => 'sub').should == 'foo'
-          format.apply('foo', 'vertical-align' => 'sup').should == 'foo'
-        end
-
-        it 'returns the formatted string (text-case)' do
-          format.apply('foo', 'text-case' => 'none').should == 'foo'
-          format.apply('foo Foo FOO', 'text-case' => 'lowercase').should == 'foo foo foo'
-          format.apply('foo Foo FoO', 'text-case' => 'uppercase').should == 'FOO FOO FOO'
-          format.apply('foo foo foo', 'text-case' => 'capitalize-first').should == 'Foo foo foo'
-          format.apply('foo FOO fOo', 'text-case' => 'capitalize-all').should == 'Foo Foo Foo'
-          format.apply('the short story of foo and bar', 'text-case' => 'title').should == 'The Short Story of Foo and Bar'
-          format.apply('the short story of FOO and BAR', 'text-case' => 'title').should == 'The Short Story of FOO and BAR'
-          format.apply('the short story of foo and bar', 'text-case' => 'sentence').should == 'The short story of foo and bar'
-        end
-
-      end
-
-    end
-  end
-end

data/spec/citeproc/item_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  describe Item do
-    
-    let(:item) { Item.new }
-    
-    describe '#new' do
-      it { should_not be_nil }
-    end
-    
-    describe '.create' do
-      it 'accepts parameters and returns a new item containing the parameters' do
-        pending #Item.new(:author => 'Poe, Edgar A.').author.family == 'Poe'
-      end
-    end
-        
-    describe '#add_observers' do
-      it 'adds a new observer to the empty list of observers' do
-        expect {
-          item.add_observer(stub('observer', :update => nil))
-        }.to change { item.count_observers }.from(0).to(1)
-      end
-      
-      it 'adds a new observers to the internal list of observers' do
-        expect {
-          item.add_observer(stub('observer1', :update => nil))
-          item.add_observer(stub('observer2', :update => nil))
-          item.add_observer(stub('observer3', :update => nil))
-        }.to change { item.count_observers }.from(0).to(3)
-      end      
-    end
-    
-    describe '#delete_observers' do
-      let(:observer) { stub('observer', :update => nil) }
-      
-      it 'raises no error if the list of observers is empty' do
-        item.delete_observer(observer)
-      end
-
-      it 'does not alter the list of observers if the given observer is not currently observing the item' do
-        item.add_observer(observer)
-        item.count_observers.should == 1
-        item.delete_observer(stub('observer2'))
-        item.count_observers.should == 1        
-      end
-      
-      it 'removes the given observer from the list of observers' do
-        item.add_observer(observer)
-        expect {
-          item.delete_observer(observer)
-        }.to change { item.count_observers }.from(1).to(0)
-      end
-    end
-    
-    describe '#[]' do
-      it 'returns the value for the given key' do
-        item['foo'] = 'foo'
-        item['foo'].should == 'foo'
-      end
-      
-      it 'notifies observers on every variable access' do
-        observer = stub('observer')
-        observer.should_receive(:update).once
-        item.add_observer(observer)
-        item['foo']
-      end
-    end
-    
-  end
-end

data/spec/citeproc/name_spec.rb

@@ -1,30 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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)[0].should == '(Poe, 1996)'
-        Processor.process(item, :mode => :citation, :style => :mla)[0].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

@@ -1,82 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,208 +0,0 @@
-# -*- 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