pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/idf/builder.rb

@@ -41,9 +41,9 @@ module Pubid
           number = parts.shift
           part = parts.shift
           subpart = parts.size.positive? ? parts.join("-") : nil
-          code_hash = { number: Components::Code.new(value: number) }
-          code_hash[:part] = Components::Code.new(value: part) if part
-          code_hash[:subpart] = Components::Code.new(value: subpart) if subpart
+          code_hash = { number: number }
+          code_hash[:part] = part if part
+          code_hash[:subpart] = subpart if subpart
           code_hash
         when :type_with_stage
           iteration = value.to_s.match(/(\d+)$/)

data/lib/pubid/idf/identifier.rb

@@ -5,8 +5,24 @@ module Pubid
   module Idf
     # An IDF identifier has no copublisher
     class Identifier < ::Pubid::Identifier
+      # A Type INSTANCE, never the raw :key symbol - lutaml materializes
+      # defaults during from_hash; casting a Symbol into the
+      # component raises InvalidFormatError (pubid#383).
+      def self.default_type
+        Components::Type.new(abbr: type[:short])
+      end
+
       attribute :typed_stage, Components::TypedStage
 
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: IDF stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def to_s(**opts)
         render(format: :human, **opts)
       end
@@ -21,11 +37,11 @@ module Pubid
       def number_portion(lang_single: false)
         [
           # Directives may not have a number
-          (number ? " #{number.value}" : ""),
+          (number ? " #{number}" : ""),
 
           # Parts and subparts are optional
-          (part ? "-#{part.value}" : ""),
-          (subpart ? "-#{subpart.value}" : ""),
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
 
           # Stage iteration is optional
           (stage_iteration ? ".#{stage_iteration.number}" : ""),
@@ -53,16 +69,16 @@ module Pubid
       end
 
       def self.parse(string)
-        if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
         end
 
-        parsed = Pubid::Idf::Parser.new.parse(string)
-        if parsed.nil? || parsed.empty?
-          raise Pubid::Idf::Parser::ParseError,
-                "Invalid identifier format"
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
+        parsed = Pubid::Idf::Parser.new.parse(string)
         Pubid::Idf::Builder.new.build(parsed)
       end
     end

data/lib/pubid/idf/identifiers/amendment.rb

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class Amendment < SupplementIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/idf/identifiers/corrigendum.rb

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class Corrigendum < SupplementIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/idf/identifiers/international_standard.rb

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # International Standard Identifier
       class InternationalStandard < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class ReviewedMethod < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
         TYPED_STAGES = [
           Components::TypedStage.new(
             code: :pwirm,

data/lib/pubid/idf/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Idf
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 

data/lib/pubid/idf/renderer.rb

@@ -43,9 +43,9 @@ module Pubid
         lang_single = opts[:lang_single] || false
 
         [
-          (id.number ? " #{id.number.render(context:)}" : ""),
-          (id.part ? "-#{id.part.render(context:)}" : ""),
-          (id.subpart ? "-#{id.subpart.render(context:)}" : ""),
+          (id.number ? " #{id.number}" : ""),
+          (id.part ? "-#{id.part}" : ""),
+          (id.subpart ? "-#{id.subpart}" : ""),
           (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
           (id.date ? ":#{id.date.render(context:)}" : ""),
           language_portion(id, lang_single: lang_single),
@@ -75,7 +75,7 @@ module Pubid
           "/",
           id.typed_stage.abbreviation,
           " ",
-          id.number.render(context:),
+          id.number,
           (id.date ? ":#{id.date.render(context:)}" : ""),
         ].join
       end

data/lib/pubid/idf/single_identifier.rb

@@ -12,7 +12,7 @@ module Pubid
     #
     # Note: The type attribute is inherited from the base Identifier class.
     # Concrete classes should add their own default value like:
-    #   attribute :type, Components::Type, default: -> { self.class.type[:key] }
+    #   attribute :type, Components::Type, default: -> { self.class.default_type }
     class SingleIdentifier < Identifier
     end
   end

data/lib/pubid/idf/urn_generator.rb

@@ -38,7 +38,7 @@ module Pubid
           end
 
           if identifier.number
-            parts << identifier.number.render(context: URN_CONTEXT)
+            parts << identifier.number
           end
         end
 

data/lib/pubid/idf.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Idf
     extend Pubid::PrefixesSupport
@@ -18,8 +19,13 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       parser = Parser.new

data/lib/pubid/iec/builder.rb

@@ -59,7 +59,7 @@ module Pubid
           supplement = identifier_class.new
           supp_attrs = identifier_class.attributes
           if supp_attrs.key?(:number)
-            supplement.number = Components::Code.new(value: supplement_number.to_s)
+            supplement.number = supplement_number.to_s
           end
           if supplement_date && supp_attrs.key?(:date)
             supplement.date = cast(:date, supplement_date)
@@ -151,7 +151,15 @@ module Pubid
 
         assign_attributes(identifier, parsed_hash)
 
-        # Detect rendering style from parsed abbreviation
+        # Detect rendering style from parsed abbreviation.
+        #
+        # UNREACHABLE TODAY: no IEC identifier class declares a
+        # `rendering_style` attribute, so this whole block never runs. Its
+        # `original_abbr` reads below are therefore NOT a live consumer of that
+        # field — which is why `original_abbr` can be left nil on both the parse
+        # and the from_hash paths (see Identifier.published_typed_stage). The
+        # long-vs-short stage spelling is already collapsed: "…/Amd 1:2017"
+        # renders back as "…/AMD1:2017". Do not treat this as working code.
         if identifier.class.attributes.key?(:rendering_style) && identifier.typed_stage
           ts = identifier.typed_stage
 
@@ -288,12 +296,12 @@ module Pubid
 
           if type == "AMD"
             Identifiers::Amendment.new(
-              number: Components::Code.new(value: number),
+              number: number,
               date: date_component,
             )
           elsif type == "COR"
             Identifiers::Corrigendum.new(
-              number: Components::Code.new(value: number),
+              number: number,
               date: date_component,
             )
           end
@@ -371,15 +379,14 @@ module Pubid
 
         when :number
           # Plain number for sub-org identifiers (CA, IECQ CS, IECQ OD)
-          # Just return as Code component
-          { number: Components::Code.new(value: value.to_s) }
+          { number: value.to_s }
 
         when :number_with_part
           # "60038" (no part)
           # or "60038-1" ('1' is part)
           # or "60038-1-2" ('1' is part, '2' is subpart)
           # or "29110-5-1-1" ('5' is part, '1-1' is subpart)
-          parse_number_with_part(value, code_class: Components::Code)
+          parse_number_with_part(value)
 
         when :type_with_stage
           # "WD"

data/lib/pubid/iec/components.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iec
     module Components
-      autoload :Code, "#{__dir__}/components/code"
       autoload :ConsolidatedAmendment, "#{__dir__}/components/consolidated_amendment"
       autoload :Publisher, "#{__dir__}/components/publisher"
       autoload :Sheet, "#{__dir__}/components/sheet"

data/lib/pubid/iec/identifier.rb

@@ -9,11 +9,15 @@ module Pubid
     # "base". No-op the delegated maps so they serialize once. (Mirrors
     # Iso::BundledIdentifier.) Fragment keeps its own stage/edition, so it
     # suppresses a subset inline instead of including this.
+    #
+    # number/part/subpart are NOT here, and deliberately so: their maps live on
+    # SingleIdentifier, which the four wrappers do not inherit from, so the
+    # exclusion is structural rather than a denylist that can drift. Only a
+    # converter can be no-opped this way, so a key that needs `with:` for
+    # another reason — year, publisher, copublishers, stage — still lists here.
+    # (`month`/`day`/`undated` are missing from that list and leak a duplicated
+    # top-level key on a wrapper; pre-existing, see docs/flavors/iec.md.)
     module DelegatedFieldSuppression
-      def number_to_kv(_model, _doc); end
-      def part_to_kv(_model, _doc); end
-      def subpart_to_kv(_model, _doc); end
-      def stage_iteration_to_kv(_model, _doc); end
       def year_to_kv(_model, _doc); end
       def publisher_to_kv(_model, _doc); end
       def copublishers_to_kv(_model, _doc); end
@@ -23,14 +27,33 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       # Override base types with IEC-specific ones. publisher defaults to the
       # type's implied publisher (IEC), so an omitted publisher key reconstructs
-      # correctly on from_hash. number/part/subpart are IEC codes.
+      # correctly on from_hash.
       attribute :publisher, ::Pubid::Iec::Components::Publisher,
                 default: -> { self.class.default_publisher }
       attribute :copublishers, ::Pubid::Iec::Components::Publisher,
                 collection: true
-      attribute :number, ::Pubid::Iec::Components::Code
-      attribute :part, ::Pubid::Iec::Components::Code
-      attribute :subpart, ::Pubid::Iec::Components::Code
+
+      # number/part/subpart are plain strings, not a Components::Code.
+      # ::Pubid::Identifier declares them as a Code, so this is a REDECLARATION
+      # — safe here because this class body lives in this one file and is never
+      # reopened, so lutaml's deep-dup of the attribute table into each subclass
+      # always sees the complete table.
+      #
+      # The Code they used to hold was an empty box. Measured over all 12,331
+      # parseable IEC pass fixtures, number/part/subpart were a Code 9,975 /
+      # 5,422 / 2,416 times and NOT ONE populated `prefix`, `parts`, `part` or
+      # `subpart` inside it; `Iec::Components::Code` existed solely to render a
+      # `prefix` that no construction path ever set, and is deleted.
+      #
+      # The split was a live defect, not just clutter: `parse` produced a Code
+      # while `new` left a String (a `:string` assigned to a Code-typed
+      # attribute stays a String), so a hand-built identifier was not `==` the
+      # parsed one — and `#matches?` is `exclude(*ignore) == other.exclude(...)`,
+      # so every match between them silently returned false while `to_s`,
+      # `to_urn` and `to_hash` all agreed. See spec/pubid/iec/number_string_spec.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
 
       # The publisher implied when none is serialized (IEC for every type).
       def self.default_publisher
@@ -45,15 +68,17 @@ module Pubid
 
       # The class's published typed_stage (canonical surface form), or nil for
       # types without a published stage.
+      #
+      # `original_abbr` is deliberately LEFT NIL. It records the spelling the
+      # input used, it is not serialized, and the parse path (Builder#
+      # locate_typed_stage) never writes it — so setting it here alone made
+      # `from_hash(to_hash) != parse` for every IEC identifier. The `dup` stays:
+      # TYPED_STAGES is frozen, its elements are not.
       def self.published_typed_stage
         return nil unless const_defined?(:TYPED_STAGES)
 
         ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
-        return nil unless ts
-
-        ts = ts.dup
-        ts.original_abbr = ts.canonical_abbreviation
-        ts
+        ts&.dup
       end
 
       # type and generic stage are derived from typed_stage, never stored — so
@@ -117,19 +142,31 @@ module Pubid
 
       # The base Pubid::Identifier no longer auto-maps attributes, so each
       # flavor's top class declares its own key_value mapping. Subclasses merge
-      # their own blocks on top of this one (e.g. SupplementIdentifier adds
-      # base; VapIdentifier adds vap), so list every base attribute IEC
-      # serializes here once. Code/Date are flattened to plain scalars; the
-      # verbose type/stage trees are not mapped (type/stage are recomputed from
-      # typed_stage, which serializes as just its code under "stage").
+      # their own blocks on top of this one — lutaml APPENDS a subclass's maps
+      # to the parent's (e.g. SingleIdentifier adds number/part/subpart,
+      # SupplementIdentifier adds base, VapIdentifier adds vap) — so list every
+      # attribute EVERY IEC type serializes here once, and put a key that only
+      # some types own on the class that owns it.
+      #
+      # Date is flattened to plain scalars; the verbose type/stage trees are not
+      # mapped (type/stage are recomputed from typed_stage, which serializes as
+      # just its code under "stage").
+      #
+      # A converter (`with:`) is for a custom class, or for splitting one
+      # attribute across several keys. A primitive takes a plain map: a nil and
+      # a default-valued attribute are both dropped by
+      # ::Pubid::Identifier#to_hash, so no converter is needed to omit them.
       key_value do
         map "_type", to: :_type, polymorphic_map: IEC_TYPE_MAP
-        # Code components serialize as their plain string value, not {value,...}.
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "part", with: { to: :part_to_kv, from: :part_from_kv }
-        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
-        map "stage_iteration",
-            with: { to: :stage_iteration_to_kv, from: :stage_iteration_from_kv }
+        # number/part/subpart are NOT mapped here — they live on
+        # SingleIdentifier, the seam that excludes the four delegating wrappers.
+        # See the comment on that block.
+        #
+        # stage_iteration is a degenerate Components::Iteration (one :string
+        # field, `number`), so the shared FLAT_SCALAR_COMPONENTS rule on
+        # ::Pubid::Identifier flattens it to a bare scalar and inflates it back.
+        # A plain map is enough; no converter.
+        map "stage_iteration", to: :stage_iteration, render_default: false
         # date serialized flat as year/month/day, nils omitted.
         map "year", with: { to: :year_to_kv, from: :year_from_kv }
         map "month", with: { to: :month_to_kv, from: :month_from_kv }
@@ -148,45 +185,9 @@ module Pubid
         # serialize only the unique typed-stage code under "stage" and recompute
         # the rest on load. _type already pins the document type.
         map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
-        # Omit the `false` default; only the meaningful `true` is serialized.
-        map "all_parts", with: { to: :all_parts_to_kv, from: :all_parts_from_kv }
-      end
-
-      # --- Code components <-> plain string ---
-      def number_to_kv(model, doc) = emit_code(doc, "number", model.number)
-      def number_from_kv(model, value) = model.number = build_code(value)
-      def part_to_kv(model, doc) = emit_code(doc, "part", model.part)
-      def part_from_kv(model, value) = model.part = build_code(value)
-      def subpart_to_kv(model, doc) = emit_code(doc, "subpart", model.subpart)
-      def subpart_from_kv(model, value) = model.subpart = build_code(value)
-
-      def emit_code(doc, key, code)
-        v = code.is_a?(::Pubid::Components::Code) ? code.value : code
-        return if v.nil? || v.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
-      end
-
-      def build_code(value)
-        return if value.nil? || value.to_s.empty?
-
-        ::Pubid::Iec::Components::Code.new(value: value.to_s)
-      end
-
-      def stage_iteration_to_kv(model, doc)
-        iter = model.stage_iteration
-        v = iter.is_a?(::Pubid::Components::Iteration) ? iter.number : iter
-        return if v.nil? || v.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
-                                                              v.to_s))
-      end
-
-      def stage_iteration_from_kv(model, value)
-        return if value.nil? || value.to_s.empty?
-
-        model.stage_iteration =
-          ::Pubid::Components::Iteration.new(number: value.to_s)
+        # A Boolean attribute whose `false` default ::Pubid::Identifier#to_hash
+        # already drops, so a plain map suffices (the GB spelling).
+        map "all_parts", to: :all_parts, render_default: false
       end
 
       # --- date serialized flat as year/month/day ---
@@ -274,17 +275,6 @@ module Pubid
         end
       end
 
-      # --- all_parts: omit the false default ---
-      def all_parts_to_kv(model, doc)
-        return unless model.all_parts
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("all_parts", true))
-      end
-
-      def all_parts_from_kv(model, value)
-        model.all_parts = value
-      end
-
       # Serialize typed_stage as just its unique code (e.g. "cd", "fdis"); the
       # published default is omitted (recomputed from the class on load).
       def stage_to_kv(model, doc)
@@ -298,6 +288,8 @@ module Pubid
       end
 
       # Resolve the typed-stage code back within this identifier's class.
+      # `original_abbr` is left nil here for the same reason as in
+      # `published_typed_stage` above.
       def stage_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
@@ -306,14 +298,17 @@ module Pubid
              Pubid::Iec.all_typed_stages.find { |t| t.code.to_s == value.to_s }
         return unless ts
 
-        ts = ts.dup
-        ts.original_abbr = ts.canonical_abbreviation
-        model.typed_stage = ts
+        model.typed_stage = ts.dup
       end
 
       def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
@@ -324,11 +319,6 @@ module Pubid
         # Apply legacy update_codes normalization first, before any other preprocessing
         normalized = Core::UpdateCodes.apply(string, :iec)
         parsed = Pubid::Iec::Parser.new.parse(normalized)
-        if parsed.nil? || parsed.empty?
-          raise Pubid::Iec::Parser::ParseError,
-                "Invalid identifier format"
-        end
-
         Pubid::Iec::Builder.new.build(parsed)
       end
 

data/lib/pubid/iec/identifiers/amendment.rb

@@ -5,8 +5,12 @@ module Pubid
     module Identifiers
       # Amendment Identifier
       class Amendment < SupplementIdentifier
-        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
-
+        # `type` is NOT redeclared here. It is derived from `typed_stage` by
+        # Pubid::Iec::Identifier#type, like every other IEC type. A redeclared
+        # attribute shadowed that reader and, because `type` is not serialized,
+        # its class-level default assigned the Symbol `:amd` on the from_hash
+        # path where the parse path assigns a Components::Type — so
+        # `from_hash(to_hash) != parse` for every amendment.
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             code: :pwi_amd,

data/lib/pubid/iec/identifiers/component_specification.rb

@@ -23,16 +23,6 @@ module Pubid
             web: :component_specification, title: "Component Specification", short: "CS" }
         end
 
-        # Override publisher_portion to add CS
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "CS"
-            result += " CS"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/conformity_assessment.rb

@@ -22,16 +22,6 @@ module Pubid
           { key: :ca, title: "Conformity Assessment", short: "CA" }
         end
 
-        # Override publisher_portion to add /CA
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "CA"
-            result += " CA"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/corrigendum.rb

@@ -5,8 +5,8 @@ module Pubid
     module Identifiers
       # Corrigendum Identifier
       class Corrigendum < SupplementIdentifier
-        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
-
+        # `type` is NOT redeclared here — see the note on Amendment. The
+        # redeclaration assigned the Symbol `:cor` on the from_hash path.
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             code: :pwi_cor,

data/lib/pubid/iec/identifiers/fragment_identifier.rb

@@ -25,10 +25,8 @@ module Pubid
           map "fragment_number", to: :fragment_number, render_default: false
         end
 
-        def number_to_kv(_model, _doc); end
-        def part_to_kv(_model, _doc); end
-        def subpart_to_kv(_model, _doc); end
-        def stage_iteration_to_kv(_model, _doc); end
+        # number/part/subpart need no no-op here: their maps live on
+        # SingleIdentifier, which this class does not inherit from.
         def year_to_kv(_model, _doc); end
         def publisher_to_kv(_model, _doc); end
         def copublishers_to_kv(_model, _doc); end

data/lib/pubid/iec/identifiers/guide.rb

@@ -80,22 +80,6 @@ module Pubid
           { key: :guide, title: "Guide", short: %w[Guide GUIDE] }
         end
 
-        # Override publisher_portion to handle Guide formatting
-        # If copublishers exist, use parent implementation
-        def publisher_portion
-          # If copublishers, delegate to parent (SingleIdentifier) which handles them
-          return super if copublishers&.any?
-
-          # No copublishers: simple Guide formatting
-          result = publisher.to_s
-
-          if typed_stage
-            abbr = typed_stage.abbreviation
-            result += " #{abbr}" unless abbr.empty?
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/international_standard.rb

@@ -13,7 +13,7 @@ module Pubid
             code: :pwi,
             stage_code: :pwi,
             type_code: :is,
-            abbr: %w[PWI PNW NWIP BWG AWIN AMW],
+            abbr: %w[PWI NWIP BWG AWIN AMW],
             name: "Preliminary Work Item",
             harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
           ),
@@ -23,7 +23,20 @@ module Pubid
             type_code: :is,
             abbr: ["NP"],
             name: "New Proposal",
-            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+            harmonized_stages: %w[10.00 10.60 10.92 10.98],
+          ),
+          # PNW is a stage of its own, not an alias of PWI. IEC's portal and
+          # pubid-iec 1.x both give it harmonized code 10.20 ("New work item
+          # proposal"), which is why 10.20 is absent from :np above — the two
+          # must not both claim it, or a lookup by harmonized code is
+          # ambiguous. See issue #360 item 1.
+          Pubid::Components::TypedStage.new(
+            code: :pnw,
+            stage_code: :pnw,
+            type_code: :is,
+            abbr: ["PNW"],
+            name: "New work item proposal",
+            harmonized_stages: %w[10.20],
           ),
           Pubid::Components::TypedStage.new(
             code: :anw,

data/lib/pubid/iec/identifiers/operational_document.rb

@@ -23,16 +23,6 @@ module Pubid
             web: :operational_document, title: "Operational Document", short: "OD" }
         end
 
-        # Override publisher_portion to add OD
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "OD"
-            result += " OD"
-          end
-
-          result
-        end
       end
     end
   end