pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

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

@@ -8,7 +8,10 @@ module Pubid
       # Handles both:
       # - SI: Published standards (IEEE/ASTM SI 10-1997)
       # - PSI: Proposed SI (drafts: IEEE/ASTM PSI 10/D2, October 2015)
-      class SiStandard < Base
+      class SiStandard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
         # TYPED_STAGES for SI standards
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -17,7 +17,10 @@ module Pubid
       #   std = Pubid::Ieee.parse("ANSI/IEEE Std 500-1984")
       #   std.publisher        # => "IEEE"
       #   std.copublisher     # => ["ANSI"]
-      class Standard < Base
+      class Standard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
         # TYPED_STAGES for published IEEE standards
         # Standards use "Std" abbreviation for published state
         TYPED_STAGES = [

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

@@ -3,19 +3,38 @@
 module Pubid
   module Ieee
     module Identifiers
-      # Base class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
+      # Identifier class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
       # Supplements modify or add to a base document
-      class SupplementIdentifier < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class SupplementIdentifier < Identifier
+        attribute :base, Identifier, polymorphic: true
 
-        # Delegate publisher to base_identifier
+        # Delegate publisher to base
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
-        # Delegate code to base_identifier if not overridden
+        # Delegate code to base if not overridden
         def code
-          base_identifier&.code
+          base&.code
+        end
+
+        # `publisher` is a pure delegation to `base`, so it must never be
+        # serialized independently on the wrapper. lutaml's default-tracking
+        # otherwise emits it asymmetrically — omitted on the parse path (the
+        # wrapper's own attribute is never assigned) but present after
+        # `from_hash` (deserialization assigns it) — which breaks the canonical
+        # `to_hash` round-trip for a supplement whose base carries a non-default
+        # publisher (e.g. an ANSI/ISO corrigendum). The truth lives in `base`.
+        def to_hash(*args)
+          hash = super
+          if hash.is_a?(::Hash)
+            # `publisher` and `code` are delegated to `base`; never serialize
+            # them on the wrapper (they'd duplicate base.publisher/base.number
+            # and, for publisher, desync across parse vs from_hash).
+            hash.delete("publisher")
+            hash.delete("code")
+          end
+          hash
         end
       end
     end

data/lib/pubid/ieee/identifiers.rb

@@ -4,9 +4,10 @@ module Pubid
   module Ieee
     module Identifiers
       autoload :AdoptedStandard, "#{__dir__}/identifiers/adopted_standard"
-      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :ConformanceIdentifier,
                "#{__dir__}/identifiers/conformance_identifier"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :CsaDualPublished, "#{__dir__}/identifiers/csa_dual_published"
       autoload :DualIdentifier, "#{__dir__}/identifiers/dual_identifier"

data/lib/pubid/ieee/ire/builder.rb

@@ -14,11 +14,12 @@ module Pubid
           # Extract type
           attributes[:type] = extract_value(parsed[:type])
 
-          # Extract number
+          # Extract the document designation. It travels as `code:` so the base
+          # initializer parses it into `code_obj` and the CodeNumber mixin
+          # hoists the flat split columns (number/prefix/parts/separator) that
+          # relaton indexes on.
           number_str = extract_value(parsed[:number])
-          if number_str
-            attributes[:number] = Components::Code.parse(number_str)
-          end
+          attributes[:code] = number_str if number_str
 
           # Extract year - handle both short (52) and full (1952) formats
           year_str = extract_value(parsed[:year])
@@ -28,13 +29,13 @@ module Pubid
             if year_int.between?(12, 63)
               year_int += 1900
             end
-            attributes[:year] = year_int
+            attributes[:year] = year_int.to_s
           end
 
           # Override with full_year if present
           full_year_str = extract_value(parsed[:full_year])
           if full_year_str
-            attributes[:year] = full_year_str.to_i
+            attributes[:year] = full_year_str.to_i.to_s
           end
 
           # Create identifier

data/lib/pubid/ieee/ire/identifier.rb

@@ -5,32 +5,36 @@ require "lutaml/model"
 module Pubid
   module Ieee
     module Ire
-      # Base class for IRE identifiers
-      # IRE (Institute of Radio Engineers): 1912-1963
-      class Identifier < Lutaml::Model::Serializable
-        attribute :publisher, :string, default: -> { "IRE" }
-        attribute :type, :string # "Trans.", "Standard", "Std"
-        attribute :number, Components::Code
-        attribute :year, :integer
-
-        def initialize(**args)
-          super()
-
-          # Handle number as string or Code object
-          if args[:number].is_a?(String)
-            self.number = Components::Code.parse(args[:number])
-          elsif args[:number]
-            self.number = args[:number]
-          end
+      # IRE identifiers (Institute of Radio Engineers: 1912-1963).
+      #
+      # Reparented onto Pubid::Ieee::Identifier + the CodeNumber mixin for the
+      # same reasons AIEE was (see Pubid::Ieee::Aiee::Identifier): descending
+      # from bare Lutaml::Model::Serializable left IRE without `#root` (relaton
+      # keys its index on `id.root.number.to_s` -> NoMethodError), without a
+      # polymorphic `_type` (so `from_hash` could not route back), and — because
+      # an IRE object was not a ::Pubid::Identifier — unassignable to
+      # Identifiers::AdoptedStandard#adopted_identifiers, which raised
+      # Lutaml::Model::IncorrectModelError on `to_hash` for the IRE-adopted
+      # forms ("IEEE Std 159-1972 (52 IRE 7 S2)").
+      #
+      # The document designation ("7.S2") is carried in the shared `code_obj`
+      # and serialized as the flat split columns (number/prefix/parts/
+      # separator); the publication year uses the base's plain `:string` `year`
+      # (IRE previously declared its own `:integer` one, which would collide).
+      class Identifier < Pubid::Ieee::Identifier
+        include Pubid::Ieee::Identifiers::CodeNumber
 
-          # Set other attributes
-          attrs = self.class.attributes
-          args.each do |key, value|
-            next if key == :number
+        attribute :publisher, :string, default: -> { "IRE" }
+        # IRE spells its type word out when present ("Trans.", "Standard",
+        # "Std") and omits it otherwise, so the base's "Std" default must go —
+        # else "52 IRE 7.S2" would render as "52 IRE Std 7.S2".
+        attribute :type, :string, default: -> {}
 
-            setter = :"#{key}="
-            public_send(setter, value) if attrs.key?(key)
-          end
+        # A distinct polymorphic name so from_hash routes to IRE. The derived
+        # default (last name segment "Identifier") would be
+        # "pubid:ieee:identifier", colliding with the base class.
+        def self.polymorphic_name
+          "pubid:ieee:ire"
         end
 
         # Parse IRE identifier string
@@ -40,17 +44,28 @@ module Pubid
           builder.build(parsed)
         end
 
-        def to_s
-          parts = []
+        def to_s(trademark: false)
           # Year comes FIRST in IRE format - render as 2-digit short year
-          if year
-            short_year = year.between?(1900, 1999) ? year - 1900 : year
-            parts << short_year.to_s
+          result = [(short_year if year), publisher, type, code&.to_s]
+            .compact.join(" ")
+          # The code is the last token, so the end of the string already *is*
+          # the code boundary — but the symbol is picked from the code, not by
+          # scanning the string (which starts with the year).
+          if trademark
+            result += Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                                       code_obj&.prefix,
+                                                       publishers: [publisher])
           end
-          parts << publisher
-          parts << type if type
-          parts << number.to_s if number
-          parts.join(" ")
+          result
+        end
+
+        private
+
+        # IRE prints the publication year first, abbreviated to two digits for
+        # the 20th century ("1952" => "52").
+        def short_year
+          value = year.to_i
+          (value.between?(1900, 1999) ? value - 1900 : value).to_s
         end
       end
     end

data/lib/pubid/ieee/nesc/builder.rb

@@ -20,6 +20,18 @@ module Pubid
       #   identifier = builder.build(parsed)
       #   # => #<Pubid::Ieee::Identifiers::Nesc::Handbook>
       class Builder
+        # The NESC's own designation (ANSI/IEEE C2). Used as the index code for
+        # the year-first forms, which print no code of their own.
+        #
+        # CAVEAT: this files the whole NESC family — including the Handbook and
+        # Redline, which are companions of the code rather than the code itself
+        # — under one `prefix "C"` + `number "2"` index key. That is deliberate:
+        # relaton narrows on `root.number` and then matches the full hash, so
+        # `_type` (and `variant`) keep the documents distinct; the alternative
+        # was an empty key, which silently defeats the binary search. Revisit if
+        # relaton ever treats `prefix + number` alone as an identity.
+        DEFAULT_CODE = "C2"
+
         # Build NESC identifier from parsed hash
         #
         # @param parsed_hash [Hash] Hash from parser
@@ -28,22 +40,18 @@ module Pubid
           # Determine identifier type based on parsed attributes
           identifier_class = determine_identifier_class(parsed_hash)
 
-          identifier = identifier_class.new
-
-          # Set code if present (C2)
-          if parsed_hash[:code]
-            code_str = parsed_hash[:code].to_s
-            identifier.code = Pubid::Ieee::Components::Code.new(
-              prefix: code_str[0], # "C" from "C2"
-              number: code_str[1..], # "2" from "C2"
-            )
-          end
+          # The code travels through the base initializer as `code:` so it lands
+          # in `code_obj` and the CodeNumber mixin hoists the flat split columns
+          # relaton indexes on. Every NESC document is the C2-designated code
+          # (or a companion of it), so the year-first forms — which print no
+          # code — still key under "C2" rather than leaving `root.number` empty.
+          identifier = identifier_class.new(
+            code: parsed_hash[:code]&.to_s || DEFAULT_CODE,
+          )
 
           # Set year (required for all NESC identifiers)
           if parsed_hash[:year]
-            identifier.year = Pubid::Components::Date.new(
-              year: parsed_hash[:year].to_s.to_i,
-            )
+            identifier.year = parsed_hash[:year].to_s
           end
 
           # Set variant (Handbook, Redline, etc.)
@@ -56,16 +64,20 @@ module Pubid
             identifier.edition = parsed_hash[:edition].to_s
           end
 
-          # Set draft flag
-          if parsed_hash[:draft]
-            identifier.draft = true
-          end
-
           # Set month (for drafts)
           if parsed_hash[:month]
             identifier.month = parsed_hash[:month].to_s
           end
 
+          # Registered-trademark "(R)" marks and the "(NESC(R))" abbreviation
+          # suffix (year-first forms) — see Identifiers::Nesc::Base#name_portion.
+          identifier.registered = true if parsed_hash[:name_registered] ||
+            parsed_hash[:abbr_registered]
+          if parsed_hash[:paren_abbr]
+            identifier.abbr_suffix = true
+            identifier.abbr_suffix_registered = true if parsed_hash[:paren_registered]
+          end
+
           identifier
         end
 
@@ -92,8 +104,9 @@ module Pubid
           # C2 code means standard NESC
           return Identifiers::Nesc::Standard if parsed_hash[:code]
 
-          # Fallback to base class
-          Identifiers::Nesc::Base
+          # Plain year-first edition. Never the abstract Nesc::Base — only
+          # concrete leaves carry the CodeNumber `number` column.
+          Identifiers::Nesc::Edition
         end
       end
     end

data/lib/pubid/ieee/nesc/parser.rb

@@ -34,15 +34,15 @@ module Pubid
           str("C2").as(:code)
         end
 
-        # NESC name variations
+        # NESC name variations (the "(R)" registered mark is captured
+        # separately by the `registered` rule so it can be round-tripped)
         rule(:nesc_full_name) do
-          str("National Electrical Safety Code(R)") |
-            str("National Electrical Safety Code") |
+          str("National Electrical Safety Code") |
             str("National Electric Safety Code") # Typo variation
         end
 
         rule(:nesc_abbr) do
-          str("NESC(R)") | str("NESC")
+          str("NESC")
         end
 
         rule(:nesc_name) do
@@ -51,7 +51,7 @@ module Pubid
 
         # Registered trademark notation
         rule(:registered) do
-          str("(R)").maybe
+          str("(R)")
         end
 
         # Edition notations
@@ -97,8 +97,8 @@ module Pubid
             dash >>
             year.as(:year) >>
             (comma.maybe >> space).maybe >>
-            nesc_full_name >>
-            (space >> str("(") >> nesc_abbr >> str(")")).maybe
+            nesc_full_name >> registered.maybe >>
+            (space >> str("(") >> nesc_abbr >> registered.maybe >> str(")")).maybe
         end
 
         # Pattern 2: YYYY NESC format (year-first)
@@ -109,11 +109,12 @@ module Pubid
           year.as(:year) >>
             space >>
             (
-              # Full name with optional (NESC) suffix
-              (nesc_full_name >> registered >>
-               (space >> str("(") >> nesc_abbr >> registered >> str(")")).maybe) |
-              # Just NESC abbreviation
-              (nesc_abbr >> registered)
+              # Full name with optional (NESC) abbreviation suffix
+              (nesc_full_name.as(:full_name) >> registered.as(:name_registered).maybe >>
+               (space >> str("(") >> nesc_abbr.as(:paren_abbr) >>
+                registered.as(:paren_registered).maybe >> str(")")).maybe) |
+              # Just the NESC abbreviation (e.g. "2017 NESC(R) Handbook")
+              (nesc_abbr.as(:abbr) >> registered.as(:abbr_registered).maybe)
             ) >>
             (space >> variant).maybe >>
             (comma >> space >> edition).maybe
@@ -123,7 +124,7 @@ module Pubid
         # Examples: "National Electrical Safety Code, C2-2012"
         #           "National Electrical Safety Code, C2-2012 - Redline"
         rule(:name_first) do
-          nesc_full_name >>
+          nesc_full_name >> registered.maybe >>
             comma >>
             space >>
             c2_code >>
@@ -138,7 +139,7 @@ module Pubid
         rule(:draft_nesc) do
           str("Draft").as(:draft) >>
             space >>
-            nesc_name >>
+            nesc_name >> registered.maybe >>
             comma >> space >>
             month >> space >> year.as(:year)
         end