pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/api/identifier.rb

@@ -1,41 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "parser"
+require_relative "builder"
+require_relative "single_identifier"
+
 module Pubid
   module Api
-    # 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
-      # `number`/`part`/`subpart` are declared here rather than inherited as a
-      # Components::Code: API 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).
-      # `code` keeps its Components::Code type on SingleIdentifier - it is not
-      # one of the three attributes the shared base declares.
-      attribute :number, :string
-      attribute :part, :string
-      attribute :subpart, :string
-
+    class Identifier
       def self.parse(input)
-        unless input.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
+        # Filter out comments
+        return nil if input.start_with?("#")
 
-        # There used to be a `return nil if input.start_with?("#")` here, to
-        # skip the comment lines of a fixture file. A comment is not an
-        # identifier, so it must be rejected like any other unparseable string:
-        # this was the one public parse in the gem that could return nil, which
-        # a caller reading `id.to_s` sees as a NoMethodError far from the cause.
-        # Both API fixture loaders already drop `#` lines themselves.
         tree = Parser.new.parse(input)
         Builder.new.build(tree)
+      rescue Parslet::ParseFailed => e
+        raise e
       end
     end
   end

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

@@ -1,11 +1,23 @@
 # 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,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Pubid
   module Api
     module Identifiers

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

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

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

@@ -1,25 +1,43 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Pubid
   module Api
     module Identifiers
       class Mpms < Base
-        # The MPMS chapter IS the document number — "API MPMS CH 12.2" is
-        # chapter 12, section 2 — so it lives in the `number` inherited from
-        # ::Pubid::Identifier, which every other API type already sets. It used
-        # to sit in a separate `chapter` :string, leaving `number` nil, so all
-        # 30 MPMS ids keyed "" for relaton-index.
-        #
-        # `section`/`subsection` stay as sibling part columns, which is what
-        # gives the bucket semantics a part-less reference needs: every section
-        # of chapter 12 shares the key "12". `CH` is a literal marker in the
-        # renderer and was never part of the value.
+        attribute :chapter, :string
         attribute :section, :string
         attribute :subsection, :string
 
         def type_string
           "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
+          # Override - MPMS doesn't use code_portion
+          nil
+        end
       end
     end
   end

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,26 @@
 # 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/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Api
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }

data/lib/pubid/api/scheme.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "identifiers/base"
+require_relative "identifiers/bulletin"
+require_relative "identifiers/continuous_operations_standard"
+require_relative "identifiers/mpms"
+require_relative "identifiers/publication"
+require_relative "identifiers/recommended_practice"
+require_relative "identifiers/specification"
+require_relative "identifiers/standard"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/typeless_standard"
+
+module Pubid
+  module Api
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Standard,
+            Identifiers::RecommendedPractice,
+            Identifiers::Specification,
+            Identifiers::TechnicalReport,
+            Identifiers::Bulletin,
+            Identifiers::Mpms,
+            Identifiers::ContinuousOperationsStandard,
+            Identifiers::Publication,
+            Identifiers::TypelessStandard,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "API" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = identifiers.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/single_identifier.rb

@@ -2,23 +2,45 @@
 
 module Pubid
   module Api
-    class SingleIdentifier < Identifier
+    class SingleIdentifier < Pubid::Identifier
       # Generate URN for this identifier
       #
       # @return [String] URN representation
 
-      # Stored as a plain string (always "API") so it round-trips through
-      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
-      # serialize a String against the Components::Publisher attribute.
-      attribute :publisher, :string, default: -> { "API" }
+      def publisher
+        "API"
+      end
 
-      # `number` and `part` are inherited as :string from
-      # Pubid::Api::Identifier. There is deliberately no `code` attribute: one
-      # existed here typed Components::Code, but nothing ever assigned it
-      # (the parser emits no `:code` key), so it only misdirected
-      # Renderer#code_portion away from the `number` the builder populates.
+      attribute :code, Components::Code
+      attribute :part, :string
       attribute :year, :string
       attribute :reaffirmation, :string
+
+      def to_s
+        parts = ["API"]
+
+        # Add type if available
+        parts << type_string if self.class.attributes.key?(:type_string) && type_string
+
+        # Add code/number with part as one token
+        parts << code_portion if code_portion
+
+        # Build result - join with space, then add dash+year as one token
+        result = parts.join(" ")
+        result += "-#{year}" if year
+        result += " (R#{reaffirmation})" if reaffirmation
+        result
+      end
+
+      private
+
+      def code_portion
+        return nil unless code
+
+        code_str = code.to_s
+        code_str += "-#{part}" if part
+        code_str
+      end
     end
   end
 end

data/lib/pubid/api/urn_generator.rb

@@ -7,6 +7,24 @@ module Pubid
         "std"
       end
 
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.value.to_s
+      end
+
+      def urn_part
+        return nil unless identifier.part
+
+        "-#{identifier.part}"
+      end
+
+      def urn_year
+        return identifier.year.to_s if identifier.year
+
+        nil
+      end
+
       def generate
         parts = ["urn", "api"]
         parts << urn_type

data/lib/pubid/api.rb

@@ -1,68 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "api/identifier"
+require_relative "api/scheme"
+
 module Pubid
   module Api
-    extend Pubid::PrefixesSupport
-
-    # Sole API publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["API"].freeze
-
-    autoload :Builder, "#{__dir__}/api/builder"
-    autoload :Identifier, "#{__dir__}/api/identifier"
-    autoload :Identifiers, "#{__dir__}/api/identifiers"
-    autoload :Parser, "#{__dir__}/api/parser"
-    autoload :Renderer, "#{__dir__}/api/renderer"
-    autoload :SingleIdentifier, "#{__dir__}/api/single_identifier"
-    autoload :UrnGenerator, "#{__dir__}/api/urn_generator"
-    autoload :UrnParser, "#{__dir__}/api/urn_parser"
-
     def self.parse(input)
       Identifier.parse(input)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace.
-    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
-    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 < Pubid::Identifier }
-        .reject { |c| c.name&.split("::")&.last == "Base" }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    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
-
-    # 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 }
-    rescue NoMethodError
-      nil
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    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
+
+  # Register this flavor with the Pubid registry
 end
 
 # Register Uapi flavor with the registry
 Pubid::Registry.register(:api, Pubid::Api)
-
-# Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Api::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Api::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Api::Renderer)