pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/jcgm.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    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 :Scheme, "#{__dir__}/jcgm/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/jcgm/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/jcgm/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/jcgm/urn_generator"
+
+    # 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)
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    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,124 @@
+# 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
+        if data[:amendment]
+          return build_amendment(data)
+        elsif data[:explanation]
+          return build_explanation(data)
+        end
+
+        # Build regular identifier
+        build_single_identifier(data)
+      end
+
+      private
+
+      def build_single_identifier(data)
+        # Build code component
+        code = build_code(data)
+
+        # Extract other attributes
+        attrs = {
+          code: code,
+          year: data[:year]&.to_i,
+          language: data[:language]&.to_s,
+          all_parts: data[:all_parts] ? true : false,
+        }
+
+        # 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,
+        )
+      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_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,
+        )
+      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
+        end
+
+        { parts: parts, part_strings: part_strings }
+      end
+    end
+  end
+end

data/lib/pubid/jis/components/code.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Jis
+    module Components
+      # Represents a JIS code with series letter, number, and optional parts
+      # Examples:
+      #   A 0001          => series: "A", number: 1, parts: []
+      #   B 0060-1        => series: "B", number: 60, parts: [1]
+      #   C 61000-3-2     => series: "C", number: 61000, parts: [3, 2]
+      #   C 5401-2-001    => series: "C", number: 5401, parts: [2, 1] (with formatting)
+      class Code < Lutaml::Model::Serializable
+        attribute :series, :string    # Single letter A-Z
+        attribute :number, :integer   # Required number
+        attribute :parts, :integer, collection: true # Optional multi-level parts
+
+        # Store original string representations for formatting
+        attr_accessor :number_string, :part_strings
+
+        def initialize(series:, number:, parts: nil, number_string: nil,
+part_strings: nil)
+          @series = series
+          @number = number
+          @parts = parts || []
+          @number_string = number_string || format_number(number)
+          @part_strings = part_strings || @parts.map(&:to_s)
+        end
+
+        # Render as "SERIES NUMBER[-PART[-SUBPART[...]]]"
+        def to_s
+          result = "#{series} #{number_string}"
+          result += part_strings.map { |p| "-#{p}" }.join if part_strings&.any?
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Code)
+
+          series == other.series &&
+            number == other.number &&
+            parts == other.parts
+        end
+
+        private
+
+        def format_number(num)
+          # Preserve leading zeros: pad to 4 digits if less than 1000
+          if num < 1000
+            num.to_s.rjust(4, "0")
+          else
+            num.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/components.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+    end
+  end
+end

data/lib/pubid/jis/identifier.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifier
+      # 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
+      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
+    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}"
+        end
+      end
+    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/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,27 @@
+# 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, title: "Japanese Industrial Standard", short: "JIS" }
+        end
+      end
+    end
+  end
+end

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