citeproc-ruby 2.2.0 → 2.3.0

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,10 +237,6 @@ 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?
@@ -244,65 +246,26 @@ module CiteProc
           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
 

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

@@ -20,14 +20,14 @@ module CiteProc
           self
         end
 
+        # A variable read more than once counts as non-empty
+        # if any of the reads was non-empty
         def update(method, key, value)
-          history[key] = value if method == :read
+          history[key] = value if method == :read && empty?(history[key])
         end
 
         def skip?
-          !history.empty? && history.values.all? { |v|
-            v.nil? || v.respond_to?(:empty?) && v.empty?
-          }
+          !history.empty? && history.values.all? { |v| empty?(v) }
         end
 
         def accessed
@@ -38,6 +38,12 @@ module CiteProc
           history.clear
           self
         end
+
+        private
+
+        def empty?(value)
+          value.nil? || value.respond_to?(:empty?) && value.empty?
+        end
       end
 
     end

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

@@ -30,6 +30,9 @@ module CiteProc
 
         attr_reader :history, :node, :item, :authors, :substitute
 
+        # @return [String, nil] the language of the item being rendered
+        attr_accessor :language
+
         def initialize
           @history, @authors = History.new(self, 3), []
           reset
@@ -55,7 +58,8 @@ module CiteProc
         end
 
         def reset
-          @item, @node, @substitute, @authors, @names = nil, nil, nil, [], nil
+          @item, @node, @substitute, @authors, @names, @language =
+            nil, nil, nil, [], nil, nil
           self
         ensure
           changed

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

@@ -16,7 +16,12 @@ module CiteProc
             # 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
+            text = (item.locator || item.data[:locator]).to_s
+
+          elsif node.variable == 'year-suffix'
+            # The year-suffix is set by the processor (for disambiguation)
+            # and does not count as a variable for group suppression
+            text = item.data.unobservable_read_attribute(:'year-suffix').to_s
 
           else
             text = item.data.variable(node.variable, node.variable_options).to_s
@@ -25,7 +30,8 @@ module CiteProc
             context, was_short_form = node.variable.split(/-short$/, 2)
 
             if !was_short_form.nil? || node[:form] == 'short'
-              if text.empty? && context != node.variable
+              # Only the short form falls back to the long form
+              if text.empty? && context != node.variable && node[:form] == 'short'
                 text = item.data.variable(context, node.variable_options).to_s
               end
 
@@ -36,7 +42,14 @@ module CiteProc
 
           case
           when node.variable == 'page'
-            format_page_range!(text, node.page_range_format)
+            text = format_page_range(text, node.page_range_format)
+
+          when node.variable == 'locator'
+            format = node.page_range_format if item.label == 'page'
+            text = format_page_range(text, format)
+
+            # Use the localized ampersand (e.g., in "213 & 235")
+            text = text.gsub(/\s*&\s*/, " #{ampersand} ")
 
           when node.variable == 'page-first' && text.empty?
             text = item.data[:'page'].to_s[/\d+/].to_s

data/lib/citeproc/ruby/renderer.rb

@@ -26,6 +26,15 @@ module CiteProc
       end
       alias abbrev abbreviate
 
+      # Clears the renderer's caches. Call this after changing styles or
+      # locales in place, or to free memory when using many different styles.
+      #
+      # @return [self]
+      def clear_cache!
+        clear_locale_cache!
+        self
+      end
+
       def allow_locale_overrides?
         return false unless engine
         engine.options[:allow_locale_overrides]
@@ -65,10 +74,14 @@ module CiteProc
       # @param node [CSL::Style::Layout]
       # @return [String] the rendered and string
       def render_single_citation(item, node)
+        state.language = language_of(item.data)
+
         # TODO author_only
         item.suppress! 'author' if item.suppress_author?
 
         join [item.prefix, render_layout(item, node), item.suffix].compact
+      ensure
+        state.language = nil
       end
 
       # @param item [CiteProc::CitationItem]
@@ -76,20 +89,37 @@ module CiteProc
       # @return [String] the rendered and formatted string
       def render_bibliography(item, node)
         state.store! item, node
+        state.language = language_of(item.data)
 
-        if allow_locale_overrides? && item.language != locale.language
+        language = item.language.to_s
+
+        if allow_locale_overrides? && !language.empty?
           begin
-            new_locale = CSL::Locale.load(item.language)
+            item_locale = locale_for(language)
 
-            unless new_locale.nil?
-              original_locale, @locale = @locale, new_locale
+            if item_locale != base_locale
+              original_locale, @locale = @locale, item_locale
             end
           rescue ParseError
             # locale not found
           end
         end
 
-        result = render item, node.layout
+        fields = node.layout.each_child.map { |child|
+          render item, child
+        }.reject(&:empty?)
+
+        # With second-field-align, the first field is rendered
+        # in the left margin and the other fields inline
+        # (without trailing whitespace)
+        if node.second_field_align? && fields.length > 1
+          fields = [
+            format!(fields[0], CSL::Style::Group.new(:display => 'left-margin')),
+            format!(join(fields[1..]).rstrip, CSL::Style::Group.new(:display => 'right-inline'))
+          ]
+        end
+
+        result = format! join(fields), node.layout
 
       ensure
         unless original_locale.nil?
@@ -101,6 +131,7 @@ module CiteProc
 
       def render_sort(item, node, key)
         state.store! nil, key
+        state.language = language_of(item)
 
         original_format = @format
         @format = Formats::Sort.new

data/lib/citeproc/ruby/version.rb

@@ -1,5 +1,5 @@
 module CiteProc
   module Ruby
-    VERSION = '2.2.0'
+    VERSION = '2.3.0'
   end
 end