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

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

@@ -1,88 +1,73 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Pubid
   module Ieee
     module Aiee
-      # Base class for AIEE identifiers
-      # AIEE (American Institute of Electrical Engineers): 1884-1963
-      class Identifier < Lutaml::Model::Serializable
-        attribute :publisher, :string, default: -> { "AIEE" }
-        attribute :type, :string # "No.", "No", "Standard", "Trans."
-        attribute :code, Components::Code
-        attribute :year, :string
-        attribute :month, :string
-        attribute :separator, :string # "," or "." for long form dates
-        attribute :original_format, :string # "short" or "long" (preserves parsed format)
-        attribute :relationships, Pubid::Ieee::Components::Relationship,
-                  collection: true
+      # AIEE identifiers (American Institute of Electrical Engineers: 1884-1963).
+      #
+      # Reparented onto Pubid::Ieee::Identifier + the CodeNumber mixin so AIEE
+      # shares the flat split-column serialization (number/prefix/parts/
+      # separator), a polymorphic `_type`, `#root`, and from_hash routing with
+      # every other IEEE type. Previously it descended from bare
+      # Lutaml::Model::Serializable and serialized a nested `code` object with no
+      # `_type`, so Pubid::Ieee::Identifier.from_hash could not route back to
+      # this class and dropped the code entirely — every AIEE row failed the
+      # relaton index-v2 round-trip gate and had a nil `root.number`.
+      #
+      # The date long-form separator is named `date_separator` (not `separator`)
+      # to avoid colliding with the CodeNumber code-part `separator`.
+      class Identifier < Pubid::Ieee::Identifier
+        include Pubid::Ieee::Identifiers::CodeNumber
 
-        def initialize(**args)
-          super()
-
-          # Handle number/code as string or Code object
-          # Builder passes :code, but also support :number for backward compatibility
-          code_value = args[:code] || args[:number]
-          if code_value.is_a?(String)
-            self.code = Components::Code.parse(code_value)
-          elsif code_value
-            self.code = code_value
-          end
-
-          # Set other attributes
-          attrs = self.class.attributes
-          args.each do |key, value|
-            next if %i[code number].include?(key)
-
-            setter = :"#{key}="
-            public_send(setter, value) if attrs.key?(key)
-          end
-        end
+        attribute :publisher, :string, default: -> { "AIEE" }
+        # AIEE carries no implicit type keyword, so override the base's "Std"
+        # default (else "AIEE 11-1937" would render as "AIEE Std 11-1937").
+        attribute :type, :string, default: -> {}
+        attribute :date_separator, :string  # "," or "." for long-form dates
+        attribute :original_format, :string # "short"/"long" (preserves parsed format)
 
-        # Provide number accessor for backward compatibility
-        # Returns the string representation of the code
-        def number
-          code&.to_s
+        # A distinct polymorphic name so from_hash routes to AIEE. The derived
+        # default (last name segment "Identifier") would be
+        # "pubid:ieee:identifier", colliding with the base class.
+        def self.polymorphic_name
+          "pubid:ieee:aiee"
         end
 
         # Parse AIEE identifier string
         def self.parse(input)
           parsed = Parser.new.parse(input)
-          builder = Builder.new
-          builder.build(parsed)
+          Builder.new.build(parsed)
         end
 
-        def to_s(date_format: nil)
+        def to_s(date_format: nil, trademark: false, **opts)
           result = [publisher]
           result << type if type
           result << code.to_s if code
 
           base = result.join(" ")
 
-          # Determine which format to use
-          # Priority: explicit parameter > original_format > default (long if month/separator, short otherwise)
-          format = date_format&.to_s || original_format
-
-          if !format
-            # Auto-detect from parsed attributes
-            format = month || separator ? "long" : "short"
+          # IEEE attaches the mark to the number, before the date suffix
+          # ("AIEE No 13™-1930").
+          if trademark
+            base += Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                                     code_obj&.prefix,
+                                                     publishers: [publisher])
           end
 
-          # Date formatting based on format parameter
+          # Priority: explicit parameter > original_format > format auto-detect
+          format = date_format&.to_s || original_format
+          format ||= month || date_separator ? "long" : "short"
+
           if year
             case format
             when "short", :short
-              # Short form: dash + year
               base += "-#{year}"
             when "long", :long
-              # Long form: separator + optional month + year
-              sep = separator || "," # Default to comma for long form
+              sep = date_separator || "," # Default to comma for long form
               base += "#{sep} #{"#{month} " if month}#{year}"
             else
-              # Preserve original format (backward compatibility)
-              base += if separator
-                        "#{separator} #{"#{month} " if month}#{year}"
+              base += if date_separator
+                        "#{date_separator} #{"#{month} " if month}#{year}"
                       elsif month
                         ", #{month} #{year}"
                       else
@@ -91,13 +76,12 @@ module Pubid
             end
           end
 
-          # Add relationships if present
-          if relationships && !relationships.empty?
-            relationship_str = relationships.join(" / ")
-            base += " (#{relationship_str})"
-          end
+          # The descriptive relationships narrative is deliberately kept out of
+          # to_s (an identifier string must stay bounded — it is used as a
+          # document number/filename downstream). It stays reachable on
+          # `relationships`.
 
-          base
+          annotate_plain_render(base, **opts)
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Pubid
     module Aiee
       # Parser for AIEE (American Institute of Electrical Engineers) identifiers
       # Historical period: 1884-1963 (merged into IEEE in 1963)
-      class Parser < Parslet::Parser
+      class Parser < ::Pubid::Parser::Grammar
         # Basic building blocks
         rule(:space) { str(" ") }
         rule(:space?) { space.maybe }