citeproc-ruby 2.1.8 → 2.3.0

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

@@ -3,39 +3,84 @@ module CiteProc
 
     class Renderer
 
+      # The date parts from largest to smallest
+      DATE_PARTS = %w{ year month day }.freeze
+
       # @param item [CiteProc::CitationItem]
       # @param node [CSL::Node]
-      # @raise RenderingError
+      # @raise CSL::Error if the locale has no date in the form of the node
       # @return [String]
       def render_date(item, node)
         return '' unless node.has_variable?
 
-        date = item.data[node.variable]
-        return '' if date.nil? || date.empty?
+        # Observers see the date as rendered:
+        # a date without the date parts used counts as empty
+        item.data.deferred_read_attribute(node.variable) do |date|
+          next '' if date.nil? || date.empty?
+          next date.to_s if date.literal?
 
-        return date.to_s if date.literal?
+          parts, delimiter = node.parts_for(locale), node.delimiter_for(locale)
 
-        # TODO date-ranges
+          if date.range?
+            render_date_range date, parts, delimiter
+          else
+            render_date_parts date, parts, delimiter
+          end
+        end
+      end
 
-        if node.localized?
-          localized_node = locale.date.detect { |d| d.form == node.form } or
-            raise RenderingError, "no localized date for form #{node.form} found"
+      # Renders a date range. The date parts which are the same for
+      # both dates are rendered only once; the date parts which differ
+      # are rendered for both dates and are joined by the range delimiter
+      # of the largest date part that differs.
+      #
+      # @param date [CiteProc::Date] the date range
+      # @param parts [Array<CSL::Style::DatePart, CSL::Locale::DatePart>]
+      # @param delimiter [String]
+      # @return [String]
+      def render_date_range(date, parts, delimiter)
+        from, to = date.parts
 
-          delimiter, filter = node.delimiter, node.parts_filter
+        # Skip date parts without values (e.g., days in a month range)
+        parts = parts.select { |part| from[part.name] || to[part.name] }
 
-          parts = localized_node.parts.select do |part|
-            filter.include? part.name
-          end
-        else
-          parts, delimiter = node.parts, node.delimiter
+        # Open ranges are rendered with a trailing range delimiter
+        return [
+          render_date_parts(from, parts, delimiter),
+          range_delimiter_for(parts, 'year')
+        ].join('') if date.open_range?
+
+        names = parts.map(&:name)
+        largest = DATE_PARTS.detect do |name|
+          names.include?(name) && from[name] != to[name]
         end
 
+        return render_date_parts(from, parts, delimiter) if largest.nil?
+
+        # If one date is more precise than the other, all parts differ
+        differing = names.any? { |name| from[name].nil? != to[name].nil? } ?
+          DATE_PARTS :
+          DATE_PARTS.drop_while { |name| name != largest }
+
+        before, range, after = split_date_parts(parts, differing) || [[], parts, []]
+
+        [
+          render_date_parts(from, before, delimiter),
+          [
+            render_date_parts(from, without_suffix(range), delimiter),
+            render_date_parts(to, range, delimiter)
+          ].join(range_delimiter_for(parts, largest)),
+          render_date_parts(from, after, delimiter)
+        ].reject(&:empty?).join(delimiter)
+      end
+
+      def render_date_parts(date, parts, delimiter)
         parts.map { |part|
           render date, part
         }.reject(&:empty?).join(delimiter)
       end
 
-      # @param date [CiteProc::Date]
+      # @param date [CiteProc::Date, CiteProc::Date::DateParts]
       # @param node [CSL::Style::DatePart, CSL::Locale::DatePart]
       # @return [String]
       def render_date_part(date, node)
@@ -48,7 +93,8 @@ module CiteProc
             if date.day > 1 && locale.limit_day_ordinals?
               date.day.to_s
             else
-              ordinalize date.day
+              # The ordinal uses the gender of the month
+              ordinalize date.day, :noun => date.month && 'month-%02d' % date.month
             end
           when node.form == 'numeric-leading-zeros'
             '%02d' % date.day
@@ -58,6 +104,8 @@ module CiteProc
 
         when node.month?
           case
+          when date.season.is_a?(String)
+            date.season
           when date.season?
             translate(('season-%02d' % date.season), node.attributes_for(:form))
           when date.month.nil?
@@ -91,6 +139,42 @@ module CiteProc
         end
       end
 
+      private
+
+      # @return [String] the range delimiter set on the date part
+      #   with the given name; defaults to an en-dash
+      def range_delimiter_for(parts, name)
+        part = parts.detect { |p| p.name == name }
+        part && part[:'range-delimiter'] || '–'
+      end
+
+      # Splits the date parts into the common parts before, the
+      # differing parts, and the common parts after them.
+      #
+      # @return [Array<Array>, nil] the split parts or nil if the
+      #   differing parts are not adjacent
+      def split_date_parts(parts, differing)
+        first = parts.index { |part| differing.include?(part.name) }
+        last = parts.rindex { |part| differing.include?(part.name) }
+        range = parts[first..last]
+
+        return unless range.all? { |part| differing.include?(part.name) }
+
+        [parts[0...first], range, parts[(last + 1)..]]
+      end
+
+      # @return [Array<CSL::Node>] the date parts with a copy
+      #   of the last date part without its suffix
+      def without_suffix(parts)
+        last = parts[-1]
+        return parts unless last.attribute?(:suffix)
+
+        copy = last.deep_copy
+        copy[:suffix] = nil
+
+        [*parts[0...-1], copy]
+      end
+
     end
 
   end

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

@@ -16,7 +16,16 @@ module CiteProc
       # Applies the current format on the string using the
       # node's formatting options.
       def format!(string, node)
-        format.apply(string, node, locale)
+        format.apply(string, node, locale, state.language)
+      end
+
+      # Reads the item's language without notifying observers.
+      #
+      # @param item [CiteProc::Item, nil]
+      # @return [String, nil] the item's language
+      def language_of(item)
+        return unless item.respond_to?(:unobservable_read_attribute)
+        item.unobservable_read_attribute(:language).to_s
       end
 
       def join(list, delimiter = nil)
@@ -42,93 +51,19 @@ module CiteProc
 			end
 
 
-      # Formats pages according 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
+      # @param pages [String] the pages to format
+      # @param format [String, nil] the page range format
+      # @return [String, nil] the pages formatted according to format
+      #   using the localized range delimiter
       def format_page_range(pages, format)
-        return if pages.nil?
-        format_page_range!(pages.dup, format)
+        CiteProc::Number.format_page_range(pages, format, range_delimiter)
       end
 
-      def format_page_range!(pages, format)
-        return if pages.nil?
-        return pages if pages.empty?
-
-        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?
-
-              # TODO
-              if format == 'chicago-16' || format == 'chicago-15'
-                format = 'chicago'
-              end
-
-              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
+      # @return [String] the localized range delimiter; defaults to an en-dash
+      def range_delimiter
+        translate('page-range-delimiter') || '–'
       end
 
-      PAGE_RANGE_PATTERN =
-        #   ------------  -2-  ------------             ------------  -5-  ------------
-        /\b([[:alpha:]]*)(\d+)([[:alpha:]]*)\s*[–-]+\s*([[:alpha:]]*)(\d+)([[:alpha:]]*)\b/
-
     end
 
   end

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

@@ -7,24 +7,36 @@ module CiteProc
       # @param node [CSL::Style::Group]
       # @return [String]
       def render_group(item, node)
-        return '' unless node.has_children?
+        render_as_group item, node, node.delimiter
+      end
+
+      private
 
+      # Renders the node's children with group suppression:
+      # the result is empty if the children call variables
+      # and ALL of them are empty; a non-empty result counts
+      # as a non-empty variable for any enclosing groups.
+      #
+      # @param item [CiteProc::CitationItem]
+      # @param node [CSL::Node]
+      # @param delimiter [String, nil]
+      # @return [String]
+      def render_as_group(item, node, delimiter = nil)
         observer = ItemObserver.new(item.data)
         observer.start
 
         begin
-          rendition = node.each_child.map { |child|
+          rendition = join(node.each_child.map { |child|
             render item, child
-          }.reject(&:empty?)
-
-          rendition = join(rendition, node.delimiter)
-
+          }.reject(&:empty?), delimiter)
         ensure
           observer.stop
         end
 
         return '' if observer.skip?
 
+        item.data.simulate_read_attribute :group, rendition unless rendition.empty?
+
         rendition
       end
 

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

@@ -15,8 +15,6 @@ module CiteProc
         when node.page?
           value, name = item.read_attribute(:page) || item.data.unobservable_read_attribute(:page).to_s, :page
 
-          format_page_range!(value, node.page_range_format)
-
         when node.locator?
 
           # Subtle: when there is no locator we also look
@@ -52,6 +50,8 @@ module CiteProc
             false
           when node.number_of_pages?, node.number_of_volumes?
             value.to_i > 1
+          when node.locator?
+            item.plural_locator?(locator_abbreviations)
           when value.respond_to?(:plural?)
             value.plural?
           else

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

@@ -5,13 +5,16 @@ module CiteProc
 
       private
 
+      # Note that the layout's delimiter is used only between
+      # cites in a citation, not between the layout's children.
+      #
       # @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
+        }.reject(&:empty?)
       end
 
     end

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

@@ -3,12 +3,16 @@ module CiteProc
 
     class Renderer
 
+      # @return [CSL::Locale] the locale including the in-style locale
+      #   definitions of the style currently being rendered
       def locale
-        @locale ||= CSL::Locale.load
+        localize(base_locale)
       end
 
+      # @param locale [CSL::Locale, String] a locale or an IETF tag;
+      #   locales are used as is and never changed by the renderer
       def locale=(locale)
-        @locale = CSL::Locale.load(locale)
+        @locale = locale.is_a?(CSL::Locale) ? locale : CSL::Locale.load(locale)
       end
 
       def translate(name, options = {})
@@ -20,6 +24,63 @@ module CiteProc
         locale.ordinalize(number, options)
       end
 
+      # @return [Hash<String,String>] the abbreviations of locator labels
+      #   including the localized short terms
+      def locator_abbreviations
+        @locator_abbreviations ||= {}.compare_by_identity
+        @locator_abbreviations[locale] ||= begin
+          terms = {}
+
+          CiteProc::CitationItem.labels.each do |label|
+            [false, true].each do |plural|
+              term = translate(label, :form => 'short', :plural => plural)
+              terms[term] = label.to_s unless term.to_s.empty?
+            end
+          end
+
+          CiteProc::CitationItem.locator_abbreviations.merge(terms)
+        end
+      end
+
+      # @return [String] the symbol form of the "and" term
+      #   if the locale defines it; otherwise "&"
+      def ampersand
+        term = locale.terms.lookup('and', :form => 'symbol')
+        term&.form == 'symbol' ? term.to_s : '&'
+      end
+
+      private
+
+      def clear_locale_cache!
+        @localized, @locales, @locator_abbreviations = nil, nil, nil
+      end
+
+      # @return [CSL::Locale] the locale without in-style locale
+      #   definitions; defaults to the default locale
+      def base_locale
+        @locale ||= CSL::Locale.load
+      end
+
+      # Localized copies are cached per style and locale; the
+      # style and the locale themselves are never changed.
+      #
+      # @param locale [CSL::Locale]
+      # @return [CSL::Locale] the locale localized for the current style
+      def localize(locale)
+        return locale if style.nil?
+
+        @localized ||= {}.compare_by_identity
+        localized = (@localized[style] ||= {}.compare_by_identity)
+        localized[locale] ||= style.localize(locale)
+      end
+
+      # @param language [String] an IETF tag
+      # @return [CSL::Locale] the (cached) locale for the language
+      def locale_for(language)
+        @locales ||= {}
+        @locales[language] ||= CSL::Locale.load(language)
+      end
+
     end
 
   end

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

@@ -6,12 +6,10 @@ module CiteProc
       private
 
       # @param item [CiteProc::CitationItem]
-      # @param node [CSL::Style::Layout]
+      # @param node [CSL::Style::Macro]
       # @return [String]
       def render_macro(item, node)
-        node.each_child.map { |child|
-          render item, child
-        }.join('')
+        render_as_group item, node
       end
 
     end

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

@@ -25,7 +25,8 @@ module CiteProc
 
           rendered_names = render_substitute item, node.substitute
 
-          if substitute_subsequent_authors_completely? &&
+          # Substituted output is replaced as a whole for all rules
+          if substitute_subsequent_authors? &&
             completely_substitute?(rendered_names)
 
             rendered_names = state.node.subsequent_author_substitute
@@ -146,8 +147,11 @@ module CiteProc
         connector = node.connector
         connector = translate('and') if connector == 'text'
 
-        # Add spaces around connector
-        connector = " #{connector} " unless connector.nil?
+        # Add spaces around connector unless it belongs to a
+        # script which does not separate words by spaces
+        if CiteProc.romanesque_start?(connector)
+          connector = " #{connector} "
+        end
 
         rendered_names =
           case
@@ -171,12 +175,14 @@ module CiteProc
               ], node.ellipsis
 
             else
-              others = node.et_al ?
-                format!(translate(node.et_al[:term]), node.et_al) :
-                translate('et-al')
+              term = translate(node.et_al ? node.et_al[:term] : 'et-al')
+              others = node.et_al ? format!(term, node.et_al) : term
 
-              connector = node.delimiter_precedes_et_al?(truncated) ?
-                delimiter : ' '
+              connector = case
+                when node.delimiter_precedes_et_al?(truncated) then delimiter
+                when CiteProc.romanesque_start?(term) then ' '
+                else ''
+                end
 
               join [
                 join(truncated.map.with_index { |name, idx|
@@ -185,7 +191,7 @@ module CiteProc
 
                 others
 
-              ], connector
+              ].reject { |part| part.to_s.empty? }, connector
 
             end
 
@@ -220,7 +226,7 @@ module CiteProc
           rendered_names = state.node.subsequent_author_substitute
         end
 
-        format! rendered_names, node
+        affix rendered_names, node
       end
 
       # @param names [CiteProc::Name]
@@ -231,78 +237,35 @@ module CiteProc
         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+/, '')
+            name.family = name.family.to_s.gsub(/[\[\]]|^[^[:word:]]+/, '')
           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?
+          name.initialize_without_hyphen! if style && style.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)
+          # Particles are demoted in sort keys unless they are never demoted
+          name.always_demote_particle! if sort_mode? && !name.never_demote_particle?
 
-                suffix = part[:suffix]
-
-                name.given.chomp! suffix
-                name.given.concat " #{name.particle}#{suffix}"
+        end
 
-                name.particle = nil
-              end
+        parts = node.name_part.to_h { |part| [part[:name].to_sym, part] }
 
-            end
-          end
-
-        end
+        formatted = name.format(
+          ->(part, text) { format_without_affixes(text, parts[part]) },
+          ->(part, text) { affix(text, parts[part]) }
+        )
 
-        format! name.format, node
+        # The affixes of the name node enclose the list of names
+        format_without_affixes formatted, node
       end
 
       # @param item [CiteProc::CitationItem]
@@ -381,6 +344,23 @@ module CiteProc
         name
       end
 
+      # @return [String, nil] the text with the formatting, but
+      #   without the affixes, of the node
+      def format_without_affixes(text, node)
+        return text if node.nil? || text.to_s.empty?
+
+        formatting = node.deep_copy
+        formatting[:prefix] = formatting[:suffix] = nil
+
+        format! text, formatting
+      end
+
+      # @return [String, nil] the text enclosed by the affixes of the node
+      def affix(text, node)
+        return text if node.nil? || text.to_s.empty?
+        "#{node[:prefix]}#{text}#{node[:suffix]}"
+      end
+
       def resolve_editor_translator_exception!(names)
 
         i = names.index { |role, _| role == :translator }
@@ -391,6 +371,9 @@ module CiteProc
 
         return names unless names[i][1] == names[j][1]
 
+        # An empty term disables the special case
+        return names if translate('editortranslator').to_s.empty?
+
         # rename the first instance and drop the second one
         i, j = j, i if j < i
 

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

@@ -16,8 +16,7 @@ module CiteProc
 
         case
         when node.ordinal? || node.long_ordinal?
-          options = node.attributes_for :form
-          # TODO lookup term of variable to check gender
+          options = node.attributes_for(:form).merge(:noun => node.variable)
 
           numbers.map! do |num|
             num =~ /^\d+$/ ? ordinalize(num, options) : num
@@ -32,6 +31,7 @@ module CiteProc
 					# nothing
         end
 
+				numbers.map! { |num| num == '-' ? range_delimiter : num }
 				numbers.join('')
       end