pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/jcgm/scheme.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Guide,
+            Identifiers::GumGuide,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Amendment,
+          ]
+        end
+
+        def typed_stages
+          (identifiers + supplement_identifiers).flat_map do |klass|
+            klass::TYPED_STAGES
+          end
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          # Empty abbr means Guide (published)
+          abbr = "" if abbr.nil? || abbr.to_s.strip.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)
+          # Check all identifier classes (base + supplement)
+          all_classes = identifiers + supplement_identifiers
+
+          identifier_klass = all_classes.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/jcgm/single_identifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class SingleIdentifier < Identifier
+      attribute :publisher, Jcgm::Components::Publisher
+      attribute :typed_stage, Pubid::Components::TypedStage
+      attribute :number, Pubid::Components::Code
+      attribute :date, Pubid::Components::Date
+      attribute :languages, Pubid::Components::Language, collection: true
+      attribute :stage, Pubid::Components::Stage
+      attribute :type, Pubid::Components::Type
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def publisher_portion
+        publisher.to_s
+      end
+
+      def number_portion
+        parts = []
+        parts << number.value if number
+        parts << ":#{date.year}" if date
+        parts.join
+      end
+
+      def language_portion
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map(&:original_code).join("/"),
+          ")",
+        ].join
+      end
+
+      def to_s
+        parts = [publisher_portion]
+        parts << number_portion unless number_portion.empty?
+        result = parts.join(" ")
+        result += language_portion
+        result
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/supplement_identifier.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Base class for JCGM supplement identifiers (amendments, corrigenda, etc.)
+    class SupplementIdentifier < SingleIdentifier
+      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :iteration, Pubid::Components::Code
+
+      # Delegate publisher to base_identifier
+      def publisher
+        base_identifier&.publisher
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/urn_generator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(SupplementIdentifier)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "jcgm"]
+
+        gum_number = maybe(:gum_number)
+        if gum_number
+          number = gum_number.to_s
+          parts << "gum.#{number}"
+        elsif identifier.number
+          number = identifier.number.to_s
+          parts << number
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          parts << "-#{p}"
+        end
+
+        subpart = maybe(:subpart)
+        if subpart
+          sp = subpart.to_s
+          parts << "-#{sp}"
+        end
+
+        if identifier.date
+          year = identifier.date.year
+          parts << year.to_s
+        elsif maybe(:year)
+          parts << maybe(:year).to_s
+        end
+
+        edition = maybe(:edition)
+        if edition
+          e = edition.number || edition.to_s
+          parts << "ed.#{e}"
+        end
+
+        stage_iteration = maybe(:stage_iteration)
+        if stage_iteration
+          iter = stage_iteration.to_s
+          parts << "iter.#{iter}"
+        end
+
+        if identifier.typed_stage
+          type_code = identifier.typed_stage.type_code
+          if type_code && type_code.to_s != "guide"
+            parts << type_code.to_s
+          end
+        end
+
+        if identifier.languages&.any?
+          lang_codes = identifier.languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "jcgm"]
+
+        base_id = maybe(:base_identifier)
+        if base_id
+          base_gen = self.class.new(base_id)
+          base_urn = base_gen.generate_base_urn
+
+          base_part = base_urn.sub(/^urn:jcgm:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+
+          if identifier.typed_stage
+            supp_type = identifier.typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          iteration = maybe(:iteration)
+          if iteration
+            iter = iteration.to_s
+            parts << iter
+          end
+
+          if identifier.date
+            year = identifier.date.year
+            parts << year.to_s
+          end
+        else
+          parts << "unknown"
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

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,61 @@
+# 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
+
+      # Factory mirroring pubid 1.x's `Pubid::Jis::Identifier.create` API.
+      #
+      # JIS uses a different attribute schema from most flavors — `series`
+      # (single letter A–Z), `number` (integer), `parts` (integer collection),
+      # `year` (integer), `language`. Publisher is hardcoded "JIS" on the
+      # instance and not a constructor kwarg; supplying `:publisher` is
+      # silently ignored.
+      #
+      # Type dispatch: :jis → Standard, :tr → TechnicalReport,
+      # :ts → TechnicalSpecification. Default → Standard.
+      def self.create(type: nil, **opts)
+        klass = if type
+                  safe_locate_klass(type) || Identifiers::Standard
+                else
+                  Identifiers::Standard
+                end
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      # JIS Scheme raises ArgumentError on miss; wrap.
+      def self.safe_locate_klass(type)
+        Scheme.locate_identifier_klass_by_type_code(type)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        attrs[:series] = opts[:series].to_s if opts[:series]
+        attrs[:number] = opts[:number].to_i if opts[:number]
+        if opts[:parts]
+          attrs[:parts] = Array(opts[:parts]).map(&:to_i)
+        end
+        attrs[:code] = opts[:code] if opts[:code]
+        attrs[:year] = opts[:year].to_i if opts[:year]
+        attrs[:language] = opts[:language].to_s if opts[:language]
+        attrs[:all_parts] = opts[:all_parts] if opts.key?(:all_parts)
+        # TODO(create-shim): :publisher silently ignored (JIS hardcodes
+        # "JIS"); supplement subclasses not yet wired through.
+        attrs
+      end
+      private_class_method :safe_locate_klass, :coerce_create_attrs
+    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