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

data/lib/relaton/iso/hit_collection.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "hit"
+
+module Relaton
+  module Iso
+    # Page of hit collection.
+    class HitCollection < Relaton::Core::HitCollection
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-iso/v2/"
+
+      def opts
+        @opts ||= {}
+      end
+
+      # Maps the legacy 1.x exclude symbols to their pubid 2.x attribute
+      # names. The public excludings API still uses :year/:iteration for
+      # backwards compatibility with existing call sites and specs.
+      LEGACY_EXCLUDE_MAP = { year: :date, iteration: :stage_iteration }.freeze
+      private_constant :LEGACY_EXCLUDE_MAP
+
+      def translate_excludings(attrs)
+        out = attrs.map { |a| LEGACY_EXCLUDE_MAP[a] || a }
+        # Excluding :stage implies excluding :typed_stage too — the two
+        # carry overlapping data and their default-published values can
+        # differ in trivia (e.g. original_abbr "" vs nil), so leaving
+        # typed_stage in the comparison breaks otherwise-equal matches.
+        out << :typed_stage if out.include?(:stage) && !out.include?(:typed_stage)
+        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_document.base
+            ref_document.dup.tap { |r| r.base = r.base.exclude(:date) }
+          else
+            ref_document.exclude(:date)
+          end
+      end
+
+      def ref_pubid_excluded
+        return @ref_pubid_excluded if defined? @ref_pubid_excluded
+
+        ref_excludings = translate_excludings(excludings) + [:all_parts]
+        @ref_pubid_excluded ||= ref_pubid_no_year.exclude(*ref_excludings)
+      end
+
+      #
+      # Find all the entries that match the given reference.
+      #
+      # @return [Array<Relaton::Iso::Hit>] hits
+      #
+      def find # rubocop:disable Metrics/AbcSize
+        # Pass `ref` (a Pubid::Identifier, not a String) so the index can
+        # narrow candidates by number via binary search before applying the
+        # block, instead of a full O(n) scan of every row. Every row's `:id`
+        # is already a Pubid::Identifier — Relaton::Index deserialized it via
+        # the `pubid_class` passed in `#index` — so `pubid_match?` compares
+        # Pubid to Pubid directly.
+        @array = index.search(ref) do |row|
+          pubid_match?(row[:id])
+        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.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
+        # published edition; without this the draft would sort first lexically
+        # ("ISO/AWI …" > "ISO …") and be returned by fetch_doc's `first`. The
+        # index id carries no lifecycle status, so the parsed stage is the only
+        # signal available here. partition is stable, preserving the year order
+        # within each group.
+        @array.sort_by! { |h| h.pubid.to_s }.reverse!
+        published, drafts = @array.partition do |h|
+          h.pubid && default_published_stage?(h.pubid)
+        end
+        @array = published + drafts
+        self
+      end
+
+      def pubid_match?(pubid)
+        match_excludings = translate_excludings(excludings) + [:all_parts]
+        match_excludings << :edition unless pubid.typed_stage&.abbr&.include?("DIR")
+        # Only the candidate is built via .create (from the index) and so may
+        # carry a compound part; `ref_pubid_no_year` is always a parsed pubid,
+        # already split, so it needs no normalization.
+        cand = normalize_compound_part(exclude_id_attrs(pubid, *match_excludings))
+        cand == exclude_id_attrs(ref_pubid_no_year, *match_excludings)
+      end
+
+      # @TODO TEMP WORKAROUND (pubid 2.x migration): the v1-generated index
+      # stores a compound part such as "5-1-3" in :part with no :subpart, and
+      # Relaton::Index builds each row via Pubid::Iso::Identifier.from_hash(id),
+      # which keeps it as part="5-1-3" subpart=nil. A parsed query splits it
+      # (part="5", subpart="1-3"), so the two never compare equal. Re-split the
+      # compound part on the first dash to mirror parse before comparing.
+      # `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.to_s
+        return pubid unless pubid.subpart.nil? && num.include?("-")
+
+        pubid.part, pubid.subpart = num.split("-", 2)
+        pubid
+      end
+
+      def exclude_id_attrs(pubid, *attrs)
+        xid = pubid.exclude(*attrs)
+        curr = xid
+        while curr.base
+          curr.base = curr.base.exclude(*attrs)
+          curr = curr.base
+        end
+        xid
+      end
+
+      def excludings # rubocop:disable Metrics/AbcSize
+        return @excludings if defined? @excludings
+
+        excl_attrs = %i[year]
+        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
+        @excludings = excl_attrs
+      end
+
+      # Pubid 2.x auto-populates a published-stage default on parse/.create,
+      # so ref.stage is never nil. Treat that default as "no stage specified".
+      def default_published_stage?(pubid)
+        return true if pubid.typed_stage.nil?
+
+        pubid.typed_stage.stage_code.to_s == "published"
+      end
+
+      def index
+        @index ||= Relaton::Index.find_or_create(
+          :iso,
+          url: "#{ENDPOINT}#{INDEXFILE}.zip",
+          file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Iso::Identifier,
+        )
+      end
+
+      def fetch_doc(options = {})
+        @excludings = nil if options != opts
+        @opts = options
+
+        if !ref.all_parts || size == 1
+          any? && first.item # (opts[:lang])
+        else
+          to_all_parts
+        end
+      end
+
+      # @return [RelatonIsoBib::IsoBibliographicItem, nil]
+      def to_all_parts # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        parts = @array.select { |h| h.pubid.part }
+        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.to_i }
+        return @array.first&.item unless hit
+
+        bibitem = hit.item
+        all_parts_item = bibitem.to_all_parts
+        @array.reject { |h| h.pubid.part == hit.pubid.part }.each do |hi|
+          all_parts_item.relation << create_relation(hi)
+        end
+        all_parts_item
+      end
+
+      def create_relation(hit)
+        # pubid = Pubid.new hit.pubid
+        docid = Docidentifier.new(content: hit.pubid, type: "ISO", primary: true)
+        isobib = ItemData.new(formattedref: Bib::Formattedref.new(content: hit.pubid.to_s), docidentifier: [docid])
+        Relation.new(type: "instanceOf", bibitem: isobib)
+      end
+    end
+  end
+end

data/lib/relaton/iso/item_data.rb

@@ -0,0 +1,50 @@
+module Relaton
+  module Iso
+    class ItemData < Bib::ItemData
+      def create_id(without_date: false)
+        docid = docidentifier.find(&:primary) || docidentifier.first
+        return unless docid
+
+        if docid.content.is_a?(String)
+          create_id_from_string(docid.content, without_date)
+        else
+          create_id_from_pubid(docid.content, without_date)
+        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+/, "")
+      end
+
+      def create_id_from_pubid(content, without_date)
+        pubid = without_date ? content.exclude(:year) : content
+        self.id = pubid.to_s.gsub(/\W+/, "")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require_relative "ext"
+
+module Relaton
+  module Iso
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Relaton
+  module Iso
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Relaton
+  module Iso
+    class Contributor < Bib::Contributor
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Relaton
+  module Iso
+    class ContributorInfo < Lutaml::Model::Serializable
+      choice do
+        attribute :person, Bib::Person
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require_relative "../type/pubid"
+
+module Relaton
+  module Iso
+    class Docidentifier < Bib::Docidentifier
+      attribute :content, Type::Pubid
+
+      attr_reader :pubid
+
+      def initialize(arg = nil, **kwargs)
+        arg.is_a?(Hash) ? super(arg) : super(**kwargs)
+        # Content may have been set before type during lutaml init. Re-run
+        # the setter so type-dependent parsing (e.g. iso-tc bypass) applies.
+        raw = arg.is_a?(Hash) ? (arg["content"] || arg[:content]) : kwargs[:content]
+        self.content = raw if raw
+      end
+
+      alias_method :original_content=, :content=
+      alias_method :original_content, :content
+
+      def content=(value)
+        @pubid = nil
+        @raw_content = nil
+
+        if type == "iso-tc" && value.is_a?(String)
+          @raw_content = value
+        else
+          parsed =
+            case value
+            when ::Pubid::Iso::Identifier then value
+            when String
+              begin
+                ::Pubid::Iso::Identifier.parse(value)
+              rescue StandardError
+                # Suppress when type is not yet set (lutaml runs the setter
+                # once during init before `type` is assigned, then `initialize`
+                # re-runs it; only the second pass is authoritative).
+                Util.warn "Failed to parse Pubid: #{value}" if type
+                nil
+              end
+            end
+
+          if parsed
+            @pubid = parsed
+            # TC committee documents have a canonical spelling ("… N1110")
+            # that pubid renders with a space ("… N 1110"). Preserve the
+            # source string (same intent as the iso-tc bypass) while keeping
+            # the parsed pubid for any structural operations.
+            if value.is_a?(String) && parsed.is_a?(::Pubid::Iso::Identifiers::TcDocument)
+              @raw_content = value
+            end
+          elsif value.is_a?(String)
+            @raw_content = value
+          end
+        end
+
+        send(:original_content=, to_s)
+      end
+
+      def content
+        return @raw_content if @raw_content
+        return render_pubid(@pubid) if @pubid
+
+        original_content
+      end
+
+      def to_s
+        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_stage!
+        @pubid = @pubid.to_all_parts
+        refresh_content!
+      end
+
+      def remove_stage!
+        remove_attr!(:stage)
+      end
+
+      def remove_part!
+        remove_attr!(:part)
+      end
+
+      def remove_date!
+        remove_attr!(:date)
+      end
+
+      def exclude_year
+        return @raw_content if @raw_content
+        return nil unless @pubid
+
+        exclude_date(@pubid)
+      end
+
+      private
+
+      def render_pubid(pubid)
+        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
+        while base
+          base.send("#{attr}=", nil)
+          base = base.base
+        end
+        refresh_content!
+      end
+
+      def refresh_content!
+        send(:original_content=, to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Relaton
+  module Iso
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        international-standard technical-specification technical-report publicly-available-specification
+        international-workshop-agreement guide recommendation amendment technical-corrigendum directive
+        committee-document addendum supplement extract
+      ].freeze
+
+      attribute :content, :string, values: TYPES
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative "doctype"
+require_relative "stagename"
+require_relative "structured_identifier"
+
+module Relaton
+  module Iso
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :structuredidentifier, StructuredIdentifier
+      attribute :horizontal, :boolean
+      attribute :stagename, Stagename
+      attribute :updates_document_type, :string, values: Doctype::TYPES
+      attribute :fast_track, :boolean
+      attribute :price_code, :string
+
+      def get_schema_version = Relaton.schema_versions["relaton-model-iso"]
+
+      xml do
+        map_element "horizontal", to: :horizontal
+        map_element "stagename", to: :stagename
+        map_element "updates-document-type", to: :updates_document_type
+        map_element "fast-track", to: :fast_track
+        map_element "price-code", to: :price_code
+      end
+
+      key_value do
+        map_element "horizontal", to: :horizontal
+        map_element "stagename", to: :stagename
+        map_element "updates_document_type", to: :updates_document_type
+        map_element "fast_track", to: :fast_track
+        map_element "price_code", to: :price_code
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative "docidentifier"
+require_relative "ext"
+
+module Relaton
+  module Iso
+    class Relation < Bib::Relation
+    end
+
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :relation, Relation, collection: true, initialize_empty: true
+      attribute :ext, Ext
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require_relative "docidentifier"
+
+module Relaton
+  module Iso
+    class ItemBase < Lutaml::Model::Serializable
+      include Bib::NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&Bib::ItemShared::ATTRIBUTES)
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :relation, Relation, collection: true, initialize_empty: true
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&Bib::ItemShared::XML_BODY)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Relaton
+  module Iso
+    class Organization < Lutaml::Model::Serializable
+      # choice(min: 1, max: 1) do
+      #   attribute
+      # end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Relaton
+  module Iso
+    class ProjectNumber < Lutaml::Model::Serializable
+      attribute :part, :integer
+      attribute :subpart, :integer
+      attribute :amendment, :integer
+      attribute :corrigendum, :integer
+      attribute :origyr, :string
+      attribute :content, :string
+
+      xml do
+        root "project-number"
+        map_attribute "part", to: :part
+        map_attribute "subpart", to: :subpart
+        map_attribute "amendment", to: :amendment
+        map_attribute "corrigendum", to: :corrigendum
+        map_attribute "origyr", to: :origyr
+        map_content to: :content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require_relative "item_base"
+
+module Relaton
+  module Iso
+    class Relation
+      attribute :bibitem, ItemBase
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Relaton
+  module Iso
+    class Stagename < Lutaml::Model::Serializable
+      attribute :abbreviation, :string
+      attribute :content, :string
+
+      xml do
+        root "stagename"
+        map_attribute "abbreviation", to: :abbreviation
+        map_content to: :content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require_relative "project_number"
+
+module Relaton
+  module Iso
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :project_number, ProjectNumber
+      attribute :tc_document_number, :integer
+
+      xml do
+        root "structuredidentifier"
+        map_attribute "type", to: :type
+        map_element "project-number", to: :project_number
+        map_element "tc-document-number", to: :tc_document_number
+      end
+
+      def remove_date!
+        project_number&.origyr = nil
+      end
+
+      def remove_part!
+        project_number&.part = nil
+      end
+
+      def to_all_parts!
+        remove_date!
+        remove_part!
+      end
+    end
+  end
+end