citeproc-ruby 1.1.8 → 1.1.10

data/features/step_definitions/engine.rb

@@ -1,21 +0,0 @@
-Given(/^the following style:$/) do |string|
-  @style = CSL::Style.parse!(string)
-end
-
-Given(/^the "(.*?)" style$/) do |style|
-  @style = CSL::Style.load(style)
-end
-
-When(/^I (cite|reference) the following items as "(.*?)":$/) do |mode, format, items|
-  processor = CiteProc::Processor.new :style => @style, format: format, locale: @locale
-  mode = if mode == 'cite' then :citation else :bibliography end
-
-  processor.import items.hashes.map.with_index { |data, idx|
-    data[:id] = "ID-#{idx}"
-    data
-  }
-
-  @results = processor.items.keys.map { |id|
-    processor.render mode, :id => id
-  }.flatten
-end

data/features/step_definitions/renderer.rb

@@ -1,85 +0,0 @@
-
-Given(/^the "(.*?)" style's (bibliography|citation) node$/) do |style, mode|
-  @node = CSL::Style.load(style).send(mode).layout
-end
-
-Given(/^the following style node:$/) do |string|
-  @node = CSL.parse!(string, CSL::Style)
-end
-
-Given(/^the following sort keys:$/) do |string|
-  @sort = CSL.parse!(string, CSL::Style)
-end
-
-Given(/^the following macro:$/) do |string|
-  @macro = CSL.parse!(string, CSL::Style)
-end
-
-Given(/^the "(.*?)" locale$/) do |locale|
-  @locale = locale
-end
-
-When(/^I render the following citation items as "(.*?)":$/) do |format, items|
-  @locale ||= 'en'
-  r = CiteProc::Ruby::Renderer.new(:format => format, :locale => @locale)
-
-  @results = items.hashes.map.with_index do |data, idx|
-    i = CiteProc::CitationItem.new(:id => "ID-#{idx}")
-
-    data[:id] = "ID-#{idx}"
-    i.data = CiteProc::Item.new(data)
-
-    r.render i, @node
-  end
-end
-
-When(/^I render the following citation item as "(.*?)":$/) do |format, item|
-  r = CiteProc::Ruby::Renderer.new(:format => format)
-
-  i = CiteProc::CitationItem.new(:id => 'ID-1')
-  i.data = CiteProc::Item.new(item.rows_hash.merge(:id => 'ID-1'))
-
-  @result = r.render i, @node
-end
-
-When(/^I sort the following items:$/) do |items|
-  engine = CiteProc::Ruby::Engine.new
-
-  @order = items.hashes.map.with_index do |data, idx|
-    data[:id] = "ID-#{idx}"
-    CiteProc::Item.new(data)
-  end
-
-  unless @macro.nil?
-    @sort.each_child do |key|
-      allow(key).to receive(:macro).and_return(@macro)
-      allow(key).to receive(:macro?).and_return(true)
-    end
-  end
-
-  engine.sort! @order, @sort.children
-end
-
-Then(/^the results should be:$/) do |expected|
-  expected = expected.raw.map(&:first)
-
-  expect(@results.length).to eq(expected.length)
-
-  @results.zip(expected).each do |result, expectation|
-    expect(result).to eq(expectation)
-  end
-end
-
-Then(/^the result should be: (.*)$/) do |expected|
-  expect(@result).to eq(expected)
-end
-
-Then(/^the order should be:$/) do |expected|
-  expected = expected.raw.map(&:first)
-
-  expect(@order.length).to eq(expected.length)
-
-  @order.zip(expected).each do |order, expectation|
-    expect(order['id']).to eq(expectation)
-  end
-end

data/features/style_immanent_locale_terms.feature

@@ -1,30 +0,0 @@
-Feature: Rendering bibliography nodes
-  As a hacker of cite processors
-  I want to render citation items
-  Using bibliography nodes
-
-  Scenario: Rendering APA style bibliographies as text in English
-    Given the "apa-with-different-translations" style
-    When I reference the following items as "text":
-      | type            | author           | title                 | issued       | translator  |
-      | book            | Thomas Pynchon   | The crying of lot 49  | July 7, 2006 | Harald Hard |
-    Then the results should be:
-      | Pynchon, T. (2006). The crying of lot 49. (H. Hard, Who translated this piece on her/his own). |
-
-  Scenario: Rendering APA style bibliographies as text in French
-    Given the "apa-with-different-translations" style
-    Given the "fr" locale
-    When I reference the following items as "text":
-      | type            | author           | title                 | issued       | translator  |
-      | book            | Thomas Pynchon   | The crying of lot 49  | July 7, 2006 | Harald Hard |
-    Then the results should be:
-      | Pynchon, T. (2006). The crying of lot 49. (H. Hard, Le merveilleux traducteur). |
-
-  Scenario: Rendering APA style bibliographies as text in German (a language where the style has no explicit terms for)
-    Given the "apa-with-different-translations" style
-    Given the "de" locale
-    When I reference the following items as "text":
-      | type            | author           | title                 | issued       | translator  |
-      | book            | Thomas Pynchon   | The crying of lot 49  | July 7, 2006 | Harald Hard |
-    Then the results should be:
-      | Pynchon, T. (2006). The crying of lot 49. (H. Hard, Übers.). |

data/features/support/env.rb

@@ -1,35 +0,0 @@
-begin
-  require 'simplecov'
-  require 'coveralls' if ENV['CI']
-rescue LoadError
-  # ignore
-end
-
-begin
-  case
-  when RUBY_PLATFORM < 'java'
-    require 'debug'
-    Debugger.start
-  when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-    require 'rubinius/debugger'
-  when RUBY_VERSION < '2.0'
-    require 'debugger'
-  else
-    require 'byebug'
-  end
-rescue LoadError
-  # ignore
-end
-
-require 'rspec/mocks/standalone'
-require 'citeproc/ruby'
-
-module Fixtures
-	PATH = File.expand_path('../../../spec/fixtures', __FILE__)
-
-	Dir[File.join(PATH, '*.rb')].each do |fixture|
-		require fixture
-	end
-end
-
-World(Fixtures)

data/features/support/hooks.rb

@@ -1,10 +0,0 @@
-Before do
-  @style_root, @locale_root = CSL::Style.root, CSL::Locale.root
-
-  CSL::Style.root  = File.join(Fixtures::PATH, 'styles')
-  CSL::Locale.root = File.join(Fixtures::PATH, 'locales')
-end
-
-After do
-  CSL::Style.root, CSL::Locale.root = @style_root, @locale_root
-end

data/spec/citeproc/ruby/engine_spec.rb

@@ -1,120 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-  describe 'The CiteProc-Ruby Engine' do
-    let(:cp) { CiteProc::Processor.new :style => 'apa', :format => 'text' }
-    let(:engine) { cp.engine }
-
-    it 'registers itself as "citeproc-ruby"' do
-      expect(CiteProc::Engine.available).to include('citeproc-ruby')
-    end
-
-    it 'is the default engine' do
-      expect(CiteProc::Engine.default).to equal(CiteProc::Ruby::Engine)
-      expect(engine).to be_a(CiteProc::Ruby::Engine)
-    end
-
-    describe '#bibliography' do
-
-      describe 'when there are no items in the processor' do
-        it 'returns an empty bibliography for any selector' do
-          expect(cp.bibliography()).to be_empty
-          expect(cp.bibliography(:all => {})).to be_empty
-          expect(cp.bibliography(:none => {})).to be_empty
-        end
-      end
-      describe 'should order entries correctly' do
-        describe 'mla 8' do
-          let(:cp_mla) { CiteProc::Processor.new :style => 'modern-language-association-8th-edition', :format => 'html' }
-          before(:each) do
-            cp_mla << items(:aaron2).data
-            cp_mla << items(:abbott).data
-            cp_mla << items(:knuth1968).data
-          end
-
-          it 'should not add quotes around text items when rendering for sorting purposes' do
-            cp_bib1_hash = cp_mla.bibliography.to_citeproc
-            bib_entries = cp_bib1_hash[1]
-            expect(bib_entries[0]).to start_with('Aaron')
-            # no author specified on Abbott.  In MLA8 title is a substitute for name, thus it was being rendered in text
-            # format to get a sortable value for author.  This produced a string starting with a quote character which
-            # messed up sorting.  Have created a special sort format which is overridden to not inject these quotes.
-            # may be other things that could be prevented here (suffix/prefix) but I haven't run across them yet
-            expect(bib_entries[1]).to start_with('“Abbott')
-            expect(bib_entries[2]).to start_with('Knuth')
-          end
-        end
-      end
-    end
-
-    describe '#render' do
-
-      describe 'when there are no items in the processor' do
-      end
-
-      describe 'when there are items in the processor' do
-        before(:each) do
-          cp << items(:grammatology).data
-          cp << items(:knuth1968).data
-          cp << items(:difference).data
-          cp << items(:literal_date).data
-        end
-
-        it 'renders the reference for the given id' do
-          expect(cp.render(:bibliography, :id => 'grammatology')).to eq(['Derrida, J. (1976). Of Grammatology (corrected ed.). Baltimore: Johns Hopkins University Press.'])
-          expect(cp.render(:citation, :id => 'grammatology', :locator => '3-4')).to eq('(Derrida, 1976, pp. 3-4)')
-          expect(cp.render(:bibliography, :id => 'knuth1968')).to eq(['Knuth, D. (1968). The art of computer programming (Vol. 1). Boston: Addison-Wesley.'])
-
-          node = cp.engine.style.macros['author']
-          (node > 'names' > 'name')[:initialize] = 'false'
-
-          cp.engine.format = 'html'
-          expect(cp.render(:bibliography, :id => 'knuth1968')).to eq(['Knuth, Donald. (1968). <i>The art of computer programming</i> (Vol. 1). Boston: Addison-Wesley.'])
-
-          expect(cp.render(:citation, :id => 'knuth1968', :locator => '23')).to eq('(Knuth, 1968, p. 23)')
-        end
-
-        it 'overrides locales if the processor option is set' do
-          expect(cp.render(:bibliography, :id => 'difference')).to eq(['Derrida, J. (1967). L’écriture et la différence (1st ed.). Paris: Éditions du Seuil.'])
-
-          cp.options[:allow_locale_overrides] = true
-          expect(cp.render(:bibliography, :id => 'difference')).to eq(['Derrida, J. (1967). L’écriture et la différence (1ʳᵉ éd.). Paris: Éditions du Seuil.'])
-        end
-
-        it 'can handle literal dates' do
-          expect(cp.render(:bibliography, :id => 'literal_date')).to eq(['Derrida, J. (sometime in 1967). L’écriture et la différence (1st ed.). Paris: Éditions du Seuil.'])
-        end
-      end
-    end
-
-    describe '#process' do
-      describe 'when there are no items in the processor' do
-      end
-
-      describe 'when there are items in the processor' do
-        before(:each) do
-          cp << items(:grammatology).data
-          cp << items(:knuth1968).data
-        end
-
-        it 'renders the citation for the given id' do
-          expect(cp.process(:id => 'knuth1968', :locator => '23')).to eq('(Knuth, 1968, p. 23)')
-        end
-
-        it 'combines and sorts multiple cite items' do
-          expect(cp.process([
-            {:id => 'knuth1968', :locator => '23'},
-            {:id => 'grammatology', :locator => '11-14'}
-          ])).to eq('(Derrida, 1976, pp. 11-14; Knuth, 1968, p. 23)')
-        end
-      end
-    end
-
-  end
-
-  end
-end

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

@@ -1,168 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module CiteProc
-  module Ruby
-
-    describe 'Formats::Text#apply' do
-      let(:format) { Format.load 'text' }
-      let(:node) { CSL::Style::Text.new }
-
-      it 'returns an empty string if input is nil' do
-        expect(format.apply(nil, node)).to eq('')
-      end
-
-      it 'returns the string unchanged if empty' do
-        input = ''
-        expect(format.apply(input, node)).to be_equal(input)
-        expect(input).to eq('')
-      end
-
-      it 'returns the string unchanged if node is nil' do
-        input = 'foo'
-        expect(format.apply(input, nil)).to be_equal(input)
-        expect(input).to eq('foo')
-      end
-
-      it 'supports localized quotes' do
-        locale = double(:locale)
-        allow(locale).to receive(:punctuation_in_quotes?).and_return(true)
-        allow(locale).to receive(:quote).and_return('bar')
-
-        node[:quotes] = true
-
-        expect(format.apply('foo', node, locale)).to eq('bar')
-      end
-
-      it 'disregards localized closing quotes when squeezing affixes' do
-        locale = double(:locale)
-        allow(locale).to receive(:punctuation_in_quotes?).and_return(true)
-        allow(locale).to receive(:quote) { |t| '"' << t << '"' }
-        allow(locale).to receive(:t) { |t| t == 'close-quote' ? '"' : "'" }
-
-        node[:quotes] = true
-        node[:suffix] = '.'
-
-        expect(format.apply('foo', node, locale)).to eq('"foo."')
-        expect(format.apply("'foo'", node, locale)).to eq("\"'foo.'\"")
-      end
-
-      describe 'text-case formats' do
-        it 'supports lowercase' do
-          node[:'text-case'] = 'lowercase'
-          expect(format.apply('Foo BAR', node)).to eq('foo bar')
-        end
-
-        it 'supports lowercase for non-ascii letters' do
-          node[:'text-case'] = 'lowercase'
-          expect(format.apply('SCHÖN!', node)).to eq('schön!')
-        end
-
-        it 'supports uppercase' do
-          node[:'text-case'] = 'uppercase'
-          expect(format.apply('Foo BAR', node)).to eq('FOO BAR')
-        end
-
-        it 'supports uppercase for non-ascii letters' do
-          node[:'text-case'] = 'uppercase'
-          expect(format.apply('schön!', node)).to eq('SCHÖN!')
-        end
-
-        it 'does not alter the original string' do
-          node[:'text-case'] = 'lowercase'
-          input = 'fooBar'
-
-          expect(format.apply(input, node)).to eq('foobar')
-          expect(input).to eq('fooBar')
-        end
-
-        it 'supports capitalize-first' do
-          node[:'text-case'] = 'capitalize-first'
-
-          expect(format.apply('foo bar', node)).to eq('Foo bar')
-          expect(format.apply('Foo bar', node)).to eq('Foo bar')
-          expect(format.apply('!foo bar', node)).to eq('!Foo bar')
-          expect(format.apply('én foo bar', node)).to eq('Én foo bar')
-        end
-
-        it 'supports capitalize-all' do
-          node[:'text-case'] = 'capitalize-all'
-
-          expect(format.apply('foo bar', node)).to eq('Foo Bar')
-          expect(format.apply('!foo bar', node)).to eq('!Foo Bar')
-          expect(format.apply('én foo bar', node)).to eq('Én Foo Bar')
-        end
-
-        it 'supports sentence case' do
-          node[:'text-case'] = 'sentence'
-
-          expect(format.apply('FOO bar', node)).to eq('Foo bar')
-          expect(format.apply('foo Bar BAR', node)).to eq('Foo Bar Bar')
-          expect(format.apply('én Foo bar', node)).to eq('Én Foo bar')
-        end
-
-        it 'supports title case' do
-          node[:'text-case'] = 'title'
-
-          expect(format.apply('The adventures of Huckleberry Finn', node)).to eq('The Adventures of Huckleberry Finn')
-          expect(format.apply('This IS a pen that is a smith pencil', node)).to eq('This IS a Pen That Is a Smith Pencil')
-          expect(format.apply('of mice and men', node)).to eq('Of Mice and Men')
-          expect(format.apply('history of the word the', node)).to eq('History of the Word The')
-          expect(format.apply('faster than the speed of sound', node)).to eq('Faster than the Speed of Sound')
-          expect(format.apply('on the drug-resistance of enteric bacteria', node)).to eq('On the Drug-Resistance of Enteric Bacteria')
-          expect(format.apply("The Mote in God's eye", node)).to eq("The Mote in God's Eye")
-          expect(format.apply("The Mote in God eye", node)).to eq("The Mote in God Eye")
-          expect(format.apply("Music community mourns death of one of its leaders", node)).to eq("Music Community Mourns Death of One of Its Leaders")
-          expect(format.apply("Pride and Prejudice", node)).to eq("Pride and Prejudice")
-          expect(format.apply("Check the page: easybib.com", node)).to eq("Check the Page: Easybib.com")
-          expect(format.apply("Dogs life.obviously the best guide for pet owners", node)).to eq("Dogs Life.obviously the Best Guide for Pet Owners")
-        end
-      end
-
-      describe 'strip-periods' do
-        before { node[:'strip-periods'] = true }
-
-        it 'strips all periods from the output' do
-          expect(format.apply('hello there...! how.are.you?', node)).to eq('hello there! howareyou?')
-          expect(format.apply('foo bar!', node)).to eq('foo bar!')
-        end
-
-        it 'does not strip periods from affixes' do
-          node[:prefix] = '...('
-          node[:suffix] = ').'
-
-          expect(format.apply('foo.bar.', node)).to eq('...(foobar).')
-        end
-      end
-
-      describe 'affixes' do
-        it 'are added after text formats have been applied' do
-          node[:prefix] = 'foo'
-          node[:suffix] = 'ooo'
-          node[:'text-case'] = 'uppercase'
-
-          expect(format.apply('ooo', node)).to eq('fooOOOooo')
-        end
-
-        it 'drop squeezable characters at start/end' do
-          node[:suffix] = ' '
-
-          expect(format.apply('foo', node)).to eq('foo ')
-          expect(format.apply('foo ', node)).to eq('foo ')
-
-          node[:suffix] = '. '
-          expect(format.apply('foo', node)).to eq('foo. ')
-          expect(format.apply('foo.', node)).to eq('foo. ')
-          expect(format.apply('foo?', node)).to eq('foo? ')
-
-          node[:prefix] = '.'
-          expect(format.apply('foo', node)).to eq('.foo. ')
-          expect(format.apply('.foo', node)).to eq('.foo. ')
-          expect(format.apply(',foo', node)).to eq('.,foo. ')
-        end
-      end
-    end
-
-  end
-end