pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,31 @@
+# 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, 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,31 @@
+# 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, 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 :Base, "#{__dir__}/identifiers/base"
+      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,109 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Jis
+    class Parser < Parslet::Parser
+      # 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) }
+
+      # Year
+      rule(:year) do
+        colon >> digits.as(:year)
+      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)
+      end
+
+      # Explanation supplement
+      rule(:explanation) do
+        str("/") >>
+          (str("EXPLANATION") | str("EXPL")).as(:expl_type) >>
+          (space >> digits.as(:expl_number)).maybe
+      end
+
+      # Supplements (AMD or EXPL, only one for JIS)
+      rule(:supplement) do
+        amendment.as(:amendment) | explanation.as(:explanation)
+      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
+      end
+
+      rule(:root) { identifier }
+
+      # Parse and normalize Japanese characters
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/jis/scheme.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Standard,
+            Identifiers::TechnicalReport,
+            Identifiers::TechnicalSpecification,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "JIS" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = identifiers.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/single_identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    # Base class for single (non-supplement) JIS identifiers
+    # Includes: JapaneseIndustrialStandard, TechnicalReport, TechnicalSpecification
+    class SingleIdentifier < Identifiers::Base
+      # Type prefix to identifier class mapping
+      TYPE_CLASSES = {
+        "TR" => "TechnicalReport",
+        "TS" => "TechnicalSpecification",
+        nil => "JapaneseIndustrialStandard", # Default
+      }.freeze
+
+      # 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)
+        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
+      end
+    end
+  end
+end

data/lib/pubid/jis/supplement_identifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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
+      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)
+      end
+
+      # Inherit code from 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
+      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.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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 :SingleIdentifier, "#{__dir__}/jis/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/jis/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/jis/urn_generator"
+
+    # Parse a JIS identifier string
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    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