citeproc 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9053957ce407de4b219008b6f732e9037a6bdec99dc4e04792bb8ca4f46f9f42
-  data.tar.gz: 96e2cbde7609f0fc9aa2c52d972a7ab51e16bce2cb3412d7042c02f32a47c08f
+  metadata.gz: 21838f9d914cb947a14c36bf1b65271170de7a12d40eb069921e3a2ab3fe8a2a
+  data.tar.gz: bf916ee190ab7850caacde982b7510ffa045d2d5e276b30e9cd3a112ef644e7b
 SHA512:
-  metadata.gz: b2e50088fd201c2546614cb5e90e6862d4b4b07ec3b5a87262b9bd70cfd453e1dc051ffaaa02379e10b709da5f5c455eca61b003b31049165a9ebf8f79f7ba63
-  data.tar.gz: 636492e1a454f7f6a3ade9c30c1346cd036df0067be69b3d4102cf0b590df0959aa6dab6a619bd17333512ab6723c4d3a6823bc66fe6b334c2e9a001e5fffcae
+  metadata.gz: 7e4d56b5e112d3a3b94b931f648a75947efce1613f33ce147991ff9d8e2497ba33c002a547f403c9977ff65f6375ce2ebf7edbbe958ec3ea5b8daebfc819ba4c
+  data.tar.gz: 3be138495514a7f85ab8df3e22215c181069d0417aa8a863173592618fab37741e5b5691a3b52770deefcd7fb2bfed95077172c3f994b558e54daa0df11605db

data/README.md

@@ -86,10 +86,9 @@ You can speed up the XML parsing by installing
 [Nokogiri](https://rubygems.org/gems/nokogiri);
 otherwise the REXML from the Ruby standard library will be used.
 
-Similarly, you can install either of the gems
-[EDTF](https://rubygems.org/gems/edtf) or
-[Chronic](https://rubygems.org/gems/chronic)
-to support a wide range of additional inputs for date variables.
+Similarly, you can install the
+[EDTF](https://rubygems.org/gems/edtf)
+gem to support a wide range of additional inputs for date variables.
 
 CSL Styles and Locales
 ----------------------
@@ -111,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/attributes.rb

@@ -37,7 +37,7 @@ module CiteProc
       return false if value.nil?
       return false if value.respond_to?(:empty?) && value.empty?
 
-      value.to_s !~ /^(false|no|never)$/i
+      value.to_s !~ /^(false|no|never|0)$/i
     end
 
     def filter_key(key)
@@ -108,7 +108,7 @@ module CiteProc
       case
       when equal?(other)
         true
-      when self.class != other.class, length != other.length
+      when self.class != other.class, attributes.length != other.attributes.length
         false
       else
         other.attributes.each_pair do |key, value|

data/lib/citeproc/bibliography.rb

@@ -193,7 +193,7 @@ module CiteProc
     end
 
     def hanging_indent?
-      options[:'hanging_indent']
+      CiteProc.boolean(options[:'hanging-indent'])
     end
 
     def join()

data/lib/citeproc/citation_data.rb

@@ -11,12 +11,72 @@ module CiteProc
     include Comparable
 
     @labels = [
-      :book, :chapter, :column, :figure, :folio, :issue, :line, :note, :opus,
-      :page, :paragraph, :part, :section, :'sub-verbo', :verse, :volume
+      :act,
+      :appendix,
+      :'article-locator',
+      :book,
+      :canon,
+      :chapter,
+      :column,
+      :elocation,
+      :equation,
+      :figure,
+      :folio,
+      :issue,
+      :line,
+      :note,
+      :opus,
+      :page,
+      :paragraph,
+      :part,
+      :rule,
+      :scene,
+      :section,
+      :'sub-verbo',
+      :supplement,
+      :table,
+      :timestamp,
+      :'title-locator',
+      :verse,
+      :version,
+      :volume
     ].freeze
 
+    # Abbreviations of locator labels (for extraction)
+    @locator_abbreviations = {
+      'app.' => 'appendix',
+      'art.' => 'article-locator',
+      'bk.' => 'book',
+      'ch.' => 'chapter',
+      'col.' => 'column',
+      'fig.' => 'figure',
+      'fol.' => 'folio',
+      'l.' => 'line',
+      'n.' => 'note',
+      'no.' => 'issue',
+      'op.' => 'opus',
+      'p.' => 'page',
+      'pp.' => 'page',
+      'para.' => 'paragraph',
+      'pt.' => 'part',
+      'r.' => 'rule',
+      'sec.' => 'section',
+      'supp.' => 'supplement',
+      'sv.' => 'sub-verbo',
+      'tbl.' => 'table',
+      'tit.' => 'title-locator',
+      'vol.' => 'volume',
+      'vrs.' => 'verse'
+    }.freeze
+
     class << self
-      attr_reader :labels
+      attr_reader :labels, :locator_abbreviations
+
+      # @param abbreviations [Hash<String,String>] label abbreviations
+      # @return [Regexp] a pattern matching any of the abbreviations
+      def locator_label_pattern(abbreviations = locator_abbreviations)
+        Regexp.union(abbreviations.keys.sort_by { |abbr| -abbr.length })
+      end
     end
 
     # @!attribute id
@@ -66,6 +126,46 @@ module CiteProc
       yield self if block_given?
     end
 
+    # @return [String, nil] the locator label;
+    #   defaults to "page" if there is a locator
+    def label
+      read_attribute(:label) || ('page' if locator?)
+    end
+
+    # 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?
+
+      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)
+
+      unless match.nil?
+        self.label = abbreviations[match[1]]
+        self.locator = match[2]
+      end
+
+      self
+    end
+
     def initialize_copy(other)
       @attributes = other.attributes.deep_copy
     end
@@ -83,8 +183,6 @@ module CiteProc
   end
 
 
-
-
   class CitationData
 
     extend Forwardable

data/lib/citeproc/date.rb

@@ -7,8 +7,8 @@ module CiteProc
   #
   # {Date Dates} can be constructed from a wide range of input values,
   # including Ruby date objects, integers, date ranges, ISO 8601 and
-  # CiteProc JSON strings or hashes, and - provided you have the respective
-  # gems installed - EDTF strings all strings supported by Chronic.
+  # CiteProc JSON strings or hashes, and - provided you have the EDTF gem
+  # installed - EDTF strings.
   #
   # @example Initialization
   #   CiteProc::Date.new
@@ -17,9 +17,6 @@ module CiteProc
   #   CiteProc::Date.today
   #   #-> #<CiteProc::Date "[2012, 6, 10]">
   #
-  #   CiteProc::Date.new('Yesterday')
-  #   #-> #<CiteProc::Date "[[2012, 6, 9]]">
-  #
   #   CiteProc::Date.new(1966)
   #   #-> #<CiteProc::Date "[1966]">
   #
@@ -80,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
 
@@ -98,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?
@@ -129,6 +132,19 @@ module CiteProc
         !bc? && year < 1000
       end
 
+      # 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 - 13) % 4 + 1 if month && month.between?(13, 24)
+      end
+
+      # @return [Boolean] whether or not the month encodes a season
+      def season?
+        !season.nil?
+      end
+
       # Formats the date parts according to the passed-in format string.
       # @param format [String] a format string
       # @return [String,nil] the formatted date string; nil if the date
@@ -148,8 +164,10 @@ module CiteProc
       # @return [Fixnum,nil] the result of the comparison (-1, 0, 1 or nil)
       def <=>(other)
         case
+        when other.is_a?(DateParts) && season? && other.season?
+          [year, season] <=> [other.year, other.season]
         when other.is_a?(DateParts)
-          to_citeproc <=> other.to_citeproc
+          comparable <=> other.comparable
         when other.respond_to?(:to_date)
           to_date <=> other.to_date
         else
@@ -192,6 +210,14 @@ module CiteProc
       def inspect
         "#<DateParts #{to_s}>"
       end
+
+      protected
+
+      # Seasons are compared like dates without month.
+      # @return [Array<Fixnum>] the date parts used for comparison
+      def comparable
+        season? ? to_citeproc.take(1) : to_citeproc
+      end
     end
 
     #
@@ -210,13 +236,11 @@ module CiteProc
     # List of date parsers (must respond to #parse)
     @parsers = []
 
-    [%w{ edtf EDTF }, %w{ chronic Chronic }].each do |date_parser, module_id|
-      begin
-        require date_parser
-        @parsers << ::Object.const_get(module_id)
-      rescue LoadError
-        # warn "failed to load `#{date_parser}' gem"
-      end
+    begin
+      require 'edtf'
+      @parsers << ::EDTF
+    rescue LoadError
+      # warn "failed to load `edtf' gem"
     end
 
     @parsers << ::Date
@@ -229,9 +253,8 @@ module CiteProc
       # A list of available date parsers. Each parser must respond to a
       # #parse method that converts a date string into a Ruby date object.
       # By default, the list will include Ruby's date parser from the
-      # standard library, as well as the parsers of the Chronic and EDTF
-      # gems if they are available; to install the latter on your system
-      # make sure to `gem install chronic edtf`.
+      # standard library, as well as the parser of the EDTF gem if it is
+      # available; to install it on your system run `gem install edtf`.
       #
       # @return [Array] the available date parsers
       attr_reader :parsers
@@ -276,12 +299,44 @@ module CiteProc
     end
 
 
-    # Make Date behave like a regular Ruby Date
-    def_delegators :to_ruby, *::Date.instance_methods(false).reject { |m|
-      m.to_s =~ /^[\W_]|[!=_]$|^(to_s|inspect|dup|clone|change)$|^(marshal|season|year|month|day|certain|uncertain)/
-    }
+    def_delegators :to_ruby, :strftime
+
+    attr_predicates :circa, :literal, :'date-parts'
+
+    # @return [Boolean] whether or not the date has a season field
+    def has_season?
+      attribute?(:season)
+    end
 
-    attr_predicates :circa, :season, :literal, :'date-parts'
+    def season=(season)
+      write_attribute :season, season
+    end
+
+    # Season names recognized in the season field
+    SEASONS = {
+      'spring' => 1, 'summer' => 2, 'autumn' => 3, 'fall' => 3, 'winter' => 4
+    }.freeze
+
+    # A season takes the place of the month. If the (start) date has a
+    # month, the season is encoded by the month (21 to 24); otherwise
+    # the season field is used. Season numbers (1 to 4) and names in
+    # the season field are converted to integers.
+    #
+    # @return [Integer, String, nil] the season (1 to 4), the season
+    #   field as a string if it is not a season number or name, or nil
+    def season
+      return parts[0].season if month
+
+      value = read_attribute(:season) or return
+      name = value.to_s.strip.downcase
+
+      SEASONS[name] || (name.match?(/\A[1-4]\z/) ? name.to_i : value.to_s)
+    end
+
+    # @return [Boolean] whether or not the date has a season (see #season)
+    def season?
+      !season.nil?
+    end
 
     def initialize(value = {})
       super
@@ -321,11 +376,15 @@ module CiteProc
       when value.is_a?(Hash)
         attributes = value.symbolize_keys
 
-        if attributes.has_key?(:raw)
-          @value = Date.parse(attributes.delete(:raw)).value
+        if attributes.has_key?(:raw) && Array(attributes[:'date-parts']).empty?
+          raw = attributes.delete(:raw)
+          attributes.delete(:'date-parts')
+          date = Date.parse(raw)
+
+          @value = date.nil? ? { :literal => raw } : date.value
           @value.merge!(attributes)
         else
-          @value = attributes.deep_copy
+          @value = attributes.except(:raw).deep_copy
         end
         convert_parts!
 
@@ -397,34 +456,16 @@ module CiteProc
       d
     end
 
-    # @return [::Date,nil] the date (start date if this instance is a range); or nil
-    def start_date
-      d = parts[0] and d.to_date
-    end
-
-    def start_date=(date)
-      parts[0] = DateParts.new(date.strftime('%Y-%m-%d').split(/-/))
-    end
-
-    def end_date=(date)
-      parts[1] = DateParts.new(date.nil? ? 0 : date.strftime('%Y-%m-%d').split(/-/))
-    end
-
-    # @return [Date,Range] the date as a Ruby date object or as a Range if
-    #   this instance is closed range
+    # @return [::Date, Range, nil] the date as a Ruby date object or as
+    #   a Range if this instance is closed range
     def to_ruby
       if closed_range?
-        start_date..end_date
+        parts[0].to_date..parts[1].to_date
       else
-        start_date
+        d = parts[0] and d.to_date
       end
     end
 
-    # @return [::Date,nil] the range's end date; or nil
-    def end_date
-      d = parts[1] and d.to_date
-    end
-
     # @return [Boolean] whether or not the date-parts contain an end date
     def has_end_date?
       parts[1] && !parts[1].empty?
@@ -506,7 +547,7 @@ module CiteProc
       case
       when literal?
         literal
-      when season?
+      when has_season?
         season
       else
         parts.map(&:to_citeproc).inspect
@@ -516,8 +557,14 @@ module CiteProc
     def <=>(other)
       case other
       when CiteProc::Date
-        return nil if season? || other.season?
-        parts <=> other.parts
+        result = parts <=> other.parts
+
+        # Seasons are ordered among themselves only
+        if result == 0 && season? && other.season?
+          result = season.to_i <=> other.season.to_i
+        end
+
+        result
       when ::Date
         parts <=> [other]
       else

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,
@@ -92,20 +101,19 @@ module CiteProc
     end
 
     # Names quack sorta like a String
-    def_delegators :to_s, :=~, :===, *String.instance_methods(false).reject { |m|
-      m.to_s =~ /^[\W_]|[!=_]$|^(to_s|inspect|replace|first|last|dup|clone)$/
-    }
+    def_delegators :to_s,
+      :to_str,
+      :=~, :===, :match, :match?, :start_with?, :end_with?, :include?,
+      :upcase, :downcase, :capitalize, :sub, :gsub, :split, :strip
 
-    # Delegate bang! methods to each field's value
-    String.instance_methods(false).each do |m|
-      if m.to_s.end_with?('!')
-        define_method(m) do |*arguments, &block|
-          Name.parts.each do |part|
-            p = attributes[part]
-            p.send(m, *arguments, &block) if p.respond_to?(m)
-          end
-          self
+    # Delegate in-place transformations to each field's value
+    [:gsub!, :sub!, :upcase!, :downcase!, :capitalize!, :strip!].each do |m|
+      define_method(m) do |*arguments, &block|
+        Name.parts.each do |part|
+          p = attributes[part]
+          p.send(m, *arguments, &block) if p.respond_to?(m)
         end
+        self
       end
     end
 
@@ -127,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!
@@ -167,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.
@@ -236,7 +274,7 @@ module CiteProc
 
     # @return [Boolean] whether or not initials will be used for printing
     def initials?
-      !!options[:'initialize-with'] && personal? && romanesque?
+      !!options[:'initialize-with'] && personal? && family? && romanesque?
     end
 
     def initialize_with
@@ -244,7 +282,7 @@ module CiteProc
     end
 
     def initialize_existing_only?
-      options[:initialize].to_s == 'false'
+      !CiteProc.boolean(options[:initialize], true)
     end
 
     def initialize_without_hyphen?
@@ -259,16 +297,15 @@ module CiteProc
       case
       when !initials?
         given
-      when initialize_existing_only?
-        existing_initials_of given
       else
         initials_of given
       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?
@@ -316,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(' ')
-      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
@@ -348,15 +421,15 @@ 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
 
     # @return [String] the name as a string stripped off all markup
     def strip_markup
-      gsub(Variable.markup, '')
+      to_s.gsub(Variable.markup, '')
     end
 
     # @return [self] the name with all parts stripped off markup
@@ -382,37 +455,72 @@ module CiteProc
       super key
     end
 
-    def initials_of(string)
-      return unless string
-      string = string.dup
+    # 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
 
-      string.gsub!(/([[:upper:]])[^[:upper:]\s-]*\s*/, "\\1#{initialize_with}")
+      unless particles.empty?
+        self.family = name
+        self.particle = particles.match?(/['’] \z/) ? particles.rstrip + ' ' : particles.rstrip
+      end
+    end
 
-      initialize_hyphen!(string)
+    # 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
 
-      string.strip!
-      string
-    end
+      particles, name = [], given.to_s
+      while (m = GIVEN_PARTICLE.match(name)) && particle_word?(m[:particle])
+        particles.unshift(m[:particle])
+        name = m[:name]
+      end
 
-    def initialize_hyphen!(string)
-      if initialize_without_hyphen?
-        string.tr!('-', '')
-      else
-        string.gsub!(/\s*-/, '-')
+      unless particles.empty?
+        self.given = name
+        self.dropping_particle = particles.join(' ')
       end
     end
 
-    def existing_initials_of(string)
-      return unless string
-      string = string.dup
-
-      string.gsub!(/([[:upper:]])([[:upper:]])/, '\1 \2')
-      string.gsub!(/\b([[:upper:]])\b[^[:alpha:]-]*/, "\\1#{initialize_with}")
+    def particle_word?(word)
+      word.sub(/\A[-'ʻ’\s]*/, '').match?(/\A\p{Ll}/)
+    end
 
-      initialize_hyphen!(string)
+    def initials_of(string)
+      return unless string
 
-      string.strip!
-      string
+      # Split abbreviations like "M.E" into "M. E"
+      string = string.gsub(/\.(?=[[:alpha:]])/, '. ')
+      string = string.tr('-', ' ') if initialize_without_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
+    end
+
+    # @return [String, nil] the initial for the given part of a name
+    #   or nil if the part should not be initialized
+    def initial_of(part)
+      case part
+      when /\A([[:upper:]])\z/, /\A(.+)\.\z/
+        "#{$1}#{initialize_with}"
+      when /\A[[:upper:]]{2}[[:lower:]]/
+        # Two letter initials like "Ts" for "TSerendorjiin"
+        "#{part[0, 2].capitalize}#{initialize_with}" unless initialize_existing_only?
+      when /\A[[:upper:]]/
+        "#{part[0]}#{initialize_with}" unless initialize_existing_only?
+      end
     end
   end
 
@@ -566,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

@@ -13,9 +13,22 @@ module CiteProc
       ['i',    1]
     ].freeze
 
+    # Numbers (with optional prefixes and suffixes) or roman numerals
+    RANGE_BOUND = /(?:[[:alnum:]]*\d[[:alnum:]]*|[ivxlcdm]+)/i
+
+    # 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/ === string
+        /\S[\s,&]\S|\df/.match?(string) || RANGE.match?(string)
       end
 
       # @param number [#to_i] the number to convert
@@ -31,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/selector.rb

@@ -19,11 +19,12 @@ module CiteProc
 
     attr_reader :type, :conditions, :skip_conditions, :custom_matcher
 
-    def initialize(attributes = nil)
+    def initialize(attributes = nil, &block)
       @conditions, @skip_conditions = {}, {}
 
       if block_given?
         @type = :ruby
+        @custom_matcher = block
 
       else
         unless attributes.nil? || attributes.empty?
@@ -54,12 +55,12 @@ module CiteProc
       @type = other.type
       @conditions = other.conditions.deep_copy
       @skip_conditions = other.skip_conditions.deep_copy
-      @custom_matcher = other
+      @custom_matcher = other.custom_matcher
     end
 
     def type=(type)
       raise TypeError, "failed to set selector type to #{type.inspect}" unless
-        type.respond_to(:to_sym) && Selector.types.include?(type.to_sym)
+        type.respond_to?(:to_sym) && Selector.types.include?(type.to_sym)
 
       @type = type.to_sym
     end
@@ -69,7 +70,7 @@ module CiteProc
     end
 
     def custom_matcher?
-      defined?(@custom_matcher)
+      !custom_matcher.nil?
     end
 
     alias ruby? custom_matcher?

data/lib/citeproc/utilities.rb

@@ -15,6 +15,26 @@ 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
+    def boolean(value, default = false)
+      case value.to_s
+      when 'true', '1' then true
+      when 'false', '0' then false
+      else default
+      end
+    end
+
   end
 
 end

data/lib/citeproc/variable.rb

@@ -131,12 +131,15 @@ module CiteProc
     # @return [Object] the value wrapped by this variable
     attr_accessor :value
 
+    # In-place transformations of the value
     def_delegators :@value, :to_s,
-      *::String.instance_methods(false).select {|m| m.to_s =~ /!$/ }
+      :gsub!, :sub!, :upcase!, :downcase!, :capitalize!, :strip!
 
-    def_delegators :to_s, :=~, :===, *String.instance_methods(false).reject { |m|
-      m.to_s =~ /^[\W_]|[!=_]$|^(to_s|inspect|replace|first|last|dup|clone|to_f|to_i)$/
-    }
+    # Variables quack sorta like a String
+    def_delegators :to_s,
+      :to_str, :empty?,
+      :=~, :===, :match, :match?, :start_with?, :end_with?, :include?,
+      :upcase, :downcase, :capitalize, :sub, :gsub, :split, :strip
 
 
     # Creates new Variable for the passed-in value
@@ -226,7 +229,7 @@ module CiteProc
 		#
     # @return [Boolean] whether or not the variable's value is numeric
     def numeric?
-      !!match(/^[\w\.:;]*\d+[\w\.:;]*(\s*[,&-]\s*[\w\.:;]*\d+[\w\.:;]*)*$/i)
+      !!to_s.match(/^[\w\.:;]*\d+[\w\.:;]*(\s*[,&-]\s*[\w\.:;]*\d+[\w\.:;]*)*$/i)
     end
 
     def date?
@@ -247,7 +250,7 @@ module CiteProc
 
     # @return [String] the variable's value stripped of markup
     def strip_markup
-      gsub(Variable.markup, '')
+      to_s.gsub(Variable.markup, '')
     end
 
     # Strips markup off the variable's value.
@@ -274,6 +277,20 @@ module CiteProc
       end
     end
 
+    # Variables are equal (in the sense of eql?) if they are of
+    # the same type and have the same value.
+    #
+    # @param other [Object] the object used for comparison
+    # @return [Boolean]
+    def eql?(other)
+      other.instance_of?(self.class) && value.eql?(other.value)
+    end
+
+    # @return [Integer] a hash value based on the type and value
+    def hash
+      [self.class, value].hash
+    end
+
     # @!method to_s
     # @return [String] the variable's value as a string
     alias to_citeproc to_s

data/lib/citeproc/version.rb

@@ -1,3 +1,3 @@
 module CiteProc
-  VERSION = '1.2.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.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Sylvester Keil
 bindir: bin
 cert_chain: []
-date: 2026-10-05 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