pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/ansi/renderer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Human-readable renderer for ANSI identifiers.
+    #
+    # Produces strings like:
+    #   "ANSI X3.4"
+    #   "ANSI/ISO 9899"
+    #   "ANSI X9.8-1:2007"
+    #
+    # The renderer is registered as the `:human` format in the ANSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        parts = []
+        parts << publisher_portion(id, context)
+        parts << number_portion(id, context)
+        result = parts.compact.join(" ")
+
+        result << language_portion(id) if id.languages&.any?
+
+        result
+      end
+
+      private
+
+      def publisher_portion(id, context)
+        if id.copublishers&.any?
+          ([id.publisher] + id.copublishers).map { |p| p.render(context:) }.join("/")
+        else
+          id.publisher.render(context:)
+        end
+      end
+
+      def number_portion(id, context)
+        [
+          id.number.render(context:),
+          (id.part ? "-#{id.part.render(context:)}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+
+      def language_portion(id)
+        return "" unless id.languages&.any?
+
+        "(#{id.languages.map(&:code).join(',')})"
+      end
+    end
+  end
+end

data/lib/pubid/ansi/single_identifier.rb

@@ -8,37 +8,8 @@ module Pubid
       #
       # @return [String] URN representation
 
-      def to_s(lang: :en)
-        [].tap do |parts|
-          parts << publisher_portion
-          parts << number_portion
-        end.compact.join(" ").tap do |s|
-          s << language_portion if languages&.any?
-        end
-      end
-
-      def publisher_portion
-        if copublishers&.any?
-          # ANSI/ISO 9899
-          ([publisher] + copublishers).map(&:body).join("/")
-        else
-          # ANSI X3.4
-          publisher.body
-        end
-      end
-
-      def number_portion
-        [
-          number.value,
-          (part ? "-#{part.value}" : ""),
-          (date ? ":#{date.year}" : ""),
-        ].join
-      end
-
-      def language_portion
-        return "" unless languages&.any?
-
-        "(#{languages.map(&:code).join(',')})"
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
     end
   end

data/lib/pubid/ansi/urn_generator.rb

@@ -3,41 +3,6 @@
 module Pubid
   module Ansi
     class UrnGenerator < Pubid::UrnGenerator::Base
-      def urn_number
-        return nil unless identifier.number
-
-        identifier.number.value.to_s
-      end
-
-      def urn_part
-        return nil unless identifier.part
-
-        "-#{identifier.part.value}"
-      end
-
-      def urn_subpart
-        return nil unless identifier.subpart
-
-        "-#{identifier.subpart.value}"
-      end
-
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        identifier.year&.to_s
-      end
-
-      def urn_edition
-        return nil unless identifier.edition
-
-        num = identifier.edition.number
-        return nil unless num
-
-        "ed.#{num}"
-      end
-
       def urn_typed_stage
         return nil unless identifier.typed_stage
 
@@ -57,12 +22,12 @@ module Pubid
         parts << urn_typed_stage if urn_typed_stage
 
         if identifier.publisher
-          parts[1] = identifier.publisher.body.to_s.downcase
+          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map(&:body)
-          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
         end
 
         if identifier.languages&.any?

data/lib/pubid/ansi/urn_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Parses ANSI URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ansi:{code}:{year}` where the code carries
+    # the alpha-numeric designation (e.g., "X3.4").
+    #
+    # Examples:
+    # - urn:ansi:X3.4:1963 → ANSI X3.4:1963
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code, year = parts
+        text = "ANSI #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ansi.rb

@@ -4,22 +4,57 @@ module Pubid
   module Ansi
     autoload :Builder, "#{__dir__}/ansi/builder"
     autoload :Identifier, "#{__dir__}/ansi/identifier"
-    autoload :Identifiers, "#{__dir__}/ansi/identifiers/standard"
+    autoload :Identifiers, "#{__dir__}/ansi/identifiers"
     autoload :Parser, "#{__dir__}/ansi/parser"
-    autoload :Scheme, "#{__dir__}/ansi/scheme"
+    autoload :Renderer, "#{__dir__}/ansi/renderer"
     autoload :SingleIdentifier, "#{__dir__}/ansi/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/ansi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ansi/urn_parser"
 
     # Parse an ANSI identifier string
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
     def self.parse(identifier)
       parser = Parser.new
-      builder = Builder.new(Scheme)
+      builder = Builder.new
 
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Ansi::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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| c.type.is_a?(Hash) }
+    end
+
+    # ANSI does not define typed stages; typed_stage lookup is not used by
+    # the builder. Provided here for API consistency with other flavors.
+    # @return [Array] always empty for ANSI
+    def self.all_typed_stages
+      []
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param _abbr [String, Symbol] unused; ANSI has no typed stages
+    # @return [nil] always nil for ANSI
+    def self.locate_stage(_abbr)
+      nil
+    end
   end
 end
 

data/lib/pubid/api/builder.rb

@@ -1,84 +1,43 @@
 # frozen_string_literal: true
 
-require_relative "components/code"
-require_relative "identifiers/bulletin"
-require_relative "identifiers/mpms"
-require_relative "identifiers/recommended_practice"
-require_relative "identifiers/specification"
-require_relative "identifiers/standard"
-require_relative "identifiers/technical_report"
-require_relative "identifiers/continuous_operations_standard"
-require_relative "identifiers/publication"
-require_relative "identifiers/typeless_standard"
-
 module Pubid
   module Api
-    class Builder
-      def build(parsed_hash)
-        # Determine identifier class based on type
-        identifier_class = case parsed_hash[:type]&.to_s
-                           when "BULL"
-                             Identifiers::Bulletin
-                           when "MPMS"
-                             Identifiers::Mpms
-                           when "RP"
-                             Identifiers::RecommendedPractice
-                           when "SPEC"
-                             Identifiers::Specification
-                           when "STD"
-                             Identifiers::Standard
-                           when "TR"
-                             Identifiers::TechnicalReport
-                           when "COS"
-                             Identifiers::ContinuousOperationsStandard
-                           when "PUBL"
-                             Identifiers::Publication
-                           else
-                             # No type = typeless standard
-                             Identifiers::TypelessStandard
-                           end
-
-        identifier = identifier_class.new
-
-        # Number (for non-MPMS)
-        if parsed_hash[:number]
-          identifier.code = Components::Code.new(value: parsed_hash[:number].to_s)
-        end
-
-        # Part
-        if parsed_hash[:part]
-          identifier.part = parsed_hash[:part].to_s
-        end
-
-        # MPMS-specific attributes
-        if parsed_hash[:chapter]
-          identifier.chapter = parsed_hash[:chapter].to_s
-        end
-
-        if parsed_hash[:section]
-          identifier.section = parsed_hash[:section].to_s
-        end
-
-        if parsed_hash[:subsection]
-          identifier.subsection = parsed_hash[:subsection].to_s
-        end
+    class Builder < Pubid::Builder::Base
+      TYPE_CLASS_MAP = {
+        "BULL" => Identifiers::Bulletin,
+        "MPMS" => Identifiers::Mpms,
+        "RP" => Identifiers::RecommendedPractice,
+        "SPEC" => Identifiers::Specification,
+        "STD" => Identifiers::Standard,
+        "TR" => Identifiers::TechnicalReport,
+        "COS" => Identifiers::ContinuousOperationsStandard,
+        "PUBL" => Identifiers::Publication,
+      }.freeze
+
+      private
+
+      def default_identifier_class
+        Identifiers::TypelessStandard
+      end
 
-        # Year
-        if parsed_hash[:year]
-          identifier.year = parsed_hash[:year].to_s
-        end
+      def select_class(data)
+        TYPE_CLASS_MAP[data[:type]&.to_s] || default_identifier_class
+      end
 
-        # Reaffirmation (nested hash with year inside)
-        if parsed_hash[:reaffirmation]
-          reaffirm_data = parsed_hash[:reaffirmation]
-          identifier.reaffirmation = if reaffirm_data.is_a?(Hash) && reaffirm_data[:year]
-                                       reaffirm_data[:year].to_s
-                                     else
-                                       reaffirm_data.to_s
-                                     end
+      def cast(key, value)
+        case key
+        # `:type` is consumed only by select_class for dispatch; it is not an
+        # identifier attribute (the concrete class is pinned by `_type`). Drop it
+        # so the raw Parslet::Slice never lands in the inherited :type attribute.
+        when :type then nil
+        when :number then Components::Code.new(value: value.to_s)
+        when :reaffirmation
+          value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
+        when :part, :chapter, :section, :subsection, :year
+          value.to_s
+        else
+          super
         end
-
-        identifier
       end
     end
   end

data/lib/pubid/api/identifier.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "parser"
-require_relative "builder"
-require_relative "single_identifier"
-require_relative "scheme"
-
 module Pubid
   module Api
-    class Identifier
+    # Common base class for all API identifiers. SingleIdentifier and the
+    # concrete Identifiers::* types descend from it, so every API identifier is
+    # `is_a?(Pubid::Api::Identifier)` natively and gets the shared polymorphic
+    # `from_hash` (no facade needed).
+    class Identifier < ::Pubid::Identifier
       def self.parse(input)
         # Filter out comments
         return nil if input.start_with?("#")
@@ -17,52 +16,6 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise e
       end
-
-      # Factory that builds an API identifier from a hash of primitives.
-      # Dispatch on `:type` to the matching subclass; default is
-      # {Identifiers::Standard}.
-      #
-      # API identifiers have a hardcoded "API" publisher (via
-      # SingleIdentifier#publisher method) so the `:publisher` kwarg is
-      # silently dropped.
-      TYPE_KEY_TO_KLASS = {
-        std:      "Standard",
-        rp:       "RecommendedPractice",
-        spec:     "Specification",
-        tr:       "TechnicalReport",
-        bull:     "Bulletin",
-        mpms:     "Mpms",
-        cos:      "ContinuousOperationsStandard",
-        publ:     "Publication",
-        typeless: "TypelessStandard",
-      }.freeze
-
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Standard if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown API type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = Pubid::Api::Components::Code.new(value: v.to_s)
-        end
-        %i[part year reaffirmation].each do |k|
-          attrs[k] = opts[k].to_s unless opts[k].nil?
-        end
-        # TODO(create-shim): :publisher silently dropped (API hardcoded).
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/api/identifiers/base.rb

@@ -1,23 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "../single_identifier"
-
 module Pubid
   module Api
     module Identifiers
+      # Base class for all API identifiers.
+      # Inherits common attributes from SingleIdentifier.
       class Base < SingleIdentifier
-        # Base class for all API identifiers
-        # Inherits common attributes from SingleIdentifier
-
-        # Include type_string in serialization for round-trip compatibility
-        def base_hash
-          hash = super
-          if self.class.attributes.key?(:type_string) && type_string
-            hash[:type] =
-              type_string
-          end
-          hash
-        end
       end
     end
   end

data/lib/pubid/api/identifiers/bulletin.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/continuous_operations_standard.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/mpms.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers
@@ -14,24 +12,6 @@ module Pubid
           "MPMS"
         end
 
-        def to_s
-          parts = ["API", "MPMS"]
-
-          # Add chapter
-          parts << "CH #{chapter}" if chapter
-
-          # Add section/subsection
-          if section
-            parts << ".#{section}"
-            parts << ".#{subsection}" if subsection
-          end
-
-          # Add year
-          parts << "-#{year}" if year
-
-          parts.join(" ").gsub(" .", ".")
-        end
-
         private
 
         def code_portion

data/lib/pubid/api/identifiers/publication.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/recommended_practice.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/specification.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/technical_report.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/typeless_standard.rb

@@ -1,26 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers
       class TypelessStandard < Base
         # No type_string method - renders without type
-        def to_s
-          parts = ["API"]
-
-          # Add code/number
-          parts << code_portion if code_portion
-
-          # Add year
-          parts << "-#{year}" if year
-
-          # Add reaffirmation
-          parts << " (R#{reaffirmation})" if reaffirmation
-
-          parts.join(" ")
-        end
       end
     end
   end

data/lib/pubid/api/identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :ContinuousOperationsStandard, "#{__dir__}/identifiers/continuous_operations_standard"
+      autoload :Mpms, "#{__dir__}/identifiers/mpms"
+      autoload :Publication, "#{__dir__}/identifiers/publication"
+      autoload :RecommendedPractice, "#{__dir__}/identifiers/recommended_practice"
+      autoload :Specification, "#{__dir__}/identifiers/specification"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TypelessStandard, "#{__dir__}/identifiers/typeless_standard"
+    end
+  end
+end

data/lib/pubid/api/renderer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Human-readable renderer for API identifiers.
+    #
+    # Produces strings like:
+    #   "API Std 650"
+    #   "API MPMS CH 4.1"
+    #   "API 5L-2018"
+    #
+    # The renderer is registered as the +:human+ format in the API format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Mpms
+          render_mpms(id)
+        when Identifiers::TypelessStandard
+          render_typeless(id)
+        else
+          render_default(id)
+        end
+      end
+
+      private
+
+      def render_default(id)
+        parts = ["API"]
+
+        # Add type if available
+        if id.class.attributes.key?(:type_string) && id.type_string
+          parts << id.type_string
+        end
+
+        # Add code/number with part as one token
+        parts << code_portion(id) if code_portion(id)
+
+        result = parts.join(" ")
+        result += "-#{id.year}" if id.year
+        result += " (R#{id.reaffirmation})" if id.reaffirmation
+        result
+      end
+
+      def render_mpms(id)
+        parts = ["API", "MPMS"]
+
+        # Add chapter
+        parts << "CH #{id.chapter}" if id.chapter
+
+        # Add section/subsection
+        if id.section
+          parts << ".#{id.section}"
+          parts << ".#{id.subsection}" if id.subsection
+        end
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        parts.join(" ").gsub(" .", ".")
+      end
+
+      def render_typeless(id)
+        parts = ["API"]
+
+        # Add code/number
+        parts << code_portion(id) if code_portion(id)
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        # Add reaffirmation
+        parts << " (R#{id.reaffirmation})" if id.reaffirmation
+
+        parts.join(" ")
+      end
+
+      def code_portion(id)
+        return nil unless id.code
+
+        code_str = id.code.to_s
+        code_str += "-#{id.part}" if id.part
+        code_str
+      end
+    end
+  end
+end