citeproc-ruby 0.0.6 → 1.0.0

data/features/renderer.feature

@@ -0,0 +1,74 @@
+Feature: Rendering CSL nodes
+  As a hacker of cite processors
+  I want to render citation items
+  With selected CSL nodes
+
+  Scenario: Simple Date Rendering
+    Given the following style node:
+      """
+      <date variable="issued">
+        <date-part name="year"/>
+      </date>
+      """
+    When I render the following citation items as "text":
+      | issued           |
+      | November 7, 2006 |
+      | 2014-01-01       |
+      | 1999             |
+    Then the results should be:
+      | 2006             |
+      | 2014             |
+      | 1999             |
+
+  Scenario: Date Group Rendering
+    Given the following style node:
+      """
+      <group prefix="(" suffix=").">
+        <date variable="issued">
+          <date-part name="year"/>
+        </date>
+        <text variable="year-suffix"/>
+      </group>
+      """
+    When I render the following citation items as "text":
+      | issued           | year-suffix |
+      | November 7, 2006 |             |
+      | 2014-01-01       |             |
+      | 1999             | a           |
+    Then the results should be:
+      | (2006).          |
+      | (2014).          |
+      | (1999a).         |
+
+  @html @formatting
+  Scenario: Formatted Groups
+    Given the following style node:
+      """
+      <group>
+        <group suffix=" " font-weight="bold">
+          <!--group formatting is pushed down-->
+          <text variable="volume" suffix=","/>
+        </group>
+        <text variable="page" suffix="," font-weight="bold"/>
+      </group>
+      """
+    When I render the following citation item as "html":
+      | volume |   5 |
+      | page   |  23 |
+    Then the result should be: <b>5</b>, <b>23</b>,
+
+  Scenario: Page labels
+    Given the following style node:
+      """
+      <label variable="page"/>
+      """
+    When I render the following citation items as "text":
+      | page   |
+      | 23     |
+      |        |
+      | 23, 34 |
+    Then the results should be:
+      | page   |
+      |        |
+      | pages  |
+

data/features/sort.feature

@@ -0,0 +1,50 @@
+Feature: Sorting
+  As a hacker of cite processors
+  I want to sort citation items
+  According to the rules of a CSL style
+
+  Scenario: Name sorting
+    Given the following sort keys:
+      """
+      <sort>
+        <key variable="author"/>
+      </sort>
+      """
+    When I sort the following items:
+      | author    |
+      | Edelweis  |
+      | ANZ-Group |
+      | Aardvaark |
+    Then the order should be:
+      | ID-2      |
+      | ID-1      |
+      | ID-0      |
+
+  Scenario: Name sorting macros
+    Given the following sort keys:
+      """
+      <sort>
+        <key macro="author"/>
+      </sort>
+      """
+    And the following macro:
+      """
+      <macro name="author">
+        <names variable="author">
+          <name name-as-sort-order="all" and="symbol" sort-separator=", "
+                initialize-with="." delimiter-precedes-last="never" delimiter=", "/>
+          <label form="short" prefix=" (" suffix=".)" text-case="capitalize-first"/>
+          <substitute>
+            <names variable="editor"/>
+            <text value="Anon"/>
+          </substitute>
+        </names>
+      </macro>
+      """
+    When I sort the following items:
+      | author    |
+      | ABC       |
+      | Aaa       |
+    Then the order should be:
+      | ID-1      |
+      | ID-0      |

data/features/step_definitions/renderer.rb

@@ -0,0 +1,80 @@
+
+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
+
+When(/^I render the following citation items as "(.*?)":$/) do |format, items|
+  r = CiteProc::Ruby::Renderer.new(:format => format)
+
+  @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|
+      key.stub(:macro).and_return(@macro)
+      key.stub(:macro?).and_return(true)
+    end
+  end
+
+  engine.sort! @order, @sort.children
+end
+
+Then(/^the results should be:$/) do |expected|
+  expected = expected.raw.map(&:first)
+
+  @results.length.should == expected.length
+
+  @results.zip(expected).each do |result, expectation|
+    result.should == expectation
+  end
+end
+
+Then(/^the result should be: (.*)$/) do |expected|
+  @result.should == expected
+end
+
+Then(/^the order should be:$/) do |expected|
+  expected = expected.raw.map(&:first)
+
+  @order.length.should == expected.length
+
+  @order.zip(expected).each do |order, expectation|
+    order['id'].should == expectation
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,33 @@
+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'
+  else
+    require 'debugger'
+  end
+rescue LoadError
+  # ignore
+end
+
+require 'cucumber/rspec/doubles'
+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

@@ -0,0 +1,10 @@
+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/lib/citeproc/ruby.rb

@@ -0,0 +1,32 @@
+require 'observer'
+
+require 'csl'
+require 'citeproc'
+
+require 'citeproc/ruby/version'
+
+require 'citeproc/ruby/format'
+
+require 'citeproc/ruby/formats/default'
+require 'citeproc/ruby/formats/html'
+
+require 'citeproc/ruby/renderer'
+
+require 'citeproc/ruby/renderer/locale'
+require 'citeproc/ruby/renderer/format'
+require 'citeproc/ruby/renderer/observer'
+require 'citeproc/ruby/renderer/state'
+require 'citeproc/ruby/renderer/history'
+
+require 'citeproc/ruby/renderer/text'
+require 'citeproc/ruby/renderer/number'
+require 'citeproc/ruby/renderer/label'
+require 'citeproc/ruby/renderer/date'
+require 'citeproc/ruby/renderer/names'
+require 'citeproc/ruby/renderer/layout'
+require 'citeproc/ruby/renderer/macro'
+require 'citeproc/ruby/renderer/group'
+require 'citeproc/ruby/renderer/choose'
+
+require 'citeproc/ruby/sort.rb'
+require 'citeproc/ruby/engine.rb'

data/lib/citeproc/ruby/engine.rb

@@ -0,0 +1,122 @@
+module CiteProc
+  module Ruby
+
+    class Engine < CiteProc::Engine
+
+      include SortItems
+
+      @name = 'citeproc-ruby'.freeze
+      @type = 'CSL'.freeze
+      @version = CSL::Schema.version
+      @priority = 1
+
+      attr_reader :renderer, :style
+
+      def_delegators :renderer,
+        :format, :format=, :locale, :locale=
+
+      def initialize(*arguments)
+        super(*arguments)
+        @renderer = Renderer.new(self)
+
+        update! unless processor.nil?
+      end
+
+      def style=(new_style)
+        @style = CSL::Style.load new_style
+      end
+
+      def process(data)
+        node = style.citation
+
+        return unless node
+        return '' if data.empty?
+
+        # populate item data
+        data.each do |item|
+          item.data = processor[item.id].dup
+        end
+
+        # TODO implement sort in citation data
+        sort!(data, node.sort_keys) unless !node.sort?
+
+        # TODO citation number (after sorting?)
+
+        renderer.render_citation data, node
+      end
+
+      def append
+        raise NotImplementedByEngine
+      end
+
+      def bibliography(selector)
+        node = style.bibliography
+        return unless node
+
+        selection = processor.data.select do |item|
+          selector.matches?(item) && !selector.skip?(item)
+        end
+
+        sort!(selection, node.sort_keys) unless selection.empty? || !node.sort?
+
+        Bibliography.new(node.bibliography_options) do |bib|
+          format.bibliography(bib)
+
+          idx = 1
+
+          selection.each do |item|
+            begin
+              bib.push item.id, renderer.render_bibliography(item.cite(idx), node)
+            rescue => error
+              bib.errors << [item.id.to_s, error]
+            ensure
+              idx += 1 unless error
+            end
+          end
+        end
+      end
+
+      def update_items
+        raise NotImplementedByEngine
+      end
+
+      def update_uncited_items
+        raise NotImplementedByEngine
+      end
+
+      # @return [String, Array<String>]
+      def render(mode, data)
+        case mode
+        when :bibliography
+          node = style.bibliography
+
+          data.map do |item|
+            item.data = processor[item.id].dup
+            renderer.render item, node
+          end
+
+        when :citation
+          node = style.citation
+
+          data.each do |item|
+            item.data = processor[item.id].dup
+          end
+
+          renderer.render_citation data, node
+
+        else
+          raise ArgumentError, "cannot render unknown mode: #{mode.inspect}"
+        end
+      end
+
+
+      def update!
+        renderer.format = processor.options[:format]
+        renderer.locale = processor.options[:locale]
+
+        @style = CSL::Style.load processor.options[:style]
+      end
+
+    end
+  end
+end

data/lib/citeproc/ruby/format.rb

@@ -0,0 +1,303 @@
+# -*- encoding: utf-8 -*-
+
+module CiteProc
+  module Ruby
+
+    class Format
+
+      @available = []
+
+      @squeezable = /^[\s\.,:;!?\)\(\[\]]+$/
+
+      @stopwords = {
+        :en => [
+          'about', 'above', 'across', 'afore', 'after', 'against', 'along',
+          'alongside', 'amid', 'amidst', 'among', 'amongst', 'anenst', 'apropos',
+          'apud', 'around', 'as', 'aside', 'astride', 'at', 'athwart', 'atop',
+          'barring', 'before', 'behind', 'below', 'beneath', 'beside', 'besides',
+          'between', 'beyond', 'but', 'by', 'circa', 'despite', 'd', 'down', 'during',
+          'except', 'for', 'forenenst', 'from', 'given', 'in', 'inside', 'into',
+          'lest', 'like', 'modulo' 'near', 'next', 'notwithstanding', 'of', 'off',
+          'on', 'onto', 'out', 'over', 'per', 'plus', 'pro', 'qua', 'sans', 'since',
+          'than', 'through', 'thru', 'throughout', 'thruout', 'till', 'to', 'toward',
+          'towards', 'under', 'underneath', 'until', 'unto', 'up', 'upon', 'versus',
+          'vs', 'v', 'via', 'vis-à-vis', 'with', 'within', 'without'
+        ]
+      }
+
+      class << self
+        attr_reader :available, :stopwords
+
+        def inherited(base)
+          Format.available << base
+        end
+
+        def load(name = nil)
+          return new unless name
+          return name if name.is_a?(Format)
+
+          name = name.to_s.downcase
+
+          klass = available.detect do |format|
+            format.name.split('::')[-1].downcase == name
+          end
+
+          raise(Error, "unknown format: #{name}") unless klass
+
+          klass.new
+        end
+
+        def stopword?(word, locale = :en)
+          return unless stopwords.key?(locale)
+          stopwords[locale].include?(word.downcase)
+        end
+
+        def squeezable?(string)
+          squeezable === string
+        end
+
+        def squeezable
+          @squeezable ||= Format.squeezable
+        end
+      end
+
+      attr_reader :locale
+
+      def keys
+        @keys ||= (CSL::Schema.attr(:formatting) - [:prefix, :suffix, :display])
+      end
+
+      def squeezable?(string)
+        self.class.squeezable?(string)
+      end
+
+      def squeeze_suffix(string, suffix)
+        raise ArgumentError unless string.is_a?(::String)
+        raise ArgumentError unless suffix.is_a?(::String)
+
+        return string.dup if suffix.empty?
+        return suffix.dup if string.empty?
+
+        string, stripped = strip(string)
+        string, quotes = split_closing_quotes(string)
+
+        suffix = decode_entities(suffix)
+
+        suffix = suffix.each_char.drop_while.with_index { |c, i|
+          squeezable?(c) && string.end_with?(suffix[0, i + 1])
+        }.join('')
+
+        # Handle special cases like ?. or ;.
+        if suffix.start_with?('.') && string.end_with?(';', ',', '!', '?', ':')
+          suffix = suffix[1..-1]
+        end
+
+        # Handle special cases ;, and :,
+        if suffix.start_with?(',') && string.end_with?(';', ':')
+          suffix = suffix[1..-1]
+        end
+
+        # Handle special cases ,; and :;
+        if suffix.start_with?(';') && string.end_with?(',', ':')
+          suffix = suffix[1..-1]
+        end
+
+        # Handle punctiation-in-quote
+        if !quotes.nil? && punctuation_in_quotes?
+          if suffix.sub!(/^([\.,])/, '')
+            punctuation = ($1).to_s
+          end
+        end
+
+        "#{string}#{punctuation}#{quotes}#{stripped}#{suffix}"
+      end
+
+      def squeeze_prefix(string, prefix)
+        raise ArgumentError unless string.is_a?(::String)
+        raise ArgumentError unless prefix.is_a?(::String)
+
+        prefix = prefix.reverse.each_char.drop_while.with_index { |c, i|
+          squeezable?(c) && string.start_with?(prefix[-(i + 1) .. -1])
+        }.join('').reverse
+
+        "#{prefix}#{string}"
+      end
+
+      alias concat squeeze_suffix
+
+      def join(list, delimiter = nil)
+        raise ArgumentError unless list.is_a?(Enumerable)
+        return '' if list.length.zero?
+        return list[0] if list.length == 1
+
+        if delimiter.nil? || delimiter.empty?
+          list.inject do |m, n|
+            concat(m, n)
+          end
+        else
+          list.inject do |m, n|
+            concat(concat(m, delimiter), n)
+          end
+        end
+      end
+
+      def bibliography(bibliography, locale = nil)
+        bibliography.connector = "\n" * bibliography.entry_spacing
+        bibliography
+      end
+
+      def apply(input, node, locale = nil)
+        return '' if input.nil?
+        return input if input.empty? || node.nil?
+
+        return ArgumentError unless node.respond_to?(:formatting_options)
+
+
+        @input, @output, @node, @locale = input, input.dup, node, locale
+
+        setup!
+
+        # NB: Layout nodes apply formatting to
+        # affixes; all other nodes do not!
+        if node.is_a? CSL::Style::Layout
+          apply_prefix if options.key?(:prefix)
+          apply_suffix if options.key?(:suffix)
+        end
+
+        keys.each do |format|
+          if options.key?(format)
+            method = "apply_#{format}".tr('-', '_')
+            send method if respond_to?(method)
+          end
+        end unless options.empty?
+
+        output.gsub!(/\.+/, '') if node.strip_periods?
+
+        apply_quotes if node.quotes? && !locale.nil?
+
+        finalize_content!
+
+        unless node.is_a? CSL::Style::Layout
+          apply_prefix if options.key?(:prefix)
+          apply_suffix if options.key?(:suffix)
+        end
+
+        apply_display if options.key?(:display)
+
+        finalize!
+
+        output
+      ensure
+        cleanup!
+      end
+
+      def escape_quotes?
+        false
+      end
+
+      def close_quote
+        locale && locale.t('close-quote') ||  '"'
+      end
+
+      def close_inner_quote
+        locale && locale.t('close-inner-quote') || "'"
+      end
+
+      def split_closing_quotes(string)
+        string.split(/([#{close_inner_quote}#{close_quote}]+)$/, 2)
+      end
+
+      def apply_quotes
+        output.replace locale.quote(output, escape_quotes?)
+      end
+
+      def apply_text_case
+        case options[:'text-case']
+        when 'lowercase'
+          output.replace CiteProc.downcase output
+
+        when 'uppercase'
+          output.replace CiteProc.upcase output
+
+        when 'capitalize-first'
+          output.sub!(/^([^\p{L}]*)(\p{Ll})/) { "#{$1}#{CiteProc.upcase($2)}" }
+
+        when 'capitalize-all'
+          output.gsub!(/\b(\p{Ll})/) { CiteProc.upcase($1) }
+
+        when 'sentence'
+          output.sub!(/^([^\p{L}]*)(\p{Ll})/) { "#{$1}#{CiteProc.upcase($2)}" }
+          output.gsub!(/\b(\p{Lu})(\p{Lu}+)\b/) { "#{$1}#{CiteProc.downcase($2)}" }
+
+        when 'title'
+          return if locale && locale.language != :en
+
+          # TODO add support for stop words consisting of multiple words
+          #output.gsub!(/\b(\p{Lu})(\p{Lu}+)\b/) { "#{$1}#{CiteProc.downcase($2)}" }
+
+          # TODO exceptions: first, last word; followed by colon
+          output.gsub!(/\b(\p{Ll})(\p{L}+)\b/) do |word|
+            if Format.stopword?(word)
+              word
+            else
+              "#{CiteProc.upcase($1)}#{$2}"
+            end
+          end
+
+        end
+      end
+
+      def punctuation_in_quotes?
+        !locale.nil? && locale.punctuation_in_quotes?
+      end
+
+      def apply_prefix
+        output.replace(squeeze_prefix(output, prefix))
+      end
+
+      def apply_suffix
+        output.replace(squeeze_suffix(output, suffix))
+      end
+
+      def prefix
+        options[:prefix].to_s
+      end
+
+      def suffix
+        options[:suffix].to_s
+      end
+
+      def strip(string)
+        string
+      end
+
+      protected
+
+      attr_reader :input, :output, :node
+
+      def options
+        @options ||= @node.formatting_options
+      end
+
+      def finalize!
+      end
+
+      def finalize_content!
+      end
+
+      def setup!
+      end
+
+      def decode_entities(string)
+        string.gsub(/&#x([0-9a-f]);/i) do
+          [Integer("0x#{$1}")].pack('U')
+        end
+      end
+
+      def cleanup!
+        @input, @output, @node, @options = nil
+      end
+    end
+
+  end
+end