citeproc-ruby 0.0.6 → 1.0.0

data/lib/citeproc/ruby/renderer/number.rb

@@ -0,0 +1,41 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Number]
+      # @return [String]
+      def render_number(item, node)
+        return '' unless node.has_variable?
+
+        variable = item.data[node.variable]
+        return variable.to_s unless variable && variable.numeric?
+
+        numbers = variable.tokenize
+
+        case
+        when node.ordinal? || node.long_ordinal?
+          options = node.attributes_for :form
+          # TODO lookup term of variable to check gender
+
+          numbers.map! do |num|
+            num =~ /^\d+$/ ? ordinalize(num, options) : num
+          end
+
+        when node.roman?
+          numbers.map! do |num|
+            num =~ /^\d+$/ ? romanize(num) : num
+          end
+
+        else
+					# nothing
+        end
+
+				numbers.join('')
+      end
+
+    end
+
+  end
+end

data/lib/citeproc/ruby/renderer/observer.rb

@@ -0,0 +1,44 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      class ItemObserver
+        attr_accessor :history, :item
+
+        def initialize(item, history = {})
+          @item, @history = item, history
+        end
+
+        def start
+          item.add_observer(self)
+          self
+        end
+
+        def stop
+          item.delete_observer(self)
+          self
+        end
+
+        def update(method, key, value)
+          history[key] = value if method == :read
+        end
+
+        def skip?
+          !history.empty? && history.values.all?(&:nil?)
+        end
+
+        def accessed
+          history.select { |key, value| !value.nil? }.keys
+        end
+
+        def clear!
+          history.clear
+          self
+        end
+      end
+
+    end
+
+  end
+end

data/lib/citeproc/ruby/renderer/state.rb

@@ -0,0 +1,96 @@
+module CiteProc
+  module Ruby
+    class Renderer
+
+      def citation_mode?
+        state.mode == 'citation'
+      end
+
+      def bibliography_mode?
+        state.mode == 'bibliography'
+      end
+
+      def sort_mode?
+        state.mode == 'key'
+      end
+
+      def substitution_mode?
+        !state.substitute.nil?
+      end
+
+      def style
+        return unless state.node && !state.node.root? &&
+          state.node.root.is_a?(CSL::Style)
+
+        state.node.root
+      end
+
+      class State
+        include Observable
+
+        attr_reader :history, :node, :item, :authors, :substitute
+
+        def initialize
+          @history, @authors = History.new(self, 3), []
+        end
+
+        def store!(item, node)
+          @item, @node = item, node
+        ensure
+          changed
+        end
+
+        def store_authors!(authors)
+          @authors << authors
+        ensure
+          changed
+        end
+
+        def clear!(result = nil)
+          memories = conserve(result)
+          @item, @node, @substitute, @authors, @names = nil, nil, nil, [], nil
+        ensure
+          changed
+          notify_observers :clear!, memories.delete(:mode), memories
+        end
+
+        def mode
+          node && node.nodename
+        end
+
+        def substitute!(names)
+          @substitute = names
+        end
+
+        def clear_substitute!(backup = nil)
+          @substitute = backup
+        end
+
+        def previous_authors
+          past = history.recall(mode)
+          return unless past && !past.empty?
+
+          past[:authors]
+        end
+
+        def rendered_names?
+          @names
+        end
+
+        def rendered_names!
+          @names = true
+        end
+
+        def conserve(result = nil)
+          {
+            :mode => mode,
+            :item => item,
+            :authors => authors,
+            :result => result
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/citeproc/ruby/renderer/text.rb

@@ -0,0 +1,62 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Text]
+      # @return [String]
+      def render_text(item, node)
+        case
+        when node.has_variable?
+
+          if node.variable == 'locator'
+
+            # Subtle: when there is no locator we also look
+            # in item.data; there should be no locator there
+            # either but the read access will be noticed by
+            # observers (if any).
+            text = item.locator || item.data[:locator].to_s
+
+          else
+            text = item.data.variable(node.variable, node.variable_options).to_s
+
+            # Check for abbreviations or short-form fallbacks!
+            context, was_short_form = node.variable.split(/-short/, 2)
+
+            if was_short_form || node[:form] == 'short'
+              if text.empty?
+                text = item.data.variable(context, node.variable_options).to_s
+              end
+
+              text = abbreviate(context, text) || text
+            end
+          end
+
+
+          case
+          when node.variable == 'page'
+            format_page_range!(text, node.page_range_format)
+
+          when node.variable == 'page-first' && text.empty?
+            text = item.data[:'page'].to_s[/\d+/].to_s
+
+          end
+
+          text
+
+        when node.has_macro?
+          render item, node.macro
+
+        when node.has_term?
+          translate node[:term], node.attributes_for(:plural, :form)
+
+        else
+          node.value.to_s
+        end
+      end
+
+    end
+
+  end
+end

data/lib/citeproc/ruby/sort.rb

@@ -0,0 +1,82 @@
+module CiteProc
+  module Ruby
+
+    module SortItems
+
+      def sort!(items, keys)
+        return itmes unless !keys.nil? && !keys.empty?
+
+        # TODO refactor
+        if items.is_a?(CitationData)
+          items.sort! do |a, b|
+            compare_items_by_keys(a.data, b.data, keys)
+          end
+        else
+          items.sort! do |a, b|
+            compare_items_by_keys(a, b, keys)
+          end
+        end
+      end
+
+      # @returns [-1, 0, 1, nil]
+      def compare_items_by_keys(a, b, keys)
+        result = 0
+
+        keys.each do |key|
+          result = compare_items_by_key(a, b, key)
+          return result unless result.zero?
+        end
+
+        result
+      end
+
+      # @returns [-1, 0, 1, nil]
+      def compare_items_by_key(a, b, key)
+        if key.macro?
+          result = compare_items(*renderer.render_sort(a, b, key.macro, key))
+
+        else
+          va, vb = a[key.variable], b[key.variable]
+
+          # Return early if one side is nil. In this
+          # case ascending/descending is irrelevant!
+          return  1 if va.nil? || va.empty?
+          return -1 if vb.nil? || va.empty?
+
+          result = case CiteProc::Variable.types[key.variable]
+            when :names
+              node = CSL::Style::Name.new(key.name_options)
+              node.all_names_as_sort_order!
+
+              compare_items(*renderer.render_sort(va, vb, node, key))
+
+            when :date
+              va <=> vb
+            when :number
+              va <=> vb
+            else
+              compare_items(va, vb)
+            end
+        end
+
+        result = -result unless key.ascending?
+        result
+      end
+
+      def compare_items(a, b)
+        if sort_case_sensitively?
+          a <=> b
+        else
+          a.to_s.downcase <=> b.to_s.downcase
+        end
+      end
+
+      def sort_case_sensitively?
+        return false unless processor && processor.options
+        processor.options[:sort_case_sensitively]
+      end
+
+    end
+
+  end
+end

data/lib/citeproc/ruby/version.rb

@@ -0,0 +1,5 @@
+module CiteProc
+  module Ruby
+    VERSION = '1.0.0'
+  end
+end

data/spec/citeproc/ruby/engine_spec.rb

@@ -0,0 +1,94 @@
+# -*- 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
+      CiteProc::Engine.available.should include('citeproc-ruby')
+    end
+
+    it 'is the default engine' do
+      CiteProc::Engine.default.should equal(CiteProc::Ruby::Engine)
+      engine.should 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
+          cp.bibliography().should be_empty
+          cp.bibliography(:all => {}).should be_empty
+          cp.bibliography(:none => {}).should be_empty
+        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
+        end
+
+        it 'renders the reference for the given id' do
+          cp.render(:bibliography, :id => 'grammatology').should == ['Derrida, J. (1976). Of Grammatology (corrected ed.). Baltimore: Johns Hopkins University Press.']
+          cp.render(:citation, :id => 'grammatology', :locator => '3-4').should == '(Derrida, 1976, pp. 3-4)'
+          cp.render(:bibliography, :id => 'knuth1968').should == ['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'
+          cp.render(:bibliography, :id => 'knuth1968').should == ['Knuth, Donald. (1968). <i>The art of computer programming</i> (Vol. 1). Boston: Addison-Wesley.']
+
+          cp.render(:citation, :id => 'knuth1968', :locator => '23').should == '(Knuth, 1968, p. 23)'
+        end
+
+        it 'overrides locales if the processor option is set' do
+          cp.render(:bibliography, :id => 'difference').should == ['Derrida, J. (1967). L’écriture et la différence (1st ed.). Paris: Éditions du Seuil.']
+
+          cp.options[:allow_locale_overrides] = true
+          cp.render(:bibliography, :id => 'difference').should == ['Derrida, J. (1967). L’écriture et la différence (1ʳᵉ éd.). 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
+          cp.process(:id => 'knuth1968', :locator => '23').should == '(Knuth, 1968, p. 23)'
+        end
+
+        it 'combines and sorts multiple cite items' do
+          cp.process([
+            {:id => 'knuth1968', :locator => '23'},
+            {:id => 'grammatology', :locator => '11-14'}
+          ]).should == '(Derrida, 1976, pp. 11-14; Knuth, 1968, p. 23)'
+        end
+      end
+    end
+
+  end
+
+  end
+end

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

@@ -0,0 +1,159 @@
+# 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
+        format.apply(nil, node).should == ''
+      end
+
+      it 'returns the string unchanged if empty' do
+        input = ''
+        format.apply(input, node).should be_equal(input)
+        input.should == ''
+      end
+
+      it 'returns the string unchanged if node is nil' do
+        input = 'foo'
+        format.apply(input, nil).should be_equal(input)
+        input.should == 'foo'
+      end
+
+      it 'supports localized quotes' do
+        locale = double(:locale)
+        locale.stub(:punctuation_in_quotes?).and_return(true)
+        locale.stub(:quote).and_return('bar')
+
+        node[:quotes] = true
+
+        format.apply('foo', node, locale).should == 'bar'
+      end
+
+      it 'disregards localized closing quotes when squeezing affixes' do
+        locale = double(:locale)
+        locale.stub(:punctuation_in_quotes?).and_return(true)
+        locale.stub(:quote) { |t| '"' << t << '"' }
+        locale.stub(:t) { |t| t == 'close-quote' ? '"' : "'" }
+
+        node[:quotes] = true
+        node[:suffix] = '.'
+
+        format.apply('foo', node, locale).should == '"foo."'
+        format.apply("'foo'", node, locale).should == "\"'foo.'\""
+      end
+
+      describe 'text-case formats' do
+        it 'supports lowercase' do
+          node[:'text-case'] = 'lowercase'
+          format.apply('Foo BAR', node).should == 'foo bar'
+        end
+
+        it 'supports lowercase for non-ascii letters' do
+          node[:'text-case'] = 'lowercase'
+          format.apply('SCHÖN!', node).should == 'schön!'
+        end
+
+        it 'supports uppercase' do
+          node[:'text-case'] = 'uppercase'
+          format.apply('Foo BAR', node).should == 'FOO BAR'
+        end
+
+        it 'supports uppercase for non-ascii letters' do
+          node[:'text-case'] = 'uppercase'
+          format.apply('schön!', node).should == 'SCHÖN!'
+        end
+
+        it 'does not alter the original string' do
+          node[:'text-case'] = 'lowercase'
+          input = 'fooBar'
+
+          format.apply(input, node).should == 'foobar'
+          input.should == 'fooBar'
+        end
+
+        it 'supports capitalize-first' do
+          node[:'text-case'] = 'capitalize-first'
+
+          format.apply('foo bar', node).should == 'Foo bar'
+          format.apply('Foo bar', node).should == 'Foo bar'
+          format.apply('!foo bar', node).should == '!Foo bar'
+          format.apply('én foo bar', node).should == 'Én foo bar'
+        end
+
+        it 'supports capitalize-all' do
+          node[:'text-case'] = 'capitalize-all'
+
+          format.apply('foo bar', node).should == 'Foo Bar'
+          format.apply('!foo bar', node).should == '!Foo Bar'
+          format.apply('én foo bar', node).should == 'Én Foo Bar'
+        end
+
+        it 'supports sentence case' do
+          node[:'text-case'] = 'sentence'
+
+          format.apply('FOO bar', node).should == 'Foo bar'
+          format.apply('foo Bar BAR', node).should == 'Foo Bar Bar'
+          format.apply('én Foo bar', node).should == 'Én Foo bar'
+        end
+
+        it 'supports title case' do
+          node[:'text-case'] = 'title'
+
+          format.apply('The adventures of Huckleberry Finn', node).should == 'The Adventures of Huckleberry Finn'
+          format.apply("This IS a pen that is a smith pencil", node).should == 'This IS a Pen That Is a Smith Pencil'
+          #format.apply('of mice and men', node).should == 'Of Mice And Men'
+        end
+      end
+
+      describe 'strip-periods' do
+        before { node[:'strip-periods'] = true }
+
+        it 'strips all periods from the output' do
+          format.apply('hello there...! how.are.you?', node).should == 'hello there! howareyou?'
+          format.apply('foo bar!', node).should == 'foo bar!'
+        end
+
+        it 'does not strip periods from affixes' do
+          node[:prefix] = '...('
+          node[:suffix] = ').'
+
+          format.apply('foo.bar.', node).should == '...(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'
+
+          format.apply('ooo', node).should == 'fooOOOooo'
+        end
+
+        it 'drop squeezable characters at start/end' do
+          node[:suffix] = ' '
+
+          format.apply('foo', node).should == 'foo '
+          format.apply('foo ', node).should == 'foo '
+
+          node[:suffix] = '. '
+          format.apply('foo', node).should == 'foo. '
+          format.apply('foo.', node).should == 'foo. '
+          format.apply('foo?', node).should == 'foo? '
+
+          node[:prefix] = '.'
+          format.apply('foo', node).should == '.foo. '
+          format.apply('.foo', node).should == '.foo. '
+          format.apply(',foo', node).should == '.,foo. '
+        end
+      end
+    end
+
+  end
+end