pubid 1.15.18 → 2.0.0.pre.alpha.1

data/lib/pubid/parser/common_parse_rules.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    module CommonParseRules
+      def self.included(base)
+        base.class_eval do
+          rule(:space) { str(" ") }
+          rule(:space?) { space.maybe }
+
+          rule(:digits) do
+            match('\d').repeat(1)
+          end
+
+          rule(:year) do
+            match('\d').repeat(4, 4).as(:year)
+          end
+
+          rule(:comma) { str(", ") }
+          rule(:comma?) { comma.maybe }
+          rule(:comma_space) { comma | space }
+          rule(:dash) { str("-") }
+          rule(:dot) { str(".") }
+          rule(:words_digits) { match('[\dA-Za-z]').repeat(1) }
+          rule(:words) { match("[A-Za-z]").repeat(1) }
+          rule(:words?) { words.maybe }
+          rule(:year_digits) do
+            (str("19") | str("20")) >> match('\d').repeat(2,
+                                                          2) >> digits.absent?
+          end
+
+          rule(:month_digits) do
+            match('\d').repeat(2, 2)
+          end
+
+          rule(:day_digits) do
+            match('\d').repeat(2, 2)
+          end
+
+          rule(:originator) do
+            organization.as(:publisher) >>
+              (space? >> str("/") >> organization.as(:copublisher)).repeat
+          end
+
+          rule(:comma_month_year) do
+            comma >> words.as(:month) >> space >> year_digits.as(:year)
+          end
+
+          rule(:year_month) do
+            year_digits >> dash >> month_digits
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/parser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
+    autoload :CommonParseRules, "pubid/parser/common_parse_rules"
+  end
+end

data/lib/pubid/parsers/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parsers
+    class Base
+      def self.parse(string)
+        raise NotImplementedError, "#{self.class}.parse not implemented"
+      end
+    end
+  end
+end

data/lib/pubid/parsers/mr_string.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parsers
+    class MrString < Base
+      FLAVOR_MAP = {
+        "ISO" => :iso,
+        "IEC" => :iec,
+        "IEEE" => :ieee,
+        "NIST" => :nist,
+        "NBS" => :nist,
+        "BS" => :bsi,
+        "CEN" => :cen_cenelec,
+        "JIS" => :jis,
+        "ETSI" => :etsi,
+        "ITU" => :itu,
+        "ANSI" => :ansi,
+        "OIML" => :oiml,
+        "CIE" => :cie,
+        "ASHRAE" => :ashrae,
+        "AMCA" => :amca,
+        "IDF" => :idf,
+        "IHO" => :iho,
+        "JCGM" => :jcgm,
+        "SAE" => :sae,
+        "ASME" => :asme,
+        "CSA" => :csa,
+        "API" => :api,
+        "ASTM" => :astm,
+        "PLATEAU" => :plateau,
+        "CCSDS" => :ccsds,
+      }.freeze
+
+      # Map flavor symbols to Pubid autoload constants
+      FLAVOR_CONSTANT_MAP = {
+        iso: :Iso,
+        iec: :Iec,
+        ieee: :Ieee,
+        nist: :Nist,
+        bsi: :Bsi,
+        cen_cenelec: :CenCenelec,
+        jis: :Jis,
+        etsi: :Etsi,
+        itu: :Itu,
+        ansi: :Ansi,
+        oiml: :Oiml,
+        cie: :Cie,
+        ashrae: :Ashrae,
+        amca: :Amca,
+        idf: :Idf,
+        iho: :Iho,
+        jcgm: :Jcgm,
+        sae: :Sae,
+        asme: :Asme,
+        csa: :Csa,
+        api: :Api,
+        astm: :Astm,
+        plateau: :Plateau,
+        ccsds: :Ccsds,
+      }.freeze
+
+      def self.parse(mr_string)
+        flavor = detect_flavor(mr_string)
+
+        # Trigger autoload to register the flavor
+        if (const_name = FLAVOR_CONSTANT_MAP[flavor])
+          Pubid.const_get(const_name)
+        end
+
+        flavor_module = Pubid::Registry.get(flavor)
+        raise ArgumentError, "Unknown flavor: #{flavor}" unless flavor_module
+
+        identifier_string = convert_to_human_readable(mr_string)
+        flavor_module.parse(identifier_string)
+      end
+
+      def self.detect_flavor(mr_string)
+        publisher = mr_string.split(".").first.upcase
+        FLAVOR_MAP[publisher] || :iso
+      end
+
+      def self.convert_to_human_readable(mr_string)
+        parts = mr_string.split(".")
+        if parts.size > 2
+          year_part = parts.pop
+          parts.join(" ") + ":#{year_part}"
+        else
+          parts.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/plateau/builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class Builder
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      def build(parsed)
+        # Check for annex supplement first
+        if parsed[:base_identifier] && parsed[:annex_letter]
+          return build_annex(parsed)
+        end
+
+        # Determine which class to use based on type
+        klass = case parsed[:type].to_s
+                when "Handbook"
+                  Identifiers::Handbook
+                when "Technical Report"
+                  Identifiers::TechnicalReport
+                else
+                  raise "Unknown PLATEAU type: #{parsed[:type]}"
+                end
+
+        # Build parameters common to all types
+        params = {
+          number: parsed[:number].to_s.to_i,
+        }
+
+        params[:annex] = parsed[:annex].to_s.to_i if parsed[:annex]
+        params[:edition] = parsed[:edition].to_s if parsed[:edition]
+
+        klass.new(**params)
+      end
+
+      private
+
+      def build_annex(parsed)
+        # Recursively parse base identifier
+        base = build(parsed[:base_identifier])
+
+        Identifiers::Annex.new(
+          base_identifier: base,
+          letter: parsed[:annex_letter].to_s,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Annex supplement
+      # Format: {BASE} Annex {letter}
+      # Example: PLATEAU Handbook #00 第1.0版 Annex A
+      class Annex < SupplementIdentifier
+        def supplement_string
+          "Annex #{letter}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # Base class for all PLATEAU identifiers
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+        attribute :number, :integer
+        attribute :annex, :integer, default: -> {}
+
+        def publisher
+          "PLATEAU"
+        end
+
+        # Subclasses must implement type_string
+        def type_string
+          raise NotImplementedError, "Subclasses must implement type_string"
+        end
+
+        def formatted_number
+          "#%02d" % number
+        end
+
+        def formatted_annex
+          annex ? "-#{annex}" : ""
+        end
+
+        def ==(other)
+          return false unless other.class == self.class
+
+          number == other.number &&
+            annex == other.annex
+        end
+
+        # Include type_string and annex in serialization for round-trip compatibility
+        def base_hash
+          hash = super
+          if self.class.attributes.key?(:type_string) && type_string
+            hash[:type] =
+              type_string
+          end
+          hash[:annex] = annex if annex
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Handbook
+      # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
+      # Example: PLATEAU Handbook #00 第1.0版
+      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
+
+        def ==(other)
+          return false unless other.is_a?(Handbook)
+
+          super && edition == other.edition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Technical Report
+      # Format: PLATEAU Technical Report #NN[-annex]
+      # Example: PLATEAU Technical Report #01
+      class TechnicalReport < Base
+        def type_string
+          "Technical Report"
+        end
+
+        def to_s
+          "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/plateau/identifiers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/pubid/plateau/parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class Parser < Parslet::Parser
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:hash) { str("#") }
+
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # PLATEAU
+      rule(:publisher) { str("PLATEAU") }
+
+      # Handbook or Technical Report
+      rule(:doc_type) do
+        (str("Handbook") | str("Technical Report")).as(:type)
+      end
+
+      # Number: #00, #01, #46, etc.
+      rule(:number) { hash >> digits.as(:number) }
+
+      # Annex: -1, -2, etc.
+      rule(:annex) { dash >> digits.as(:annex) }
+
+      # Edition: 第1.0版, 第2.3版, etc. (only for Handbook)
+      rule(:edition_part) do
+        str("第") >>
+          (digits >> str(".") >> digits).as(:edition) >>
+          str("版")
+      end
+
+      rule(:edition) { space >> edition_part }
+
+      # Annex supplement: "Annex A", "Annex B", etc.
+      rule(:annex_letter) { match["A-Z"].as(:annex_letter) }
+      rule(:annex_supplement) do
+        space >> str("Annex") >> space >> annex_letter
+      end
+
+      # Full identifier patterns
+      rule(:handbook) do
+        publisher >> space >> doc_type >> space >>
+          number >> annex.maybe >> edition.maybe
+      end
+
+      rule(:technical_report) do
+        publisher >> space >> doc_type >> space >>
+          number >> annex.maybe
+      end
+
+      # Annex identifier (supplement)
+      rule(:annex_identifier) do
+        (handbook | technical_report).as(:base_identifier) >> annex_supplement
+      end
+
+      rule(:identifier) { annex_identifier | handbook | technical_report }
+
+      rule(:root) { identifier }
+    end
+  end
+end

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

@@ -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,25 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Plateau
+    autoload :Builder, "#{__dir__}/plateau/builder"
+    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,19 @@
+# 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
+    end
+  end
+end

data/lib/pubid/renderers/directives_renderer.rb

@@ -0,0 +1,62 @@
+# 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)
+        pub_str = @id.publisher.render(context:) if @id.publisher
+        abbr = @id.typed_stage ? @id.typed_stage.abbreviation(format_long: false) : ""
+        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}" : ""),
+          (abbr.empty? ? "" : " #{abbr}"),
+        ].join
+      end
+
+      def render_number_portion(context)
+        parts = []
+        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 << ":#{date_str}" if date_str
+        result = parts.join.strip
+        result.empty? ? nil : result
+      end
+    end
+  end
+end