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

data/lib/pubid/jcgm/single_identifier.rb

@@ -3,95 +3,17 @@
 module Pubid
   module Jcgm
     class SingleIdentifier < Identifier
-      attribute :publisher, Jcgm::Components::Publisher,
-                default: -> { self.class.default_publisher }
-      attribute :typed_stage, Pubid::Components::TypedStage,
-                default: -> { self.class.published_typed_stage }
+      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
 
-      # Compact serialization: only per-instance information is mapped. The
-      # publisher (always "JCGM") and the derived type / stage / typed_stage
-      # (fully determined by the class, i.e. `_type`) are intentionally NOT
-      # mapped — they are reconstructed from the class on load via the
-      # attribute defaults above. Components collapse to bare scalars:
-      # number is already a bare :string; date -> year/month/day scalars.
-      # Mirrors ISO (lib/pubid/iso/identifier.rb) and OIML.
-      key_value do
-        map "_type", to: :_type
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
-        map "month", with: { to: :month_to_kv, from: :month_from_kv }
-        map "day", with: { to: :day_to_kv, from: :day_from_kv }
-        map "languages", to: :languages
-      end
-
-      # The publisher implied when none is serialized — always JCGM.
-      def self.default_publisher
-        Jcgm::Components::Publisher.new(publisher: Jcgm::PREFIXES.first)
-      end
-
-      # The class's published typed_stage (canonical surface form). Each JCGM
-      # class registers exactly one, all :published; `_type` fixes the class,
-      # so an omitted typed_stage reconstructs deterministically on from_hash.
+      # Generate URN for this identifier
       #
-      # `original_abbr` is deliberately LEFT NIL. It records the spelling the
-      # input used and is not serialized, so it cannot survive a round trip —
-      # and this method is one of the two paths that fill `typed_stage`. The
-      # other is the parse path (`Builder#locate_typed_stage` ->
-      # `Jcgm.locate_stage`), which returns the registry entry untouched.
-      # Setting it here made the two disagree, so `from_hash(to_hash) != parse`
-      # for every type the grammar tags (Meeting, Corrigendum, Amendment) —
-      # and because `#matches?` is `exclude(...) == other.exclude(...)`, a
-      # relaton index lookup then silently matched nothing. Nothing in JCGM
-      # reads the field: the renderer hardcodes its surface words, the URN
-      # generator reads only `type_code`, and `TypedStage#abbreviation` chooses
-      # among long_abbr/short_abbr/abbr.first. Recording the *matched* token
-      # instead would not work either — "/Cor 1" would store "Cor" where
-      # from_hash rebuilds "Corrigendum".
-      def self.published_typed_stage
-        return nil unless const_defined?(:TYPED_STAGES)
-
-        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
-        # dup: locate_stage hands out the shared object from the frozen
-        # TYPED_STAGES array (the array is frozen, its elements are not), so a
-        # future in-place mutation would otherwise leak globally.
-        ts&.dup
-      end
-
-      # type and stage are derived from typed_stage, never stored — so the
-      # doctype (fixed by the class / _type) is not carried in the hash.
-      def type
-        typed_stage&.to_type
-      end
-
-      def stage
-        typed_stage&.to_stage
-      end
-
-      # --- number ---
-      def number_to_kv(model, doc) = emit_kv(doc, "number", model.number)
-      def number_from_kv(model, value) = model.number = value.to_s
-
-      # --- date flattened to top-level year/month/day scalars ---
-      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
-      def month_to_kv(model, doc) = emit_kv(doc, "month", model.date&.month)
-      def day_to_kv(model, doc) = emit_kv(doc, "day", model.date&.day)
-      def year_from_kv(model, value) = date_for(model).year = value.to_s
-      def month_from_kv(model, value) = date_for(model).month = value.to_s
-      def day_from_kv(model, value) = date_for(model).day = value.to_s
-
-      def emit_kv(doc, key, value)
-        return if value.nil? || value.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
-      end
-
-      def date_for(model)
-        model.date ||= Pubid::Components::Date.new
-      end
+      # @return [String] URN representation
 
       def publisher_portion
         publisher.to_s
@@ -99,7 +21,7 @@ module Pubid
 
       def number_portion
         parts = []
-        parts << number if number
+        parts << number.value if number
         parts << ":#{date.year}" if date
         parts.join
       end
@@ -113,6 +35,14 @@ module Pubid
           ")",
         ].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

@@ -3,48 +3,13 @@
 module Pubid
   module Jcgm
     # Base class for JCGM supplement identifiers (amendments, corrigenda, etc.)
-    #
-    # The supplement's OWN number (the "1" in "/Cor 1", the "2" in "/Amd 2")
-    # is stored in the inherited `number` attribute — NOT a separate
-    # `iteration` attribute. Each supplement is itself a numbered document,
-    # just like the base. The base document's number is accessed via
-    # `base.number`. This mirrors how pubid-Iso models supplements.
     class SupplementIdentifier < SingleIdentifier
-      attribute :base, Identifier, polymorphic: true
+      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :iteration, Pubid::Components::Code
 
-      # The base document nests under the compact key "base" (mirrors ISO/JIS),
-      # serialized via its own to_hash so it collapses to {_type, number, year}.
-      # On load the sub-hash is re-dispatched through Jcgm::Identifier.from_hash,
-      # which resolves `_type` to the concrete Guide/GumGuide — a bare
-      # polymorphic cast would rebuild it as a plain Identifier and later fail
-      # on publisher_portion. This custom mapping replaces the former
-      # self.from_hash override.
-      #
-      # `number` (the supplement's own number) is mapped by SingleIdentifier's
-      # key_value block via number_to_kv / number_from_kv — no override needed.
-      key_value do
-        map "base", with: { to: :base_to_kv, from: :base_from_kv }
-      end
-
-      def base_to_kv(model, doc)
-        return unless model.base
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new(
-            "base", model.base.to_hash
-          ),
-        )
-      end
-
-      def base_from_kv(model, value)
-        return unless value
-
-        model.base = ::Pubid::Jcgm::Identifier.from_hash(value)
-      end
-
-      # Delegate publisher to base
+      # Delegate publisher to base_identifier
       def publisher
-        base&.publisher
+        base_identifier&.publisher
       end
     end
   end

data/lib/pubid/jcgm/urn_generator.rb

@@ -4,9 +4,7 @@ module Pubid
   module Jcgm
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        if identifier.is_a?(Identifiers::Meeting)
-          generate_meeting_urn
-        elsif identifier.is_a?(SupplementIdentifier)
+        if identifier.is_a?(SupplementIdentifier)
           generate_supplement_urn
         else
           generate_base_urn
@@ -15,21 +13,16 @@ module Pubid
 
       protected
 
-      # urn:jcgm:meeting:<number>:<year>, e.g. urn:jcgm:meeting:17:2012
-      def generate_meeting_urn
-        parts = ["urn", "jcgm", "meeting"]
-        parts << identifier.number if identifier.number
-        parts << identifier.date.year if identifier.date
-        parts.join(":")
-      end
-
       def generate_base_urn
         parts = ["urn", "jcgm"]
 
-        if identifier.is_a?(Identifiers::GumGuide) && identifier.number
-          parts << "gum.#{identifier.number}"
+        gum_number = maybe(:gum_number)
+        if gum_number
+          number = gum_number.to_s
+          parts << "gum.#{number}"
         elsif identifier.number
-          parts << identifier.number.to_s
+          number = identifier.number.to_s
+          parts << number
         end
 
         part = maybe(:part)
@@ -44,8 +37,9 @@ module Pubid
           parts << "-#{sp}"
         end
 
-        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-          parts << identifier.date.render(context: URN_CONTEXT)
+        if identifier.date
+          year = identifier.date.year
+          parts << year.to_s
         elsif maybe(:year)
           parts << maybe(:year).to_s
         end
@@ -62,11 +56,9 @@ module Pubid
           parts << "iter.#{iter}"
         end
 
-        # Guide and GUM-guide are already implied by the number form (bare
-        # number vs "gum.N"), so their type_code is not appended.
         if identifier.typed_stage
           type_code = identifier.typed_stage.type_code
-          if type_code && !%w[guide gum_guide].include?(type_code.to_s)
+          if type_code && type_code.to_s != "guide"
             parts << type_code.to_s
           end
         end
@@ -82,7 +74,7 @@ module Pubid
       def generate_supplement_urn
         parts = ["urn", "jcgm"]
 
-        base_id = maybe(:base)
+        base_id = maybe(:base_identifier)
         if base_id
           base_gen = self.class.new(base_id)
           base_urn = base_gen.generate_base_urn
@@ -97,13 +89,15 @@ module Pubid
             parts << supp_type if supp_type
           end
 
-          # The supplement's own number (the "1" in "/Cor 1") — NOT iteration.
-          if identifier.number
-            parts << identifier.number.to_s
+          iteration = maybe(:iteration)
+          if iteration
+            iter = iteration.to_s
+            parts << iter
           end
 
-          if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-            parts << identifier.date.render(context: URN_CONTEXT)
+          if identifier.date
+            year = identifier.date.year
+            parts << year.to_s
           end
         else
           parts << "unknown"

data/lib/pubid/jcgm.rb

@@ -2,81 +2,26 @@
 
 module Pubid
   module Jcgm
-    extend Pubid::PrefixesSupport
-
-    # Sole JCGM publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["JCGM"].freeze
-
     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 :Renderer, "#{__dir__}/jcgm/renderer"
+    autoload :Scheme, "#{__dir__}/jcgm/scheme"
     autoload :SingleIdentifier, "#{__dir__}/jcgm/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/jcgm/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/jcgm/urn_generator"
-    autoload :UrnParser, "#{__dir__}/jcgm/urn_parser"
 
     # Parse a JCGM identifier string
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
     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
-
       parser = Parser.new
-      builder = Builder.new
+      builder = Builder.new(Scheme)
 
       parsed = parser.parse(identifier)
       builder.build(parsed)
     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: Jcgm::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
 
   # Register this flavor with the Pubid registry

data/lib/pubid/jis/builder.rb

@@ -8,37 +8,29 @@ module Pubid
       end
 
       def build(data)
-        # Handle supplement case first; the SYMBOL clause (if any) attaches to
-        # the outermost identifier, be it the base or the supplement.
-        identifier = if data[:amendment]
-                       build_amendment(data)
-                     elsif data[:explanation]
-                       build_explanation(data)
-                     elsif data[:corrigendum]
-                       build_corrigendum(data)
-                     else
-                       build_single_identifier(data)
-                     end
-        attach_symbol(identifier, 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
 
-      # nil => no SYMBOL clause; "" => bare "SYMBOL" keyword; otherwise value.
-      def attach_symbol(identifier, data)
-        identifier.symbol = data[:symbol_value].to_s if data[:symbol_present]
-        identifier
-      end
-
       def build_single_identifier(data)
+        # Build code component
+        code = build_code(data)
+
+        # Extract other attributes
         attrs = {
-          series: data[:series].to_s,
-          number: data[:number].to_s,
-          parts: extract_part_strings(data[:parts]),
+          code: code,
           year: data[:year]&.to_i,
           language: data[:language]&.to_s,
-          all_parts: (true if data[:all_parts]),
-          reaffirmed: (true if data[:reaffirmed]),
+          all_parts: data[:all_parts] ? true : false,
         }
 
         # Determine identifier class from type
@@ -67,7 +59,6 @@ module Pubid
           base: base,
           number: amd_data[:amd_number].to_i,
           year: amd_data[:amd_year].to_i,
-          reaffirmed: (true if amd_data[:amd_reaffirmed]),
         )
       end
 
@@ -86,30 +77,47 @@ module Pubid
         )
       end
 
-      def build_corrigendum(data)
-        corr_data = data[:corrigendum]
-
-        # Build base document (without supplement)
-        base_data = data.except(:corrigendum)
-        base = build_single_identifier(base_data)
-
-        # Build corrigendum
-        Identifiers::Corrigendum.new(
-          base: base,
-          number: corr_data[:corr_number].to_i,
-          year: corr_data[:corr_year].to_i,
-          reaffirmed: (true if corr_data[:corr_reaffirmed]),
+      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
 
-      # parts_data is an array of `{ part: "1" }` hashes (or a single hash for
-      # a one-level part); return the part numbers as strings.
-      def extract_part_strings(parts_data)
-        case parts_data
-        when Array then parts_data.filter_map { |h| h[:part]&.to_s }
-        when Hash then [parts_data[:part]&.to_s].compact
-        else []
+      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

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/{astm → jis}/components.rb

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