pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/jcgm/urn_parser.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Parses JCGM URNs back into identifiers.
+    #
+    # Identifiers are rebuilt **directly from the URN segments** rather than
+    # rendered to a human-readable string and re-parsed (the BIPM UrnParser
+    # pattern). Round-tripping through the grammar flattened the segments into
+    # one string and silently lost everything the string form could not carry:
+    # a GUM guide (`urn:jcgm:gum.6:2020`) raised, and the language and
+    # supplement segments were dropped, so a corrigendum read back as the
+    # standard it amends — a different document, with no error.
+    #
+    # Shapes emitted by UrnGenerator, and read back here:
+    #   urn:jcgm:200:2008                        → JCGM 200:2008
+    #   urn:jcgm:100:2008:en                     → JCGM 100:2008(E)
+    #   urn:jcgm:200:2012:en,fr                  → JCGM 200:2012(E/F)
+    #   urn:jcgm:GUM                             → JCGM GUM
+    #   urn:jcgm:gum.6:2020                      → JCGM GUM-6:2020
+    #   urn:jcgm:200:2008:corrigendum            → JCGM 200:2008 Corrigendum
+    #   urn:jcgm:101:2008:corrigendum:1:2009     → JCGM 101:2008/Cor 1:2009
+    #   urn:jcgm:100:2008:amendment:1:2023       → JCGM 100:2008/Amd 1:2023
+    #   urn:jcgm:meeting:17:2012                 → JCGM 17th Meeting (2012)
+    #   urn:jcgm:meeting:11                      → JCGM 11st Meeting
+    #
+    # KNOWN GAP, on the generator side and unchanged here: a full date is
+    # rendered as its year alone (`JCGM GUM-1:2022-11-28` →
+    # `urn:jcgm:gum.1:2022`), so a URN cannot restore the month and day.
+    # Widening it would change already-published URNs.
+    class UrnParser < Pubid::UrnParser::Base
+      MEETING_MARKER = "meeting"
+
+      # The GUM-guide number is written "gum.<n>" by UrnGenerator.
+      GUM_PREFIX = "gum."
+
+      # The supplement marker UrnGenerator writes is the typed stage's
+      # `type_code`; the abbreviation is what `Jcgm.locate_stage` matches on.
+      SUPPLEMENT_ABBRS = {
+        "corrigendum" => "Cor",
+        "amendment" => "Amd",
+      }.freeze
+
+      MEETING_ABBR = "Meeting"
+
+      # Mirrors `year_digits` in the shared parser rules.
+      YEAR_PATTERN = /\A(?:19|20)\d{2}\z/
+
+      # A language segment is one or more comma-joined ISO codes.
+      LANGUAGES_PATTERN = /\A[a-z]{2}(?:,[a-z]{2})*\z/
+
+      # Language codes back to the single-letter form the identifier prints;
+      # the builder maps the other way when parsing "(E)" / "(E/F)".
+      LANGUAGE_LETTERS = Pubid::Builder::Base::LANG_CHAR_MAP.invert.freeze
+
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        return parse_meeting_urn(parts) if parts.first == MEETING_MARKER
+
+        parse_document_urn(parts)
+      end
+
+      private
+
+      # urn:jcgm:meeting:<number>[:<year>] -> Identifiers::Meeting
+      #
+      # The reconstruction must agree with a parsed identifier attribute for
+      # attribute, so `typed_stage` comes from the same registry lookup
+      # `Builder#locate_typed_stage` uses. (The attribute default now agrees
+      # too — it no longer sets `original_abbr` — so this mirrors the builder
+      # for clarity rather than out of necessity.)
+      def parse_meeting_urn(parts)
+        _, number, year = parts
+
+        Identifiers::Meeting.new(
+          number: meeting_number(number),
+          date: urn_date(year),
+          typed_stage: Jcgm.locate_stage(MEETING_ABBR),
+        )
+      end
+
+      # A guide, a GUM guide, or a supplement wrapping one of those. The
+      # supplement marker splits the segments: everything before it describes
+      # the base document, everything after is the supplement's own number and
+      # date.
+      def parse_document_urn(parts)
+        marker_at = parts.index { |segment| SUPPLEMENT_ABBRS.key?(segment) }
+        return build_document(parts) unless marker_at
+
+        build_supplement(
+          parts[marker_at],
+          build_document(parts[0...marker_at]),
+          parts[(marker_at + 1)..] || [],
+        )
+      end
+
+      # The class comes from the same registry the builder uses, so a URN and a
+      # parsed reference resolve to one class and one typed_stage.
+      def build_supplement(marker, base, tail)
+        typed_stage = Jcgm.locate_stage(SUPPLEMENT_ABBRS.fetch(marker))
+        number, year = tail
+
+        Jcgm.locate_type(typed_stage.type_code).new(
+          base: base,
+          number: (number.nil? || number.empty? ? nil : number.to_s),
+          date: urn_date(year),
+          typed_stage: typed_stage,
+        )
+      end
+
+      # <number>[:<year>][:<languages>] — the number segment carries the
+      # "gum." prefix for a GUM guide, which is what selects the class.
+      #
+      # Guide and GumGuide deliberately take their `typed_stage` from the
+      # attribute default: the grammar emits no type token for them, so
+      # `Builder#build` fills it from `published_typed_stage` too, and both
+      # paths agree.
+      def build_document(parts)
+        number, *rest = parts
+        require_number!(number)
+        gum = number.start_with?(GUM_PREFIX)
+
+        (gum ? Identifiers::GumGuide : Identifiers::Guide).new(
+          number: (gum ? number.delete_prefix(GUM_PREFIX) : number).to_s,
+          date: urn_date(segment_matching(rest, YEAR_PATTERN)),
+          languages: urn_languages(segment_matching(rest, LANGUAGES_PATTERN)),
+        )
+      end
+
+      def require_number!(segment)
+        return unless segment.nil? || segment.empty?
+
+        raise Pubid::UrnParser::Errors::ParseError,
+              "JCGM URN has no document number"
+      end
+
+      def segment_matching(segments, pattern)
+        segments.find { |segment| segment.match?(pattern) }
+      end
+
+      # The ordinal, normalized the way `Identifiers::Meeting.ordinal` does it
+      # (`number.to_i`), so "011" reads back as "11" and a missing or
+      # non-numeric segment as "0" — the behaviour of the previous
+      # render-and-re-parse implementation.
+      def meeting_number(segment)
+        segment.to_i.to_s
+      end
+
+      # nil for an absent year; a Date for a well-formed one. The grammar
+      # accepts only a 19xx/20xx year, so anything else is a malformed URN and
+      # must still be rejected now that no re-parse validates it.
+      def urn_date(segment)
+        return nil if segment.nil? || segment.empty?
+
+        unless segment.match?(YEAR_PATTERN)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid year in JCGM URN: #{segment.inspect}"
+        end
+
+        Pubid::Components::Date.new(year: segment)
+      end
+
+      # "en" -> (E), "en,fr" -> (E/F). `original_code` is what the renderer
+      # prints, so it is restored from the code rather than left nil.
+      def urn_languages(segment)
+        return nil if segment.nil? || segment.empty?
+
+        segment.split(",").map do |code|
+          Pubid::Components::Language.new(
+            code: code,
+            original_code: LANGUAGE_LETTERS.fetch(code, code),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    extend Pubid::PrefixesSupport
+
+    # Sole JCGM publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["JCGM"].freeze
+
+    autoload :Builder, "#{__dir__}/jcgm/builder"
+    autoload :Components, "#{__dir__}/jcgm/components"
+    autoload :Identifier, "#{__dir__}/jcgm/identifier"
+    autoload :Identifiers, "#{__dir__}/jcgm/identifiers"
+    autoload :Parser, "#{__dir__}/jcgm/parser"
+    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)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      parser = Parser.new
+      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
+end
+
+# Register Ujcgm flavor with the registry
+Pubid::Registry.register(:jcgm, Pubid::Jcgm)

data/lib/pubid/jis/builder.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(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
+
+      # 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
+
+      def build_single_identifier(data)
+        attrs = {
+          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: (true if data[:all_parts]),
+          reaffirmed: (true if data[:reaffirmed]),
+        }
+
+        # Determine identifier class from type
+        type = data[:type]&.to_s
+        klass = case type
+                when "TR"
+                  Identifiers::TechnicalReport
+                when "TS"
+                  Identifiers::TechnicalSpecification
+                else
+                  Identifiers::JapaneseIndustrialStandard
+                end
+
+        klass.new(**attrs)
+      end
+
+      def build_amendment(data)
+        amd_data = data[:amendment]
+
+        # Build base document (without supplement)
+        base_data = data.except(:amendment)
+        base = build_single_identifier(base_data)
+
+        # Build amendment
+        Identifiers::Amendment.new(
+          base: base,
+          number: amd_data[:amd_number].to_i,
+          year: amd_data[:amd_year].to_i,
+          reaffirmed: (true if amd_data[:amd_reaffirmed]),
+        )
+      end
+
+      def build_explanation(data)
+        expl_data = data[:explanation]
+
+        # Build base document (without supplement)
+        base_data = data.except(:explanation)
+        base = build_single_identifier(base_data)
+
+        # Build explanation
+        Identifiers::Explanation.new(
+          base: base,
+          number: expl_data[:expl_number]&.to_i,
+          year: base.year,
+        )
+      end
+
+      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
+
+      # 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
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifier.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # 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
+
+      # JIS exposes its publisher as the `PUBLISHER` constant rather than the
+      # inherited `publisher` attribute, so the generic mr_publisher returns
+      # nil. Without this override every JIS id would lose its "JIS." prefix.
+      # Lowercased to match the all-lowercase MR convention.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # JIS stores its identity across `series` (division letter A–Z), `number`
+      # (string, may have leading zeros), and `parts` (multi-level). The
+      # generic mr_number_with_part only knows about `number`/`part`/`subpart`,
+      # so without these overrides every JIS id would collapse onto its
+      # document number and drop the division letter (issue #142).
+      # Lowercased to match the all-lowercase MR convention.
+      def mr_type
+        return nil unless respond_to?(:type_prefix)
+
+        type_prefix&.downcase
+      end
+
+      def mr_number_with_part
+        segments = []
+        segments << series.to_s.downcase if series
+        segments << number.to_s if number
+        parts&.each { |p| segments << p.to_s }
+        return nil if segments.empty?
+
+        segments.join("-")
+      end
+
+      # JIS stores the year as a bare integer (not a Components::Date), so the
+      # inherited mr_year (which reads `date`) returns nil. Emit it directly,
+      # including the reaffirmation marker so `JIS X:2019` and `JIS X:2019R`
+      # stay distinct in MR.
+      def mr_year
+        return nil unless year
+
+        year_with_reaffirmation.to_s
+      end
+
+      def mr_languages
+        return nil unless language
+
+        "(#{language})"
+      end
+
+      def mr_all_parts
+        return nil unless all_parts?
+
+        "all-parts"
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # JIS_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse a JIS identifier string into an identifier object
+      # @param identifier [String] The JIS identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Amendment identifier type
+      # Format: {base}/AMD {number}:{year}
+      # Example: JIS A 0001:1999/AMD 1:2000
+      class Amendment < SupplementIdentifier
+        def supplement_notation
+          "AMD #{number}:#{year_with_reaffirmation}"
+        end
+      end
+    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/explanation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Explanation identifier type
+      # Format: {base}/EXPL[ {number}]
+      # Examples:
+      #   JIS K 2151:2004/EXPL
+      #   JIS K 2249-4:2011/EXPL 4
+      class Explanation < SupplementIdentifier
+        def supplement_notation
+          if number
+            "EXPL #{number}"
+          else
+            "EXPL"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Default JIS identifier type (no type prefix)
+      # Examples: JIS A 0001:1999, JIS B 0060-1:2015
+      class JapaneseIndustrialStandard < SingleIdentifier
+        # No type prefix for default standards
+        def type_prefix
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      class Standard < SingleIdentifier
+        # Note: type is handled through TYPED_STAGES, not as a separate attribute
+        # The Components::Type dependency was removed as it doesn't exist
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubjis,
+            stage_code: :published,
+            type_code: :jis,
+            abbr: ["JIS"],
+            name: "Japanese Industrial Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :jis,
+            web: :japanese_industrial_standard, title: "Japanese Industrial Standard", short: "JIS" }
+        end
+      end
+    end
+  end
+end