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

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -6,13 +6,19 @@ module Pubid
       # PLATEAU Handbook
       # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
       # Example: PLATEAU Handbook #00 第1.0版
-      class Handbook < Identifier
+      class Handbook < Base
         attribute :edition, :string, default: -> {}
 
         def type_string
           "Handbook"
         end
 
+        def to_s
+          result = "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
+          result += " #{formatted_edition}" if edition
+          result
+        end
+
         def formatted_edition
           "第#{edition}版"
         end

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

@@ -6,10 +6,14 @@ module Pubid
       # PLATEAU Technical Report
       # Format: PLATEAU Technical Report #NN[-annex]
       # Example: PLATEAU Technical Report #01
-      class TechnicalReport < Identifier
+      class TechnicalReport < Base
         def type_string
           "Technical Report"
         end
+
+        def to_s
+          "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
+        end
       end
     end
   end

data/lib/pubid/plateau/identifiers.rb

@@ -4,6 +4,7 @@ module Pubid
   module Plateau
     module Identifiers
       autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"
       autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
     end

data/lib/pubid/plateau/parser.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Plateau
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }
       rule(:hash) { str("#") }
@@ -21,23 +21,17 @@ module Pubid
       # Number: #00, #01, #46, etc.
       rule(:number) { hash >> digits.as(:number) }
 
-      # Annex: -1, -2, etc. Legacy Latin references use "_" as the sub-number
-      # separator (e.g. "#46_1"); both render as the canonical dash.
-      rule(:annex) { (dash | str("_")) >> digits.as(:annex) }
+      # Annex: -1, -2, etc.
+      rule(:annex) { dash >> digits.as(:annex) }
 
-      # Edition (Handbook only). Canonical form is 第X.Y版; legacy Latin
-      # references write the bare X.Y (e.g. "PLATEAU Handbook #00 1.0"). Both
-      # capture the same numeric :edition slice, so they build the same object
-      # and render to the canonical 第X.Y版.
+      # Edition: 第1.0版, 第2.3版, etc. (only for Handbook)
       rule(:edition_part) do
         str("第") >>
           (digits >> str(".") >> digits).as(:edition) >>
           str("版")
       end
 
-      rule(:edition_latin) { (digits >> str(".") >> digits).as(:edition) }
-
-      rule(:edition) { space >> (edition_part | edition_latin) }
+      rule(:edition) { space >> edition_part }
 
       # Annex supplement: "Annex A", "Annex B", etc.
       rule(:annex_letter) { match["A-Z"].as(:annex_letter) }
@@ -51,10 +45,6 @@ module Pubid
           number >> annex.maybe >> edition.maybe
       end
 
-      # Technical Report has no edition. A legacy Latin TR reference carrying a
-      # trailing edition (e.g. "#00 1.0") is matched by the `handbook` rule
-      # (doc_type matches either keyword, tried first); the builder dispatches
-      # on :type and drops the captured edition for Technical Report.
       rule(:technical_report) do
         publisher >> space >> doc_type >> space >>
           number >> annex.maybe
@@ -62,7 +52,7 @@ module Pubid
 
       # Annex identifier (supplement)
       rule(:annex_identifier) do
-        (handbook | technical_report).as(:base) >> annex_supplement
+        (handbook | technical_report).as(:base_identifier) >> annex_supplement
       end
 
       rule(:identifier) { annex_identifier | handbook | technical_report }

data/lib/pubid/plateau/scheme.rb

@@ -0,0 +1,45 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class Scheme < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :number, :integer
+      attribute :annex, :integer, default: -> {}
+      attribute :edition, :string, default: -> {}
+
+      def to_s
+        result = "PLATEAU #{type_string} #{formatted_number}"
+        result += formatted_annex if annex
+        result += " #{formatted_edition}" if edition
+        result
+      end
+
+      private
+
+      def type_string
+        case type
+        when "Handbook"
+          "Handbook"
+        when "Technical Report"
+          "Technical Report"
+        else
+          type
+        end
+      end
+
+      def formatted_number
+        "#%02d" % number
+      end
+
+      def formatted_annex
+        "-#{annex}"
+      end
+
+      def formatted_edition
+        "第#{edition}版"
+      end
+    end
+  end
+end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -7,7 +7,7 @@ module Pubid
     # Base class for PLATEAU supplements (Annex)
     # Supplements reference a base identifier
     class SupplementIdentifier < Pubid::Identifier
-      attribute :base, Identifier
+      attribute :base_identifier, Identifiers::Base
       attribute :letter, :string, default: -> {}
 
       def publisher
@@ -19,20 +19,24 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement supplement_string"
       end
 
-      # Override base_hash to extract edition, type, and annex from base
+      def to_s
+        "#{base_identifier} #{supplement_string}"
+      end
+
+      # Override base_hash to extract edition, type, and annex from base_identifier
       def base_hash
         hash = super
         # For Plateau supplements, edition comes from the base identifier
-        if base.class.attributes.key?(:edition) && base.edition
-          hash[:edition] = base.edition
+        if base_identifier.class.attributes.key?(:edition) && base_identifier.edition
+          hash[:edition] = base_identifier.edition
         end
-        # Include type from base
-        if base.class.attributes.key?(:type_string) && base.type_string
-          hash[:type] = base.type_string
+        # Include type from base_identifier
+        if base_identifier.class.attributes.key?(:type_string) && base_identifier.type_string
+          hash[:type] = base_identifier.type_string
         end
-        # Include annex from base
-        if base.class.attributes.key?(:annex) && base.annex
-          hash[:annex] = base.annex
+        # Include annex from base_identifier
+        if base_identifier.class.attributes.key?(:annex) && base_identifier.annex
+          hash[:annex] = base_identifier.annex
         end
         hash
       end
@@ -60,7 +64,7 @@ module Pubid
       def ==(other)
         return false unless other.class == self.class
 
-        base == other.base &&
+        base_identifier == other.base_identifier &&
           letter == other.letter
       end
     end

data/lib/pubid/plateau.rb

@@ -4,77 +4,20 @@ require "parslet"
 
 module Pubid
   module Plateau
-    extend Pubid::PrefixesSupport
-
-    # Sole PLATEAU publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["PLATEAU"].freeze
-
     autoload :Builder, "#{__dir__}/plateau/builder"
-    autoload :Identifier, "#{__dir__}/plateau/identifiers/base"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
-    autoload :Renderer, "#{__dir__}/plateau/renderer"
+    autoload :Scheme, "#{__dir__}/plateau/scheme"
     autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"
-    autoload :UrnParser, "#{__dir__}/plateau/urn_parser"
 
     def self.parse(input)
-      unless input.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if input.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       # Apply legacy update_codes normalization first
       normalized = Core::UpdateCodes.apply(input, :plateau)
       parser = Parser.new
       parsed = parser.parse(normalized)
       Builder.build(parsed)
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Plateau::Renderer)
-    SupplementIdentifier.format_registry = Identifier.format_registry
-
-    # 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
 

data/lib/pubid/renderers/base.rb

@@ -14,53 +14,6 @@ module Pubid
       def self.render(identifier)
         new(identifier).render
       end
-
-      # Partitions a value into (leading separators, core, trailing separators)
-      # so "- : / space , ." stay OUTSIDE the annotation span (v1 parity).
-      SEMANTIC_SPLIT = %r{\A([-:/ ,.]*)(.*?)([-:/ ,.]*)\z}m
-
-      # type_code (a string) → semantic CSS class for the typed-stage token.
-      # Anything not listed (and not the default "is") renders as "doctype".
-      TYPED_STAGE_CSS = {
-        "amd" => "amendment",
-        "cor" => "corrigendum",
-        "add" => "addendum",
-      }.freeze
-
-      private
-
-      # Wrap a rendered value in a <span class="css_class"> when annotation is
-      # enabled, keeping leading/trailing separator chars outside the span.
-      def annotate(value, css_class, annotated:)
-        str = value.to_s
-        return value unless annotated && css_class && !str.empty?
-
-        lead, core, trail = str.match(SEMANTIC_SPLIT).captures
-        return value if core.empty?
-
-        %(#{lead}<span class="#{css_class}">#{core}</span>#{trail})
-      end
-
-      # Render a value that may be a component or a bare scalar.
-      #
-      # `number`, `part` and `subpart` are `Components::Code` on
-      # ::Pubid::Identifier but a plain `:string` in a growing number of
-      # flavors, so a shared renderer cannot assume the format-aware
-      # `#render(context:)` seam is there. This keeps both shapes working while
-      # the flavors convert one tranche at a time.
-      def render_component(value, context)
-        return nil if value.nil?
-
-        value.respond_to?(:render) ? value.render(context: context) : value.to_s
-      end
-
-      # Choose between "stage" and a type/supplement class for a typed stage.
-      def typed_stage_css(typed_stage)
-        code = typed_stage&.type_code.to_s
-        return "stage" if code.empty? || code == "is"
-
-        TYPED_STAGE_CSS[code] || "doctype"
-      end
     end
   end
 end

data/lib/pubid/renderers/directives_renderer.rb

@@ -27,18 +27,18 @@ module Pubid
       private
 
       def render_publisher_portion(context)
-        ann = context.annotated
-        if @id.publisher
-          pub_str = annotate(@id.publisher.render(context:), "publisher",
-                             annotated: ann)
-        end
+        pub_str = @id.publisher.render(context:) if @id.publisher
         abbr = @id.typed_stage ? @id.typed_stage.abbreviation(format_long: false) : ""
-        unless abbr.empty?
-          abbr = annotate(abbr, typed_stage_css(@id.typed_stage), 
-                          annotated: ann)
-        end
         subgroup_str = @id.subgroup.render(context:) if @id.subgroup
 
+        unless @id.publisher&.copublished?
+          return [
+            pub_str,
+            (subgroup_str ? " #{subgroup_str}" : ""),
+            (abbr.empty? ? "" : " #{abbr}"),
+          ].join
+        end
+
         [
           pub_str,
           (subgroup_str ? " #{subgroup_str}" : ""),
@@ -47,26 +47,13 @@ module Pubid
       end
 
       def render_number_portion(context)
-        ann = context.annotated
         parts = []
-        if @id.number
-          parts << annotate(render_component(@id.number, context), "docnumber",
-                            annotated: ann)
-        end
-        if @id.part
-          parts << " #{annotate(render_component(@id.part, context), 'part', 
-                                annotated: ann)}"
-        end
-        if @id.subpart
-          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
-                                annotated: ann)}"
-        end
-        if @id.stage_iteration
-          parts << ".#{annotate(@id.stage_iteration.render(context:), 
-                                'iteration', annotated: ann)}"
-        end
+        parts << @id.number.render(context:) if @id.number
+        parts << " #{@id.part.render(context:)}" if @id.part
+        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
+        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
+        parts << ":#{date_str}" if date_str
         result = parts.join.strip
         result.empty? ? nil : result
       end

data/lib/pubid/renderers/guide_renderer.rb

@@ -6,16 +6,10 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        ann = context.annotated
-        if @id.publisher
-          pub_str = annotate(@id.publisher.render(context:), "publisher",
-                             annotated: ann)
-        end
+        pub_str = @id.publisher.render(context:) if @id.publisher
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?
-          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
-                               annotated: ann)
           "#{pub_str} #{stage_str}"
         else
           pub_str

data/lib/pubid/renderers/human_readable.rb

@@ -3,9 +3,7 @@
 module Pubid
   module Renderers
     class HumanReadable < Base
-      # `**_opts` absorbs render flags that only some flavors honour (e.g. the
-      # IEEE-specific `:trademark`), so the shared renderer tolerates them.
-      def render(context:, with_edition: false, **_opts)
+      def render(context:, with_edition: false)
         parts = []
         parts << render_publisher_and_stage(context)
         parts << render_number_portion(context)
@@ -19,18 +17,12 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        ann = context.annotated
-        if @id.publisher
-          pub_str = annotate(@id.publisher.render(context:), "publisher",
-                             annotated: ann)
-        end
+        pub_str = @id.publisher.render(context:) if @id.publisher
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?
           has_copub = @id.publisher&.copublished?
           sep = has_copub ? " " : "/"
-          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
-                               annotated: ann)
           "#{pub_str}#{sep}#{stage_str}"
         else
           pub_str
@@ -38,34 +30,18 @@ module Pubid
       end
 
       def render_number_portion(context)
-        ann = context.annotated
         parts = []
-        if @id.number
-          parts << annotate(render_component(@id.number, context), "docnumber",
-                            annotated: ann)
-        end
-        if @id.part
-          parts << "-#{annotate(render_component(@id.part, context), 'part', 
-                                annotated: ann)}"
-        end
-        if @id.subpart
-          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
-                                annotated: ann)}"
-        end
-        if @id.stage_iteration
-          parts << ".#{annotate(@id.stage_iteration.render(context:), 
-                                'iteration', annotated: ann)}"
-        end
+        parts << @id.number.render(context:) if @id.number
+        parts << "-#{@id.part.render(context:)}" if @id.part
+        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
+        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
+        parts << ":#{date_str}" if date_str
         parts.join
       end
 
       def render_edition_portion(context)
-        return unless @id.edition&.number
-
-        annotate(@id.edition.render(context:), "edition",
-                 annotated: context.annotated)
+        @id.edition.render(context:) if @id.edition&.number
       end
 
       def render_language_portion(context, with_edition: false)
@@ -73,8 +49,7 @@ module Pubid
 
         use_single = with_edition ? false : context.with_language_code == :single
         rendered = @id.languages.map do |l|
-          annotate(l.render(context:, lang_single: use_single), "language",
-                   annotated: context.annotated)
+          l.render(context:, lang_single: use_single)
         end
         "(#{rendered.join(use_single ? '/' : ',')})"
       end

data/lib/pubid/renderers/iwa_renderer.rb

@@ -5,11 +5,7 @@ module Pubid
     class IwaRenderer < HumanReadable
       def render(context:, with_edition: false)
         parts = []
-        if @id.typed_stage
-          parts << annotate(@id.typed_stage.render(context:),
-                            typed_stage_css(@id.typed_stage),
-                            annotated: context.annotated)
-        end
+        parts << @id.typed_stage.render(context:) if @id.typed_stage
         parts << render_number_portion(context)
         result = parts.compact.join(" ")
         result << render_language_portion(context, with_edition: with_edition)

data/lib/pubid/renderers/mr_string.rb

@@ -2,62 +2,14 @@
 
 module Pubid
   module Renderers
-    # Machine-readable string renderer.
-    #
-    # Produces a lossless, dot-separated, all-lowercase, filename-safe slug:
-    #
-    #   iso 9001:2015                       -> iso.9001.2015
-    #   iso/iec 17031-1:2020                -> iso-iec.17031-1.2020
-    #   iso 1234-1-2-3:2020                 -> iso.1234-1-2-3.2020
-    #   iso/tr 14627:2017                   -> iso.tr.14627.2017
-    #   iso 16634:--                        -> iso.16634.--
-    #   iso 9001:2015/amd 1:2020            -> iso.9001.2015_amd.1.2020
-    #   iso/iec 13818-1:2015/amd 3:2016/cor 1:2017
-    #                                       -> iso-iec.13818-1.2015_amd.3.2016_cor.1.2017
-    #
-    # The renderer recurses into a supplement's `base` (one level per
-    # `mr_supplement_suffix`) so chained Cor-Amd-IS structures render fully,
-    # instead of every supplement layer collapsing onto its own
-    # type/number/year and dropping the base (issue #142).
-    #
-    # Character set is restricted to [a-z0-9.-] plus `_` (supplement
-    # separator), so `to_mr_string` doubles as a filesystem-/URL-safe slug.
-    # `Identifier#to_slug` delegates here; NIST is the one flavor that
-    # overrides `to_slug` because its MR shape is fixed by the pubid standard
-    # and stays uppercase.
     class MrString < Base
-      SEPARATOR_SUPPLEMENT = "_"
-
-      # The flat MR segments, in order, as the hook each one reads. A hook
-      # returning nil contributes no segment, so a flavor fills only the slots
-      # its identity actually uses — `mr_volume` (ECMA) is nil everywhere else.
-      SEGMENTS = %i[
-        mr_publisher
-        mr_type
-        mr_number_with_part
-        mr_year
-        mr_edition
-        mr_volume
-        mr_languages
-        mr_all_parts
-      ].freeze
-
       def render(context: nil, **)
-        suffix = @id.mr_supplement_suffix
-
-        if suffix
-          base = @id.base
-          head = base ? self.class.new(base).render : ""
-          head.empty? ? suffix : "#{head}#{SEPARATOR_SUPPLEMENT}#{suffix}"
-        else
-          render_flat(@id)
-        end
-      end
-
-      private
-
-      def render_flat(id)
-        SEGMENTS.filter_map { |hook| id.public_send(hook) }.join(".")
+        parts = []
+        parts << @id.mr_publisher
+        parts << @id.mr_type
+        parts << @id.mr_number_with_part
+        parts << @id.mr_year
+        parts.compact.join(".")
       end
     end
   end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -6,16 +6,13 @@ module Pubid
       def render(context:, with_edition: false)
         parts = []
 
-        base_str = @id.base.to_s(
+        base_str = @id.base_identifier.to_s(
           with_edition: with_edition,
           stage_format_long: context.stage_format_long,
           with_date: context.with_date,
-          annotated: context.annotated,
         )
 
-        stage_str = annotate(@id.typed_stage.render(context:),
-                             typed_stage_css(@id.typed_stage),
-                             annotated: context.annotated)
+        stage_str = @id.typed_stage.render(context:)
         parts << "#{base_str}/#{stage_str}"
 
         num_port = render_number_portion(context)

data/lib/pubid/renderers.rb

@@ -2,7 +2,6 @@
 
 module Pubid
   module Renderers
-    autoload :Annotator, "pubid/renderers/annotator"
     autoload :Base, "pubid/renderers/base"
     autoload :DirectivesRenderer, "pubid/renderers/directives_renderer"
     autoload :GuideRenderer, "pubid/renderers/guide_renderer"