pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/plateau/supplement_identifier.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Plateau
+    # Base class for PLATEAU supplements (Annex)
+    # Supplements reference a base identifier
+    class SupplementIdentifier < Pubid::Identifier
+      attribute :base_identifier, Identifiers::Base
+      attribute :letter, :string, default: -> {}
+
+      def publisher
+        "PLATEAU"
+      end
+
+      # Subclasses must implement supplement_string
+      def supplement_string
+        raise NotImplementedError, "Subclasses must implement supplement_string"
+      end
+
+      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_identifier.class.attributes.key?(:edition) && base_identifier.edition
+          hash[:edition] = base_identifier.edition
+        end
+        # 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_identifier
+        if base_identifier.class.attributes.key?(:annex) && base_identifier.annex
+          hash[:annex] = base_identifier.annex
+        end
+        hash
+      end
+
+      # Override supplement_hash to include letter instead of number
+      def supplement_hash(supplement)
+        {
+          type: extract_supplement_type(supplement),
+          letter: supplement.letter,
+        }.compact
+      end
+
+      # Extract supplement type from class name
+      def extract_supplement_type(supplement)
+        return nil unless supplement.class
+
+        # Get class name without namespace
+        class_name = supplement.class.name.to_s
+        parts = class_name.split("::")
+        simple_name = parts.last
+        # Convert camel case to snake case (Annex -> annex)
+        simple_name&.gsub(/([a-z])([A-Z])/, '\1_\2')&.downcase
+      end
+
+      def ==(other)
+        return false unless other.class == self.class
+
+        base_identifier == other.base_identifier &&
+          letter == other.letter
+      end
+    end
+  end
+end

data/lib/pubid/plateau/urn_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "plateau"]
+
+        if identifier.type_string
+          type_str = identifier.type_string.to_s.downcase
+          parts << case type_str
+                   when "technical report"
+                     "tr"
+                   when "annex"
+                     "an"
+                   else
+                     type_str
+                   end
+        end
+
+        parts << format("%02d", identifier.number) if identifier.number
+
+        parts << format("%02d", identifier.annex) if identifier.annex
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/plateau.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Plateau
+    autoload :Builder, "#{__dir__}/plateau/builder"
+    autoload :Identifier, "#{__dir__}/plateau/identifier"
+    autoload :Identifiers, "#{__dir__}/plateau/identifiers"
+    autoload :Parser, "#{__dir__}/plateau/parser"
+    autoload :Scheme, "#{__dir__}/plateau/scheme"
+    autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"
+
+    def self.parse(input)
+      # Apply legacy update_codes normalization first
+      normalized = Core::UpdateCodes.apply(input, :plateau)
+      parser = Parser.new
+      parsed = parser.parse(normalized)
+      Builder.build(parsed)
+    end
+  end
+end
+
+# Register Uplateau flavor with the registry
+Pubid::Registry.register(:plateau, Pubid::Plateau)

data/lib/pubid/renderers/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class Base
+      def initialize(identifier)
+        @id = identifier
+      end
+
+      def render
+        raise NotImplementedError, "#{self.class}#render not implemented"
+      end
+
+      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
+
+      # 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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class DirectivesRenderer < HumanReadable
+      def render(context:, with_edition: false)
+        parts = []
+        parts << render_publisher_portion(context)
+        num_port = render_number_portion(context)
+
+        if num_port && !num_port.empty?
+          if num_port.start_with?(":")
+            result = parts.compact.join(" ") + num_port
+          else
+            parts << num_port
+            result = parts.compact.join(" ")
+          end
+        else
+          result = parts.compact.join(" ")
+        end
+
+        result << " #{render_edition_portion(context)}" if with_edition && @id.edition&.number
+        result << render_language_portion(context, with_edition: with_edition)
+        result
+      end
+
+      private
+
+      def render_publisher_portion(context)
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) if @id.publisher
+        abbr = @id.typed_stage ? @id.typed_stage.abbreviation(format_long: false) : ""
+        abbr = annotate(abbr, typed_stage_css(@id.typed_stage), annotated: ann) unless abbr.empty?
+        subgroup_str = @id.subgroup.render(context:) if @id.subgroup
+
+        [
+          pub_str,
+          (subgroup_str ? " #{subgroup_str}" : ""),
+          (abbr.empty? ? "" : " #{abbr}"),
+        ].join
+      end
+
+      def render_number_portion(context)
+        ann = context.annotated
+        parts = []
+        parts << annotate(@id.number.render(context:), "docnumber",
+                          annotated: ann) if @id.number
+        parts << " #{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
+        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.stage_iteration
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+        end
+        date_str = @id.date.render(context:) if @id.date && context.with_date
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
+        result = parts.join.strip
+        result.empty? ? nil : result
+      end
+    end
+  end
+end

data/lib/pubid/renderers/guide_renderer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class GuideRenderer < HumanReadable
+      private
+
+      def render_publisher_and_stage(context)
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) 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
+        end
+      end
+    end
+  end
+end

data/lib/pubid/renderers/human_readable.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class HumanReadable < Base
+      def render(context:, with_edition: false)
+        parts = []
+        parts << render_publisher_and_stage(context)
+        parts << render_number_portion(context)
+        parts << render_edition_portion(context) if with_edition
+        result = parts.compact.join(" ")
+        result << render_language_portion(context, with_edition: with_edition)
+        result << " (all parts)" if @id.all_parts
+        result
+      end
+
+      private
+
+      def render_publisher_and_stage(context)
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) 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
+        end
+      end
+
+      def render_number_portion(context)
+        ann = context.annotated
+        parts = []
+        parts << annotate(@id.number.render(context:), "docnumber",
+                          annotated: ann) if @id.number
+        parts << "-#{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
+        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.stage_iteration
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+        end
+        date_str = @id.date.render(context:) if @id.date && context.with_date
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" 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)
+      end
+
+      def render_language_portion(context, with_edition: false)
+        return "" unless @id.languages&.any? && context.with_language_code != :none
+
+        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)
+        end
+        "(#{rendered.join(use_single ? '/' : ',')})"
+      end
+    end
+  end
+end

data/lib/pubid/renderers/iwa_renderer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    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 << render_number_portion(context)
+        result = parts.compact.join(" ")
+        result << render_language_portion(context, with_edition: with_edition)
+        result
+      end
+    end
+  end
+end

data/lib/pubid/renderers/mr_string.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class MrString < Base
+      def render(context: nil, **)
+        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
+end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class SupplementRenderer < HumanReadable
+      def render(context:, with_edition: false)
+        parts = []
+
+        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)
+        parts << "#{base_str}/#{stage_str}"
+
+        num_port = render_number_portion(context)
+        if num_port && !num_port.empty? && !num_port.start_with?(":")
+          parts << (stage_str.end_with?(".") ? "" : " ")
+        end
+        parts << num_port
+
+        parts << " #{render_edition_portion(context)}" if with_edition && @id.edition&.number
+        if @id.languages&.any?
+          parts << render_language_portion(context,
+                                           with_edition: with_edition)
+        end
+        parts.compact.join
+      end
+    end
+  end
+end

data/lib/pubid/renderers/urn.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class Urn < Base
+      def render(context: nil, **)
+        @id.to_urn
+      end
+    end
+  end
+end

data/lib/pubid/renderers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    autoload :Base, "pubid/renderers/base"
+    autoload :DirectivesRenderer, "pubid/renderers/directives_renderer"
+    autoload :GuideRenderer, "pubid/renderers/guide_renderer"
+    autoload :HumanReadable, "pubid/renderers/human_readable"
+    autoload :IwaRenderer, "pubid/renderers/iwa_renderer"
+    autoload :MrString, "pubid/renderers/mr_string"
+    autoload :SupplementRenderer, "pubid/renderers/supplement_renderer"
+    autoload :Urn, "pubid/renderers/urn"
+  end
+end

data/lib/pubid/rendering/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "publisher"
+require_relative "numbering"
+require_relative "date"
+require_relative "supplement"
+require_relative "stage"
+require_relative "language"
+require_relative "format"
+
+module Pubid
+  module Rendering
+    module Base
+      include Pubid::Rendering::Publisher
+      include Pubid::Rendering::Numbering
+      include Pubid::Rendering::Date
+      include Pubid::Rendering::Supplement
+      include Pubid::Rendering::Stage
+      include Pubid::Rendering::Language
+      include Pubid::Rendering::Format
+
+      # Base rendering method to be composed by subclasses
+      # @param options [Hash] rendering options
+      # @return [String] formatted identifier string
+      def render_base(**options)
+        parts = []
+
+        # Publisher/copublisher
+        pub = maybe(:publisher)
+        if pub
+          parts << render_publisher(pub,
+                                    maybe(:copublishers), **options)
+        end
+
+        # Numbering (number, part, subpart)
+        num = maybe(:number)
+        if num
+          parts << render_numbering(num, maybe(:part),
+                                    maybe(:subpart), **options)
+        end
+
+        # Date
+        d = maybe(:date)
+        if d
+          parts << render_date(d, **options)
+        end
+
+        # Stage and type
+        stg = maybe(:stage)
+        if stg
+          parts << render_stage(stg, maybe(:type),
+                                has_copublisher: maybe(:copublishers)&.any?, **options)
+        end
+
+        # Language codes
+        langs = maybe(:languages)
+        if langs&.any?
+          parts << render_languages(langs, **options)
+        end
+
+        parts.compact.join
+      end
+
+      private
+
+      def maybe(method_name)
+        return nil unless self.class.attributes.key?(method_name)
+
+        public_send(method_name)
+      end
+    end
+  end
+end