citeproc-ruby 1.1.8 → 1.1.10

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

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-    describe 'Formats::Html' do
-      it 'can be created with an options hash' do
-        expect(Formats::Html.new(:css_only => true)).to 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'
-          expect(format.apply('Foo BAR', node)).to eq('foo bar')
-        end
-      end
-
-      describe 'entity escaping' do
-        it 'escapes entities in the original text' do
-          node[:'text-case'] = 'lowercase'
-          expect(format.apply('Foo & BAR', node)).to eq('foo & bar')
-        end
-
-        it 'does not not apply casing to escaped entities' do
-          node[:'text-case'] = 'uppercase'
-          expect(format.apply('Foo & BAR', node)).to eq('FOO & BAR')
-        end
-
-        it 'escapes entities in affixes' do
-          node[:prefix] = '<'
-          node[:suffix] = '>'
-          expect(format.apply('foo', node)).to eq('&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
-          expect(format.apply('foo', node, locale)).to eq('&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'
-
-          expect(format.apply('ooo', node)).to eq('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'
-
-          expect(format.apply('ooo', layout)).to eq('<i>foooooooo</i>')
-        end
-      end
-
-      describe 'font-style' do
-        it 'supports italic in both modes' do
-          node[:'font-style'] = 'italic'
-
-          expect(format.apply('foo bar', node)).to eq('<i>foo bar</i>')
-
-          format.config[:italic] = 'em'
-          expect(format.apply('foo bar', node)).to eq('<em>foo bar</em>')
-
-          format.config[:css_only] = true
-          expect(format.apply('foo bar', node)).to eq('<span style="font-style: italic">foo bar</span>')
-        end
-
-        it 'supports normal and oblique via css' do
-          node[:'font-style'] = 'oblique'
-          expect(format.apply('foo bar', node)).to eq('<span style="font-style: oblique">foo bar</span>')
-
-          node[:'font-style'] = 'normal'
-          expect(format.apply('foo bar', node)).to eq('<span style="font-style: normal">foo bar</span>')
-        end
-      end
-
-      it 'supports font-variant via css' do
-        node[:'font-variant'] = 'small-caps'
-        expect(format.apply('foo bar', node)).to eq('<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'
-
-          expect(format.apply('foo bar', node)).to eq('<b>foo bar</b>')
-
-          format.config[:bold] = 'strong'
-          expect(format.apply('foo bar', node)).to eq('<strong>foo bar</strong>')
-
-          format.config[:css_only] = true
-          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: bold">foo bar</span>')
-        end
-
-        it 'supports normal and light via css' do
-          node[:'font-weight'] = 'light'
-          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: light">foo bar</span>')
-
-          node[:'font-weight'] = 'normal'
-          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: normal">foo bar</span>')
-        end
-      end
-
-      it 'supports text-decoration via css' do
-        node[:'text-decoration'] = 'underline'
-        expect(format.apply('foo bar', node)).to eq('<span style="text-decoration: underline">foo bar</span>')
-      end
-
-      it 'supports vertical-align via css' do
-        node[:'vertical-align'] = 'sup'
-        expect(format.apply('foo bar', node)).to eq('<span style="vertical-align: super">foo bar</span>')
-      end
-
-      describe 'display' do
-        it 'is supported in an outer container' do
-          node[:'display'] = 'block'
-          node[:'text-decoration'] = 'underline'
-          expect(format.apply('foo bar', node)).to eq('<div class="csl-block"><span style="text-decoration: underline">foo bar</span></div>')
-
-          node[:prefix] = '('
-          expect(format.apply('foo bar', node)).to eq('<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)
-          expect(bibliography.join).to eq('<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)
-          expect(bibliography.join).to eq('<div class="csl-bibliography"><span>foo</span><span>bar</span></div>')
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,293 +0,0 @@
-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
-          expect(renderer.render(item, node)).to eq('')
-        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
-            expect(renderer.render(item, node)).to eq('retrieved')
-          end
-
-          it 'returns an empty string when the condition does not hold' do
-            block[:variable] = 'issue'
-            expect(renderer.render(item, node)).to eq('')
-          end
-        end
-      end
-
-      describe 'Renderer#render_block' do
-        let(:node) { CSL::Style::Choose::Block.new }
-
-        it 'returns an empty string by default' do
-          expect(renderer.render(item, node)).to eq('')
-        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
-            expect(renderer.render(item, node)).to eq('retrieved')
-          end
-        end
-      end
-
-      describe 'Renderer#evaluates?' do
-        let(:node) { CSL::Style::Choose::Block.new }
-
-        it 'returns true by default (else block)' do
-          expect(renderer.evaluates?(item, node)).to be_truthy
-        end
-
-        it 'fails if there is an unknown condition type' do
-          allow(node).to receive(:conditions).and_return([[:unknown, :all?, 'x']])
-          expect { renderer.evaluates?(item, node) }.to raise_error(RuntimeError)
-        end
-
-        it 'returns false for disambiguate (implementation pending)' do
-          node[:disambiguate] = true
-          expect(renderer.evaluates?(item, node)).to be_falsey
-        end
-
-        it 'returns false for position (implementation pending)' do
-          node[:position] = 'first'
-          expect(renderer.evaluates?(item, node)).to be_falsey
-        end
-
-        describe 'for is-numeric conditions' do
-          before { node[:'is-numeric'] = 'note archive' }
-
-          it 'returns false unless all variables are numeric' do
-            expect(renderer.evaluates?(item, node)).to be_falsey
-
-            item.data[:archive] = 1
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:note] = 'L2d'
-            expect(renderer.evaluates?(item, node)).to be_truthy
-
-            item.data[:archive] = 'second'
-            expect(renderer.evaluates?(item, node)).to be_falsey
-          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
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:issued] = 2012
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:issued].uncertain!
-            expect(renderer.evaluates?(item, node)).to be_truthy
-          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
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.locator = :book
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.locator = 'volume'
-            expect(renderer.evaluates?(item, node)).to be_falsey
-
-            item.locator = 'figure'
-            expect(renderer.evaluates?(item, node)).to be_falsey
-          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
-              expect(renderer.evaluates?(item, node)).to be_falsey
-              
-              item.locator = :book
-              expect(renderer.evaluates?(item, node)).to be_truthy
-              
-              item.locator = 'volume'
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.locator = 'figure'
-              expect(renderer.evaluates?(item, node)).to be_truthy
-            end
-
-            it 'matches "sub verbo" as "sub-verbo"' do
-              item.locator = 'sub-verbo'
-              expect(renderer.evaluates?(item, node)).to be_truthy
-
-              item.locator = 'sub verbo'
-              expect(renderer.evaluates?(item, node)).to be_truthy
-            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
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:type] = :book
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:type] = 'article'
-            expect(renderer.evaluates?(item, node)).to be_falsey
-
-            item.data[:type] = 'treaty'
-            expect(renderer.evaluates?(item, node)).to be_falsey
-          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
-              expect(renderer.evaluates?(item, node)).to be_falsey
-              
-              item.data[:type] = :book
-              expect(renderer.evaluates?(item, node)).to be_truthy
-              
-              item.data[:type] = 'article'
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.data[:type] = 'treaty'
-              expect(renderer.evaluates?(item, node)).to be_truthy
-            end
-          end
-        end
-
-        describe 'for variable conditions' do
-          before { node[:variable] = 'volume issue' }
-          
-          it 'returns false unless the item has all variables' do
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:volume] = 1
-            expect(renderer.evaluates?(item, node)).to be_falsey
-            
-            item.data[:issue] = 1
-            expect(renderer.evaluates?(item, node)).to be_truthy
-
-            item.data[:volume] = nil
-            expect(renderer.evaluates?(item, node)).to be_falsey
-          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
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.data[:volume] = 1
-              expect(renderer.evaluates?(item, node)).to be_truthy
-
-              item.data[:issue] = 1
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.data[:volume] = nil
-              expect(renderer.evaluates?(item, node)).to be_falsey
-            end
-          end
-
-          describe 'and the any-matcher' do
-            before { node[:match] = 'any' }
-
-            it 'returns false unless the item has any of the variables' do
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.data[:volume] = 1
-              expect(renderer.evaluates?(item, node)).to be_truthy
-
-              item.data[:issue] = 1
-              expect(renderer.evaluates?(item, node)).to be_truthy
-              
-              item.data[:volume] = nil
-              expect(renderer.evaluates?(item, node)).to be_truthy
-            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
-                expect(renderer.evaluates?(item, node)).to be_truthy
-
-                item.data[:volume] = 1
-                expect(renderer.evaluates?(item, node)).to be_truthy
-
-                item.data[:issue] = 1
-                expect(renderer.evaluates?(item, node)).to be_truthy
-
-                item.data[:volume] = nil
-                expect(renderer.evaluates?(item, node)).to be_falsey
-              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
-              expect(renderer.evaluates?(item, node)).to be_truthy
-
-              item.data[:volume] = 1
-              expect(renderer.evaluates?(item, node)).to be_falsey
-
-              item.data[:issue] = 1
-              expect(renderer.evaluates?(item, node)).to be_falsey
-              
-              item.data[:volume] = nil
-              expect(renderer.evaluates?(item, node)).to be_falsey
-            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
-                expect(renderer.evaluates?(item, node)).to be_falsey
-
-                item.data[:volume] = 1
-                expect(renderer.evaluates?(item, node)).to be_falsey
-
-                item.data[:issue] = 1
-                expect(renderer.evaluates?(item, node)).to be_falsey
-
-                item.data[:volume] = nil
-                expect(renderer.evaluates?(item, node)).to be_truthy
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-end