pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

data/lib/pubid/jcgm/urn_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Parses JCGM URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:jcgm:{number}:{year}`.
+    #
+    # Examples:
+    # - urn:jcgm:200:2012 → JCGM 200:2012
+    # - urn:jcgm:100:2008 → JCGM 100:2008
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        number, year = parts
+        text = "JCGM #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/jcgm.rb

@@ -7,21 +7,62 @@ module Pubid
     autoload :Identifier, "#{__dir__}/jcgm/identifier"
     autoload :Identifiers, "#{__dir__}/jcgm/identifiers"
     autoload :Parser, "#{__dir__}/jcgm/parser"
-    autoload :Scheme, "#{__dir__}/jcgm/scheme"
+    autoload :Renderer, "#{__dir__}/jcgm/renderer"
     autoload :SingleIdentifier, "#{__dir__}/jcgm/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/jcgm/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/jcgm/urn_generator"
+    autoload :UrnParser, "#{__dir__}/jcgm/urn_parser"
 
     # Parse a JCGM 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: Jcgm::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
 
   # Register this flavor with the Pubid registry

data/lib/pubid/jis/builder.rb

@@ -8,29 +8,37 @@ module Pubid
       end
 
       def build(data)
-        # Handle supplement case first
-        if data[:amendment]
-          return build_amendment(data)
-        elsif data[:explanation]
-          return build_explanation(data)
-        end
-
-        # Build regular identifier
-        build_single_identifier(data)
+        # Handle supplement case first; the SYMBOL clause (if any) attaches to
+        # the outermost identifier, be it the base or the supplement.
+        identifier = if data[:amendment]
+                       build_amendment(data)
+                     elsif data[:explanation]
+                       build_explanation(data)
+                     elsif data[:corrigendum]
+                       build_corrigendum(data)
+                     else
+                       build_single_identifier(data)
+                     end
+        attach_symbol(identifier, data)
       end
 
       private
 
-      def build_single_identifier(data)
-        # Build code component
-        code = build_code(data)
+      # nil => no SYMBOL clause; "" => bare "SYMBOL" keyword; otherwise value.
+      def attach_symbol(identifier, data)
+        identifier.symbol = data[:symbol_value].to_s if data[:symbol_present]
+        identifier
+      end
 
-        # Extract other attributes
+      def build_single_identifier(data)
         attrs = {
-          code: code,
+          series: data[:series].to_s,
+          number: data[:number].to_s,
+          parts: extract_part_strings(data[:parts]),
           year: data[:year]&.to_i,
           language: data[:language]&.to_s,
-          all_parts: data[:all_parts] ? true : false,
+          all_parts: (true if data[:all_parts]),
+          reaffirmed: (true if data[:reaffirmed]),
         }
 
         # Determine identifier class from type
@@ -59,6 +67,7 @@ module Pubid
           base: base,
           number: amd_data[:amd_number].to_i,
           year: amd_data[:amd_year].to_i,
+          reaffirmed: (true if amd_data[:amd_reaffirmed]),
         )
       end
 
@@ -77,47 +86,30 @@ module Pubid
         )
       end
 
-      def build_code(data)
-        series = data[:series].to_s
-        number_str = data[:number].to_s
-        number = number_str.to_i
-
-        # Extract parts with both integer values and original strings
-        parts_result = extract_parts(data[:parts])
-        parts = parts_result[:parts]
-        part_strings = parts_result[:part_strings]
-
-        Components::Code.new(
-          series: series,
-          number: number,
-          parts: parts,
-          number_string: number_str,
-          part_strings: part_strings,
+      def build_corrigendum(data)
+        corr_data = data[:corrigendum]
+
+        # Build base document (without supplement)
+        base_data = data.except(:corrigendum)
+        base = build_single_identifier(base_data)
+
+        # Build corrigendum
+        Identifiers::Corrigendum.new(
+          base: base,
+          number: corr_data[:corr_number].to_i,
+          year: corr_data[:corr_year].to_i,
+          reaffirmed: (true if corr_data[:corr_reaffirmed]),
         )
       end
 
-      def extract_parts(parts_data)
-        parts = []
-        part_strings = []
-
-        return { parts: parts, part_strings: part_strings } unless parts_data
-
-        # parts_data is an array of hashes with :part key
-        if parts_data.is_a?(Array)
-          parts_data.each do |part_hash|
-            if part_hash[:part]
-              part_str = part_hash[:part].to_s
-              parts << part_str.to_i
-              part_strings << part_str
-            end
-          end
-        elsif parts_data.is_a?(Hash) && parts_data[:part]
-          part_str = parts_data[:part].to_s
-          parts << part_str.to_i
-          part_strings << part_str
+      # parts_data is an array of `{ part: "1" }` hashes (or a single hash for
+      # a one-level part); return the part numbers as strings.
+      def extract_part_strings(parts_data)
+        case parts_data
+        when Array then parts_data.filter_map { |h| h[:part]&.to_s }
+        when Hash then [parts_data[:part]&.to_s].compact
+        else []
         end
-
-        { parts: parts, part_strings: part_strings }
       end
     end
   end

data/lib/pubid/jis/identifier.rb

@@ -2,11 +2,140 @@
 
 module Pubid
   module Jis
-    module Identifier
+    # Base class for every JIS identifier AND the flavor's parse/create entry
+    # point — mirrors Pubid::Iso::Identifier. Concrete identifiers under
+    # Pubid::Jis::Identifiers descend from this class, so a parsed JIS id is an
+    # instance of Pubid::Jis::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # JIS keeps its number flat at the top level (string, to preserve leading
+      # zeros like "0205"), with the division letter in `series` and any
+      # multi-level part numbers in `parts`. Supplements override `number` with
+      # their integer sequence number; the document number then lives on `base`.
+      attribute :number, :string
+      attribute :series, :string # Division letter A-Z
+      attribute :parts, :string, collection: true # Optional multi-level parts
+      attribute :year, :integer
+      attribute :language, :string # "E" or "J"
+      # Boolean flags carry no default, so they stay nil (and are omitted from
+      # the serialized hash) unless actually set true.
+      attribute :all_parts, :boolean
+      # Reaffirmation (再確認): a trailing "R" on the year marks an edition
+      # that was reaffirmed without revision (e.g. ":2019R").
+      attribute :reaffirmed, :boolean
+      # Graphical-symbol sub-reference (JIS Z 8210 etc.): the value after
+      # "SYMBOL". nil means no SYMBOL clause; an empty string means a bare
+      # "SYMBOL" keyword with no value.
+      attribute :symbol, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization:
+      # maps each subclass's polymorphic_name to its class name so a stored
+      # hash rebuilds the correct identifier type via from_hash.
+      JIS_TYPE_MAP = {
+        "pubid:jis:japanese-industrial-standard" =>
+          "Pubid::Jis::Identifiers::JapaneseIndustrialStandard",
+        "pubid:jis:standard" => "Pubid::Jis::Identifiers::Standard",
+        "pubid:jis:technical-report" =>
+          "Pubid::Jis::Identifiers::TechnicalReport",
+        "pubid:jis:technical-specification" =>
+          "Pubid::Jis::Identifiers::TechnicalSpecification",
+        "pubid:jis:amendment" => "Pubid::Jis::Identifiers::Amendment",
+        "pubid:jis:corrigendum" => "Pubid::Jis::Identifiers::Corrigendum",
+        "pubid:jis:explanation" => "Pubid::Jis::Identifiers::Explanation",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: JIS_TYPE_MAP
+        map "series", to: :series
+        map "number", to: :number
+        map "parts", to: :parts
+        map "year", to: :year
+        map "language", to: :language
+        map "all_parts", to: :all_parts
+        map "reaffirmed", to: :reaffirmed
+        # render_empty keeps a bare "SYMBOL" (empty-string value) in the hash so
+        # it round-trips distinctly from "no symbol" (nil).
+        map "symbol", to: :symbol, render_empty: true
+      end
+
+      # Publisher is always "JIS". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "JIS"
+
+      def all_parts?
+        all_parts == true
+      end
+
+      def reaffirmed?
+        reaffirmed == true
+      end
+
+      # Render a year with its reaffirmation marker, e.g. "2019R".
+      def year_with_reaffirmation
+        "#{year}#{'R' if reaffirmed?}"
+      end
+
+      # Render the trailing " SYMBOL[ <value>]" clause, or "" when absent.
+      def symbol_suffix
+        return "" if symbol.nil?
+
+        symbol.empty? ? " SYMBOL" : " SYMBOL #{symbol}"
+      end
+
+      # The rendered document code, e.g. "B 0205-1" (series, number, parts).
+      # A convenience for rendering; the underlying data is the flat
+      # series/number/parts attributes.
+      def code
+        result = "#{series} #{number}"
+        result += parts.map { |p| "-#{p}" }.join if parts&.any?
+        result
+      end
+
+      # Comparison with all_parts logic
+      # When either identifier has all_parts=true, compare only series and number
+      def ==(other)
+        return false unless other.is_a?(Identifier)
+
+        if all_parts? || other.all_parts?
+          # Compare only series and number, ignore year, parts, all_parts
+          return series == other.series && number == other.number
+        end
+
+        # Normal full comparison
+        series == other.series &&
+          number == other.number &&
+          (parts || []) == (other.parts || []) &&
+          year == other.year &&
+          language == other.language &&
+          all_parts? == other.all_parts? &&
+          reaffirmed? == other.reaffirmed? &&
+          symbol == other.symbol
+      end
+
+      # Basic string representation. Delegates to renderer.
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Dispatch deserialization to the concrete identifier class named by the
+      # stored `_type`, so `from_hash` rebuilds e.g. a Corrigendum rather than a
+      # bare Pubid::Jis::Identifier. lutaml resolves `_type` only for validation,
+      # not instantiation, so we route to the mapped subclass and let its own
+      # (inherited) from_hash do the actual work.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = JIS_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
+        end
+        super
+      end
+
       # Parse a JIS identifier string into an identifier object
       # @param identifier [String] The JIS identifier string to parse
-      # @return [Identifiers::Base] The appropriate identifier object
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @return [Identifier] The appropriate identifier object
+      # @raise [RuntimeError] If parsing fails
       def self.parse(identifier)
         parsed = Parser.parse(identifier)
         Builder.build(parsed)

data/lib/pubid/jis/identifiers/amendment.rb

@@ -8,7 +8,7 @@ module Pubid
       # Example: JIS A 0001:1999/AMD 1:2000
       class Amendment < SupplementIdentifier
         def supplement_notation
-          "AMD #{number}:#{year}"
+          "AMD #{number}:#{year_with_reaffirmation}"
         end
       end
     end

data/lib/pubid/jis/identifiers/corrigendum.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Corrigendum identifier type
+      # Format: {base}/CORRIGENDUM {number}:{year}
+      # Example: JIS B 3700-11:1996/CORRIGENDUM 1:2002
+      class Corrigendum < SupplementIdentifier
+        def supplement_notation
+          "CORRIGENDUM #{number}:#{year_with_reaffirmation}"
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :jis, title: "Japanese Industrial Standard", short: "JIS" }
+          { key: :jis,
+            web: :japanese_industrial_standard, title: "Japanese Industrial Standard", short: "JIS" }
         end
       end
     end

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

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tr, title: "Technical Report", short: "TR" }
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
         end
 
         def type_prefix

data/lib/pubid/jis/identifiers/technical_specification.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts, title: "Technical Specification", short: "TS" }
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
         end
 
         def type_prefix

data/lib/pubid/jis/identifiers.rb

@@ -4,7 +4,7 @@ module Pubid
   module Jis
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
-      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Explanation, "#{__dir__}/identifiers/explanation"
       autoload :JapaneseIndustrialStandard,
                "#{__dir__}/identifiers/japanese_industrial_standard"

data/lib/pubid/jis/parser.rb

@@ -43,9 +43,12 @@ module Pubid
 
       rule(:parts) { part.repeat(0).as(:parts) }
 
+      # Reaffirmation marker (再確認): trailing "R" on a year
+      rule(:reaffirmed) { str("R").maybe.as(:reaffirmed) }
+
       # Year
       rule(:year) do
-        colon >> digits.as(:year)
+        colon >> digits.as(:year) >> reaffirmed
       end
 
       # Language code
@@ -68,7 +71,8 @@ module Pubid
           space >>
           digits.as(:amd_number) >>
           colon >>
-          digits.as(:amd_year)
+          digits.as(:amd_year) >>
+          str("R").maybe.as(:amd_reaffirmed)
       end
 
       # Explanation supplement
@@ -78,9 +82,30 @@ module Pubid
           (space >> digits.as(:expl_number)).maybe
       end
 
-      # Supplements (AMD or EXPL, only one for JIS)
+      # Corrigendum supplement
+      rule(:corrigendum) do
+        str("/") >>
+          (str("CORRIGENDUM") | str("CORR")).as(:corr_type) >>
+          space >>
+          digits.as(:corr_number) >>
+          colon >>
+          digits.as(:corr_year) >>
+          str("R").maybe.as(:corr_reaffirmed)
+      end
+
+      # Supplements (AMD, EXPL or CORRIGENDUM, only one for JIS)
       rule(:supplement) do
-        amendment.as(:amendment) | explanation.as(:explanation)
+        amendment.as(:amendment) | explanation.as(:explanation) |
+          corrigendum.as(:corrigendum)
+      end
+
+      # Graphical-symbol sub-reference (e.g. JIS Z 8210 safety signs):
+      # "SYMBOL <id>" where <id> runs to the end of the string and may be a
+      # number, an alphanumeric code or a free-text phrase. The keyword may
+      # also appear bare with no value.
+      rule(:symbol_clause) do
+        space >> str("SYMBOL").as(:symbol_present) >>
+          (space >> match["^\n"].repeat(1).as(:symbol_value)).maybe
       end
 
       # Main identifier
@@ -95,7 +120,8 @@ module Pubid
           year.maybe >>
           language.maybe >>
           all_parts.maybe >>
-          supplement.maybe
+          supplement.maybe >>
+          symbol_clause.maybe
       end
 
       rule(:root) { identifier }

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