pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/iec.rb

@@ -2,84 +2,56 @@
 
 module Pubid
   module Iec
-  end
-end
-
-# Require scheme first
-require_relative "scheme"
+    autoload :Components, "#{__dir__}/iec/components"
+    autoload :Identifier, "#{__dir__}/iec/identifier"
+    autoload :Identifiers, "#{__dir__}/iec/identifiers"
+    autoload :SingleIdentifier, "#{__dir__}/iec/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/iec/supplement_identifier"
+    autoload :Parser, "#{__dir__}/iec/parser"
+    autoload :Builder, "#{__dir__}/iec/builder"
+    autoload :UrnParser, "#{__dir__}/iec/urn_parser"
+    autoload :UrnGenerator, "#{__dir__}/iec/urn_generator"
+    autoload :RenderingStyle, "#{__dir__}/iec/rendering_style"
+    autoload :Renderer, "#{__dir__}/iec/renderer"
 
-# Require all identifier classes
-require_relative "iec/identifiers/international_standard"
-require_relative "iec/identifiers/technical_report"
-require_relative "iec/identifiers/technical_specification"
-require_relative "iec/identifiers/publicly_available_specification"
-require_relative "iec/identifiers/guide"
-require_relative "iec/identifiers/test_report_form"
-require_relative "iec/identifiers/interpretation_sheet"
-require_relative "iec/identifiers/systems_reference_document"
-require_relative "iec/identifiers/working_document"
-require_relative "iec/identifiers/amendment"
-require_relative "iec/identifiers/corrigendum"
+    def self.parse(identifier_string)
+      parsed = Parser.new.parse(identifier_string)
+      Builder.new.build(parsed)
+    end
 
-# Wrapper identifier types
-require_relative "iec/identifiers/vap_identifier"
-require_relative "iec/identifiers/sheet_identifier"
-require_relative "iec/identifiers/consolidated_identifier"
-require_relative "iec/identifiers/fragment_identifier"
+    def self.parse_urn(urn)
+      UrnParser.parse(urn)
+    end
 
-# Additional document types
-require_relative "iec/identifiers/component_specification"
-require_relative "iec/identifiers/operational_document"
-require_relative "iec/identifiers/societal_technology_trend_report"
-require_relative "iec/identifiers/white_paper"
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iec::Renderer)
 
-module Pubid
-  module Iec
-    # Primary document types (not supplements)
-    IDENTIFIER_TYPES = [
-      Identifiers::InternationalStandard,
-      Identifiers::TechnicalReport,
-      Identifiers::TechnicalSpecification,
-      Identifiers::PubliclyAvailableSpecification,
-      Identifiers::Guide,
-      Identifiers::TestReportForm,
-      Identifiers::InterpretationSheet,
-      Identifiers::SystemsReferenceDocument,
-      Identifiers::WorkingDocument,
-    ].freeze
-
-    # Supplement types (can appear with / notation)
-    SUPPLEMENT_IDENTIFIER_TYPES = [
-      Identifiers::Amendment,
-      Identifiers::Corrigendum,
-      Identifiers::InterpretationSheet, # ISH can act as supplement (/ISH1:1996)
-      Identifiers::FragmentIdentifier,  # FRAG wraps amendments/corrigenda
-    ].freeze
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| begin; c.type.is_a?(Hash); rescue NotImplementedError; false; end }
+    end
 
-    # Create the Scheme registry with all identifier types
-    Scheme = Pubid::Scheme.new(
-      identifiers: IDENTIFIER_TYPES,
-      supplement_identifiers: SUPPLEMENT_IDENTIFIER_TYPES,
-    )
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
 
-    # Main entry point for IEC identifiers
-    def self.parse(identifier_string)
-      parsed = Parser.new.parse(identifier_string)
-      Builder.new(Scheme).build(parsed)
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
     end
 
-    # Parse an IEC URN string
-    # @param urn [String] the URN string to parse
-    # @return [Identifier] the parsed identifier
-    # @raise [Errors::ParseError] if URN is invalid
-    def self.parse_urn(urn)
-      UrnParser.parse(urn)
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
     end
   end
 end
 
-require_relative "iec/urn_parser"
-require_relative "iec/builder"
-require_relative "iec/parser"
-
 Pubid::Registry.register(:iec, Pubid::Iec)

data/lib/pubid/ieee/builder.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Ieee
     # Builder class for constructing IEEE identifier scheme from parsed data
-    # Single Responsibility: Transform parsed data into Scheme objects
+    # Single Responsibility: Transform parsed data into identifier objects
     class Builder
       attr_accessor :original_input
       attr_reader :identifier_class
@@ -14,7 +14,7 @@ module Pubid
 
       # Build a scheme object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Scheme] the constructed scheme object
+      # @return [identifier] the constructed identifier object
       def build(parsed)
         # Handle CSA dual published patterns
         if parsed[:ieee_portion] && parsed[:csa_portion]
@@ -458,7 +458,7 @@ module Pubid
           stage_abbr = attributes[:iso_stage]
           if stage_abbr
             attributes[:typed_stage] =
-              Ieee::Scheme.locate_typed_stage_by_abbr(stage_abbr)
+              Pubid::Ieee.locate_stage(stage_abbr)
           end
         else
           # IEEE format - lead party is IEEE
@@ -477,7 +477,7 @@ module Pubid
 
           # Create typed_stage for IEEE project
           attributes[:typed_stage] =
-            Ieee::Scheme.locate_typed_stage_by_abbr("P")
+            Pubid::Ieee.locate_stage("P")
         end
 
         Identifiers::JointDevelopment.new(**attributes)
@@ -575,7 +575,7 @@ module Pubid
       end
 
       # Determine which identifier class to use based on attributes
-      # CRITICAL: Use Scheme for type-based decisions, NOT hardcoded logic here
+      # CRITICAL: Use flavor module for type-based decisions, NOT hardcoded logic here
       # Builder's job is ONLY to cast types, not make business decisions
       def determine_identifier_class(attributes)
         # Check for AIEE publisher FIRST (AIEE has its own identifier class)
@@ -584,12 +584,12 @@ module Pubid
           return Ieee::Aiee::Identifier
         end
 
-        # Get type from attributes and use Scheme to locate class
+        # Get type from attributes and use flavor module to locate class
         type_code = attributes[:type]
 
-        # Use Scheme registry for type-to-class mapping
+        # Use flavor module for type-to-class mapping
         if type_code
-          klass = Ieee::Scheme.locate_identifier_klass_by_type_code(type_code)
+          klass = Pubid::Ieee.locate_type(type_code)
           return klass if klass
         end
 
@@ -678,7 +678,7 @@ module Pubid
 
       # Extract and normalize attributes from parsed data
       # @param parsed [Hash] the parsed data
-      # @return [Hash] normalized attributes for Scheme
+      # @return [Hash] normalized attributes for identifier
       def extract_attributes(parsed)
         attributes = {}
 
@@ -785,7 +785,7 @@ module Pubid
         end
 
         # Set type attribute for backward compatibility (after P extraction)
-        # NOTE: "P" IS a type code that maps to ProjectDraftIdentifier via Scheme
+        # NOTE: "P" IS a type code that maps to ProjectDraftIdentifier via flavor module
         # Type can be: "Std", "No", "P" (project draft), etc.
         attributes[:type] = type_value if type_value
 
@@ -794,7 +794,7 @@ module Pubid
                                                 parsed)
         if typed_stage_abbr
           attributes[:typed_stage] =
-            Ieee::Scheme.locate_typed_stage_by_abbr(typed_stage_abbr)
+            Pubid::Ieee.locate_stage(typed_stage_abbr)
         end
 
         attributes[:draft_status] = draft_status_value
@@ -880,7 +880,7 @@ module Pubid
             if version
               draft_abbr = "D#{version}"
               # Check if this specific draft stage is in registry
-              stage = Ieee::Scheme.locate_typed_stage_by_abbr(draft_abbr)
+              stage = Pubid::Ieee.locate_stage(draft_abbr)
               return draft_abbr if stage&.abbr&.include?(draft_abbr)
             end
           end

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

@@ -11,6 +11,10 @@ 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.)
@@ -96,6 +100,10 @@ original_separator: nil)
 
           result
         end
+
+        def render(context: nil)
+          to_s
+        end
       end
     end
   end

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

@@ -42,6 +42,20 @@ day: nil)
           self.day = day
         end
 
+        # Parse a draft string like "D5", "D3.4", or "5" into a Draft object.
+        # @param value [String, Draft] the value to coerce
+        # @return [Draft]
+        def self.parse(value)
+          return value if value.is_a?(Draft)
+
+          str = value.to_s
+          if str =~ /^D(\d+)(?:\.(\d+))?/
+            new(version: $1, revision: $2)
+          else
+            new(version: str)
+          end
+        end
+
         # Convert month name to numeric value
         def convert_month(month_name)
           return nil unless month_name

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

@@ -1,157 +1,13 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
+# 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.
 module Pubid
   module Ieee
     module Components
-      # 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
+      class Relationship < ::Pubid::Components::Relationship; end
     end
   end
 end

data/lib/pubid/ieee/identifier.rb

@@ -2,52 +2,17 @@
 
 module Pubid
   module Ieee
+    # NOTE: intentionally does NOT `extend Pubid::IdentifierFacade`. IEEE's
+    # `to_hash`/`from_hash` does not round-trip yet (e.g. `code`/`year` are
+    # dropped on rebuild), so the facade would advertise a `from_hash` that
+    # silently returns lossy objects — and a consumer's `instance_of?(module)`
+    # validation can't catch it. Re-enable once IEEE serialization round-trips
+    # cleanly. See identifier_facade.rb.
     module Identifier
       class << self
         def parse(input)
           Identifiers::Base.parse(input)
         end
-
-        # Factory mirroring pubid 1.x's `Pubid::Ieee::Identifier.create` API.
-        # Dispatches via {Pubid::Ieee::Scheme.locate_identifier_klass_by_type_code}.
-        # Default subclass (no `type:`) is Identifiers::Standard — the
-        # canonical class produced by parsing typical IEEE identifiers.
-        def create(type: nil, **opts)
-          klass = type ?
-                  Scheme.locate_identifier_klass_by_type_code(type) :
-                  Identifiers::Standard
-          attrs = coerce_create_attrs(opts)
-          # ProjectDraftIdentifier renders the "P" prefix from typed_stage,
-          # not from `type`. Set both so the output matches a parsed form.
-          if klass == Identifiers::ProjectDraftIdentifier
-            attrs[:type] = "P"
-            attrs[:typed_stage] ||= Scheme.locate_typed_stage_by_abbr("P")
-          end
-          klass.new(**attrs)
-        end
-
-        private
-
-        def coerce_create_attrs(opts)
-          attrs = {}
-          attrs[:publisher] = opts[:publisher].to_s if opts[:publisher]
-          if opts[:copublisher]
-            attrs[:copublisher] =
-              Array(opts[:copublisher]).map(&:to_s)
-          end
-          # :code or :number alias
-          if (v = opts[:code] || opts[:number])
-            attrs[:code] = v.to_s
-          end
-          %i[year edition month day draft_status].each do |k|
-            v = opts[k]
-            attrs[k] = v.to_s unless v.nil?
-          end
-          attrs[:redline] = opts[:redline] if opts.key?(:redline)
-          # TODO(create-shim): amendments/corrigenda/revision_of/incorporates
-          # are nested Base relations; not yet wired through.
-          attrs
-        end
       end
     end
   end

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

@@ -16,12 +16,7 @@ module Pubid
                                               collection: true
 
         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
+          render(format: :human)
         end
 
         def publisher