citeproc-ruby 0.0.1

data/resource/style/nlm.csl

@@ -0,0 +1,117 @@
+<style 
+      xmlns="http://purl.org/net/xbiblio/csl"
+      class="in-text"
+      xml:lang="en">
+  <info>
+    <title>National Library of Medicine</title>
+    <id>http://www.zotero.org/styles/nlm</id>
+    <link href="http://www.zotero.org/styles/nlm" />
+    <author>
+      <name>Michael Berkowitz</name>
+      <email>mberkowi@gmu.edu</email>
+    </author>
+    <category term="generic-base" />
+    <category term="numeric" />
+    <updated />
+  </info>
+  <macro name="author">
+    <names suffix=". " variable="author">
+      <name delimiter=", " delimiter-precedes-last="always" initialize-with="" name-as-sort-order="all" sort-separator=" " />
+    </names>
+  </macro>
+  <macro name="editor">
+    <names suffix=", editor(s). " variable="editor">
+      <name delimiter=", " delimiter-precedes-last="always" initialize-with="" name-as-sort-order="all" sort-separator=" " />
+    </names>
+  </macro>
+  <macro name="publisher">
+    <text suffix=": " variable="publisher-place" />
+    <text suffix="; " variable="publisher" />
+    <date variable="issued">
+      <date-part name="year" suffix=". " />
+    </date>
+  </macro>
+  <macro name="access">
+    <group delimiter=" ">
+      <group delimiter=" " prefix="[" suffix="]">
+        <text term="cited" text-case="lowercase" />
+        <date suffix=" " variable="accessed">
+          <date-part name="year" />
+          <date-part form="short" name="month" prefix=" " />
+          <date-part name="day" prefix=" " />
+        </date>
+      </group>
+      <group>
+        <text value="Available from: " />
+        <text variable="URL" />
+      </group>
+    </group>
+  </macro>
+  <macro name="title">
+    <group delimiter=" ">
+      <text variable="title" />
+      <choose>
+        <if variable="URL">
+          <text prefix="[" suffix="]" term="internet" text-case="capitalize-first" />
+        </if>
+      </choose>
+    </group>
+  </macro>
+  <macro name="edition">
+    <choose>
+      <if is-numeric="edition">
+        <group delimiter=" ">
+          <number form="ordinal" variable="edition" />
+          <text form="short" suffix="." term="edition" />
+        </group>
+      </if>
+      <else>
+        <text suffix="." variable="edition" />
+      </else>
+    </choose>
+  </macro>
+  <citation 
+         collapse="citation-number">
+    <sort>
+      <key variable="citation-number" />
+    </sort>
+    <layout delimiter="; " prefix="(" suffix=")">
+      <text variable="citation-number" />
+    </layout>
+  </citation>
+  <bibliography 
+         second-field-align="true">
+    <layout>
+      <text suffix=". " variable="citation-number" />
+      <text macro="author" />
+      <text macro="title" suffix=". " />
+      <choose>
+        <if type="book">
+          <text macro="edition" prefix=" " suffix=" " />
+          <text macro="publisher" prefix=" " />
+        </if>
+        <else-if type="chapter">
+          <group prefix=" " suffix=". ">
+            <text suffix=": " term="in" text-case="capitalize-first" />
+            <text macro="editor" />
+            <text variable="container-title" />
+          </group>
+          <text macro="publisher" prefix=" " />
+          <text prefix=" p. " suffix="." variable="page" />
+        </else-if>
+        <else>
+          <text form="short" suffix=". " variable="container-title" />
+          <date suffix=";" variable="issued">
+            <date-part name="year" suffix=" " />
+            <date-part form="short" name="month" suffix=" " />
+            <date-part name="day" />
+          </date>
+          <text variable="volume" />
+          <text prefix="(" suffix="):" variable="issue" />
+          <text suffix="." variable="page" />
+        </else>
+      </choose>
+      <text macro="access" />
+    </layout>
+  </bibliography>
+</style>

data/spec/citeproc/bibliography_spec.rb

@@ -0,0 +1,45 @@
+module CiteProc
+  describe Bibliography do
+    
+    let(:json) {'[{"test":"test","bibliography-errors":[]},["1","2"]]'}
+    
+    describe '#new' do
+      it { should_not be_nil }
+      
+      it 'accepts a JSON string' do
+        Bibliography.new(json).should_not be_empty
+      end
+      
+      it 'accepts a data array' do
+        Bibliography.new([1,2,3]).data.should == [1,2,3]
+      end
+      
+      it 'accepts an options hash' do
+        Bibliography.new('test'=>'test').options['test'].should == 'test'
+      end
+      
+      it 'accepts an options hash with errors' do
+        Bibliography.new('bibliography-errors'=>[1,2,3]).errors.should == [1,2,3]
+      end
+    end
+    
+    describe '#to_json' do
+      it 'returns valid JSON when empty' do
+        JSON.parse(Bibliography.new.to_json).should_not be_nil
+      end
+      it 'returns valid JSON with data' do
+        JSON.parse(Bibliography.new([1,2,3]).to_json).should_not be_nil
+      end
+      it 'returns valid JSON with options' do
+        JSON.parse(Bibliography.new({'test'=>'test'}).to_json).should_not be_nil
+      end
+      it 'returns valid JSON with options and data' do
+        JSON.parse(Bibliography.new([{'test'=>'test'}, [1,2]]).to_json).should_not be_nil
+      end
+      it 'supports round-trips' do
+        Bibliography.new(json).to_json.should == json
+      end
+    end
+    
+  end
+end

data/spec/citeproc/citeproc_spec.rb

@@ -0,0 +1,76 @@
+#
+# This generates RSpec tests from the JSON test cases of the citeproc-tests
+# suite.
+#
+
+
+#
+# Filter applied to each test to decide whether we should run it. Use this
+# to stay sane while the Processor is not feature-complete!
+#
+def filter(file, fixture)
+  # return ['affix_InterveningEmpty.json'].include?(File.basename(file))
+  # File.basename(file) =~ /bugreports_greek/i
+  # File.basename(file) =~ /sort_stripmark/i
+  # return File.basename(file) =~ /^date_rawparsesimpledate/i
+  true
+end
+
+module CiteProc
+  
+  describe 'citeproc' do
+
+    let(:proc) { Processor.new }
+
+    Test::Fixtures::Processor.each_pair do |file, fixture|
+
+      tokens = File.basename(file).split(/_|\.json/)
+    
+      describe tokens[0].downcase do
+      
+        name = tokens[1].gsub(/([[:lower:]])([[:upper:]])/, '\1 \2').downcase
+      
+        it name do
+          pending if tokens[0] =~ /^(position|disambiguate|integration|flipflop|collapse|parallel)/
+          
+          proc.style = fixture['csl']
+          proc.import(fixture['input'])
+          proc.format = :html
+
+          proc.add_abbreviations(fixture['abbreviations']) if fixture['abbreviations']
+      
+          case fixture['mode']
+        
+          when 'citation'
+            # citations => process_citation_cluster
+            # citation_items || :all => make_citation_cluster
+            data = fixture['citation_items']
+        
+            unless data
+              result = proc.cite((fixture['bibentries'] && fixture['bibentries'].last) || :all).map { |d| d[1] }.join
+            else
+              result = data.map { |d| proc.cite(d).map { |c| c[1] }.join }.join("\n")
+            end
+        
+          when 'bibliography'
+            result = proc.bibliography(fixture['bibsection'] || :all).to_s
+            
+          when 'bibliography-header'
+            pending('not yet implemented')
+        
+          when 'bibliography-nosort'
+            pending('not yet implemented')
+        
+          else
+            CiteProc.log.warn "unkown processor mode: #{fixture['mode']}"
+            pending('not yet implemented')
+          end
+      
+          result.should == fixture['result']
+      
+        end
+      end if filter(file, fixture)
+  
+    end
+  end
+end

data/spec/citeproc/date_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module CiteProc
+
+  describe Date do
+    
+    describe '#new' do
+      it { should_not be_nil }
+    end
+    
+    describe '.create' do
+      it 'should accept parameters and return a new instance' do
+        Date.create('date-parts' => [[2001, 1]]).year.should == 2001
+      end
+    end
+    
+    describe '#sort' do
+      
+      let(:ad2k) { Date.create('date-parts' => [[2000]])}
+      let(:may) { Date.create('date-parts' => [[2000, 5]])}
+      let(:first_of_may) { Date.create('date-parts' => [[2000, 5, 1]])}
+      
+      let(:bc100) { Date.create('date-parts' => [[-100]]) }
+      let(:bc50) { Date.create('date-parts' => [[-50]]) }
+      let(:ad50) { Date.create('date-parts' => [[50]]) }
+      let(:ad100) { Date.create('date-parts' => [[100]]) }
+
+      it 'dates with more date-parts will come after those with fewer parts' do
+        (ad2k < may  && may < first_of_may).should be true
+      end
+      
+      it 'negative years are sorted inversely' do
+        [ad50, bc100, bc50, ad100].sort.map(&:year).should == [-100, -50, 50, 100]
+      end
+    end
+    
+    Test::Fixtures::Dates.keys.each do |feature|
+      describe feature do
+        Test::Fixtures::Dates[feature].each do |example|
+
+          it example['it'] do
+            dates = example['dates'].map { |date| Date.new(date) }
+            expected = example['expected']
+            options = example['options']
+
+            result = case feature
+              when 'display'
+                dates.map { |date| date.display(options) }
+              when 'json-api'
+                dates.map(&:to_json)
+              end
+            
+            result.should == expected
+          end  
+
+        end
+      end
+    end
+
+    describe 'literal dates' do
+      
+      it 'is not literal by default' do
+        Date.new.should_not be_literal
+      end
+      
+      it 'is literal if it contains only a literal field' do
+        Date.create(:literal => 'foo').should be_literal
+      end
+      
+      it 'is literal if it contains a literal field' do
+        Date.create('date-parts' => [[2000]], :literal => 'foo').should be_literal
+      end
+    end
+    
+    describe 'uncertain dates' do
+      it 'are uncertain' do
+        Date.new({ 'date-parts' => [[-225]], 'circa' => '1' }).should be_uncertain
+        Date.new { |d| d.parts = [[-225]]; d.circa = true }.should be_uncertain
+      end
+    end
+
+    
+  end
+
+end

data/spec/citeproc/formatter_spec.rb

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

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