pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Technical Report identifier type
+      # Format: JIS TR SERIES NUMBER:YEAR
+      # Example: JIS TR Z 8301:2019
+      class TechnicalReport < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+
+        def type_prefix
+          "TR"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Technical Specification identifier type
+      # Format: JIS TS SERIES NUMBER:YEAR
+      # Example: JIS TS Z 0030-1:2017
+      class TechnicalSpecification < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :ts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Technical Specification",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
+        end
+
+        def type_prefix
+          "TS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :Explanation, "#{__dir__}/identifiers/explanation"
+      autoload :JapaneseIndustrialStandard,
+               "#{__dir__}/identifiers/japanese_industrial_standard"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TechnicalSpecification,
+               "#{__dir__}/identifiers/technical_specification"
+    end
+  end
+end

data/lib/pubid/jis/parser.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Jis
+    class Parser < ::Pubid::Parser::Grammar
+      # Japanese character normalization
+      rule(:jp_dash) { str("ｰ") } # Full-width dash
+      rule(:jp_space) { str("　") }  # Full-width space
+      rule(:jp_colon) { str("：") }  # Full-width colon
+      rule(:jp_lparen) { str("（") }
+      rule(:jp_rparen) { str("）") }
+
+      # Normalized separators
+      rule(:dash) { (str("-") | jp_dash).as(:dash) }
+      rule(:space) { str(" ") | jp_space }
+      rule(:colon) { str(":") | jp_colon }
+
+      # Basic elements
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match["A-Z"] }
+
+      # JIS prefix (optional, handles both "JIS " and "JIS/")
+      rule(:jis_prefix) { str("JIS") >> (space | str("/")).maybe }
+
+      # Type prefix (TR or TS, can come with or without slash)
+      rule(:type_prefix) do
+        (str("TR") | str("TS")).as(:type) >> (space | str("/"))
+      end
+
+      # Series letter
+      rule(:series) { letter.as(:series) }
+
+      # Number (preserve as string to maintain leading zeros)
+      rule(:number) { digits.as(:number) }
+
+      # Parts (multi-level: -1, -2-1, -3-2-1, etc.)
+      rule(:part) do
+        dash >> digits.as(:part)
+      end
+
+      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) >> reaffirmed
+      end
+
+      # Language code
+      rule(:language) do
+        (str("(") | jp_lparen) >>
+          match["EJ"].as(:language) >>
+          (str(")") | jp_rparen)
+      end
+
+      # All-parts notation (Japanese)
+      rule(:all_parts) do
+        ((jp_lparen >> str("規格群") >> jp_rparen) |
+         (str("(") >> str("規格群") >> str(")"))).as(:all_parts)
+      end
+
+      # Amendment supplement
+      rule(:amendment) do
+        str("/") >>
+          (str("AMENDMENT") | str("AMD")).as(:amd_type) >>
+          space >>
+          digits.as(:amd_number) >>
+          colon >>
+          digits.as(:amd_year) >>
+          str("R").maybe.as(:amd_reaffirmed)
+      end
+
+      # Explanation supplement
+      rule(:explanation) do
+        str("/") >>
+          (str("EXPLANATION") | str("EXPL")).as(:expl_type) >>
+          (space >> digits.as(:expl_number)).maybe
+      end
+
+      # 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) |
+          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
+      rule(:identifier) do
+        jis_prefix.maybe >>
+          type_prefix.maybe >>
+          space.maybe >>
+          series >>
+          space.maybe >>
+          number >>
+          parts >>
+          year.maybe >>
+          language.maybe >>
+          all_parts.maybe >>
+          supplement.maybe >>
+          symbol_clause.maybe
+      end
+
+      rule(:root) { identifier }
+
+      # Parse and normalize Japanese characters
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # Base class for single (non-supplement) JIS identifiers
+    # Includes: JapaneseIndustrialStandard, TechnicalReport, TechnicalSpecification
+    class SingleIdentifier < Identifier
+      # Type prefix to identifier class mapping
+      TYPE_CLASSES = {
+        "TR" => "TechnicalReport",
+        "TS" => "TechnicalSpecification",
+        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]
+        return nil unless class_name
+
+        Identifiers.const_get(class_name)
+      end
+
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+    end
+  end
+end

data/lib/pubid/jis/supplement_identifier.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # Base class for supplement identifiers (Amendment, Explanation)
+    # Supplements are modifications to base documents
+    class SupplementIdentifier < SingleIdentifier
+      attribute :base, Pubid::Jis::Identifier # Base document being supplemented
+      attribute :number, :integer # Supplement number (optional for Explanation)
+
+      # 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 the rendered code from the base document.
+      def code
+        base&.code
+      end
+
+      # Render as base + supplement notation
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # Override in subclasses
+      def supplement_notation
+        raise NotImplementedError, "Subclass must implement supplement_notation"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(SupplementIdentifier)
+        return false unless other.class == self.class
+
+        base == other.base &&
+          number == other.number &&
+          year == other.year
+      end
+    end
+  end
+end

data/lib/pubid/jis/urn_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "jis"]
+
+        parts << identifier.code.to_s if identifier.code
+
+        parts << identifier.year.to_s if identifier.year
+
+        parts << identifier.language.to_s.downcase if identifier.language
+
+        parts << "all" if identifier.all_parts?
+
+        if identifier.is_a?(SupplementIdentifier) && identifier.supplement_notation
+          parts << identifier.supplement_notation.to_s.downcase
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    extend Pubid::PrefixesSupport
+
+    # Sole JIS publisher token (see the parser's `jis_prefix` rule). Document
+    # types (TR/TS) follow the JIS prefix and are excluded.
+    PREFIXES = ["JIS"].freeze
+
+    autoload :Builder, "#{__dir__}/jis/builder"
+    autoload :Identifier, "#{__dir__}/jis/identifier"
+    autoload :Identifiers, "#{__dir__}/jis/identifiers"
+    autoload :Parser, "#{__dir__}/jis/parser"
+    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
+
+# Register JIS flavor with the registry
+Pubid::Registry.register(:jis, Pubid::Jis)

data/lib/pubid/lutaml/no_store_registration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Lutaml::Model::Store registers every Serializable instance in a global array
+# on initialization via register_in_reference_store. For PubID, which parses
+# tens of thousands of identifiers in test runs, this causes unbounded memory
+# growth (~26 slots per parse, ~26GB for the full suite).
+#
+# PubID doesn't use Lutaml's reference resolution, so we disable it globally
+# by overriding the method on Lutaml::Model::Serializable.
+#
+# Also provides default to_urn for all PubID identifier objects that resolve
+# to their flavor's UrnGenerator class.
+Lutaml::Model::Serializable.class_eval do
+  def register_in_reference_store
+    # no-op: PubID doesn't use Lutaml::Model reference resolution
+  end
+
+  def to_urn
+    resolve_urn_generator.new(self).generate
+  end
+
+  private
+
+  def resolve_urn_generator
+    flavor = self.class.name.split("::")[1]
+    Object.const_get("Pubid::#{flavor}::UrnGenerator")
+  rescue NameError
+    Pubid::UrnGenerator::Base
+  end
+end