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

data/lib/pubid/jcgm/renderer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Human-readable renderer for JCGM identifiers.
+    #
+    # Produces strings like:
+    #   "JCGM 100:2008"
+    #   "JCGM 100:2008/Amd 1:2023"
+    #   "JCGM GUM-6:2020"
+    #
+    # The renderer is registered as the `:human` format in the JCGM format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Amendment
+          render_amendment(id, context)
+        when Identifiers::GumGuide
+          render_gum_guide(id, context)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      def render_single(id)
+        parts = [id.publisher_portion]
+        parts << id.number_portion unless id.number_portion.empty?
+        result = parts.join(" ")
+        result += id.language_portion if id.languages&.any?
+        result
+      end
+
+      def render_amendment(id, context)
+        result = id.base_identifier.to_s if id.base_identifier
+        result += "/Amd"
+        result += " #{id.iteration.render(context:)}" if id.iteration
+        result += ":#{id.date}" if id.date
+        result
+      end
+
+      def render_gum_guide(id, context)
+        parts = []
+        parts << id.publisher.publisher if id.publisher
+        parts << "GUM-#{id.gum_number.render(context:)}" if id.gum_number
+
+        result = parts.join(" ")
+        result += ":#{id.date}" if id.date
+        result += gum_language_portion(id) if id.languages&.any?
+        result
+      end
+
+      def gum_language_portion(id)
+        return "" unless id.languages&.any?
+
+        codes = id.languages.map do |lang|
+          lang.original_code || lang.code
+        end
+
+        "(#{codes.join('/')})"
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/single_identifier.rb

@@ -37,11 +37,7 @@ module Pubid
       end
 
       def to_s
-        parts = [publisher_portion]
-        parts << number_portion unless number_portion.empty?
-        result = parts.join(" ")
-        result += language_portion
-        result
+        render(format: :human)
       end
     end
   end

data/lib/pubid/jcgm/urn_generator.rb

@@ -37,9 +37,8 @@ module Pubid
           parts << "-#{sp}"
         end
 
-        if identifier.date
-          year = identifier.date.year
-          parts << year.to_s
+        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+          parts << identifier.date.render(context: URN_CONTEXT)
         elsif maybe(:year)
           parts << maybe(:year).to_s
         end
@@ -95,9 +94,8 @@ module Pubid
             parts << iter
           end
 
-          if identifier.date
-            year = identifier.date.year
-            parts << year.to_s
+          if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+            parts << identifier.date.render(context: URN_CONTEXT)
           end
         else
           parts << "unknown"

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,60 +2,146 @@
 
 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)
       rescue Parslet::ParseFailed => e
         raise "Failed to parse JIS identifier '#{identifier}': #{e.message}"
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Jis::Identifier.create` API.
-      #
-      # JIS uses a different attribute schema from most flavors — `series`
-      # (single letter A–Z), `number` (integer), `parts` (integer collection),
-      # `year` (integer), `language`. Publisher is hardcoded "JIS" on the
-      # instance and not a constructor kwarg; supplying `:publisher` is
-      # silently ignored.
-      #
-      # Type dispatch: :jis → Standard, :tr → TechnicalReport,
-      # :ts → TechnicalSpecification. Default → Standard.
-      def self.create(type: nil, **opts)
-        klass = if type
-                  safe_locate_klass(type) || Identifiers::Standard
-                else
-                  Identifiers::Standard
-                end
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      # JIS Scheme raises ArgumentError on miss; wrap.
-      def self.safe_locate_klass(type)
-        Scheme.locate_identifier_klass_by_type_code(type)
-      rescue ArgumentError
-        nil
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        attrs[:series] = opts[:series].to_s if opts[:series]
-        attrs[:number] = opts[:number].to_i if opts[:number]
-        if opts[:parts]
-          attrs[:parts] = Array(opts[:parts]).map(&:to_i)
-        end
-        attrs[:code] = opts[:code] if opts[:code]
-        attrs[:year] = opts[:year].to_i if opts[:year]
-        attrs[:language] = opts[:language].to_s if opts[:language]
-        attrs[:all_parts] = opts[:all_parts] if opts.key?(:all_parts)
-        # TODO(create-shim): :publisher silently ignored (JIS hardcodes
-        # "JIS"); supplement subclasses not yet wired through.
-        attrs
-      end
-      private_class_method :safe_locate_klass, :coerce_create_attrs
     end
   end
 end

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 }