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

data/lib/pubid/jis/renderer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # Human-readable renderer for JIS identifiers.
+    #
+    # Produces strings like:
+    #   "JIS A 0001:1999"
+    #   "JIS TR Z 8301:2019"
+    #   "JIS B 3700-11:1996/CORRIGENDUM 1:2002"
+    #   "JIS K 2151:2004/EXPL"
+    #
+    # The renderer is registered as the `:human` format in the JIS format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "JIS"
+
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+
+      def render_base(id)
+        result = "#{PUBLISHER} #{id.code}"
+        result += ":#{id.year_with_reaffirmation}" if id.year
+        result += "(#{id.language})" if id.language
+        result += "（規格群）" if id.all_parts?
+        result + id.symbol_suffix
+      end
+
+      def render_single(id)
+        with_pub = with_publisher?(id)
+        parts = []
+        parts << PUBLISHER if with_pub
+        parts << id.type_prefix if id.class.method_defined?(:type_prefix) && id.type_prefix
+        result = parts.join(" ")
+        result += " " if result.length.positive?
+        result += id.code.to_s
+        result += ":#{id.year_with_reaffirmation}" if id.year
+        result += "(#{id.language})" if id.language
+        result += "（規格群）" if id.all_parts?
+        result += id.symbol_suffix
+        result
+      end
+
+      def render_supplement(id)
+        with_pub = with_publisher?(id)
+        result = id.base.to_s(with_publisher: with_pub)
+        result += "/#{id.supplement_notation}"
+        result += id.symbol_suffix
+        result
+      end
+    end
+  end
+end

data/lib/pubid/jis/single_identifier.rb

@@ -4,7 +4,7 @@ module Pubid
   module Jis
     # Base class for single (non-supplement) JIS identifiers
     # Includes: JapaneseIndustrialStandard, TechnicalReport, TechnicalSpecification
-    class SingleIdentifier < Identifiers::Base
+    class SingleIdentifier < Identifier
       # Type prefix to identifier class mapping
       TYPE_CLASSES = {
         "TR" => "TechnicalReport",
@@ -12,6 +12,8 @@ module Pubid
         nil => "JapaneseIndustrialStandard", # Default
       }.freeze
 
+      attr_reader :with_publisher
+
       # Determine identifier class from type prefix
       def self.identifier_class_for_type(type)
         class_name = TYPE_CLASSES[type]
@@ -20,17 +22,9 @@ module Pubid
         Identifiers.const_get(class_name)
       end
 
-      def to_s(with_publisher: true)
-        parts = []
-        parts << publisher if with_publisher
-        parts << type_prefix if self.class.method_defined?(:type_prefix) && type_prefix
-        result = parts.join(" ")
-        result += " " if result.length.positive?
-        result += code.to_s
-        result += ":#{year}" if year
-        result += "(#{language})" if language
-        result += "（規格群）" if all_parts?
-        result
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
       end
     end
   end

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