citeproc-ruby 0.0.6 → 1.0.0

data/lib/citeproc/ruby/formats/default.rb

@@ -0,0 +1,25 @@
+module CiteProc
+  module Ruby
+    module Formats
+
+      class Text < Format
+
+        private
+
+        def finalize!
+          super
+          output.gsub!(/&(amp|lt|gt);/i, {
+            '&amp;' => '&',
+            '&gt;'  => '>',
+            '&lt;'  => '<'
+          })
+        end
+
+      end
+
+      class Debug < Format
+      end
+
+    end
+  end
+end

data/lib/citeproc/ruby/formats/html.rb

@@ -0,0 +1,221 @@
+module CiteProc
+  module Ruby
+    module Formats
+
+      class Html < Format
+
+        @defaults = {
+          :css_only  => false,
+          :italic    => 'i',      # em
+          :bold      => 'b',      # strong
+          :container => 'span',   # inner container
+          :display   => 'div',    # display container
+
+          :bib_container       => 'ol',
+          :bib_container_class => 'csl-bibliography',
+          :bib_entry           => 'li',
+          :bib_entry_class     => 'csl-entry',
+          :bib_hanging_indent  => '0.5',
+          :bib_unit            => 'em',
+          :bib_indent          => '  '
+        }
+
+        class << self
+          attr_reader :defaults
+        end
+
+        attr_reader :config
+
+        def initialize(config = nil)
+          if config.nil?
+            @config = Html.defaults.dup
+          else
+            @config = Html.defaults.merge(config)
+          end
+        end
+
+        def bibliography(bibliography)
+          ol, li, indent, unit =
+            config.values_at(:bib_container, :bib_entry, :bib_indent, :bib_unit)
+
+          container_options = {}
+          container_options['class'] = config[:bib_container_class]
+
+          entry_options = {}
+          entry_options['class'] = config[:bib_entry_class]
+
+          entry_options['style'] = {}
+          container_options['style'] = {}
+
+          if bibliography.line_spacing != 1.0
+            container_options['style']['line-height'] = bibliography.line_spacing
+          end
+
+          if bibliography.hanging_indent?
+            hanging_indent = "#{config[:bib_hanging_indent]}#{bib_unit}"
+
+            container_options['style']['padding-left'] = hanging_indent
+            entry_options['style']['text-indent'] = "-#{hanging_indent}"
+          end
+
+          if bibliography.entry_spacing != 1.0
+            entry_options['style']['margin-bottom'] = "#{bibliography.entry_spacing}#{unit}"
+          end
+
+          bibliography.header = opening_tag(ol, container_options)
+          bibliography.footer = closing_tag(ol)
+
+          bibliography.prefix = [indent, opening_tag(li, entry_options)].join('')
+          bibliography.suffix = closing_tag(li)
+
+          bibliography.connector = indent ? "\n" : ''
+          bibliography
+        end
+
+        def css_only?
+          config[:css_only]
+        end
+
+        def apply_font_style
+          if options[:'font-style'] == 'italic' && !css_only?
+            output.replace content_tag(config[:italic], output)
+          else
+            css['font-style'] = options[:'font-style']
+          end
+        end
+
+        def apply_font_variant
+          css['font-variant'] = options[:'font-variant']
+        end
+
+        def apply_font_weight
+          if options[:'font-weight'] == 'bold' && !css_only?
+            output.replace content_tag(config[:bold], output)
+          else
+            css['font-weight'] = options[:'font-weight']
+          end
+        end
+
+        def apply_text_decoration
+          css['text-decoration'] = options[:'text-decoration']
+        end
+
+        def apply_vertical_align
+          css['vertical-align'] = options[:'vertical-align']
+        end
+
+        def apply_display
+          output.replace(
+            content_tag(config[:display], output, 'class' => "csl-#{options[:display]}" )
+          )
+        end
+
+        def prefix
+          CSL.encode_xml_text(options[:prefix])
+        end
+
+        def suffix
+          CSL.encode_xml_text(options[:suffix])
+        end
+
+        def escape_quotes?
+          true
+        end
+
+        def strip(string)
+          string.split(/((?:^<[^>]+>)|(?:<[^>]+>))$/, 2)
+        end
+
+        protected
+
+        def css
+          @css ||= {}
+        end
+
+        def finalize_content!
+          super
+          output.replace content_tag(config[:container], output, 'style' => css) if @css
+        end
+
+        def setup!
+          # TODO find a better solution for this (strip tags?)
+          # For now make sure not to double encode entities
+          # by matching spaces before or after.
+
+          output.gsub!(/[&<]\s/, '& ' => '&amp; ', '< ' => '&lt; ')
+          output.gsub!(/\s>/, ' &gt;')
+        end
+
+        def cleanup!
+          @css = nil
+          super
+        end
+
+        private
+
+        def content_tag(name, content, options = nil)
+          opening_tag(name, options) << content << closing_tag(name)
+        end
+
+        def style_for(options)
+          return unless options && !options.empty?
+          options.map { |*kv| kv.join(': ') }.join('; ')
+        end
+
+        def attribute_assignments(options)
+          return unless options
+
+          options = options.select { |k, v| !v.nil? }
+
+          return unless !options.empty?
+
+          ' ' << options.map { |k, v| [k, v.inspect].join('=') }.join(' ')
+        end
+
+        def opening_tag(name, options = nil)
+          if options && options.key?('style')
+            options['style'] = style_for(options['style'])
+          end
+
+          "<#{name}#{attribute_assignments(options)}>"
+        end
+
+        def closing_tag(name)
+          "</#{name}>"
+        end
+      end
+
+      class CiteProcJS < Html
+        def initialize
+          super(
+            :bib_container => 'div',
+            :bib_container_class => 'csl-bib-body',
+            :bib_entry => 'div',
+            :bib_entry_class => 'csl-entry'
+          )
+        end
+
+        def bibliography(bibliography)
+          ol, li, indent =
+            config.values_at(:bib_container, :bib_entry, :bib_indent)
+
+          container_options = {}
+          container_options['class'] = config[:bib_container_class]
+
+          entry_options = {}
+          entry_options['class'] = config[:bib_entry_class]
+
+          bibliography.header = opening_tag(ol, container_options)
+          bibliography.footer = closing_tag(ol)
+
+          bibliography.prefix = [indent, opening_tag(li, entry_options)].join('')
+          bibliography.suffix = closing_tag(li)
+
+          bibliography.connector = indent ? "\n" : ''
+          bibliography
+        end
+      end
+
+    end
+  end
+end

data/lib/citeproc/ruby/renderer.rb

@@ -0,0 +1,140 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      attr_reader :state
+
+      attr_accessor :engine
+
+      def initialize(options_or_engine = nil)
+        @state = State.new
+
+        case options_or_engine
+        when Engine
+          @engine = options_or_engine
+        when Hash
+          locale, format = options_or_engine.values_at(:locale, :format)
+          @locale, @format = CSL::Locale.load(locale), Format.load(format)
+        end
+      end
+
+      def locale
+        @locale ||= CSL::Locale.load
+      end
+
+      def locale=(new_locale)
+        @locale = CSL::Locale.load new_locale
+      end
+
+      def abbreviate(*arguments)
+        return unless engine
+        engine.abbreviate(*arguments)
+      end
+      alias abbrev abbreviate
+
+      def allow_locale_overrides?
+        return false unless engine
+        engine.options[:allow_locale_overrides]
+      end
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Node]
+      # @return [String] the rendered and formatted string
+      def render(item, node)
+        raise ArgumentError, "no CSL node: #{node.inspect}" unless
+          node.respond_to?(:nodename)
+
+        specialize = "render_#{node.nodename.tr('-', '_')}"
+
+        raise ArgumentError, "#{specialize} not implemented" unless
+          respond_to?(specialize, true)
+
+        format! send(specialize, item, node), node
+      end
+
+      # @param data [CiteProc::CitationData]
+      # @param node [CSL::Style::Citation]
+      # @return [String] the rendered and formatted string
+      def render_citation(data, node)
+        state.store! data, node
+
+        citations = join data.map { |item|
+          render_single_citation item, node.layout
+        }, node.layout.delimiter || ''
+
+        result = format! citations, node.layout
+      ensure
+        state.clear! result
+      end
+
+      # @param data [CiteProc::CitationItem]
+      # @param node [CSL::Style::Layout]
+      # @return [String] the rendered and string
+      def render_single_citation(item, node)
+        # TODO author_only
+        item.suppress! 'author' if item.suppress_author?
+
+        join [item.prefix, render_layout(item, node), item.suffix].compact
+      end
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Bibliography]
+      # @return [String] the rendered and formatted string
+      def render_bibliography(item, node)
+        state.store! item, node
+
+        if allow_locale_overrides? && item.language != locale.language
+          begin
+            new_locale = CSL::Locale.load(item.language)
+
+            unless new_locale.nil?
+              new_locale.merge!(locale)
+              original_locale, @locale = @locale, new_locale
+            end
+          rescue ParseError
+            # locale not found
+          end
+        end
+
+        result = render item, node.layout
+
+      ensure
+        unless original_locale.nil?
+          @locale = original_locale
+        end
+
+        state.clear! result
+      end
+
+      def render_sort(a, b, node, key)
+        state.store! nil, key
+
+        original_format = @format
+        @format = Formats::Text.new
+
+        if a.is_a?(CiteProc::Names)
+          [render_name(a, node), render_name(b, node)]
+
+        else
+          # We need to clear any items that are suppressed
+          # because they were used as substitutes during
+          # rendering for sorting purposes!
+          a_rendered = render a.cite, node
+          a.suppressed.clear
+
+          b_rendered = render b.cite, node
+          b.suppressed.clear
+
+          [a_rendered, b_rendered]
+        end
+
+      ensure
+        @format = original_format
+        state.clear!
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,106 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Choose]
+      # @return [String]
+      def render_choose(item, node)
+        return '' unless node.has_children?
+
+        node.each_child do |child|
+          return render_block(item, child) if evaluates?(item, child)
+        end
+
+        '' # no block was rendered
+      end
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Choose::Block]
+      # @return [String]
+      def render_block(item, node)
+        return '' unless node.has_children?
+
+        join node.each_child.map { |child|
+          render item, child
+        }
+      end
+
+
+      # Evaluates the conditions of the passed-in Choose::Block
+      # against the passed-in CitationItem using the Block's matcher.
+      #
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Choose::Block]
+      #
+      # @return [Boolean] whether or not the node's conditions
+      #   are true for the passed-in item
+      def evaluates?(item, node)
+
+        # subtle: else-nodes have no conditions. since the default
+        # matcher :all? returns true for an empty list we do not
+        # need to check for an else node specifically.
+
+        # return true if node.nodename == 'else'
+
+        node.conditions.send(node.matcher) do |type, matcher, values|
+          case type
+          when :disambiguate
+            false # TODO not implemented yet
+
+          when :'is-numeric'
+            evaluates_condition? matcher, values do |value|
+              v = item.data.unobservable_read_attribute(value)
+              v.respond_to?(:numeric?) && v.numeric?
+            end
+
+          when :'is-uncertain-date'
+            evaluates_condition? matcher, values do |value|
+              v = item.data.unobservable_read_attribute(value)
+              v.respond_to?(:uncertain?) && v.uncertain?
+            end
+
+
+          when :locator
+            locator = item.locator.to_s.tr(' ', '-')
+
+            evaluates_condition? matcher, values do |value|
+              value.to_s == locator
+            end
+
+          when :position
+            false # TODO not implemented yet
+
+          when :type
+            type = item.data.unobservable_read_attribute(:type).to_s
+
+            evaluates_condition? matcher, values do |value|
+              value.to_s == type
+            end
+
+          when :variable
+            evaluates_condition? matcher, values do |value|
+              item.data.attribute?(value)
+            end
+
+          else
+            fail "unknown condition type: #{type}"
+          end
+        end
+      end
+
+      # Evaluates the passed-in block for each value in values,
+      # negating the result if the value is prefixed with 'not:'
+      def evaluates_condition?(matcher, values, &condition)
+        values.send(matcher) do |value|
+          value, negate = value.split(/^not:/, 2).reverse
+          result = condition.call(value)
+
+          negate ? !result : result
+        end
+      end
+    end
+
+  end
+end