pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/oiml/urn_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        return "r" unless identifier.type
+
+        identifier.type.to_s.downcase
+      end
+
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.to_s
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        nil
+      end
+
+      def urn_stage
+        identifier.stage&.to_s&.downcase
+      end
+
+      def urn_iteration
+        identifier.iteration&.to_s
+      end
+
+      def urn_language
+        identifier.language&.to_s&.downcase
+      end
+
+      def generate
+        parts = ["urn", "oiml"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << urn_stage if urn_stage
+        parts << urn_iteration if urn_iteration
+        parts << urn_language if urn_language
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        if identifier.is_a?(SupplementIdentifier)
+          if identifier.typed_stage
+            supp_type = identifier.typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          if identifier.number
+            parts << identifier.number.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/oiml.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    autoload :Builder, "#{__dir__}/oiml/builder"
+    autoload :Components, "#{__dir__}/oiml/components"
+    autoload :Identifier, "#{__dir__}/oiml/identifier"
+    autoload :Identifiers, "#{__dir__}/oiml/identifiers"
+    autoload :Parser, "#{__dir__}/oiml/parser"
+    autoload :Scheme, "#{__dir__}/oiml/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
+
+    def self.parse(identifier)
+      parser = Parser.new
+      builder = Builder.new
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    end
+  end
+end
+
+# Register Uoiml flavor with the registry
+Pubid::Registry.register(:oiml, Pubid::Oiml)

data/lib/pubid/parser/common_parse_methods.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    module CommonParseMethods
+      def array_to_str(array)
+        array.reduce(str(array.first)) do |acc, value|
+          acc | str(value)
+        end
+      end
+    end
+  end
+end

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/identifier.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Plateau factory entry point. `.parse` lives on `Pubid::Plateau`
+    # itself for historical reasons; this module hosts `.create` for API
+    # consistency with the other pubid flavors.
+    module Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
+
+      # Factory that builds a PLATEAU identifier from a hash of primitives.
+      #
+      # Dispatch on `:type`:
+      #   * `:handbook` (default)            → Identifiers::Handbook
+      #   * `:technical_report` / `:tr`      → Identifiers::TechnicalReport
+      #   * `:annex`                         → Identifiers::Annex
+      #
+      # Attributes are plain integers/strings — no Component wrapping.
+      # `:publisher` is silently ignored (PLATEAU is hardcoded).
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        case type&.to_sym
+        when nil, :handbook
+          Identifiers::Handbook
+        when :technical_report, :tr
+          Identifiers::TechnicalReport
+        when :annex
+          Identifiers::Annex
+        else
+          raise ArgumentError, "Unknown PLATEAU type: #{type.inspect}"
+        end
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+        attrs[:number] = opts[:number].to_i if opts[:number]
+        attrs[:annex]  = opts[:annex].to_i  if opts[:annex]
+        # :edition exists only on Handbook (and possibly TechnicalReport);
+        # silently drop on Annex.
+        if opts[:edition] && klass.attributes.key?(:edition)
+          attrs[:edition] = opts[:edition].to_s
+        end
+        # TODO(create-shim): :publisher silently ignored (PLATEAU hardcoded).
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+    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