citeproc-ruby 0.0.6 → 1.0.0

data/spec/citeproc/ruby/formats/html_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+module CiteProc
+  module Ruby
+
+    describe 'Formats::Html' do
+      it 'can be created with an options hash' do
+        Formats::Html.new(:css_only => true).should be_css_only
+      end
+    end
+
+    describe 'Formats::Html#apply' do
+      let(:format) { Format.load 'html' }
+      let(:node) { CSL::Style::Text.new }
+
+      describe 'text-case formats' do
+        it 'supports lowercase' do
+          node[:'text-case'] = 'lowercase'
+          format.apply('Foo BAR', node).should == 'foo bar'
+        end
+      end
+
+      describe 'entity escaping' do
+        it 'escapes entities in the original text' do
+          node[:'text-case'] = 'lowercase'
+          format.apply('Foo & BAR', node).should == 'foo & bar'
+        end
+
+        it 'escapes entities in affixes' do
+          node[:prefix] = '<'
+          node[:suffix] = '>'
+          format.apply('foo', node).should == '&lt;foo&gt;'
+        end
+
+        it 'escapes entities in quotes' do
+          locale = CSL::Locale.new
+          locale.store 'open-quote', '<'
+          locale.store 'close-quote', '>'
+
+          node[:quotes] = true
+          format.apply('foo', node, locale).should == '&lt;foo&gt;'
+        end
+      end
+
+      describe 'affixes' do
+        it 'are added after text formats have been applied' do
+          node[:prefix] = 'foo'
+          node[:suffix] = 'ooo'
+          node[:'font-style'] = 'italic'
+
+          format.apply('ooo', node).should == 'foo<i>ooo</i>ooo'
+        end
+
+        it 'are added before text formats have been applied for layout nodes' do
+          layout = CSL::Style::Layout.new
+
+          layout[:prefix] = 'foo'
+          layout[:suffix] = 'ooo'
+          layout[:'font-style'] = 'italic'
+
+          format.apply('ooo', layout).should == '<i>foooooooo</i>'
+        end
+      end
+
+      describe 'font-style' do
+        it 'supports italic in both modes' do
+          node[:'font-style'] = 'italic'
+
+          format.apply('foo bar', node).should == '<i>foo bar</i>'
+
+          format.config[:italic] = 'em'
+          format.apply('foo bar', node).should == '<em>foo bar</em>'
+
+          format.config[:css_only] = true
+          format.apply('foo bar', node).should == '<span style="font-style: italic">foo bar</span>'
+        end
+
+        it 'supports normal and oblique via css' do
+          node[:'font-style'] = 'oblique'
+          format.apply('foo bar', node).should == '<span style="font-style: oblique">foo bar</span>'
+
+          node[:'font-style'] = 'normal'
+          format.apply('foo bar', node).should == '<span style="font-style: normal">foo bar</span>'
+        end
+      end
+
+      it 'supports font-variant via css' do
+        node[:'font-variant'] = 'small-caps'
+        format.apply('foo bar', node).should == '<span style="font-variant: small-caps">foo bar</span>'
+      end
+
+      describe 'font-weight' do
+        it 'supports bold in both modes' do
+          node[:'font-weight'] = 'bold'
+
+          format.apply('foo bar', node).should == '<b>foo bar</b>'
+
+          format.config[:bold] = 'strong'
+          format.apply('foo bar', node).should == '<strong>foo bar</strong>'
+
+          format.config[:css_only] = true
+          format.apply('foo bar', node).should == '<span style="font-weight: bold">foo bar</span>'
+        end
+
+        it 'supports normal and light via css' do
+          node[:'font-weight'] = 'light'
+          format.apply('foo bar', node).should == '<span style="font-weight: light">foo bar</span>'
+
+          node[:'font-weight'] = 'normal'
+          format.apply('foo bar', node).should == '<span style="font-weight: normal">foo bar</span>'
+        end
+      end
+
+      it 'supports text-decoration via css' do
+        node[:'text-decoration'] = 'underline'
+        format.apply('foo bar', node).should == '<span style="text-decoration: underline">foo bar</span>'
+      end
+
+      it 'supports vertical-align via css' do
+        node[:'vertical-align'] = 'sup'
+        format.apply('foo bar', node).should == '<span style="vertical-align: sup">foo bar</span>'
+      end
+
+      describe 'display' do
+        it 'is supported in an outer container' do
+          node[:'display'] = 'block'
+          node[:'text-decoration'] = 'underline'
+          format.apply('foo bar', node).should == '<div class="csl-block"><span style="text-decoration: underline">foo bar</span></div>'
+
+          node[:prefix] = '('
+          format.apply('foo bar', node).should == '<div class="csl-block">(<span style="text-decoration: underline">foo bar</span></div>'
+        end
+      end
+
+      describe 'bibliography formats' do
+        let(:bibliography) do
+          CiteProc::Bibliography.new do |b|
+            b.push 'id-1', 'foo'
+            b.push 'id-2', 'bar'
+          end
+        end
+
+        it 'can be applied' do
+          format.config[:bib_indent] = nil
+          format.bibliography(bibliography)
+          bibliography.join.should == '<ol class="csl-bibliography"><li class="csl-entry">foo</li><li class="csl-entry">bar</li></ol>'
+        end
+
+        it 'can be customized' do
+          format.config[:bib_indent] = nil
+          format.config[:bib_entry_class] = nil
+          format.config[:bib_entry] = 'span'
+          format.config[:bib_container] = 'div'
+
+          format.bibliography(bibliography)
+          bibliography.join.should == '<div class="csl-bibliography"><span>foo</span><span>bar</span></div>'
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+module CiteProc
+  module Ruby
+    describe 'Conditional Rendering Elements' do
+      let(:renderer) { Renderer.new }
+
+      let(:item) {
+        i = CiteProc::CitationItem.new(:id => 'ID-1')
+        i.data = CiteProc::Item.new(:id => 'ID-1')
+        i
+      }
+      
+      describe 'Renderer#render_choose' do
+        let(:node) { CSL::Style::Choose.new }
+
+        it 'returns an empty string by default' do
+          renderer.render(item, node).should == ''
+        end
+
+        describe 'when there is a single nested block' do
+          let(:block) do
+            CSL::Style::Choose::Block.new do |b|
+              b << CSL::Style::Text.new( :term => 'retrieved')
+            end
+          end
+
+          before(:each) { node << block }
+
+          it 'returns the content of the nested node when the condition evaluates' do
+            block[:variable] = 'issue'
+            item.data[:issue] = 1
+            renderer.render(item, node).should == 'retrieved'
+          end
+
+          it 'returns an empty string when the condition does not hold' do
+            block[:variable] = 'issue'
+            renderer.render(item, node).should == ''
+          end
+        end
+      end
+
+      describe 'Renderer#render_block' do
+        let(:node) { CSL::Style::Choose::Block.new }
+
+        it 'returns an empty string by default' do
+          renderer.render(item, node).should == ''
+        end
+
+        describe 'when there is a text node in the block' do
+          before(:each) { node << CSL::Style::Text.new( :term => 'retrieved') }
+
+          it 'returns the content of the nested node when there is no condition' do
+            renderer.render(item, node).should == 'retrieved'
+          end
+        end
+      end
+
+      describe 'Renderer#evaluates?' do
+        let(:node) { CSL::Style::Choose::Block.new }
+
+        it 'returns true by default (else block)' do
+          renderer.evaluates?(item, node).should be_true
+        end
+
+        it 'fails if there is an unknown condition type' do
+          node.stub(:conditions).and_return([[:unknown, :all?, 'x']])
+          lambda { renderer.evaluates?(item, node) }.should raise_error
+        end
+
+        it 'returns false for disambiguate (implementation pending)' do
+          node[:disambiguate] = true
+          renderer.evaluates?(item, node).should be_false
+        end
+
+        it 'returns false for position (implementation pending)' do
+          node[:position] = 'first'
+          renderer.evaluates?(item, node).should be_false
+        end
+
+        describe 'for is-numeric conditions' do
+          before { node[:'is-numeric'] = 'note archive' }
+
+          it 'returns false unless all variables are numeric' do
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:archive] = 1
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:note] = 'L2d'
+            renderer.evaluates?(item, node).should be_true
+
+            item.data[:archive] = 'second'
+            renderer.evaluates?(item, node).should be_false
+          end
+        end
+
+        describe 'for is-uncertain-date conditions' do
+          before { node[:'is-uncertain-date'] = 'issued' }
+
+          it 'returns false unless all variables contain uncertain dates' do
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:issued] = 2012
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:issued].uncertain!
+            renderer.evaluates?(item, node).should be_true
+          end
+        end
+
+        describe 'for locator conditions' do
+          before { node[:locator] = 'figure book sub-verbo' }
+
+          it 'returns false unless the locator matches all of the given locators' do
+            renderer.evaluates?(item, node).should be_false
+            
+            item.locator = :book
+            renderer.evaluates?(item, node).should be_false
+            
+            item.locator = 'volume'
+            renderer.evaluates?(item, node).should be_false
+
+            item.locator = 'figure'
+            renderer.evaluates?(item, node).should be_false
+          end
+
+          describe 'when the match attribute is set to "any"' do
+            before { node[:match] = 'any' }
+
+            it 'returns false unless the locator matches any of the given locators' do
+              renderer.evaluates?(item, node).should be_false
+              
+              item.locator = :book
+              renderer.evaluates?(item, node).should be_true
+              
+              item.locator = 'volume'
+              renderer.evaluates?(item, node).should be_false
+
+              item.locator = 'figure'
+              renderer.evaluates?(item, node).should be_true
+            end
+
+            it 'matches "sub verbo" as "sub-verbo"' do
+              item.locator = 'sub-verbo'
+              renderer.evaluates?(item, node).should be_true
+
+              item.locator = 'sub verbo'
+              renderer.evaluates?(item, node).should be_true
+            end
+          end
+        end
+
+        describe 'for type conditions' do
+          before { node[:type] = 'book treaty' }
+
+          it 'returns false unless the type matches all of the given types' do
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:type] = :book
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:type] = 'article'
+            renderer.evaluates?(item, node).should be_false
+
+            item.data[:type] = 'treaty'
+            renderer.evaluates?(item, node).should be_false
+          end
+
+          describe 'when the match attribute is set to "any"' do
+            before { node[:match] = 'any' }
+
+            it 'returns false unless the locator matches any of the given locators' do
+              renderer.evaluates?(item, node).should be_false
+              
+              item.data[:type] = :book
+              renderer.evaluates?(item, node).should be_true
+              
+              item.data[:type] = 'article'
+              renderer.evaluates?(item, node).should be_false
+
+              item.data[:type] = 'treaty'
+              renderer.evaluates?(item, node).should be_true
+            end
+          end
+        end
+
+        describe 'for variable conditions' do
+          before { node[:variable] = 'volume issue' }
+          
+          it 'returns false unless the item has all variables' do
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:volume] = 1
+            renderer.evaluates?(item, node).should be_false
+            
+            item.data[:issue] = 1
+            renderer.evaluates?(item, node).should be_true
+
+            item.data[:volume] = nil
+            renderer.evaluates?(item, node).should be_false
+          end
+
+          describe 'with internal negations' do
+            before { node[:variable] = 'volume not:issue' }
+            
+            it 'returns false unless the item has (or does not have) all variables' do
+              renderer.evaluates?(item, node).should be_false
+
+              item.data[:volume] = 1
+              renderer.evaluates?(item, node).should be_true
+
+              item.data[:issue] = 1
+              renderer.evaluates?(item, node).should be_false
+
+              item.data[:volume] = nil
+              renderer.evaluates?(item, node).should be_false
+            end
+          end
+
+          describe 'and the any-matcher' do
+            before { node[:match] = 'any' }
+
+            it 'returns false unless the item has any of the variables' do
+              renderer.evaluates?(item, node).should be_false
+
+              item.data[:volume] = 1
+              renderer.evaluates?(item, node).should be_true
+
+              item.data[:issue] = 1
+              renderer.evaluates?(item, node).should be_true
+              
+              item.data[:volume] = nil
+              renderer.evaluates?(item, node).should be_true
+            end
+            
+            describe 'with internal negations' do
+              before { node[:variable] = 'volume not:issue' }
+
+              it 'returns false unless the item has (or does not have) any of the variables' do
+                renderer.evaluates?(item, node).should be_true
+
+                item.data[:volume] = 1
+                renderer.evaluates?(item, node).should be_true
+
+                item.data[:issue] = 1
+                renderer.evaluates?(item, node).should be_true
+
+                item.data[:volume] = nil
+                renderer.evaluates?(item, node).should be_false
+              end
+            end
+          end
+          
+          describe 'and the none-matcher' do
+            before { node[:match] = 'none' }
+
+            it 'returns false unless the item has none of the variables' do
+              renderer.evaluates?(item, node).should be_true
+
+              item.data[:volume] = 1
+              renderer.evaluates?(item, node).should be_false
+
+              item.data[:issue] = 1
+              renderer.evaluates?(item, node).should be_false
+              
+              item.data[:volume] = nil
+              renderer.evaluates?(item, node).should be_false
+            end
+            
+            describe 'with internal negations' do
+              before { node[:variable] = 'volume not:issue' }
+
+              it 'returns false unless the item has (or does not have) none of the variables' do
+                renderer.evaluates?(item, node).should be_false
+
+                item.data[:volume] = 1
+                renderer.evaluates?(item, node).should be_false
+
+                item.data[:issue] = 1
+                renderer.evaluates?(item, node).should be_false
+
+                item.data[:volume] = nil
+                renderer.evaluates?(item, node).should be_true
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end