citeproc 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8708658d44ed66deb17744c846697187edbcd1f6dc308c4bf3bc69933ede3e7e
-  data.tar.gz: 1d1af4037b6dae14f20adffdbb7e51b35ecd02728586f95932348416788347c1
+  metadata.gz: 21838f9d914cb947a14c36bf1b65271170de7a12d40eb069921e3a2ab3fe8a2a
+  data.tar.gz: bf916ee190ab7850caacde982b7510ffa045d2d5e276b30e9cd3a112ef644e7b
 SHA512:
-  metadata.gz: 4dc2d276583d4071cf17459265a3c706f8eb4091c59527a80506241e8f5187de4eba9f6cb140e560327fde38f8e8225348818dfeda0e1b2b98ef53acb67c5064
-  data.tar.gz: 33de631e29bd0e3484a0509e4f61bfb4e2b59fe87aeb8e7cbd25c1d9065ce20588637725f00d9f88ab2e19bcee765d3a19bc71d25adced9135d6a74627018279
+  metadata.gz: 7e4d56b5e112d3a3b94b931f648a75947efce1613f33ce147991ff9d8e2497ba33c002a547f403c9977ff65f6375ce2ebf7edbbe958ec3ea5b8daebfc819ba4c
+  data.tar.gz: 3be138495514a7f85ab8df3e22215c181069d0417aa8a863173592618fab37741e5b5691a3b52770deefcd7fb2bfed95077172c3f994b558e54daa0df11605db

data/README.md

@@ -110,6 +110,18 @@ to install all official CSL styles and locales.
 To make the styles and locales available,
 simply `require 'csl/styles'`.
 
+Development
+-----------
+To get started, install the development dependencies and run all tests:
+
+    $ bundle install
+    $ bundle exec rake
+
+The [CSL test-suite](https://github.com/citation-style-language/test-suite)
+runs as Cucumber features using CiteProc-Ruby:
+
+    $ bundle exec cucumber
+
 Credits
 -------
 Thanks to Rintze M. Zelle, Sebastian Karcher, Frank G. Bennett, Jr.,

data/lib/citeproc/citation_data.rb

@@ -132,14 +132,28 @@ module CiteProc
       read_attribute(:label) || ('page' if locator?)
     end
 
-    # Moves a label at the start of the locator into the label
-    # (e.g., "vol. 1" becomes "1" with the label "volume") unless
-    # the item has a label other than "page".
+    # Only the locator up to the first embedded label (e.g., "fol."
+    # in "1, fol. 186") determines whether or not it is plural.
+    #
+    # @param abbreviations [Hash<String,String>] label abbreviations
+    # @return [Boolean] whether or not the locator is plural
+    def plural_locator?(abbreviations = CitationItem.locator_abbreviations)
+      pattern = CitationItem.locator_label_pattern(abbreviations)
+      Number.pluralize?(locator.to_s.split(/\s(?:#{pattern})\s/, 2)[0])
+    end
+
+    # Removes whitespace around the locator and moves a label at the
+    # start of the locator into the label (e.g., "vol. 1" becomes "1"
+    # with the label "volume") unless the item has a label other than
+    # "page".
     #
     # @param abbreviations [Hash<String,String>] label abbreviations
     # @return [self]
     def parse_locator!(abbreviations = CitationItem.locator_abbreviations)
-      return self unless locator? && label.to_s == 'page'
+      return self unless locator?
+
+      self.locator = locator.to_s.strip
+      return self unless label.to_s == 'page'
 
       pattern = CitationItem.locator_label_pattern(abbreviations)
       match = /\A(#{pattern})\s+(.+)\z/m.match(locator.to_s)

data/lib/citeproc/date.rb

@@ -77,7 +77,7 @@ module CiteProc
           d = arguments[0]
           super(d.year, d.month, d.day)
         else
-          super(*arguments.map(&:to_i))
+          super(*arguments.map { |value| to_part(value) })
         end
       end
 
@@ -95,12 +95,18 @@ module CiteProc
         end
 
         parts.each_pair do |part, value|
-          self[part] = value.nil? ? nil : value.to_i
+          self[part] = to_part(value)
         end
 
         self
       end
 
+      # @return [Integer, nil] the value as a date part; empty values are unset
+      def to_part(value)
+        value.to_i unless value.to_s.strip.empty?
+      end
+      private :to_part
+
       # @return [Boolean] whether or not the date parts are unset
       def empty?
         to_citeproc.empty?
@@ -126,11 +132,12 @@ module CiteProc
         !bc? && year < 1000
       end
 
-      # Seasons may be encoded as months 21 to 24 (Spring to Winter).
+      # Seasons may be encoded as months 21 to 24 (Spring to Winter)
+      # and, as citeproc-js does, 13 to 20 (Spring to Winter, twice).
       # @return [Integer, nil] the season (1 to 4) or nil if the
       #   month does not encode a season
       def season
-        month - 20 if month && month.between?(21, 24)
+        (month - 13) % 4 + 1 if month && month.between?(13, 24)
       end
 
       # @return [Boolean] whether or not the month encodes a season

data/lib/citeproc/item.rb

@@ -74,11 +74,28 @@ module CiteProc
     protected :attributes
 
 
+    # Legacy names of variables in CSL-JSON
+    LEGACY_NAMES = {
+      :journalAbbreviation => :'container-title-short',
+      :shortTitle => :'title-short'
+    }.freeze
+
     def initialize(attributes = nil)
       merge(attributes)
       yield self if block_given?
     end
 
+    def merge(other)
+      super
+
+      LEGACY_NAMES.each do |legacy, name|
+        value = attributes.delete(legacy)
+        write_attribute(name, value) unless value.nil? || attribute?(name)
+      end
+
+      self
+    end
+
     def initialize_copy(other)
       @attributes = other.attributes.deep_copy
     end
@@ -100,14 +117,24 @@ module CiteProc
     end
 
     def observable_read_attribute(key)
-      value = original_read_attribute(key)
-      return if suppressed?(key)
-      value
+      value = original_read_attribute(key) unless suppressed?(key)
     ensure
       changed
       notify_observers :read, key, value
     end
 
+    # Reads the variable without notifying observers and yields it;
+    # observers are notified of the block's result instead
+    # (e.g., what a renderer made of the variable).
+    # @return the block's result
+    def deferred_read_attribute(key)
+      value = original_read_attribute(key) unless suppressed?(key)
+      result = yield value
+    ensure
+      changed
+      notify_observers :read, key, result
+    end
+
     def simulate_read_attribute(key, value)
       changed
       notify_observers :read, key, value

data/lib/citeproc/names.rb

@@ -42,6 +42,15 @@ module CiteProc
     include Attributes
     include Comparable
 
+    # Leading particle of a family name: "van der Vlist", "d'Alembert", "al-Hassan"
+    FAMILY_PARTICLE = /\A(?<particle>\S+[-ʻ’' ] *)(?<name>.+)\z/
+
+    # Trailing particle of a given name: "Alexander von"
+    GIVEN_PARTICLE = /\A(?<name>.+)\s+(?<particle>\S+)\z/
+
+    # Suffix after a comma in a given name: "John, III" or "John,! Jr."
+    SUFFIX = /\A(?<given>.*?)\s*,(?<comma>!?)\s*(?<suffix>.+)\z/
+
     # Class instance variables
 
     @romanesque =
@@ -51,7 +60,7 @@ module CiteProc
     @defaults = {
       :form => 'long',
       :'name-as-sort-order' => false,
-      :'demote-non-dropping-particle' => :never,
+      :'demote-non-dropping-particle' => 'display-and-sort',
       :'sort-separator' => ', ',
       :initialize => true,
       :'initialize-with-hyphen' => true,
@@ -126,6 +135,30 @@ module CiteProc
     end
 
 
+    # Parses name particles and suffixes out of the family and given names
+    # and sets parse-names to false, so the name is not parsed again.
+    # Names with parse-names set to false are not parsed.
+    # Quotes around the family name are removed
+    # and the family name is not parsed.
+    # Names without family or given name, or with any particle or suffix set,
+    # are not parsed.
+    #
+    # @return [self]
+    def parse!
+      return self unless CiteProc.boolean(read_attribute(:'parse-names'), true)
+
+      quoted = family? && family.match?(/\A".+"\z/)
+      self.family = family[1...-1] if quoted
+
+      if family? && given? && !(particle? || dropping_particle? || suffix?)
+        parse_family! unless quoted
+        parse_given!
+      end
+
+      write_attribute(:'parse-names', false)
+      self
+    end
+
     # Resets the object's options to the default settings.
     # @return [self]
     def reset!
@@ -166,6 +199,12 @@ module CiteProc
       static_ordering? || !romanesque?
     end
 
+    # @return [Boolean] whether or not the name can be printed in sort
+    #   order (literal names and names in static order cannot)
+    def invertible?
+      personal? && !static_order?
+    end
+
     # Set the name to use static order for printing, i.e., print the family
     # name before the given name as is customary, for example, in Hungarian
     # and many Asian languages.
@@ -263,9 +302,10 @@ module CiteProc
       end
     end
 
+    # @return [Boolean] whether or not the non-dropping particle is demoted
+    #   when the name is printed; "sort-only" demotes it only in sort keys
     def demote_non_dropping_particle?
-      always_demote_non_dropping_particle? ||
-        !!(sort_order? && options[:'demote-non-dropping-particle'] =~ /^sort(-only)?$/i)
+      always_demote_non_dropping_particle?
     end
 
     alias demote_particle? demote_non_dropping_particle?
@@ -313,30 +353,66 @@ module CiteProc
     end
 
     # @return [String] the name formatted according to the current options
-    def format
-      case
-      when literal?
-        literal.to_s
-      when static_order?
-        [family, initials].compact.join(romanesque? ? ' ' : '')
-      when !short_form?
-        case
-        when !sort_order?
-          [[initials, dropping_particle, particle, family].compact_join(' '),
-            suffix].compact_join(comma_suffix? ? comma : ' ')
+    # Formats the name according to the formatting options. The name
+    # parts may be formatted and enclosed in affixes: the formatter is
+    # called with the name part (:given or :family) and its text, and the
+    # affixer with the name part and the text it encloses. The given
+    # formatting applies to the given name and the dropping particle, the
+    # family formatting to the family name and the non-dropping particle.
+    # The family affixes enclose all preceding particles and, for names in
+    # display order, the suffix; the given affixes enclose the particles
+    # following the given name in sort order.
+    #
+    # @param formatter [#call] formats the text of a name part
+    # @param affixer [#call] encloses the text of a name part in affixes
+    # @return [String] the formatted name
+    def format(formatter = nil, affixer = nil)
+      format_part = ->(part, text) { formatter.nil? || text.to_s.empty? ? text : formatter.(part, text) }
+      affix_part = ->(part, text) { affixer.nil? || text.to_s.empty? ? text : affixer.(part, text) }
 
-        when !demote_particle?
-          [[particle, family].compact_join(' '), [initials,
-            dropping_particle].compact_join(' '), suffix].compact_join(comma)
+      return affix_part.(:family, format_part.(:family, literal.to_s)) if literal?
 
-        else
-          [family, [initials, dropping_particle, particle].compact_join(' '),
-            suffix].compact_join(comma)
-        end
+      given = format_part.(:given, initials)
+      dropping = format_part.(:given, dropping_particle)
+      particle = format_part.(:family, self.particle)
+      family = format_part.(:family, self.family)
+      particle_family = [particle, family].compact_join(particle_separator)
+
+      case
+      when static_order?
+        [affix_part.(:family, family), affix_part.(:given, given)]
+          .compact_join(romanesque? ? ' ' : '')
+      when short_form?
+        affix_part.(:family, particle_family)
+      when !sort_order?
+        given = affix_part.(:given, given)
+        family = [[dropping, particle_family].compact_join(particle_separator(dropping_particle)),
+          suffix].compact_join(comma_suffix? ? comma : ' ')
+
+        # Affixes ending in a space (e.g., a no-break space) replace the space
+        [given, affix_part.(:family, family)]
+          .compact_join(given.to_s.match?(/[[:space:]]\z/) ? '' : ' ')
+      when !demote_particle?
+        [affix_part.(:family, particle_family),
+          affix_part.(:given, [given, dropping].compact_join(' ')), suffix].compact_join(comma)
       else
-        [particle, family].compact_join(' ')
+        [affix_part.(:family, family),
+          affix_part.(:given, [given, dropping, particle].compact_join(' ')), suffix].compact_join(comma)
       end
     end
+
+    # @return [String] the family name preceded by the non-dropping particle
+    def particle_family
+      [particle, family].compact_join(particle_separator)
+    end
+
+    # @param particle [String] the dropping or non-dropping particle
+    # @return [String] the separator following the particle; particles
+    #   ending in a hyphen or apostrophe (e.g., "al-" or "d'") are joined
+    #   without a space
+    def particle_separator(particle = self.particle)
+      particle.to_s.match?(/[-'’ʻ\s]\z/) ? '' : ' '
+    end
     alias print format
 
     # @return [Array<String>] an ordered array of formatted name parts to be used for sorting
@@ -345,9 +421,9 @@ module CiteProc
       when literal?
         [literal.to_s.sub(sort_prefix, '')]
       when never_demote_particle?
-        [[particle, family].compact_join(' '), dropping_particle, given, suffix].map(&:to_s)
+        [particle_family, dropping_particle, given, suffix].map(&:to_s)
       else
-        [family, [particle, dropping_particle].compact_join(' '), given, suffix].map(&:to_s)
+        [family, [dropping_particle, particle].compact_join(' '), given, suffix].map(&:to_s)
       end
     end
 
@@ -379,6 +455,45 @@ module CiteProc
       super key
     end
 
+    # Leading lowercase words of the family name become the non-dropping particle;
+    # particles may be joined by hyphens or apostrophes ("d'Alembert", "al-Hassan").
+    def parse_family!
+      particles, name = '', family.to_s
+      while (m = FAMILY_PARTICLE.match(name)) && particle_word?(m[:particle])
+        particles, name = particles + m[:particle], m[:name]
+      end
+
+      unless particles.empty?
+        self.family = name
+        self.particle = particles.match?(/['’] \z/) ? particles.rstrip + ' ' : particles.rstrip
+      end
+    end
+
+    # Text after a comma in the given name becomes the suffix
+    # ("John, III"; with "John,! Jr." the suffix keeps its comma)
+    # and trailing lowercase words the dropping particle.
+    def parse_given!
+      if (m = SUFFIX.match(given.to_s))
+        self.given, self.suffix = m[:given], m[:suffix]
+        self.comma_suffix = true unless m[:comma].empty?
+      end
+
+      particles, name = [], given.to_s
+      while (m = GIVEN_PARTICLE.match(name)) && particle_word?(m[:particle])
+        particles.unshift(m[:particle])
+        name = m[:name]
+      end
+
+      unless particles.empty?
+        self.given = name
+        self.dropping_particle = particles.join(' ')
+      end
+    end
+
+    def particle_word?(word)
+      word.sub(/\A[-'ʻ’\s]*/, '').match?(/\A\p{Ll}/)
+    end
+
     def initials_of(string)
       return unless string
 
@@ -386,7 +501,9 @@ module CiteProc
       string = string.gsub(/\.(?=[[:alpha:]])/, '. ')
       string = string.tr('-', ' ') if initialize_without_hyphen?
 
-      string.scan(/([^\s-]+)\s*(-)?\s*/).map { |part, hyphen|
+      # Hyphens followed by a lowercase letter (e.g., "Guo-ping") do not
+      # separate parts of the name
+      string.scan(/((?:[^\s-]|-(?=\p{Ll}))+)\s*(-)?\s*/).map { |part, hyphen|
         part = initial_of(part) || " #{part} "
         hyphen ? "#{part.rstrip}-" : part
       }.join.gsub(/-\s+/, '-').squeeze(' ').strip
@@ -557,7 +674,7 @@ module CiteProc
         when value.is_a?(Name)
           @value << value
         when value.respond_to?(:each_pair), value.respond_to?(:to_hash)
-          @value << Name.new(value)
+          @value << Name.new(value).parse!
         when value.respond_to?(:to_s)
           begin
             @value.concat Namae.parse!(value.to_s).map { |n| Name.new n }

data/lib/citeproc/number.rb

@@ -19,6 +19,13 @@ module CiteProc
     # Ranges between numbers; escaped hyphens are not range delimiters
     RANGE = /(?<![[:alnum:]])#{RANGE_BOUND}\s*[–-]\s*#{RANGE_BOUND}(?![[:alnum:]])/
 
+    PAGE_RANGE = /([[:alnum:]]+)\s*[–-]+\s*([[:alnum:]]+)/
+
+    # A page number with optional prefix and suffix
+    PAGE = /\A(\d*[[:alpha:]]+)?(\d+)([[:alpha:]]*)\z/
+
+    ROMAN = /\A[ivxlcdm]+\z/i
+
     class << self
       def pluralize?(string)
         /\S[\s,&]\S|\df/.match?(string) || RANGE.match?(string)
@@ -37,6 +44,108 @@ module CiteProc
           code * count
         }.join
       end
+
+      # Formats the page ranges in pages according to format:
+      #
+      # * "chicago-15" (or "chicago") and "chicago-16": 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.
+      # * "minimal-two": As "minimal", but at least two digits
+      #   are kept in the second number: 42-45, 321-28, 2787-816.
+      #
+      # Without a format only the range delimiter is replaced. Ranges
+      # with different prefixes (e.g., "N110-5") keep a plain hyphen;
+      # escaped hyphens ("\-") are not range delimiters.
+      #
+      # @param pages [String] the pages to format
+      # @param format [String, nil] the page range format
+      # @param delimiter [String] the range delimiter
+      # @return [String, nil] the formatted pages
+      def format_page_range(pages, format = nil, delimiter = '–')
+        return if pages.nil?
+
+        pages.to_s
+          .gsub(PAGE_RANGE) { format_page_bounds($1, $2, format, delimiter) || "#{$1}-#{$2}" }
+          .gsub('\\-', '-')
+      end
+
+      private
+
+      # @return [String, nil] the formatted page range or nil if
+      #   the bounds do not form a page range
+      def format_page_bounds(from, to, format, delimiter)
+        if ROMAN.match?(from) && ROMAN.match?(to)
+          return "#{from}#{delimiter}#{to}"
+        end
+
+        f, t = PAGE.match(from), PAGE.match(to)
+
+        # Ranges must have the same prefix on both sides
+        return unless f && t && f[1] == t[1]
+
+        # When there are suffixes or no format was
+        # specified we only replace the delimiter
+        if format.nil? || !f[3].empty? || !t[3].empty?
+          return "#{from}#{delimiter}#{to}"
+        end
+
+        prefix = f[1]
+        last = format_page_number(f[2], t[2].dup, format)
+
+        # The prefix is repeated only for expanded ranges
+        "#{prefix}#{f[2]}#{delimiter}#{prefix if format == 'expanded'}#{last}"
+      end
+
+      def format_page_number(f, t, format)
+        dim = f.length
+        delta = dim - t.length
+
+        if delta >= 0
+          t.prepend f[0, delta] unless delta.zero?
+
+          format = 'chicago-15' if format == 'chicago'
+
+          if format == 'chicago-15' || format == 'chicago-16'
+            # Only the 15th edition expands four digit
+            # numbers when three or more digits change
+            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 && format == 'chicago-15' && 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
+
+        t
+      end
     end
 
     def <=>(other)

data/lib/citeproc/utilities.rb

@@ -15,6 +15,15 @@ module CiteProc
       process(:bibliography, items, options)
     end
 
+    # @param string [String, nil]
+    # @return [Boolean] whether or not the string starts with a letter of
+    #   a script which separates words by spaces (as decided by citeproc-js);
+    #   the Hebrew conjunction "ו" is excluded because it is written as a
+    #   prefix of the following word
+    def romanesque_start?(string)
+      /\A(?!ו)[&\p{Latin}\p{Greek}\p{Cyrillic}\p{Hebrew}\p{Arabic}\p{Thai}]/.match?(string.to_s)
+    end
+
     # @param value [String, Boolean, nil] an xsd:boolean value
     # @param default [Boolean] the value if the value is not set
     # @return [Boolean] the boolean value

data/lib/citeproc/version.rb

@@ -1,3 +1,3 @@
 module CiteProc
-  VERSION = '1.3.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: citeproc
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Sylvester Keil
 bindir: bin
 cert_chain: []
-date: 2026-10-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: namae
@@ -15,56 +15,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: date
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: forwardable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: observer
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +93,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: citeproc-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: A cite processor interface for Citation Style Language (CSL) styles.
 email:
 - sylvester@keil.or.at
@@ -124,7 +138,10 @@ files:
 homepage: https://github.com/inukshuk/citeproc
 licenses:
 - BSD-2-Clause
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/inukshuk/citeproc
+  bug_tracker_uri: https://github.com/inukshuk/citeproc/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib