pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/jis/identifier.rb

@@ -2,192 +2,16 @@
 
 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.
-
+    module Identifier
       # 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
+      # @return [Identifiers::Base] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] 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)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse JIS identifier '#{identifier}': #{e.message}"
       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_with_reaffirmation}"
+          "AMD #{number}:#{year}"
         end
       end
     end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Base class for all JIS identifiers
+      # Provides common attributes and behavior
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        attribute :code, Pubid::Jis::Components::Code
+        attribute :year, :integer
+        attribute :language, :string # "E" or "J"
+        attribute :all_parts, :boolean, default: -> { false }
+
+        def initialize(code: nil, series: nil, number: nil, parts: nil,
+                      year: nil, language: nil, all_parts: false)
+          if code
+            @code = code
+          elsif series && number
+            @code = Components::Code.new(
+              series: series,
+              number: number,
+              parts: parts || [],
+            )
+          end
+          @year = year
+          @language = language
+          @all_parts = all_parts
+        end
+
+        # Publisher is always JIS
+        def publisher
+          "JIS"
+        end
+
+        def all_parts?
+          all_parts == true
+        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?(Base)
+
+          if all_parts? || other.all_parts?
+            # Compare only series and number, ignore year, parts, all_parts
+            return code.series == other.code.series &&
+                code.number == other.code.number
+          end
+
+          # Normal full comparison
+          code == other.code &&
+            year == other.year &&
+            language == other.language &&
+            all_parts == other.all_parts
+        end
+
+        # Basic string representation (override in subclasses)
+        def to_s
+          parts = [publisher, code.to_s]
+          parts << ":#{year}" if year
+          parts << "(#{language})" if language
+          parts << "（規格群）" if all_parts?
+          parts.join(" ")
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -19,8 +19,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts,
-            web: :technical_specification, title: "Technical Specification", short: "TS" }
+          { key: :ts, 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 :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Explanation, "#{__dir__}/identifiers/explanation"
       autoload :JapaneseIndustrialStandard,
                "#{__dir__}/identifiers/japanese_industrial_standard"

data/lib/pubid/jis/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Jis
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Japanese character normalization
       rule(:jp_dash) { str("ｰ") } # Full-width dash
       rule(:jp_space) { str("　") }  # Full-width space
@@ -43,12 +43,9 @@ 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) >> reaffirmed
+        colon >> digits.as(:year)
       end
 
       # Language code
@@ -71,8 +68,7 @@ module Pubid
           space >>
           digits.as(:amd_number) >>
           colon >>
-          digits.as(:amd_year) >>
-          str("R").maybe.as(:amd_reaffirmed)
+          digits.as(:amd_year)
       end
 
       # Explanation supplement
@@ -82,30 +78,9 @@ module Pubid
           (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)
+      # Supplements (AMD or EXPL, 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
+        amendment.as(:amendment) | explanation.as(:explanation)
       end
 
       # Main identifier
@@ -120,8 +95,7 @@ module Pubid
           year.maybe >>
           language.maybe >>
           all_parts.maybe >>
-          supplement.maybe >>
-          symbol_clause.maybe
+          supplement.maybe
       end
 
       rule(:root) { identifier }

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

@@ -4,7 +4,7 @@ module Pubid
   module Jis
     # Base class for single (non-supplement) JIS identifiers
     # Includes: JapaneseIndustrialStandard, TechnicalReport, TechnicalSpecification
-    class SingleIdentifier < Identifier
+    class SingleIdentifier < Identifiers::Base
       # Type prefix to identifier class mapping
       TYPE_CLASSES = {
         "TR" => "TechnicalReport",
@@ -12,8 +12,6 @@ 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]
@@ -22,9 +20,17 @@ module Pubid
         Identifiers.const_get(class_name)
       end
 
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
-        render(format: :human, **opts)
+      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

data/lib/pubid/jis/supplement_identifier.rb

@@ -4,32 +4,29 @@ 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
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base, Pubid::Jis::Identifiers::Base # 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
+      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 the rendered code from the base document.
+      # Inherit code from 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)
+      def to_s(with_publisher: true)
+        result = base.to_s(with_publisher: with_publisher)
+        result += "/#{supplement_notation}"
+        result
       end
 
       # Override in subclasses

data/lib/pubid/jis.rb

@@ -2,66 +2,20 @@
 
 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 :Components, "#{__dir__}/jis/components"
     autoload :Identifier, "#{__dir__}/jis/identifier"
     autoload :Identifiers, "#{__dir__}/jis/identifiers"
     autoload :Parser, "#{__dir__}/jis/parser"
-    autoload :Renderer, "#{__dir__}/jis/renderer"
+    autoload :Scheme, "#{__dir__}/jis/scheme"
     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