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

data/lib/pubid/jis/supplement_identifier.rb

@@ -4,29 +4,32 @@ module Pubid
   module Jis
     # Base class for supplement identifiers (Amendment, Explanation)
     # Supplements are modifications to base documents
-    class SupplementIdentifier < Identifiers::Base
-      attribute :base, Pubid::Jis::Identifiers::Base # Base document being supplemented
+    class SupplementIdentifier < SingleIdentifier
+      attribute :base, Pubid::Jis::Identifier # Base document being supplemented
       attribute :number, :integer # Supplement number (optional for Explanation)
 
-      def initialize(base:, number: nil, year: nil, **args)
-        @base = base
-        @number = number
-        # Year comes from parameter or base document
-        supplement_year = year || base&.year
-        # Call super with year to set it in Base
-        super(year: supplement_year, **args)
+      # A supplement adds `base` to the attribute set and reuses `number` as its
+      # integer sequence number (the document number lives on `base`). The
+      # nested base round-trips polymorphically via its own _type.
+      key_value do
+        map "_type", to: :_type,
+                     polymorphic_map: Pubid::Jis::Identifier::JIS_TYPE_MAP
+        map "base", to: :base
+        map "number", to: :number
+        map "year", to: :year
+        map "reaffirmed", to: :reaffirmed
+        map "symbol", to: :symbol, render_empty: true
       end
 
-      # Inherit code from base document
+      # Inherit the rendered code from the base document.
       def code
         base&.code
       end
 
       # Render as base + supplement notation
-      def to_s(with_publisher: true)
-        result = base.to_s(with_publisher: with_publisher)
-        result += "/#{supplement_notation}"
-        result
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
       end
 
       # Override in subclasses

data/lib/pubid/jis/urn_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # Parses JIS URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:jis:{code}:{year}` where code is the
+    # classification letter + number (e.g., "X 0201").
+    #
+    # Examples:
+    # - urn:jis:X 0201:1997 → JIS X 0201:1997
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code, year = parts
+        text = "JIS #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/jis.rb

@@ -3,19 +3,59 @@
 module Pubid
   module Jis
     autoload :Builder, "#{__dir__}/jis/builder"
-    autoload :Components, "#{__dir__}/jis/components"
     autoload :Identifier, "#{__dir__}/jis/identifier"
     autoload :Identifiers, "#{__dir__}/jis/identifiers"
     autoload :Parser, "#{__dir__}/jis/parser"
-    autoload :Scheme, "#{__dir__}/jis/scheme"
+    autoload :Renderer, "#{__dir__}/jis/renderer"
     autoload :SingleIdentifier, "#{__dir__}/jis/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/jis/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/jis/urn_generator"
+    autoload :UrnParser, "#{__dir__}/jis/urn_parser"
 
     # Parse a JIS identifier string
     def self.parse(identifier)
       Identifier.parse(identifier)
     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: Jis::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
+
+    # 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 }
+    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
 end