pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/ieee/components/code.rb

@@ -11,10 +11,6 @@ module Pubid
       #   802.15.4     - dotted parts
       #   C57.12.00    - prefix with parts
       #   11073-10404  - dashed parts
-      #
-      # Stays independent of Pubid::Components::Code because IEEE tracks
-      # +original_separator+ to round-trip dot vs dash notation, and uses
-      # +number+ rather than +value+.
       class Code < Lutaml::Model::Serializable
         attribute :prefix, :string             # C, P for some identifiers
         attribute :number, :string             # Main number (802, 1234, etc.)
@@ -100,10 +96,6 @@ original_separator: nil)
 
           result
         end
-
-        def render(context: nil)
-          to_s
-        end
       end
     end
   end

data/lib/pubid/ieee/components/draft.rb

@@ -42,60 +42,6 @@ day: nil)
           self.day = day
         end
 
-        # Month names as an alternation, longest-first so "September" wins over
-        # "Sep"; each may carry a trailing period ("Sept."). Used to split a
-        # rendered draft's trailing date back out.
-        MONTH_ALTERNATION =
-          MONTH_NAMES.keys.sort_by { |m| -m.length }
-            .map { |m| "#{Regexp.escape(m)}\\.?" }.join("|").freeze
-        private_constant :MONTH_ALTERNATION
-
-        DATE_SUFFIX =
-          /(?:(, | )(#{MONTH_ALTERNATION})(?: (\d{1,2}))?(?:, | )| )((?:19|20)\d{2}[a-z]{0,2})\z/
-        private_constant :DATE_SUFFIX
-
-        # Parse a rendered draft such as "/D3", "/D3.4", "/D7 Jul 2019", or a
-        # bare "D5"/"5" back into a Draft. This is the exact inverse of #to_s:
-        # `Draft.parse(d.to_s).to_s == d.to_s` must hold, because the identifier
-        # stores the draft as its rendered string and rebuilds the object with
-        # this method after `from_hash` (a mismatch breaks `to_hash` round-trip).
-        # @param value [String, Draft] the value to coerce
-        # @return [Draft]
-        def self.parse(value)
-          return value if value.is_a?(Draft)
-
-          body = strip_prefix(value.to_s)
-          version, month, day, year, comma = split_date(body)
-          draft = new(version: version, month: month, day: day, year: year)
-          draft.comma_before_month = comma
-          draft
-        end
-
-        # Remove the leading "/D" (or a bare leading "D"/"/") that #to_s emits,
-        # leaving the version and any trailing date.
-        def self.strip_prefix(str)
-          return str[2..] if str.start_with?("/D")
-          return str[1..] if str.start_with?("/")
-          return str[1..] if str.start_with?("D") && str.length > 1
-
-          str
-        end
-        private_class_method :strip_prefix
-
-        # Split a trailing rendered date off the version, so the version stays
-        # clean (the SI/PSI renderer reads `draft_obj.version` directly). Returns
-        # [version, month, day, year, comma_before_month].
-        def self.split_date(body)
-          m = body.match(DATE_SUFFIX)
-          return [body, nil, nil, nil, false] unless m
-
-          version = body[0...m.begin(0)]
-          # The leading group is nil for the month-less " YEAR" form.
-          comma = m[1] == ", "
-          [version, m[2], m[3], m[4], comma]
-        end
-        private_class_method :split_date
-
         # Convert month name to numeric value
         def convert_month(month_name)
           return nil unless month_name

data/lib/pubid/ieee/components/relationship.rb

@@ -1,13 +1,157 @@
 # frozen_string_literal: true
 
-# IEEE's Relationship component is now the shared Pubid::Components::Relationship.
-# This subclass exists so existing references (Pubid::Ieee::Components::Relationship,
-# the VALID_TYPES constants, etc.) continue to resolve without rewriting every
-# call site.
+require "lutaml/model"
+
 module Pubid
   module Ieee
     module Components
-      class Relationship < ::Pubid::Components::Relationship; end
+      # Represents a relationship between IEEE identifiers
+      # E.g., "Revision of IEEE Std X, Y" or "incorporates A, B, C"
+      #
+      # Relationships capture metadata about how identifiers relate to each other:
+      # - Revision relationships (one standard revises another)
+      # - Amendment relationships (amendments to base standards)
+      # - Incorporation relationships (one standard incorporates others)
+      # - Adoption relationships (adopting external standards)
+      #
+      # Example usage:
+      #   relationship = Relationship.new(
+      #     relationship_type: Relationship::REVISION_OF,
+      #     related_identifiers: [Base.parse("IEEE Std 802.11-2012")]
+      #   )
+      #   relationship.to_s  # => "Revision of IEEE Std 802.11-2012"
+      class Relationship < Lutaml::Model::Serializable
+        # Relationship type constants
+        REVISION_OF = "revision_of"
+        AMENDMENT_TO = "amendment_to"
+        CORRIGENDUM_TO = "corrigendum_to"
+        INCORPORATES = "incorporates"
+        INCORPORATING = "incorporating" # Synonym for incorporates
+        ADOPTION_OF = "adoption_of"
+        SUPPLEMENT_TO = "supplement_to"
+        DRAFT_AMENDMENT_TO = "draft_amendment_to"
+        DRAFT_REVISION_OF = "draft_revision_of"
+        REAFFIRMATION_OF = "reaffirmation_of"
+        REDESIGNATION_OF = "redesignation_of"
+        SUPERSEDES = "supersedes"
+        PREVIOUSLY_DESIGNATED_AS = "previously_designated_as"
+        INCLUDES = "includes" # NEW Session 171: For "Includes IEEE Std X" pattern
+
+        # All valid relationship types
+        VALID_TYPES = [
+          REVISION_OF,
+          AMENDMENT_TO,
+          CORRIGENDUM_TO,
+          INCORPORATES,
+          INCORPORATING,
+          ADOPTION_OF,
+          SUPPLEMENT_TO,
+          DRAFT_AMENDMENT_TO,
+          DRAFT_REVISION_OF,
+          REAFFIRMATION_OF,
+          REDESIGNATION_OF,
+          SUPERSEDES,
+          PREVIOUSLY_DESIGNATED_AS,
+          INCLUDES, # NEW Session 171
+        ].freeze
+
+        # Attributes
+        attribute :relationship_type, :string
+
+        # Use regular Ruby attributes to avoid circular dependency
+        # related_identifiers: Array of Base identifiers
+        # intermediate_amendments: Array of Base identifiers (for "as amended by" clause)
+        attr_accessor :related_identifiers, :intermediate_amendments,
+                      :approved_amendments_flag
+
+        # Validation
+        def initialize(**args)
+          # Extract our non-Lutaml attributes before calling super
+          @related_identifiers = args.delete(:related_identifiers)
+          @intermediate_amendments = args.delete(:intermediate_amendments)
+          @approved_amendments_flag = args.delete(:approved_amendments_flag)
+
+          # Let Lutaml handle relationship_type
+          super
+
+          # Normalize INCORPORATING to INCORPORATES for consistent rendering
+          if relationship_type == INCORPORATING
+            self.relationship_type = INCORPORATES
+          end
+
+          # Validate after initialization
+          validate_relationship_type if relationship_type
+        end
+
+        def validate_relationship_type
+          unless VALID_TYPES.include?(relationship_type)
+            raise ArgumentError, "Invalid relationship type: #{relationship_type}. " \
+                                 "Valid types: #{VALID_TYPES.join(', ')}"
+          end
+        end
+
+        # Rendering
+        def to_s
+          return "" if related_identifiers.nil? || related_identifiers.empty?
+
+          # Format: "Relationship Type IEEE Std X, IEEE Std Y, and IEEE Std Z"
+          prefix = format_relationship_prefix
+          ids = format_identifier_list(related_identifiers)
+
+          # Add intermediate amendments if present (for "as amended by" clause)
+          if intermediate_amendments && !intermediate_amendments.empty?
+            amendments = format_identifier_list(intermediate_amendments)
+            "#{prefix} #{ids} as amended by #{amendments}"
+          elsif approved_amendments_flag
+            # "and its approved amendments" clause (no specific list)
+            "#{prefix} #{ids} and its approved amendments"
+          else
+            "#{prefix} #{ids}"
+          end
+        end
+
+        private
+
+        # Get the human-readable prefix for the relationship type
+        def format_relationship_prefix
+          case relationship_type
+          when REVISION_OF then "Revision of"
+          when AMENDMENT_TO then "Amendment to"
+          when CORRIGENDUM_TO then "Corrigendum to"
+          when INCORPORATES, INCORPORATING then "incorporates"
+          when ADOPTION_OF then "Adoption of"
+          when SUPPLEMENT_TO then "Supplement to"
+          when DRAFT_AMENDMENT_TO then "Draft Amendment to"
+          when DRAFT_REVISION_OF then "Draft Revision of"
+          when REAFFIRMATION_OF then "Reaffirmation of"
+          when REDESIGNATION_OF then "Redesignation of"
+          when SUPERSEDES then "Supersedes"
+          when PREVIOUSLY_DESIGNATED_AS then "Previously designated as"
+          when INCLUDES then "Includes" # NEW Session 171
+          else relationship_type
+          end
+        end
+
+        # Format a list of identifiers using proper English grammar:
+        # - Single: "IEEE Std X"
+        # - Two: "IEEE Std X and IEEE Std Y"
+        # - Three+: "IEEE Std X, IEEE Std Y, and IEEE Std Z"
+        def format_identifier_list(identifiers)
+          return "" if identifiers.nil? || identifiers.empty?
+
+          case identifiers.length
+          when 1
+            identifiers.first.to_s
+          when 2
+            "#{identifiers.first} and #{identifiers.last}"
+          else
+            # X, Y, and Z format (Oxford comma)
+            last = identifiers.last
+            others = identifiers[0..-2]
+            "#{others.join(', ')}, and #{last}"
+          end
+        end
+      end
     end
   end
 end

data/lib/pubid/ieee/identifier.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
-# Pubid::Ieee::Identifier is the IEEE base class (a real Pubid::Identifier
-# subclass); IEEE builds its identifiers as instances of it directly. Its body and `.parse` live in
-# identifiers/base.rb. This file just ensures it is loaded.
+module Pubid
+  module Ieee
+    module Identifier
+      class << self
+        def parse(input)
+          Identifiers::Base.parse(input)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/adopted_standard.rb

@@ -7,73 +7,25 @@ module Pubid
       # IEEE's adoption of another organization's standard
       # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
       # This means IEEE adopted ANSI's standard C55.1-1968 as their Std No 18-1968
-      class AdoptedStandard < Identifier
-        # IEEE's identifier for this adopted standard.
-        #
-        # Typed as the cross-flavor base `::Pubid::Identifier` (not the
-        # IEEE-only `Identifier`) so serialization never rejects a cross-flavor
-        # value. lutaml enforces the declared attribute type; `polymorphic:
-        # true` permits only *subclasses* of it, and a `Pubid::Ansi::…` /
-        # `Pubid::Iec::…` object is not a subclass of `Pubid::Ieee::Identifier`.
-        # The cross-flavor child carries its own `_type`, so `from_hash` routes
-        # it back via `TypeResolver`.
-        attribute :ieee_identifier, ::Pubid::Identifier, polymorphic: true
+      class AdoptedStandard < Base
+        # IEEE's identifier for this adopted standard
+        attribute :ieee_identifier, Base, polymorphic: true
 
-        # Original identifiers from ANSI/ASME/ISO/IEC/etc (array for multi-part
-        # adoptions). Cross-flavor by design: an `IEEE Std <n> (ANSI <m>)`
-        # adoption stores a `Pubid::Ansi::…` object here. See `ieee_identifier`
-        # above for why this must be `::Pubid::Identifier`, not IEEE-only.
-        attribute :adopted_identifiers, ::Pubid::Identifier, polymorphic: true,
+        # Original identifiers from ANSI/ISO/IEC/etc (array for multi-part adoptions)
+        attribute :adopted_identifiers, Base, polymorphic: true,
                                               collection: true
 
-        def publisher
-          ieee_identifier&.publisher || "IEEE"
-        end
-
-        # An adoption names one document by two designations and carries no
-        # number of its own, so `root.number` — the key relaton-index sorts and
-        # bsearches on — was "". Walk to the IEEE designation, which is the one
-        # IEEE files the document under, and which is also the source of truth
-        # for `publisher` above.
-        def root
-          ieee_identifier ? ieee_identifier.root : self
-        end
-
-        # The document number must reach the URN and the MR slug too, not only
-        # `#root` — the project rule that an identity-bearing marker reaches
-        # every identity surface. `UrnGenerator#code_component` and the base
-        # `mr_number_with_part` both read `code_obj`, which a wrapper does not
-        # have, so all 66 adoptions collapsed onto 5 URNs and 5 slugs — and
-        # `to_slug` is an output FILENAME, so that is 66 documents overwriting
-        # each other. Delegate to the IEEE designation, as `#root` does.
-        #
-        # `code_obj` is a plain attr_accessor on the base, not a lutaml
-        # attribute, so overriding it as a method is safe here.
-        def code_obj
-          ieee_identifier&.code_obj
-        end
-
-        # Likewise the year: without it "AIEE No 15-1944" and "AIEE No 15-1959"
-        # — two different documents — produced the same slug "aiee.std.15".
-        # This is the `mr_year` HOOK, not a `#year` method: `year` is a lutaml
-        # attribute on the base, and a method of that name would shadow the
-        # generated accessor (the CLAUDE.md landmine).
-        def mr_year
-          (year || ieee_identifier&.year)&.to_s
+        def to_s
+          result = ieee_identifier.to_s
+          if adopted_identifiers && !adopted_identifiers.empty?
+            adopted_strs = adopted_identifiers.map(&:to_s)
+            result += " (#{adopted_strs.join(' and ')})"
+          end
+          result
         end
 
-        # `publisher` is *derived* from `ieee_identifier` (the serialized source
-        # of truth), so it must not be serialized. Emitting it breaks the
-        # canonical round-trip: the derived value is default-omitted on the parse
-        # path (publisher unset), but re-emitted after from_hash materializes the
-        # attribute default (the override then returns ieee_identifier.publisher,
-        # e.g. "AIEE", not the "IEEE" default). Drop it — ieee_identifier rebuilds
-        # it. (AdoptedStandard is always a top-level wrapper, never nested, so a
-        # to_hash-level drop is sufficient — same as JointDevelopment.)
-        def to_hash(*args)
-          hash = super
-          hash.delete("publisher") if hash.is_a?(::Hash)
-          hash
+        def publisher
+          ieee_identifier&.publisher || "IEEE"
         end
       end
     end