relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/iso/hit_collection.rb

@@ -28,12 +28,21 @@ module Relaton
         out
       end
 
+      # `ref` itself when it is a plain identifier; the wrapped member when an
+      # all-parts request wrapped it. pubid's `==` is class-strict, so
+      # comparing against index rows (always plain identifiers) needs this
+      # unwrapped form — `ref.root` would over-unwrap a supplement's own
+      # `.base` chain, which this must leave intact.
+      def ref_document
+        ref.all_parts? ? ref.identifiers.first : ref
+      end
+
       def ref_pubid_no_year
         @ref_pubid_no_year ||=
-          if ref.base_identifier
-            ref.dup.tap { |r| r.base_identifier = r.base_identifier.exclude(:date) }
+          if ref_document.base
+            ref_document.dup.tap { |r| r.base = r.base.exclude(:date) }
           else
-            ref.exclude(:date)
+            ref_document.exclude(:date)
           end
       end
 
@@ -61,7 +70,7 @@ module Relaton
         end.map { |row| Hit.new row, self }
         # An all-parts query drops :part from the match, so multiple rows can
         # resolve to the same pubid; collapse them so each part appears once.
-        @array.uniq! { |h| h.pubid.to_s } if ref.root.all_parts
+        @array.uniq! { |h| h.pubid.to_s } if ref.all_parts
         # Most-recent first (pubid string desc ~ year desc), then float
         # published-stage ids above drafts. An undated query excludes :stage
         # when matching, so a future draft (e.g. ISO/AWI) matches alongside the
@@ -97,21 +106,19 @@ module Relaton
       # `exclude` returns a fresh instance, so mutating this copy is safe.
       # Remove once pubid create() splits compound parts itself.
       def normalize_compound_part(pubid)
-        num = pubid.part&.value.to_s
+        num = pubid.part.to_s
         return pubid unless pubid.subpart.nil? && num.include?("-")
 
-        head, tail = num.split("-", 2)
-        pubid.part = ::Pubid::Iso::Components::Code.new(value: head)
-        pubid.subpart = ::Pubid::Iso::Components::Code.new(value: tail)
+        pubid.part, pubid.subpart = num.split("-", 2)
         pubid
       end
 
       def exclude_id_attrs(pubid, *attrs)
         xid = pubid.exclude(*attrs)
         curr = xid
-        while curr.base_identifier
-          curr.base_identifier = curr.base_identifier.exclude(*attrs)
-          curr = curr.base_identifier
+        while curr.base
+          curr.base = curr.base.exclude(*attrs)
+          curr = curr.base
         end
         xid
       end
@@ -120,8 +127,13 @@ module Relaton
         return @excludings if defined? @excludings
 
         excl_attrs = %i[year]
-        excl_attrs << :part if ref.root.part.nil? || ref.root.all_parts
-        if default_published_stage?(ref) || ref.root.all_parts
+        excl_attrs << :part if ref.root.part.nil? || ref.all_parts
+        # `ref_document` (not `ref`), since an all-parts-wrapped `ref`'s own
+        # `typed_stage` is never set (always nil) — reading it directly would
+        # answer "no stage specified" for the wrapper regardless of the real
+        # underlying document's stage. Correct today only because this is
+        # OR'd with `ref.all_parts` (already true whenever wrapped).
+        if default_published_stage?(ref_document) || ref.all_parts
           excl_attrs << :stage
           excl_attrs << :iteration
         end
@@ -149,7 +161,7 @@ module Relaton
         @excludings = nil if options != opts
         @opts = options
 
-        if !ref.root.all_parts || size == 1
+        if !ref.all_parts || size == 1
           any? && first.item # (opts[:lang])
         else
           to_all_parts
@@ -162,7 +174,7 @@ module Relaton
         if opts[:publication_date_before] || opts[:publication_date_after]
           parts = parts.select { |h| Bibliography.send(:year_in_range?, (h.pubid.date&.year || h.hit[:year]).to_i, opts) }
         end
-        hit = parts.min_by { |h| h.pubid.part.value.to_i }
+        hit = parts.min_by { |h| h.pubid.part.to_i }
         return @array.first&.item unless hit
 
         bibitem = hit.item

data/lib/relaton/iso/item_data.rb

@@ -12,8 +12,30 @@ module Relaton
         end
       end
 
+      # These item-level transforms rewrite every docidentifier in place
+      # (all-parts / date removal). That can collapse the `iso-undated`
+      # entry onto the primary, so re-run the same de-dup the builders apply
+      # at construction time (see DataParser#undated_docid).
+      def to_all_parts
+        drop_redundant_undated_docid(super)
+      end
+
+      def to_most_recent_reference
+        drop_redundant_undated_docid(super)
+      end
+
       private
 
+      def drop_redundant_undated_docid(item)
+        primary = item.docidentifier.find(&:primary)
+        return item unless primary
+
+        item.docidentifier = item.docidentifier.reject do |d|
+          !d.primary && d.type == "iso-undated" && d.to_s == primary.to_s
+        end
+        item
+      end
+
       def create_id_from_string(content, without_date)
         pubid = without_date ? content.sub(/:\d{4}$/, "") : content
         self.id = pubid.gsub(/\W+/, "")

data/lib/relaton/iso/model/docidentifier.rb

@@ -68,13 +68,17 @@ module Relaton
         content.to_s
       end
 
+      # `remove_part!`/`remove_date!` are unnecessary here: `to_all_parts`'s
+      # own identity computation already excludes part/date (down the whole
+      # base chain, so a supplement's own year is dropped too — a disclosed
+      # pubid behavior change, not a bug; see spec/iso/…/docidentifier_spec.rb
+      # "#to_all_parts!"). `remove_stage!` stays: stage isn't one of the
+      # attributes pubid's `all_parts_edition_keys` strips.
       def to_all_parts!
         return unless @pubid
 
-        remove_part!
-        remove_date!
         remove_stage!
-        @pubid.all_parts = true
+        @pubid = @pubid.to_all_parts
         refresh_content!
       end
 
@@ -94,13 +98,7 @@ module Relaton
         return @raw_content if @raw_content
         return nil unless @pubid
 
-        pubid = @pubid.exclude(:date)
-        current = pubid
-        while current.base_identifier
-          current.base_identifier = current.base_identifier.exclude(:date)
-          current = current.base_identifier
-        end
-        pubid
+        exclude_date(@pubid)
       end
 
       private
@@ -109,19 +107,33 @@ module Relaton
         case type
         when "URN" then pubid.to_urn
         when "ISO" then pubid.exclude(:languages).to_s
+        when "iso-undated" then exclude_date(pubid).exclude(:languages).to_s
         else
           pubid.to_s
         end
       end
 
+      # Return a copy of +pubid+ with the year removed from it and every
+      # identifier in its `base` chain (e.g. the base of an
+      # amendment/corrigendum). The original is left untouched.
+      def exclude_date(pubid)
+        result = pubid.exclude(:date)
+        current = result
+        while current.base
+          current.base = current.base.exclude(:date)
+          current = current.base
+        end
+        result
+      end
+
       def remove_attr!(attr)
         return unless @pubid
 
         @pubid.send("#{attr}=", nil)
-        base = @pubid.base_identifier
+        base = @pubid.base
         while base
           base.send("#{attr}=", nil)
-          base = base.base_identifier
+          base = base.base
         end
         refresh_content!
       end

data/lib/relaton/iso/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_iso
         @prefix = "ISO"
+        @pubid_flavor = :Iso # global prefixes sourced from Pubid::Iso.prefixes
         @defaultprefix = %r{^ISO(/IEC)?\s}
         @idtype = "ISO"
         @datasets = %w[iso-open-data iso-open-data-all]

data/lib/relaton/iso/scraper.rb

@@ -104,7 +104,7 @@ module Relaton
         return @pubid if @pubid
 
         @pubid = ::Pubid::Iso::Identifier.parse(id)
-        @pubid.root.edition ||= edition.content if @pubid.base_identifier
+        @pubid.root.edition ||= edition.content if @pubid.base
         @pubid
       rescue StandardError => e
         Util.error "Failed to parse pubid from #{id}: #{e.message}"
@@ -128,11 +128,27 @@ module Relaton
       # @return [Array<RelatonBib::DocumentIdentifier>]
       #
       def fetch_relaton_docids
+        primary = Docidentifier.new(content: pubid, type: "ISO", primary: true)
         [
-          Docidentifier.new(content: pubid, type: "ISO", primary: true),
+          primary,
+          undated_docid(primary),
           Docidentifier.new(content: isoref, type: "iso-reference"),
           Docidentifier.new(content: urn, type: "URN"),
-        ]
+        ].compact
+      end
+
+      #
+      # Create the undated reference docid (e.g. `ISO 123` from `ISO 123:2001`).
+      # Returns nil for an already-undated identifier so it does not duplicate
+      # the primary.
+      #
+      # @return [Relaton::Iso::Docidentifier, nil]
+      #
+      def undated_docid(primary)
+        undated = Docidentifier.new(content: pubid, type: "iso-undated")
+        undated unless undated.to_s == primary.to_s
+      rescue StandardError
+        nil
       end
 
       #

data/lib/relaton/itu/bibliography.rb

@@ -43,10 +43,13 @@ module Relaton
 
       def fetch_ref_err(refid, missed_years)
         Util.info "Not found.", key: refid.to_s
-        if missed_years.any?
-          plural = missed_years.size > 1 ? "s" : ""
+        # one hit per edition means a year can repeat (a recommendation and its
+        # amendment); the requested year itself is not a "different year" hint
+        years = missed_years.uniq.reject { |y| y == refid.year }
+        if years.any?
+          plural = years.size > 1 ? "s" : ""
           Util.info "There was no match for `#{refid.year}` year, though there were matches " \
-                    "found for `#{missed_years.join('`, `')}` year#{plural}.", key: refid.to_s
+                    "found for `#{years.join('`, `')}` year#{plural}.", key: refid.to_s
         end
         nil
       end
@@ -70,7 +73,9 @@ module Relaton
             return { ret: ret } if ret
           end
 
-          missed_years << pyear
+          # a hit whose code carries no year contributes nothing to the
+          # "matches found for `<year>`" hint
+          missed_years << pyear if pyear
         end
         { years: missed_years }
       end