neu-mods 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa2cba0771dfcd203ae956c9f5a84cb58c004df684620e378bf4034b978ee6b3
-  data.tar.gz: e3610d3984fecaebccdb88032ab07b4fab55b0e6932ee5f54218b654016ceca5
+  metadata.gz: 66a8dc19c0e19ccd43f170c117414ddb1df82c3cec889a83c27c6416f778173b
+  data.tar.gz: 445176fc7abc0748d47eddae0ee99137321c743b53a9de3432bb5e45a418ea68
 SHA512:
-  metadata.gz: 8bcbcf544da159f6e2377ae868808e73e78d254e9c597e2dcd676d140cbb6f59a8624ca698233bd0ab18866c9438ddae988a7fc0ac485ce7fa3557c34d199a76
-  data.tar.gz: de478ac9c203c1edf05fb604c9da85b05e95e133fb20231716a6ef7dd9310292dacf753f13781d253ecbd93a04aa290e2eff40dc32c5331de0e278c1b07c736f
+  metadata.gz: 1f453251ae9fd5c98737370fcd26e69d85cc8cf615d4e16bf1fd2b0e0f6cb80a23a9b6819fb1f364044161725a9f828c8df3776b760b5b59f24ac0589ed956b3
+  data.tar.gz: 7a04ed96b243039b19457a7df660966f9cd73ec1de92585403fa02a2c0711a80455029d1107cb4d7f3efac9d39b3acf0069bd1ce00031856fff2ce0b350558e6

data/.version

@@ -1 +1 @@
-0.10.0
+0.12.0

data/README.md

@@ -27,24 +27,53 @@ require "neu-mods"
 doc = NEU::MODS::Document.parse(xml_string)
 
 # Projection (plain data)
-doc.plain_title    # => "What's New - How We Respond to Disaster, Episode 1"
+doc.plain_title    # => "What's New, Episode 1 - How We Respond to Disaster"
 doc.title_parts    # => { non_sort:, subtitle:, title:, part_name:, part_number: }
                    #    byte-faithful -- the edit forms pre-fill from these
 doc.abstract       # => normalized, paragraph-joined String
-doc.languages      # => ["English"]   a code-only <languageTerm>eng</> included
+doc.languages      # => [{ term: "English", object_part: nil, script: nil }, ...]
+                   #    a code-only <languageTerm>eng</> is read through the
+                   #    ISO 639 registry. @objectPart rides along because
+                   #    objectPart="subtitles" says the SUBTITLES are Spanish,
+                   #    not the resource
 doc.topical_subjects # => ["Civil society", ...]   (every <topic>, for the access copy)
 doc.keywords       # => [...]   (only the editable attribute-free keyword subjects)
 doc.date_created_parts
                    # => { value:, precision:, end_value:, end_precision:,
-                   #      qualifier:, key_date: }   everything the record
+                   #      qualifier:, key_date:, text: }   everything the record
                    #    declared about one date. w3cdtf YYYY, YYYY-MM and
                    #    YYYY-MM-DD all parse, and the precision says which
                    #    shape it gave, so display cannot invent a month or a
                    #    day. The points are read by @point, not by document
                    #    order, and the end carries its OWN precision.
-                   #    Same for date_issued_parts and copyright_date_parts;
-                   #    each part is also a reader of its own, e.g.
+                   #    A keyDate="yes" node chooses the value, ahead of
+                   #    @point and document order; one date per type is the
+                   #    rule, so an unflagged repeat is discarded.
+                   #    A value that is not a w3cdtf date projects NO date
+                   #    and keeps its literal in :text -- "19uu", "ca. 1920"
+                   #    and "undated" are statements a cataloguer made, and
+                   #    guessing a date for them is worse than either losing
+                   #    them or showing them as written.
+                   #    Same for the other six originInfo dates --
+                   #    date_issued, copyright_date, date_captured,
+                   #    date_valid, date_other and date_modified. Each part is
+                   #    also a reader of its own, e.g.
                    #    doc.date_created_qualifier.
+doc.place_of_publication
+                   # => ["Boston"]   the type="text" placeTerm wins, and a
+                   #    bare marccountry code drops rather than reaching a
+                   #    places facet as a place name. A bare code under any
+                   #    other authority still projects
+doc.host_collections
+                   # => [{ title:, volume:, issue:, start_page:, end_page:,
+                   #      date:, text:, details: [...], extents: [...] }, ...]
+                   #    this work's position in its host. The entry survives on
+                   #    its part alone, so a host with no titleInfo is kept
+doc.identifiers    # => [{ type: "isbn", value: "...", invalid: false }, ...]
+                   #    @invalid means cancelled or superseded, so it travels
+doc.table_of_contents
+                   # => ["Ch 1\nCh 2"]   line breaks kept: in a contents list
+                   #    the break is the structure, not stray formatting
 doc.notes          # => [{ type: "funding", value: "..." }, ...]
 doc.related_items  # => [{ type: "otherFormat", title: "..." }, ...]
                    #    every relatedItem that is not a series or a host
@@ -69,7 +98,9 @@ NEU::MODS::FIELDS  # => { main_title: :one, names: :many, ... }
 # the parts (e.g. Atlas's access-copy model) and must not re-parse XML on read.
 NEU::MODS.compose_title(non_sort: "", title: "What's New",
                         part_name: "How We Respond to Disaster", part_number: "Episode 1")
-# => "What's New - How We Respond to Disaster, Episode 1"   (== doc.plain_title)
+# => "What's New, Episode 1 - How We Respond to Disaster"   (== doc.plain_title)
+# The part NUMBER precedes the part NAME: "Part 2. The Marshes" is the
+# cataloguing convention, and titleInfo is an unordered choice in the schema.
 
 # Selectors (live nodes — for editing)
 node = doc.primary_title_info.at_xpath("mods:title", NEU::MODS::NAMESPACE)

data/lib/neu/mods/canonicalize.rb

@@ -18,6 +18,15 @@ module NEU
         str.to_s.tr(NBSP, " ").gsub(/\s+/, " ").strip
       end
 
+      # canonical_ws per line, keeping the line breaks. For a field where a
+      # newline is structure rather than formatting -- tableOfContents, where
+      # the break separates one entry from the next. Blank lines drop, so a
+      # double-spaced list does not project empty entries.
+      def canonical_lines(str)
+        str.to_s.tr(NBSP, " ").split("\n").map { |line| line.gsub(/\s+/, " ").strip }
+           .reject(&:empty?).join("\n")
+      end
+
       # Treat values differing only by insignificant whitespace (NBSP vs space,
       # collapsible runs, leading/trailing) as equal.
       def whitespace_equivalent?(current, incoming)

data/lib/neu/mods/projection.rb

@@ -52,10 +52,17 @@ module NEU
       # (reaching for Nokogiri in a decorator is the smell this avoids). Keys:
       # :non_sort :title :subtitle :part_name :part_number (nil or "" for absent).
       # Returns "" when there is no title. Exposed as NEU::MODS.compose_title.
+      #
+      # The part NUMBER precedes the part NAME. titleInfo is an unordered choice
+      # in the schema, so no document order is available to follow, and a fixed
+      # order that put the name first read the number as a trailing qualifier on
+      # the section rather than as the section it numbers. Cataloguing practice
+      # is "Part 2. The Marshes". The separator travels with the part, not with
+      # the position, so the swap moves the comma with the number.
       def self.compose_title(parts)
         return "" if parts[:title].to_s.strip.empty?
 
-        optional = { ": " => parts[:subtitle], " - " => parts[:part_name], ", " => parts[:part_number] }
+        optional = { ": " => parts[:subtitle], ", " => parts[:part_number], " - " => parts[:part_name] }
         suffix = optional.filter_map { |sep, val| "#{sep}#{val}" unless val.to_s.strip.empty? }.join
         "#{join_non_sort(parts[:non_sort], parts[:title])}#{suffix}"
       end
@@ -106,6 +113,12 @@ module NEU
       def use_and_reproduction = access_conditions_of_type("use and reproduction")
       def restriction_on_access = access_conditions_of_type("restriction on access")
 
+      # An open-string @type reduced to its letters and digits, so casing, word
+      # separators and camelCasing cannot decide whether a field matches.
+      def self.fold_type(str)
+        NEU::MODS.canonical_ws(str).downcase.gsub(/[^a-z0-9]/, "")
+      end
+
       # --- Subjects ------------------------------------------------------------
 
       # The editable free-text keyword set (Cerberus simple form): topics under the
@@ -205,8 +218,18 @@ module NEU
       # cataloguer who records that a person both wrote and edited a work means
       # both. Each term prefers the type="text" roleTerm, falling back to the raw
       # code (NOT MARC-relator-translated -- see README).
+      #
+      # A name with no name text drops out. A mods:name carrying only a role
+      # projected { name: nil, roles: ["edt"] }, which a display renders as a
+      # labelled empty row and which every consumer had to guard against with
+      # its own compact_blank. #preserved_names deliberately keeps it: that list
+      # tells a curator what the XML holds, so an element they need to fix has
+      # to stay visible there.
       def names
-        doc.xpath("/mods:mods/mods:name", NAMESPACE).map { |node| name_entry(node) }
+        doc.xpath("/mods:mods/mods:name", NAMESPACE).filter_map do |node|
+          entry = name_entry(node)
+          entry if entry[:name]
+        end
       end
 
       # Editable (depositor-managed) creators: the plain names (no authority
@@ -233,17 +256,24 @@ module NEU
 
       # --- Scalars / simple arrays --------------------------------------------
 
-      # Prefer the type="text" term, and translate a code-only one through the
-      # ISO 639 registry. A record saying `eng` projects "English", so the
-      # display and the Solr language facet read the same value rather than the
-      # facet showing codes. An unrecognised code survives as itself.
+      # { term:, object_part:, script: } per language element. Prefer the
+      # type="text" term, and translate a code-only one through the ISO 639
+      # registry. A record saying `eng` projects "English", so the display and
+      # the Solr language facet read the same value rather than the facet
+      # showing codes. An unrecognised code survives as itself.
+      #
+      # An entry rather than a bare string because @objectPart changes what the
+      # record is claiming. `<language objectPart="subtitles">spa` says the
+      # subtitles are Spanish, and projected flat it said the resource was --
+      # which is the case a captioned video hits every time. The script rides
+      # along for the same reason a name's role does: a consumer cannot
+      # recover it from the term.
       def languages
         doc.xpath("/mods:mods/mods:language", NAMESPACE).filter_map do |lang|
-          text = lang.at_xpath("mods:languageTerm[@type='text']", NAMESPACE)
-          next clean(text.text) if text
+          term = language_term(lang)
+          next unless term
 
-          code = clean(lang.at_xpath("mods:languageTerm", NAMESPACE)&.text)
-          code && LanguageCodes.term(code)
+          { term: term, object_part: attr_value(lang, "objectPart"), script: script_term(lang) }
         end
       end
 
@@ -263,7 +293,34 @@ module NEU
       # back by nothing.
       def publication_information = texts_at("/mods:mods/mods:originInfo/mods:publisher")
       def edition = texts_at("/mods:mods/mods:originInfo/mods:edition")
-      def place_of_publication = texts_at("/mods:mods/mods:originInfo/mods:place/mods:placeTerm")
+
+      # Prefer the type="text" term per place, falling back to a coded one --
+      # the pattern #role_term_value and #languages already use.
+      #
+      # A bare marccountry code is the exception, and it drops. "mau" is not a
+      # place name, and unfiltered it reached the display and the Solr places
+      # facet as one, sitting in the list beside Boston. That is the call
+      # #geographic_code_subjects already makes for a MARC GAC code. A code
+      # under any other authority survives, because there the code may be the
+      # only statement the record made and nothing here can say it is not text.
+      #
+      # TODO: expand a marccountry code through a registry, as LanguageCodes
+      # does for eng -> English. That needs a vendored code list, and would let
+      # this project "Massachusetts" instead of dropping the element.
+      MARC_COUNTRY_AUTHORITY = "marccountry"
+
+      def place_of_publication
+        doc.xpath("/mods:mods/mods:originInfo/mods:place", NAMESPACE).filter_map do |place|
+          text = clean(place.at_xpath("mods:placeTerm[@type='text']", NAMESPACE)&.text)
+          next text if text
+
+          code = place.at_xpath("mods:placeTerm", NAMESPACE)
+          next if attr_value(code, "authority") == MARC_COUNTRY_AUTHORITY
+
+          clean(code&.text)
+        end
+      end
+
       def issuance = texts_at("/mods:mods/mods:originInfo/mods:issuance")
 
       # Serials. The @authority a record puts on a frequency is not projected:
@@ -272,7 +329,17 @@ module NEU
       # inconsistent.
       def frequency = texts_at("/mods:mods/mods:originInfo/mods:frequency")
 
-      def table_of_contents = texts_at("/mods:mods/mods:tableOfContents")
+      # Read with its line breaks intact. A legacy contents list separates its
+      # entries by newline, and the whitespace collapse every other field wants
+      # ran the entries together into one line -- there the break IS the
+      # structure, not stray formatting. A "--"-separated list is unaffected.
+      def table_of_contents
+        doc.xpath("/mods:mods/mods:tableOfContents", NAMESPACE).filter_map do |node|
+          lines = NEU::MODS.canonical_lines(node.text)
+          lines unless lines.empty?
+        end
+      end
+
       def reformatting_quality = texts_at("/mods:mods/mods:physicalDescription/mods:reformattingQuality")
 
       # A note about the object rather than about the work -- "Scanned at 600
@@ -338,10 +405,14 @@ module NEU
       # record, and a transcribed copy goes stale the moment that record is
       # edited. A part is the exception, because a volume, issue and page range
       # describe this article and no other record holds that fact.
+      #
+      # An entry survives on its part alone. Requiring a title discarded the
+      # one piece of the block that was ours along with the metadata that never
+      # was, and how to render a titleless host is the consumer's call.
       def host_collections
         doc.xpath("/mods:mods/mods:relatedItem[@type='host']", NAMESPACE).filter_map do |node|
-          title = child_text(node, "mods:titleInfo/mods:title")
-          { title: title, **host_part(node) } if title
+          entry = { title: child_text(node, "mods:titleInfo/mods:title"), **host_part(node) }
+          entry if entry.values.any?
         end
       end
 
@@ -349,6 +420,13 @@ module NEU
       # catch-all below does not repeat them.
       NAMED_RELATED_ITEM_TYPES = %w[series host].freeze
 
+      # The part detail types volume and issue already have named keys on a
+      # host entry, so #host_details does not repeat them -- the same split
+      # NAMED_RELATED_ITEM_TYPES makes for relatedItem. A caption is kept
+      # because it is the label a cataloguer wrote for the number ("chap."
+      # before "3"), which no consumer can reconstruct from an open @type.
+      NAMED_HOST_DETAIL_TYPES = %w[volume issue].freeze
+
       # Every other relatedItem, keeping its @type. MODS also defines
       # constituent, otherFormat, original, preceding, succeeding, isReferencedBy
       # and reviewOf, and a record carrying any of them projected nothing at all.
@@ -371,10 +449,13 @@ module NEU
       # is a DOI, and a display cannot decide to linkify it. The same argument
       # #notes already makes for its @type, and #permanent_url already proves
       # the attribute is load-bearing by special-casing @type='hdl'.
+      # @invalid rides along because in MODS it means the identifier is
+      # cancelled, superseded or simply wrong. Projected flat, a dead ISBN read
+      # exactly like a live one and invited a reader to use it.
       def identifiers
         doc.xpath("/mods:mods/mods:identifier", NAMESPACE).filter_map do |node|
           value = clean(node.text)
-          { type: clean(node["type"]), value: value } if value
+          { type: clean(node["type"]), value: value, invalid: attr_value(node, "invalid") == "yes" } if value
         end
       end
 
@@ -383,10 +464,6 @@ module NEU
         node && clean(node.text)
       end
 
-      # The three w3cdtf date shapes a dateCreated may stop at: year, year-month,
-      # or a full date. Matching the shape explicitly, rather than widening
-      # DateTime.parse, is what lets the declared precision fall out of the parse
-      # instead of being guessed after it.
       # The eleven children the XSD allows under hierarchicalGeographic, in the
       # order MODS lists them -- broadest first, which is also the order a
       # consumer composing a place string wants to reverse.
@@ -407,15 +484,27 @@ module NEU
         language_of_cataloging: "mods:languageOfCataloging/mods:languageTerm"
       }.freeze
 
-      W3CDTF_DATE = /\A(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?\z/
+      # The w3cdtf date shapes a date element may stop at: year, year-month, a
+      # full date, or a full date with a time. Matching the shape explicitly,
+      # rather than widening DateTime.parse, is what lets the declared precision
+      # fall out of the parse instead of being guessed after it.
+      #
+      # A value outside these shapes is NOT a date, and #parse_w3cdtf says so
+      # rather than guessing. Ruby's DateTime.parse fills the components it
+      # cannot find from the CURRENT date, so "19uu" -- standard MARC 008 fill,
+      # which the v1 corpus carries at scale -- asserted today's date at "day"
+      # precision, and the assertion changed daily. What the record actually
+      # wrote survives in the matching *_text field instead.
+      W3CDTF_DATE = /\A(\d{4})(?:-(\d{2})(?:-(\d{2})(T\S+)?)?)?\z/
 
       # What #date_parts returns when the element is absent entirely, so an
       # absent date is distinguishable from one present and unparseable.
-      EMPTY_DATE = { value: nil, precision: nil, end_value: nil,
-                     end_precision: nil, qualifier: nil, key_date: nil }.freeze
+      EMPTY_DATE = { value: nil, precision: nil, end_value: nil, end_precision: nil,
+                     qualifier: nil, key_date: nil, text: nil }.freeze
 
       # Everything a record declared about one originInfo date, as
-      # { value:, precision:, end_value:, end_precision:, qualifier:, key_date: }.
+      # { value:, precision:, end_value:, end_precision:, qualifier:, key_date:,
+      #   text: }.
       #
       # A date is not a scalar. Precision established that: a year-only date
       # parses to January 1st, and no consumer downstream can tell that month
@@ -428,10 +517,23 @@ module NEU
       #
       # The parts are projected as separate flat fields rather than one nested
       # value, because the value half has three consumers that need a real date
-      # object -- a Solr sort key, a citation year and an OAI date.
+      # object -- a Solr sort key, a citation year and an OAI date. Those three
+      # are also why the literal gets its own field rather than sharing the
+      # value: a sort key cannot hold "ca. 1920", and a display can.
+      # MODS puts seven date elements under originInfo and this reads all of
+      # them. dateCaptured is when the object was digitised and dateModified is
+      # when the resource changed -- preservation and cataloguing provenance,
+      # which a consumer may keep off a page but cannot recover from anywhere
+      # else. dateValid is the period the content holds for, and dateOther is
+      # where a date fitting no other element lands, which is where a quantity
+      # of migrated v1 date data goes.
       def date_created_parts = date_parts("dateCreated")
       def date_issued_parts = date_parts("dateIssued")
       def copyright_date_parts = date_parts("copyrightDate")
+      def date_captured_parts = date_parts("dateCaptured")
+      def date_valid_parts = date_parts("dateValid")
+      def date_other_parts = date_parts("dateOther")
+      def date_modified_parts = date_parts("dateModified")
 
       def date_created = date_created_parts[:value]
       def date_created_precision = date_created_parts[:precision]
@@ -439,6 +541,7 @@ module NEU
       def date_created_end_precision = date_created_parts[:end_precision]
       def date_created_qualifier = date_created_parts[:qualifier]
       def date_created_key_date = date_created_parts[:key_date]
+      def date_created_text = date_created_parts[:text]
 
       def date_issued = date_issued_parts[:value]
       def date_issued_precision = date_issued_parts[:precision]
@@ -446,6 +549,7 @@ module NEU
       def date_issued_end_precision = date_issued_parts[:end_precision]
       def date_issued_qualifier = date_issued_parts[:qualifier]
       def date_issued_key_date = date_issued_parts[:key_date]
+      def date_issued_text = date_issued_parts[:text]
 
       def copyright_date = copyright_date_parts[:value]
       def copyright_date_precision = copyright_date_parts[:precision]
@@ -453,6 +557,39 @@ module NEU
       def copyright_date_end_precision = copyright_date_parts[:end_precision]
       def copyright_date_qualifier = copyright_date_parts[:qualifier]
       def copyright_date_key_date = copyright_date_parts[:key_date]
+      def copyright_date_text = copyright_date_parts[:text]
+
+      def date_captured = date_captured_parts[:value]
+      def date_captured_precision = date_captured_parts[:precision]
+      def date_captured_end = date_captured_parts[:end_value]
+      def date_captured_end_precision = date_captured_parts[:end_precision]
+      def date_captured_qualifier = date_captured_parts[:qualifier]
+      def date_captured_key_date = date_captured_parts[:key_date]
+      def date_captured_text = date_captured_parts[:text]
+
+      def date_valid = date_valid_parts[:value]
+      def date_valid_precision = date_valid_parts[:precision]
+      def date_valid_end = date_valid_parts[:end_value]
+      def date_valid_end_precision = date_valid_parts[:end_precision]
+      def date_valid_qualifier = date_valid_parts[:qualifier]
+      def date_valid_key_date = date_valid_parts[:key_date]
+      def date_valid_text = date_valid_parts[:text]
+
+      def date_other = date_other_parts[:value]
+      def date_other_precision = date_other_parts[:precision]
+      def date_other_end = date_other_parts[:end_value]
+      def date_other_end_precision = date_other_parts[:end_precision]
+      def date_other_qualifier = date_other_parts[:qualifier]
+      def date_other_key_date = date_other_parts[:key_date]
+      def date_other_text = date_other_parts[:text]
+
+      def date_modified = date_modified_parts[:value]
+      def date_modified_precision = date_modified_parts[:precision]
+      def date_modified_end = date_modified_parts[:end_value]
+      def date_modified_end_precision = date_modified_parts[:end_precision]
+      def date_modified_qualifier = date_modified_parts[:qualifier]
+      def date_modified_key_date = date_modified_parts[:key_date]
+      def date_modified_text = date_modified_parts[:text]
 
       # The [value, precision] pair the precision work introduced. Retained
       # because it is the documented entry point for a caller that wants both
@@ -506,26 +643,58 @@ module NEU
         edition: :many,
         issuance: :many,
         frequency: :many,
-        # Six rows per originInfo date. Flat rather than one nested value,
-        # because the value half has consumers that need a real date object.
+        # Seven rows per originInfo date, for each of the seven MODS defines.
+        # Flat rather than one nested value, because the value half has
+        # consumers that need a real date object.
         date_created: :one,
         date_created_precision: :one,
         date_created_end: :one,
         date_created_end_precision: :one,
         date_created_qualifier: :one,
         date_created_key_date: :one,
+        date_created_text: :one,
         date_issued: :one,
         date_issued_precision: :one,
         date_issued_end: :one,
         date_issued_end_precision: :one,
         date_issued_qualifier: :one,
         date_issued_key_date: :one,
+        date_issued_text: :one,
         copyright_date: :one,
         copyright_date_precision: :one,
         copyright_date_end: :one,
         copyright_date_end_precision: :one,
         copyright_date_qualifier: :one,
         copyright_date_key_date: :one,
+        copyright_date_text: :one,
+        date_captured: :one,
+        date_captured_precision: :one,
+        date_captured_end: :one,
+        date_captured_end_precision: :one,
+        date_captured_qualifier: :one,
+        date_captured_key_date: :one,
+        date_captured_text: :one,
+        date_valid: :one,
+        date_valid_precision: :one,
+        date_valid_end: :one,
+        date_valid_end_precision: :one,
+        date_valid_qualifier: :one,
+        date_valid_key_date: :one,
+        date_valid_text: :one,
+        date_other: :one,
+        date_other_precision: :one,
+        date_other_end: :one,
+        date_other_end_precision: :one,
+        date_other_qualifier: :one,
+        date_other_key_date: :one,
+        date_other_text: :one,
+        date_modified: :one,
+        date_modified_precision: :one,
+        date_modified_end: :one,
+        date_modified_end_precision: :one,
+        date_modified_qualifier: :one,
+        date_modified_key_date: :one,
+        date_modified_text: :one,
 
         # physical description
         resource_type: :many,
@@ -598,37 +767,62 @@ module NEU
 
       # --- helpers -------------------------------------------------------------
 
-      # A shape-matched but impossible date (2026-13, 2026-02-30) reaches DateTime
-      # and raises; it falls to the "" sentinel like any other unparseable value.
-      # Anything outside the three shapes keeps the old permissive parse, so a
-      # timestamp still projects as a full date.
+      # [DateTime, precision] for a w3cdtf date, or nil for a string that is not
+      # one. A shape-matched but impossible date (2026-13, 2026-02-30) reaches
+      # DateTime, raises, and is nil like any other unreadable value; the caller
+      # keeps its literal text.
+      #
+      # A full timestamp goes through DateTime.parse rather than being rebuilt,
+      # so the time of day a dateModified declares survives. Its precision is
+      # "day" because that is the finest granularity a consumer renders.
       def parse_w3cdtf(str)
         m = W3CDTF_DATE.match(str)
-        return [DateTime.parse(str), "day"] unless m
-
-        precision = if m[3]
-                      "day"
-                    elsif m[2]
-                      "month"
-                    else
-                      "year"
-                    end
-        [DateTime.new(m[1].to_i, (m[2] || 1).to_i, (m[3] || 1).to_i), precision]
+        return nil unless m
+        return [DateTime.parse(str), "day"] if m[4]
+
+        [DateTime.new(m[1].to_i, (m[2] || 1).to_i, (m[3] || 1).to_i), w3cdtf_precision(m)]
       rescue Date::Error
-        ["", nil]
+        nil
+      end
+
+      # The granularity the record stopped at, which is the whole point of
+      # matching the shape rather than widening the parse.
+      def w3cdtf_precision(match)
+        return "day" if match[3]
+
+        match[2] ? "month" : "year"
       end
 
       # One originInfo date element, read by its attributes rather than by
       # position. A record is free to write point="end" first, and taking the
       # first node would then invert the range.
+      #
+      # ONE DATE PER TYPE is the rule, and a repeated, non-ranged, unflagged
+      # date of the same type is discarded. A range is one date with two ends,
+      # which @point already models, and every consumer of the value -- a sort
+      # key, a citation year, an OAI date -- holds exactly one. Note the
+      # contrast with a repeated publisher, which survives because
+      # publication_information is :many; dates differ because the value is
+      # singular downstream, not because repetition went unnoticed.
       def date_parts(element)
         nodes = doc.xpath("/mods:mods/mods:originInfo/mods:#{element}", NAMESPACE)
         return EMPTY_DATE if nodes.empty?
 
-        start = nodes.find { |n| attr_value(n, "point") == "start" } ||
-                nodes.find { |n| attr_value(n, "point") != "end" }
         finish = nodes.find { |n| attr_value(n, "point") == "end" }
-        date_entry(start, finish, nodes)
+        date_entry(start_date_node(nodes), finish, nodes)
+      end
+
+      # The node the value comes from: the flagged one, then the declared
+      # start, then document order.
+      #
+      # keyDate leads because the flag is the record nominating its own
+      # principal date. Projecting the flag while reading the value from a
+      # different node made the two contradict each other -- a consumer was told
+      # the record chose this date and then handed the one before it.
+      def start_date_node(nodes)
+        nodes.find { |n| attr_value(n, "keyDate") == "yes" && attr_value(n, "point") != "end" } ||
+          nodes.find { |n| attr_value(n, "point") == "start" } ||
+          nodes.find { |n| attr_value(n, "point") != "end" }
       end
 
       # The end point carries its OWN precision. "1935-06" to "1940" is legal,
@@ -641,7 +835,7 @@ module NEU
       # itself: MODS enumerates approximate, inferred and questionable, but the
       # record still said something.
       def date_entry(start, finish, nodes)
-        value, precision = node_date(start)
+        value, precision, text = node_date(start)
         end_value, end_precision = node_date(finish)
         {
           value: value,
@@ -649,17 +843,28 @@ module NEU
           end_value: end_value,
           end_precision: end_precision,
           qualifier: attr_value(start, "qualifier") || attr_value(finish, "qualifier"),
-          key_date: nodes.any? { |n| attr_value(n, "keyDate") == "yes" }
+          key_date: nodes.any? { |n| attr_value(n, "keyDate") == "yes" },
+          text: text
         }
       end
 
+      # [value, precision, text]. A node whose text is not a w3cdtf date yields
+      # no value and keeps its literal instead: "ca. 1920", "19th century" and
+      # "1918-1921" in one element are all real statements a cataloguer made,
+      # and a preservation repository must neither invent a date for them nor
+      # delete them. Only the start node's literal is kept -- the observed
+      # corpus writes an unreadable date as one element, and an end point that
+      # needs its own literal has never been seen.
       def node_date(node)
-        return [nil, nil] unless node
+        return [nil, nil, nil] unless node
 
         str = NEU::MODS.canonical_ws(node.text)
-        return [nil, nil] if str.empty?
+        return [nil, nil, nil] if str.empty?
+
+        parsed = parse_w3cdtf(str)
+        return [parsed[0], parsed[1], nil] if parsed
 
-        parse_w3cdtf(str)
+        [nil, nil, str]
       end
 
       def attr_value(node, name)
@@ -738,6 +943,14 @@ module NEU
       # punctuation of a citation is display policy, the same call #map_data
       # makes for cartographics. MODS leaves @unit optional, so a page extent
       # without one is read rather than dropped.
+      #
+      # Volume, issue and the page range keep named keys because they are the
+      # citation and a consumer asks for them by name. Everything else the
+      # schema allows under part arrives structured, because detail/@type and
+      # extent/@unit are open strings -- a fixed key per type cannot cover a
+      # vocabulary the schema does not close. #date is the article's year within
+      # the host, which after the title is the most-cited element of a journal
+      # citation and was reaching no consumer at all.
       def host_part(node)
         part = node.at_xpath("mods:part", NAMESPACE)
         return {} if part.nil?
@@ -747,8 +960,46 @@ module NEU
           volume: child_text(part, "mods:detail[@type='volume']/mods:number"),
           issue: child_text(part, "mods:detail[@type='issue']/mods:number"),
           start_page: child_text(part, "#{pages}/mods:start"),
-          end_page: child_text(part, "#{pages}/mods:end")
-        }.compact
+          end_page: child_text(part, "#{pages}/mods:end"),
+          date: child_text(part, "mods:date"),
+          text: child_text(part, "mods:text"),
+          details: host_details(part),
+          extents: host_extents(part)
+        }.reject { |_, value| value.nil? || value == [] }
+      end
+
+      def host_details(part)
+        part.xpath("mods:detail", NAMESPACE).filter_map do |node|
+          type = clean(node["type"])
+          next if NAMED_HOST_DETAIL_TYPES.include?(type)
+
+          entry = {
+            type: type,
+            number: child_text(node, "mods:number"),
+            caption: child_text(node, "mods:caption"),
+            title: child_text(node, "mods:title")
+          }
+          entry if entry.except(:type).values.any?
+        end
+      end
+
+      # Every extent EXCEPT the page range, which start_page and end_page hold.
+      # A unit other than page -- the minutes of a recording, the columns of a
+      # newspaper -- means nothing without its unit, so the unit travels with
+      # the numbers rather than being flattened away.
+      def host_extents(part)
+        part.xpath("mods:extent", NAMESPACE).filter_map do |node|
+          unit = clean(node["unit"])
+          next if unit.nil? || unit == "page"
+
+          {
+            unit: unit,
+            start: child_text(node, "mods:start"),
+            end: child_text(node, "mods:end"),
+            total: child_text(node, "mods:total"),
+            list: child_text(node, "mods:list")
+          }
+        end
       end
 
       def text_at(xpath)
@@ -778,6 +1029,26 @@ module NEU
         doc.xpath(xpath, NAMESPACE).filter_map { |node| clean(node.text) }
       end
 
+      # The language of one element: the text term, or a code read through the
+      # ISO 639 registry.
+      def language_term(lang)
+        text = lang.at_xpath("mods:languageTerm[@type='text']", NAMESPACE)
+        return clean(text.text) if text
+
+        code = clean(lang.at_xpath("mods:languageTerm", NAMESPACE)&.text)
+        code && LanguageCodes.term(code)
+      end
+
+      # A scriptTerm, text form preferred. No registry expands a code here: the
+      # ISO 15924 list is not vendored, and inventing a half-translation would
+      # be worse than handing the consumer what the record wrote.
+      def script_term(lang)
+        text = lang.at_xpath("mods:scriptTerm[@type='text']", NAMESPACE)
+        return clean(text.text) if text
+
+        clean(lang.at_xpath("mods:scriptTerm", NAMESPACE)&.text)
+      end
+
       def child_text(parent, xpath)
         return nil unless parent
 
@@ -802,12 +1073,20 @@ module NEU
         NEU::MODS.canonical_ws(str)
       end
 
-      # The schema leaves accessCondition/@type an open string, so match on the
-      # canonicalised, case-folded value rather than in the XPath: real records
-      # carry "Use and Reproduction" as readily as the MODS-recommended casing.
+      # The schema leaves accessCondition/@type an open string, so match on a
+      # folded key rather than in the XPath. Real records carry "Use and
+      # Reproduction", "useAndReproduction" and "restriction-on-access" as
+      # readily as the MODS-recommended casing, and an unmatched
+      # restrictionOnAccess fell through to the generic #access_condition --
+      # which is the same defect the two typed fields exist to prevent, reached
+      # by a different route: a restriction presented to a reader as a licence.
+      #
+      # A genuinely unrecognised type still falls through, which is what
+      # #access_condition is for.
       def access_conditions_of_type(type)
+        wanted = Projection.fold_type(type)
         nodes = doc.xpath("/mods:mods/mods:accessCondition", NAMESPACE)
-                   .select { |node| NEU::MODS.canonical_ws(node["type"].to_s).downcase == type }
+                   .select { |node| Projection.fold_type(node["type"]) == wanted }
         join_paragraphs(nodes)
       end
 

data/lib/neu/mods/selectors.rb

@@ -19,6 +19,15 @@ module NEU
       # next title edit, leaving the record with no primary title at all. nil is
       # the right answer instead -- MODSMerge creates a proper primary titleInfo
       # from nil, and each variant is projected under its own field.
+      #
+      # Where a record carries two UNTYPED titleInfo and marks neither, .first
+      # decides and the second reaches no field. That is the schema's answer
+      # rather than a shortfall: @usage is fixed="primary" and exists precisely
+      # to nominate the principal title, @type is a closed enumeration of the
+      # four variants, and MODS 3.5 gives a legitimate second untyped title an
+      # @altRepGroup (one title in two scripts) or an @otherType. An unmarked
+      # duplicate carries none of those, so MODS gives it no meaning to
+      # preserve, and it stays in the preservation XML with no projected field.
       def primary_title_info
         doc.at_xpath("/mods:mods/mods:titleInfo[@usage='primary']", NAMESPACE) ||
           doc.xpath("/mods:mods/mods:titleInfo", NAMESPACE).reject { |ti| variant_title?(ti) }.first

data/lib/neu-mods.rb

@@ -35,6 +35,7 @@ module NEU
 
     # Whitespace no-op guard (see Canonicalize).
     def canonical_ws(str) = Canonicalize.canonical_ws(str)
+    def canonical_lines(str) = Canonicalize.canonical_lines(str)
     def whitespace_equivalent?(current, incoming) = Canonicalize.whitespace_equivalent?(current, incoming)
 
     # Curator-freetext normalization for the access copy (see TextNormalizer).

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: neu-mods
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - David Cliff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-06 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '1.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.12'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.60'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.60'
 description: 'Nokogiri-native, dependency-light reading/projection contract over MODS
@@ -62,7 +62,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".version"
+- .version
 - Gemfile
 - README.md
 - Rakefile
@@ -85,16 +85,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.0.9
 signing_key:
 specification_version: 4
 summary: Northeastern-flavored MODS XML projection + selection for the DRS.