pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

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
@@ -84,6 +109,7 @@ module Pubid
         "pubid:iec:societal-technology-trend-report" => "Pubid::Iec::Identifiers::SocietalTechnologyTrendReport",
         "pubid:iec:systems-reference-document" => "Pubid::Iec::Identifiers::SystemsReferenceDocument",
         "pubid:iec:technology-report" => "Pubid::Iec::Identifiers::TechnologyReport",
+        "pubid:iec:technical-group" => "Pubid::Iec::Identifiers::TechnicalGroup",
         "pubid:iec:test-report-form" => "Pubid::Iec::Identifiers::TestReportForm",
         "pubid:iec:white-paper" => "Pubid::Iec::Identifiers::WhitePaper",
         "pubid:iec:working-document" => "Pubid::Iec::Identifiers::WorkingDocument",
@@ -116,21 +142,38 @@ 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 }
-        # IEC dates are year-only, so flatten the Date component to a scalar year.
+        # 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 }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        # IEC undated reference (e.g. IEC 60050:--). The `false` default is
+        # omitted; only the meaningful `true` round-trips via to_hash.
+        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
         map "edition", to: :edition, render_default: false
         map "languages", to: :languages, render_default: false
         # publisher emitted only when the primary isn't the IEC default;
@@ -142,59 +185,62 @@ 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 }
+        # 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
 
-      # --- 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?
+      # --- date serialized flat as year/month/day ---
+      def year_to_kv(model, doc)
+        y = model.date&.year
+        return if y.nil? || y.to_s.empty?
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
       end
 
-      def build_code(value)
+      def year_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
-        ::Pubid::Iec::Components::Code.new(value: value.to_s)
+        (model.date ||= ::Pubid::Components::Date.new).year = 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?
+      def month_to_kv(model, doc)
+        m = model.date&.month
+        return if m.nil? || m.to_s.empty?
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
-                                                              v.to_s))
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("month", m.to_s))
       end
 
-      def stage_iteration_from_kv(model, value)
+      def month_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
-        model.stage_iteration =
-          ::Pubid::Components::Iteration.new(number: value.to_s)
+        (model.date ||= ::Pubid::Components::Date.new).month = value.to_s
       end
 
-      # --- date <-> scalar year (IEC dates are year-only) ---
-      def year_to_kv(model, doc)
-        y = model.date&.year
-        return if y.nil? || y.to_s.empty?
+      def day_to_kv(model, doc)
+        d = model.date&.day
+        return if d.nil? || d.to_s.empty?
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("day", d.to_s))
       end
 
-      def year_from_kv(model, value)
+      def day_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
-        (model.date ||= ::Pubid::Components::Date.new).year = value.to_s
+        (model.date ||= ::Pubid::Components::Date.new).day = value.to_s
+      end
+
+      # --- date undated flag (IEC undated reference, e.g. IEC 60050:--) ---
+      # The `false` default is omitted; only the meaningful `true` round-trips
+      # via to_hash / from_hash.
+      def undated_to_kv(model, doc)
+        return unless model.date&.undated?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
+      end
+
+      def undated_from_kv(model, value)
+        (model.date ||= ::Pubid::Components::Date.new).undated = value.to_s == "true"
       end
 
       # --- publisher: primary only when non-default; copublishers as a list ---
@@ -229,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)
@@ -253,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?
 
@@ -261,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)
@@ -279,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/base.rb

@@ -31,8 +31,8 @@ module Pubid
           # Add subpart if present
           result += "-#{subpart}" if subpart && subpart.to_s != ""
 
-          # Add date if present
-          result += ":#{date.year}" if date
+          # Render the date (year[-month[-day]], or `--` for undated).
+          result += ":#{date.render}" if date
 
           result
         end

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/consolidated_identifier.rb

@@ -69,6 +69,12 @@ module Pubid
           identifiers&.first
         end
 
+        # The origin document. A consolidated bundle stores its members in
+        # `identifiers` (not `base`), so walk the first member to its root.
+        def root
+          identifiers&.first&.root || self
+        end
+
         # Get all supplements (identifiers after first)
         def supplements
           identifiers&.drop(1) || []

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

@@ -8,7 +8,7 @@ module Pubid
       # Example: "IEC 60050-191/AMD2/FRAG2 ED1" = Fragment 2 of Amendment 2
       # Fragments are independently approved and have their own lifecycle stages.
       class FragmentIdentifier < Identifier
-        attribute :base_identifier, Identifier, polymorphic: true
+        attribute :base, Identifier, polymorphic: true
         attribute :fragment_number, :string
         attribute :edition, ::Pubid::Components::Edition, default: -> {}
         # Fragments have their own lifecycle; default to the published FRAG stage
@@ -16,7 +16,7 @@ module Pubid
         attribute :typed_stage, ::Pubid::Components::TypedStage,
                   default: -> { self.class.published_typed_stage }
 
-        # number/date/publisher delegate to base_identifier, but the fragment's
+        # number/date/publisher delegate to base, but the fragment's
         # stage and edition are its own. Serialize the wrapped identifier under
         # "base" plus the fragment number; suppress only the truly-delegated
         # common maps (keep stage/edition from the inherited block).
@@ -25,16 +25,14 @@ 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
 
         def base_to_kv(model, doc)
-          base = model.base_identifier
+          base = model.base
           return unless base
 
           doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
@@ -42,7 +40,7 @@ module Pubid
         end
 
         def base_from_kv(model, value)
-          model.base_identifier = ::Pubid::Iec::Identifier.from_hash(value) if value
+          model.base = ::Pubid::Iec::Identifier.from_hash(value) if value
         end
 
         TYPED_STAGES = [
@@ -118,29 +116,29 @@ module Pubid
             web: :fragment_identifier, title: "Fragment", short: "FRAG" }
         end
 
-        # Delegate common attributes to base_identifier
+        # Delegate common attributes to base
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         def copublishers
-          base_identifier&.copublishers
+          base&.copublishers
         end
 
         def code
-          base_identifier&.code
+          base&.code
         end
 
         def number
-          base_identifier&.number
+          base&.number
         end
 
         def date
-          base_identifier&.date
+          base&.date
         end
 
         def stage
-          typed_stage&.to_stage || base_identifier&.stage
+          typed_stage&.to_stage || base&.stage
         end
       end
     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: ["PWI"],
+            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,
@@ -45,7 +58,9 @@ module Pubid
             code: :cd,
             stage_code: :cd,
             type_code: :is,
-            abbr: ["CD"],
+            abbr: %w[CD 2CD 3CD 4CD 5CD 6CD 7CD 8CD 9CD
+                     ACD A2CD A3CD A4CD A5CD A6CD A7CD A8CD A9CD
+                     CDM],
             name: "Committee Draft",
             harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
           ),
@@ -53,7 +68,7 @@ module Pubid
             code: :cdv,
             stage_code: :cdv,
             type_code: :is,
-            abbr: ["CDV"],
+            abbr: %w[CDV ACDV CCDV CDVM NCDV],
             name: "Committee Draft for Vote",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
           ),
@@ -61,7 +76,7 @@ module Pubid
             code: :fdis,
             stage_code: :fdis,
             type_code: :is,
-            abbr: ["FDIS", "PRF"],
+            abbr: %w[FDIS PRF NFDIS NADIS RDISH RFDIS CFDIS],
             name: "Final Draft International Standard",
             harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
           ),
@@ -69,7 +84,8 @@ module Pubid
             code: :is,
             stage_code: :published,
             type_code: :is,
-            abbr: [""],
+            abbr: ["", "BPUB", "PPUB", "APUB", "WPUB", "DELPUB",
+                   "RR", "CAN"],
             name: "International Standard",
             harmonized_stages: %w[60.00 60.60 90.20 90.60 90.92 90.93 90.99
                                   95.20 95.60 95.92 95.99],

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

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

@@ -82,18 +82,6 @@ module Pubid
             web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
         end
 
-        # Override publisher_portion to add PAS or DPAS stage
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage
-            abbr = typed_stage.abbreviation
-            # PAS uses space for all stages
-            result += " #{abbr}" unless abbr.empty?
-          end
-
-          result
-        end
       end
     end
   end