citeproc-ruby 0.0.6 → 1.0.0

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

@@ -0,0 +1,90 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Node]
+      # @raise RenderingError
+      # @return [String]
+      def render_date(item, node)
+        return '' unless node.has_variable?
+
+        date = item.data[node.variable]
+        return '' if date.nil? || date.empty?
+
+        # TODO date-ranges
+
+        if node.localized?
+          localized_node = locale.date.detect { |d| d.form == node.form } or
+            raise RenderingError, "no localized date for form #{node.form} found"
+
+          delimiter, filter = node.delimiter, node.parts_filter
+
+          parts = localized_node.parts.select do |part|
+            filter.include? part.name
+          end
+        else
+          parts, delimiter = node.parts, node.delimiter
+        end
+
+        parts.map { |part|
+          render date, part
+        }.reject(&:empty?).join(delimiter)
+      end
+
+      # @param date [CiteProc::Date]
+      # @param node [CSL::Style::DatePart, CSL::Locale::DatePart]
+      # @return [String]
+      def render_date_part(date, node)
+        case
+        when node.day?
+          case
+          when date.day.nil?
+            ''
+          when node.form == 'ordinal'
+            if date.day > 1 && locale.limit_day_ordinals?
+              date.day.to_s
+            else
+              ordinalize date.day
+            end
+          when node.form == 'numeric-leading-zeros'
+            '%02d' % date.day
+          else
+            date.day.to_s
+          end
+
+        when node.month?
+          case
+          when date.season?
+            translate(('season-%02d' % date.season), node.attributes_for(:form))
+          when date.month.nil?
+            ''
+          when node.numeric?
+            date.month.to_s
+          when node.numeric_leading_zeros?
+            '%02d' % date.month
+          else
+            translate(('month-%02d' % date.month), node.attributes_for(:form))
+          end
+
+        when node.year?
+          year = date.year
+          year = year % 100 if node.short?
+
+          year = year.to_s
+
+          year << translate(:ad) if date.ad?
+          year << translate(:ad) if date.ad?
+
+          year
+
+        else
+          ''
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,129 @@
+# -*- encoding: utf-8 -*-
+
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      def format
+       @format ||= Format.load
+      end
+
+      def format=(format)
+        @format = Format.load(format)
+      end
+
+      # Applies the current format on the string using the
+      # node's formatting options.
+      def format!(string, node)
+        format.apply(string, node, locale)
+      end
+
+      def join(list, delimiter = nil)
+        format.join(list, delimiter)
+      end
+
+      # Concatenates two strings, making sure that squeezable
+      # characters are not duplicated between string and suffix.
+      #
+      # @param [String] string
+      # @param [String] suffix
+      #
+      # @return [String] new string consisting of string
+      #   and suffix
+      def concat(string, suffix)
+        format.concat(string, suffix)
+      end
+
+
+      # @return [String] the roman numeral of number
+			def romanize(number)
+				CiteProc::Number.romanize(number)
+			end
+
+
+      # Formats pages accoring to format. Valid formats are:
+      #
+      # * "chicago": page ranges are abbreviated according to
+      #   the Chicago Manual of Style rules.
+      # * "expanded": Abbreviated page ranges are expanded to
+      #   their non-abbreviated form: 42-45, 321-328, 2787-2816.
+      # * "minimal": All digits repeated in the second number
+      #   are left out: 42-45, 321-8, 2787-816.
+      #
+      # @param [String] pages to be formatted
+      # @param [String] format to use for formatting
+      def format_page_range(pages, format)
+        return if pages.nil?
+        format_page_range!(pages.dup, format)
+      end
+
+      def format_page_range!(pages, format)
+        return if pages.nil?
+
+        dash = translate('page-range-delimiter') || '–' # en-dash
+
+        pages.gsub! PAGE_RANGE_PATTERN do
+          affixes, f, t = [$1, $3, $4, $6], $2, $5
+
+          # When there are affixes or no format was
+          # specified we skip this part. As a result,
+          # only the delimiter will be replaced!
+
+          if affixes.all?(&:empty?) && !format.nil?
+
+            dim = f.length
+            delta = dim - t.length
+
+            if delta >= 0
+              t.prepend f[0, delta] unless delta.zero?
+
+              if format == 'chicago'
+                changes = dim - f.chars.zip(t.chars).
+                  take_while { |a,b| a == b }.length if dim == 4
+
+                format = case
+                  when dim < 3
+                    'expanded'
+                  when dim == 4 && changes > 2
+                    'expanded'
+                  when f[-2, 2] == '00'
+                    'expanded'
+                  when f[-2] == '0'
+                    'minimal'
+                  else
+                    'minimal-two'
+                  end
+              end
+
+              case format
+              when 'expanded'
+                # nothing to do
+              when 'minimal'
+                t = t.each_char.drop_while.with_index { |c, i| c == f[i] }.join('')
+              when 'minimal-two'
+                if dim > 2
+                  t = t.each_char.drop_while.with_index { |c, i|
+                    c == f[i] && dim - i > 2
+                  }.join('')
+                end
+              else
+                raise ArgumentError, "unknown page range format: #{format}"
+              end
+            end
+          end
+
+          affixes.zip([f, dash, t]).flatten.compact.join('')
+        end
+
+        pages
+      end
+
+      PAGE_RANGE_PATTERN =
+        #   ------------  -2-  ------------             ------------  -5-  ------------
+        /\b([[:alpha:]]*)(\d+)([[:alpha:]]*)\s*[–-]+\s*([[:alpha:]]*)(\d+)([[:alpha:]]*)\b/
+
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Group]
+      # @return [String]
+      def render_group(item, node)
+        return '' unless node.has_children?
+
+        observer = ItemObserver.new(item.data)
+        observer.start
+
+        begin
+          rendition = node.each_child.map { |child|
+            render item, child
+          }.reject(&:empty?)
+
+          rendition = join(rendition, node.delimiter)
+
+        ensure
+          observer.stop
+        end
+
+        return '' if observer.skip?
+
+        rendition
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+module CiteProc
+  module Ruby
+    class Renderer
+
+      class History
+        attr_reader :maxsize, :memory
+
+        def initialize(state, maxsize = 10)
+          @state, @maxsize, = state, maxsize
+          @state.add_observer(self)
+
+          @memory = Hash.new do |hash, key|
+            hash[key] = []
+          end
+        end
+
+        def update(action, mode, memories = {})
+          history = memory[mode]
+          history << memories
+
+        ensure
+          history.shift if history.length > maxsize
+        end
+
+        def recall(mode)
+          memory[mode][-1]
+        end
+
+        def citation
+          memory['citation']
+        end
+
+        def bibliography
+          memory['bibliography']
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Label]
+      # @param variable [String]
+      #
+      # @return [String]
+      def render_label(item, node, variable = node.variable)
+        return '' if variable.nil? || variable.empty?
+
+        case
+        when node.page?
+          value, name = item.read_attribute(:page) || item.data[:page].to_s, :page
+
+          format_page_range!(value, node.page_range_format)
+
+        when node.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).
+          value, name = item.locator || item.data.locator, item.label || 'page'
+
+        when node.names_label?
+
+          # We handle the editortranslator special case
+          # by fetching editors since we can assume
+          # that both are present and identical!
+          if variable == :editortranslator
+            value, name = item.data[:editor], variable.to_s
+          else
+            value, name = item.data[variable], variable.to_s
+          end
+
+        else
+          value, name = item.data[variable], node.term
+        end
+
+        return '' if value.nil? || value.respond_to?(:empty?) && value.empty?
+
+        options = node.attributes_for :form
+
+        options[:plural] = case
+          when node.always_pluralize?
+            true
+          when node.never_pluralize?
+            false
+          when node.number_of_pages?, node.number_of_volumes?
+            value.to_i > 1
+          when value.respond_to?(:plural?)
+            value.plural?
+          else
+            CiteProc::Number.pluralize?(value.to_s)
+          end
+
+        translate name, options
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      private
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Layout]
+      # @return [String]
+      def render_layout(item, node)
+        join node.each_child.map { |child|
+          render item, child
+        }.reject(&:empty?), node.delimiter
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      def locale
+        @locale ||= CSL::Locale.load
+      end
+
+      def locale=(locale)
+        @locale = CSL::Locale.load(locale)
+      end
+
+      def translate(name, options = {})
+        locale.translate(name, options)
+      end
+
+      # @return [String] number as an ordinal
+      def ordinalize(number, options = {})
+        locale.ordinalize(number, options)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+module CiteProc
+  module Ruby
+    
+    class Renderer
+      
+      private
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Layout]
+      # @return [String]
+      def render_macro(item, node)
+        node.each_child.map { |child|
+          render item, child
+        }.join('')
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,401 @@
+module CiteProc
+  module Ruby
+
+    class Renderer
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Names]
+      # @return [String]
+      def render_names(item, node)
+        return '' unless node.has_variable?
+
+        names = node.variable.split(/\s+/).map do |role|
+          [role.to_sym, item.data[role]]
+        end
+
+        names.reject! { |n| n[1].nil? || n[1].empty? }
+
+        # Filter out suppressed names only now, because
+        # we are not interested in suppressed variables
+        # which are empty anyway!
+        suppressed = names.reject! { |n| item.suppressed? n }
+
+        if names.empty?
+          # We also return when the list is empty because
+          # of a suppression, because we do not want to
+          # substitute suppressed items!
+          return '' unless suppressed.nil? && node.has_substitute?
+
+          rendered_names = render_substitute item, node.substitute
+
+          if substitute_subsequent_authors_completely? &&
+            completely_substitute?(rendered_names)
+
+            rendered_names = state.node.subsequent_author_substitute
+          end
+
+          rendered_names
+
+        else
+
+          resolve_editor_translator_exception! names
+
+          # Pick the names node that will be used for
+          # formatting; if we are currently in substiution
+          # mode, the node that is being substituted for
+          # will take precedence if the current node is
+          # a descendant of it.
+          #
+          # This makes sure that nodes in macros do not
+          # use the original names node.
+          #
+          # When the current node has children the names
+          # will not be substituted either.
+          if substitution_mode? && !node.has_children? &&
+            node.ancestors.include?(state.substitute)
+
+            names_node = state.substitute
+
+          else
+            names_node = node
+          end
+
+          name = name_node_for(names_node)
+
+          return count_names(names, name).to_s if name.count?
+
+          names.map! do |role, ns|
+            if names_node.has_label?
+              label = render_label item, names_node.label, role
+              label = format! label, names_node.label
+
+              rendered_names = render_name(ns, name)
+
+              if rendered_names.empty?
+                rendered_names
+              else
+                if names_node.prefix_label?
+                  concat label, rendered_names
+                else
+                  concat rendered_names, label
+                end
+              end
+
+            else
+              render_name ns, name
+            end
+          end
+
+          join names, names_node.delimiter(state.node)
+        end
+
+      ensure
+        state.rendered_names!
+      end
+
+      def count_names(names, node)
+        names.reduce(0) do |count, (_, ns)|
+          if node.truncate?(ns)
+            count + node.truncate(ns).length
+          else
+            count + ns.length
+          end
+        end
+      end
+
+      def substitute_subsequent_authors?
+        bibliography_mode? && state.node.substitute_subsequent_authors?
+      end
+
+      def substitute_subsequent_authors_completely?
+        substitute_subsequent_authors? &&
+          state.node.substitute_subsequent_authors_completely?
+      end
+
+      def substitute_subsequent_authors_individually?
+        substitute_subsequent_authors? &&
+          state.node.substitute_subsequent_authors_individually?
+      end
+
+      def completely_substitute?(names)
+        # Substitution applies only to the first names
+        # node being rendered!
+        return false if state.rendered_names?
+
+        state.store_authors! names
+        previous_names = state.previous_authors
+
+        return false unless previous_names
+
+        names == previous_names[0]
+      end
+
+      def individually_substitute!(names)
+      end
+
+      # Formats one or more names according to the
+      # configuration of the passed-in node.
+      # Returns the formatted name(s) as a string.
+      #
+      # @param names [CiteProc::Names]
+      # @param node [CSL::Style::Name]
+      # @return [String]
+      def render_name(names, node)
+
+        # TODO handle subsequent citation rules
+
+        delimiter = node.delimiter
+
+        connector = node.connector
+        connector = translate('and') if connector == 'text'
+
+        # Add spaces around connector
+        connector = " #{connector} " unless connector.nil?
+
+        rendered_names = case
+          when node.truncate?(names)
+            truncated = node.truncate(names)
+
+            return '' if truncated.empty?
+
+            if node.delimiter_precedes_last?(truncated)
+              connector = join [delimiter, connector].compact
+            end
+
+            if node.ellipsis? && names.length - truncated.length > 1
+              join [
+                join(truncated.map.with_index { |name, idx|
+                  render_individual_name name, node, idx + 1
+                }, delimiter),
+
+                render_individual_name(names[-1], node, truncated.length + 1)
+
+              ], node.ellipsis
+
+            else
+              others = node.et_al ?
+                format!(translate(node.et_al[:term]), node.et_al) :
+                translate('et-al')
+
+              connector = node.delimiter_precedes_et_al?(truncated) ?
+                delimiter : ' '
+
+              join [
+                join(truncated.map.with_index { |name, idx|
+                  render_individual_name name, node, idx + 1
+                }, delimiter),
+
+                others
+
+              ], connector
+
+            end
+
+          when names.length < 3
+            if node.delimiter_precedes_last?(names)
+              connector = [delimiter, connector].compact.join('').squeeze(' ')
+            end
+
+            join names.map.with_index { |name, idx|
+              render_individual_name name, node, idx + 1
+            }, connector || delimiter
+
+          else
+            if node.delimiter_precedes_last?(names)
+              connector = [delimiter, connector].compact.join('').squeeze(' ')
+            end
+
+            join [
+              join(names[0...-1].map.with_index { |name, idx|
+                render_individual_name name, node, idx + 1
+              }, delimiter),
+
+              render_individual_name(names[-1], node, names.length)
+
+            ], connector || delimiter
+          end
+
+
+        if substitute_subsequent_authors_completely? &&
+          completely_substitute?(rendered_names)
+
+          rendered_names = state.node.subsequent_author_substitute
+        end
+
+        format! rendered_names, node
+      end
+
+      # @param names [CiteProc::Name]
+      # @param node [CSL::Style::Name]
+      # @param position [Fixnum]
+      # @return [String]
+      def render_individual_name(name, node, position = 1)
+        if name.personal?
+          name = name.dup
+
+          # TODO move parts of the formatting logic here
+          # because name parts may include particles etc.
+
+
+          # Strip away some unusual characters to normalize
+          # sort order for names.
+          if sort_mode?
+            name.family = name.family.to_s.gsub(/[\[\]]|^\W+/, '')
+          end
+
+          name.options.merge! node.name_options
+          name.sort_order! node.name_as_sort_order_at?(position)
+
+          name.initialize_without_hyphen! if node.initialize_without_hyphen?
+
+          if style && style.demote_particle?
+            name.options[:'demote-non-dropping-particle'] = style.demote_particle
+          end
+
+          # Strip away (hyphenated) particles in sort mode!
+          if sort_mode? && name.demote_particle?
+            name.family = name.family.to_s.sub(/^[[:lower:]]+[\s-]/, '')
+          end
+
+          node.name_part.each do |part|
+            case part[:name]
+            when 'family'
+              if !name.particle? || name.demote_particle?
+                name.family = format!(name.family, part)
+              else
+                name.family = format!("#{name.particle} #{name.family}", part)
+                name.particle = nil
+              end
+
+              # Name suffix must be enclosed by family-part
+              # suffix in display order!
+              if name.has_suffix? && !name.sort_order? && part.attribute?(:suffix)
+                comma = name.comma_suffix? ? name.comma : ' '
+                suffix = part[:suffix]
+
+                name.family.chomp! suffix
+                name.family.concat "#{comma}#{name.suffix}#{suffix}"
+                name.suffix = nil
+              end
+
+            when 'given'
+              if name.dropping_particle?
+                name.given = format!("#{name.initials} #{name.dropping_particle}", part)
+                name.dropping_particle = nil
+              else
+                name.given = format!(name.initials, part)
+              end
+
+              # Demoted particles must be enclosed by
+              # given-part affixes in sort order!
+              if name.particle? && name.demote_particle? &&
+                name.sort_order? && part.attribute?(:suffix)
+
+                suffix = part[:suffix]
+
+                name.given.chomp! suffix
+                name.given.concat " #{name.particle}#{suffix}"
+
+                name.particle = nil
+              end
+
+            end
+          end
+
+        end
+
+        format! name.format, node
+      end
+
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Style::Substitute]
+      # @return [String]
+      def render_substitute(item, node)
+        return '' unless node.has_children?
+
+        if substitution_mode?
+          saved_substitute = state.substitute
+        end
+
+        state.substitute! node.parent
+        observer = ItemObserver.new(item.data)
+
+        node.each_child do |child|
+          observer.start
+
+          begin
+            string = render(item, child)
+
+            unless string.empty?
+              # Variables rendered as substitutes
+              # must be suppressed during the remainder
+              # of the rendering process!
+              item.suppress!(*observer.accessed)
+
+              return string # break out of each loop!
+            end
+
+          ensure
+            observer.stop
+            observer.clear!
+          end
+
+        end
+
+        '' # no substitute was rendered
+      ensure
+        state.clear_substitute! saved_substitute
+      end
+
+
+      private
+
+      def name_node_for(names_node)
+        # Make a copy of the name node and inherit
+        # options from root and citation/bibliography
+        # depending on current rendering mode.
+        if names_node.has_name?
+          name = names_node.name.deep_copy
+        else
+          name = CSL::Style::Name.new
+        end
+
+        # Inherit name options from style and the
+        # current rendering node. We pass both in,
+        # because this is now an unlinked node!
+        options = name.inherited_name_options(state.node, names_node.root)
+
+        name.reverse_merge! options
+        name.et_al = names_node.et_al if names_node.has_et_al?
+
+        # Override options if we are rendering a sort key!
+        if sort_mode?
+          name.merge! state.node.name_options
+          name.all_names_as_sort_order!
+        end
+
+        name
+      end
+
+      def resolve_editor_translator_exception!(names)
+
+        i = names.index { |role, _| role == :translator }
+        return names if i.nil?
+
+        j = names.index { |role, _| role == :editor }
+        return names if j.nil?
+
+        return names unless names[i][1] == names[j][1]
+
+        # rename the first instance and drop the second one
+        i, j = j, i if j < i
+
+        names[i][0] = :editortranslator
+        names.slice!(j)
+
+        names
+      end
+    end
+
+  end
+end