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

data/lib/pubid/oiml/components/code.rb

@@ -3,34 +3,17 @@
 module Pubid
   module Oiml
     module Components
-      # Code component for OIML identifiers.
-      #
-      # Stays independent of Pubid::Components::Code because OIML uses
-      # +number+ as the primary field (shared Code uses +value+). The
-      # shape is otherwise compatible; a future rename of +number+ →
-      # +value+ would let this become a subclass.
       class Code < Lutaml::Model::Serializable
         attribute :number, :string
         attribute :part, :string
         attribute :subpart, :string
-        # Free-form trailing suffix glued to the code, e.g. "sup", "A",
-        # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
-        attribute :suffix, :string
-        # When true the suffix is space-separated ("D 1 Brochure") rather than
-        # the default dash ("R 60-sup").
-        attribute :space_suffix, :boolean, default: false
 
         def to_s
           result = number.to_s
           result += "-#{part}" if part
           result += "-#{subpart}" if subpart
-          result += "#{space_suffix ? ' ' : '-'}#{suffix}" if suffix
           result
         end
-
-        def render(context: nil)
-          to_s
-        end
       end
     end
   end

data/lib/pubid/oiml/identifier.rb

@@ -3,59 +3,6 @@
 module Pubid
   module Oiml
     class Identifier < Pubid::Identifier
-      # Maps each concrete identifier's polymorphic_name => class name, so
-      # key_value (de)serialization can re-instantiate the correct subclass
-      # from the `_type` discriminator. Kept in sync with the Identifiers
-      # namespace by a spec assertion (see spec/pubid/oiml/to_hash_spec.rb).
-      OIML_TYPE_MAP = {
-        "pubid:oiml:recommendation" => "Pubid::Oiml::Identifiers::Recommendation",
-        "pubid:oiml:basic-publication" => "Pubid::Oiml::Identifiers::BasicPublication",
-        "pubid:oiml:bulletin" => "Pubid::Oiml::Identifiers::Bulletin",
-        "pubid:oiml:document" => "Pubid::Oiml::Identifiers::Document",
-        "pubid:oiml:guide" => "Pubid::Oiml::Identifiers::Guide",
-        "pubid:oiml:vocabulary" => "Pubid::Oiml::Identifiers::Vocabulary",
-        "pubid:oiml:expert-report" => "Pubid::Oiml::Identifiers::ExpertReport",
-        "pubid:oiml:seminar-report" => "Pubid::Oiml::Identifiers::SeminarReport",
-        "pubid:oiml:amendment" => "Pubid::Oiml::Identifiers::Amendment",
-        "pubid:oiml:errata" => "Pubid::Oiml::Identifiers::Errata",
-        "pubid:oiml:annex" => "Pubid::Oiml::Identifiers::Annex",
-      }.freeze
-
-      # The base Pubid::Identifier no longer auto-maps attributes, so OIML must
-      # declare its own key_value mapping. SingleIdentifier and
-      # SupplementIdentifier (siblings) add their disjoint attribute deltas on
-      # top of this shared block. `type` is deliberately NOT mapped: OIML's
-      # `type` is a String-returning method (e.g. "R"), incompatible with the
-      # inherited Components::Type attribute — and the `_type` discriminator
-      # already pins the concrete subclass (and thus the type letter).
-      key_value do
-        map "_type", to: :_type, polymorphic_map: OIML_TYPE_MAP
-        map "language", to: :language
-        map "parsed_format", to: :parsed_format
-      end
-
-      # lutaml's polymorphic_map only validates `_type` on deserialization; it
-      # does not re-instantiate the concrete subclass. Route by `_type` so
-      # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its
-      # nested base), mirroring Pubid::Iso::Identifier.from_hash.
-      def self.from_hash(data, options = {})
-        type = data["_type"] || data[:_type]
-        klass_name = OIML_TYPE_MAP[type]
-        if klass_name
-          klass = Object.const_get(klass_name)
-          return klass.from_hash(data, options) unless klass == self
-        end
-        super
-      end
-
-      # Uniform class-level parse entry, mirroring every other flavor's
-      # `Pubid::<Flavor>::Identifier.parse`. OIML's real logic lives in the
-      # module method, so delegate to it (same pattern as jcgm/nist/plateau).
-      # The `Pubid::MAX_INPUT_LENGTH` ReDoS guard lives in `Pubid::Oiml.parse`.
-      def self.parse(identifier)
-        Pubid::Oiml.parse(identifier)
-      end
-
       def to_urn
         UrnGenerator.new(self).generate
       end

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

@@ -4,24 +4,57 @@ module Pubid
   module Oiml
     module Identifiers
       class Annex < SupplementIdentifier
-        attribute :letter, :string # For "Annex A", "Annex B", "Annex B-C"
-        # True when the publication year is glued to the base ("OIML R 60:2017
-        # Annexes") rather than the marker ("OIML R 60 Annexes:2017"); drives
-        # exact round-trip in the renderer.
-        attribute :year_on_base, :boolean, default: false
-
-        key_value do
-          map "letter", to: :letter
-          map "year_on_base", to: :year_on_base
-        end
+        attribute :letter, :string # For "Annex A", "Annex B", etc.
 
         def supplement_type
           letter ? "Annex #{letter}" : "Annexes"
         end
 
-        def to_s(format: nil, **opts)
-          @requested_format = format
-          render(format: :human, **opts)
+        def to_s(format: nil)
+          # Determine base format from its parsed_format
+          base_format = if base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
+                          :long
+                        else
+                          :short
+                        end
+
+          # Use format parameter or annex's own parsed_format
+          annex_format = if format
+                           format
+                         elsif self.class.attributes.key?(:parsed_format) && parsed_format == "long"
+                           :long
+                         else
+                           :short
+                         end
+
+          # Annexes have different pattern than amendments
+          base_str = base_identifier.to_s(format: base_format)
+          result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
+            /\(.*\)/, ""
+          ).strip
+          if letter
+            # Specific annex: "OIML R 60 Annex A Edition 2013 (E)"
+            result += " Annex #{letter}"
+
+            result += " Edition #{year}" if year
+
+          # Supplements ALWAYS use space before language
+
+          else
+            # General annexes: "OIML R 60 Annexes Edition 2021 (E)" or "OIML R 60 Annexes:2021 (E)"
+            result += " Annexes"
+
+            if year
+              result += annex_format == :long ? " Edition #{year}" : ":#{year}"
+            elsif base_identifier.date
+              result += annex_format == :long ? " Edition #{base_identifier.date.year}" : ":#{base_identifier.date.year}"
+            end
+
+            # Supplements ALWAYS use space before language
+
+          end
+          result += " (#{language})" if language
+          result
         end
       end
     end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Base < Pubid::Identifier
+        attribute :publisher, :string
+        attribute :type, :string
+        attribute :code, Oiml::Components::Code
+        attribute :date, Pubid::Components::Date
+        attribute :stage, :string
+        attribute :iteration, :string
+        attribute :language, :string
+
+        def to_s
+          result = "#{publisher} #{type} #{code}"
+
+          # Add date if present
+          result += ":#{date.year}" if date
+
+          # Add draft stage if present (iteration + stage)
+          if stage || iteration
+            result += " "
+            result += iteration.to_s if iteration
+            result += stage.to_s if stage
+          end
+
+          # Add language portion if present
+          result += "(#{language})" if language
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/basic_publication.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class BasicPublication < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "B"
         end

data/lib/pubid/oiml/identifiers/document.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class Document < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "D"
         end

data/lib/pubid/oiml/identifiers/expert_report.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class ExpertReport < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "E"
         end

data/lib/pubid/oiml/identifiers/guide.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class Guide < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "G"
         end

data/lib/pubid/oiml/identifiers/recommendation.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class Recommendation < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "R"
         end

data/lib/pubid/oiml/identifiers/seminar_report.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class SeminarReport < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "S"
         end

data/lib/pubid/oiml/identifiers/vocabulary.rb

@@ -4,8 +4,6 @@ module Pubid
   module Oiml
     module Identifiers
       class Vocabulary < SingleIdentifier
-        include CodeNumber
-
         def type_string
           "V"
         end

data/lib/pubid/oiml/identifiers.rb

@@ -5,11 +5,9 @@ module Pubid
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
-      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
-      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Document, "#{__dir__}/identifiers/document"
-      autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
       autoload :Guide, "#{__dir__}/identifiers/guide"
       autoload :Recommendation, "#{__dir__}/identifiers/recommendation"

data/lib/pubid/oiml/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Oiml
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -18,9 +18,7 @@ module Pubid
 
       # Main identifier pattern - check supplements first
       rule(:identifier) do
-        amendment_identifier | amendment_short | annex_letter_identifier |
-          annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | bulletin_identifier | base
+        amendment_identifier | amendment_short | annex_letter_identifier | annex_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -29,77 +27,17 @@ module Pubid
       # Document type - single letter
       rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
 
-      # Bulletin locator — structured form. Year optionally followed by
-      # 2-digit issue and 2-digit sequence:
-      #   "OIML Bulletin", "OIML Bulletin 1960",
-      #   "OIML Bulletin 1960-03", "OIML Bulletin 1960-03-01"
-      # All four shapes appear as primary docids in relaton-data-oiml.
-      rule(:bulletin_date) do
-        space >> year_digits.as(:year) >>
-          (dash >> two_digits.as(:issue)).maybe >>
-          (dash >> two_digits.as(:sequence)).maybe
-      end
-
-      # Two-digit zero-padded number (used for issue / sequence).
-      rule(:two_digits) { match('\d').repeat(2, 2) }
-
-      # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
-      # OIML's print convention). Captured so the builder can cross-check
-      # the declared volume against the year implied by the article_id.
-      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1).as(:volume_roman) }
-
-      # Bulletin locator — citation form. The format OIML prints on the
-      # article page is: "LXVII(2) 20260211" where LXVII is the volume in
-      # roman numerals, (2) is the issue in arabic without zero padding,
-      # and 20260211 is the 8-digit oiml.org article id (YYYYNNSS).
-      rule(:bulletin_citation) do
-        space >> roman_numeral >>
-          lparen >> digits.as(:issue_arabic) >> rparen >>
-          space >> match('\d').repeat(8, 8).as(:article_id)
-      end
-
-      # Bulletin identifier — no code; the locator (when present) is the
-      # (year, issue, sequence) tuple drawn from either the structured
-      # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
-      # decode to the same record. Tried before base because
-      # "Bulletin" is a word that the single-letter doc_type rule cannot
-      # match.
-      rule(:bulletin_identifier) do
-        publisher >> str("Bulletin").as(:type) >>
-          (bulletin_citation | bulletin_date).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
       # Number with optional part and subpart
       rule(:number_only) { digits.as(:number) }
 
-      # Part number, optionally a slashed multi-part continuation captured
-      # verbatim, e.g. "1/-2" in "OIML R 46-1/-2:2012".
-      rule(:part_number) do
-        dash >> (digits >> (slash >> dash >> digits).repeat).as(:part)
-      end
+      rule(:part_number) { dash >> digits.as(:part) }
 
       rule(:subpart_number) { dash >> digits.as(:subpart) }
 
-      # Free-form named/lettered code suffix glued after the numeric part:
-      #   -GUM 1, -special, -sup, -erratum, -A, -ISO3930, -Amend, -Amended_2012
-      # plus the space-separated "Brochure" label. "GUM <n>" is tried first so
-      # its trailing number isn't lost to the bare-word alternative. The
-      # trailing `(_?digits)*` captures joint codes ("ISO3930") and the
-      # "Amended_2012" amendment label (the hand-off treats these as part
-      # suffixes, preserved verbatim for round-trip).
-      rule(:named_suffix) do
-        (dash >> (
-          (str("GUM") >> space >> digits) |
-          (match("[A-Za-z]").repeat(1) >> (str("_").maybe >> digits).repeat)
-        ).as(:code_suffix)) |
-          (space >> str("Brochure").as(:code_suffix) >> str("").as(:space_suffix))
-      end
-
       rule(:full_number) do
-        (number_only >> part_number >> subpart_number >> named_suffix.maybe) |
-          (number_only >> part_number >> named_suffix.maybe) |
-          (number_only >> named_suffix.maybe)
+        (number_only >> part_number >> subpart_number) |
+          (number_only >> part_number) |
+          number_only
       end
 
       # Edition number - ordinal numbers
@@ -144,18 +82,8 @@ module Pubid
       end
 
       # Language codes
-      #
-      # relaton-data-oiml encodes the publication language with its own code
-      # set (lib/oiml_fetcher.rb DOCID_LANG_CODE): single uppercase letters
-      # E F D R S C A U X, plus two-letter PO/PT/PE/SR. The two-letter OIML
-      # codes must be tried before the single-letter rule so e.g. "PE" isn't
-      # left with a dangling "E".
       rule(:lang_single) do
-        match("[EFRXDSCAU]")
-      end
-
-      rule(:lang_multi_oiml) do
-        str("PO") | str("PT") | str("PE") | str("SR")
+        match("[EFRX]") # Single letter: E, F, R, X
       end
 
       rule(:lang_multi) do
@@ -165,9 +93,8 @@ module Pubid
       rule(:language_code) do
         (
           (lang_single >> slash >> lang_single) | # E/F
-          lang_multi_oiml |                        # PO, PT, PE, SR
-          lang_single |                            # E, F, D, R, S, C, A, U, X
-          lang_multi                               # en, fr
+          lang_single |                          # E, F
+          lang_multi                             # en, fr
         ).as(:language)
       end
 
@@ -187,7 +114,7 @@ module Pubid
       rule(:amendment_identifier) do
         str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
           space >> str("to") >> space >>
-          base_without_language.as(:base) >>
+          base_without_language.as(:base_identifier) >>
           language_portion.maybe.as(:language)
       end
 
@@ -204,49 +131,21 @@ module Pubid
           language_portion.maybe.as(:language)
       end
 
-      # Trailing supplement word - "BASE Amendment" / "BASE Errata" where the
-      # publication year stays on the base (e.g. "OIML R 138:2009 Amendment").
-      # amendment_short is tried first; it only matches when a year follows the
-      # word, so the no-year trailing form falls through to here.
-      rule(:trailing_supplement_identifier) do
-        base_without_language.as(:base) >>
-          space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
-      # the base and the supplement carry their own year. Used for amendments
-      # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
-      # Annexes already encode the year-on-base intent via their own model.
-      rule(:plus_supplement_identifier) do
-        base_without_language.as(:base) >>
-          str("+") >>
-          (str("Amendment") | str("Errata")).as(:plus_marker) >>
-          (colon >> year_digits.as(:year)).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
-      # "BASE:YYYY Annexes" (year on the base, no annex year).
+      # Annex identifier - "BASE Annexes Edition YYYY" or "BASE Annexes:YYYY"
       rule(:annex_identifier) do
-        base_without_language.as(:base) >>
+        base_without_language.as(:base_identifier) >>
           space >> str("Annexes").as(:annex_marker) >>
           (
             (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
             (colon >> year_digits.as(:year))
-          ).maybe >>
+          ) >>
           language_portion.maybe.as(:language)
       end
 
-      # Annex letter or letter range, e.g. "A" or "B-C".
-      rule(:annex_letter_value) do
-        (match("[A-Z]") >> (dash >> match("[A-Z]")).maybe).as(:annex_letter)
-      end
-
-      # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
+      # Annex with letter - "BASE Annex A Edition YYYY"
       rule(:annex_letter_identifier) do
-        base_without_language.as(:base) >>
-          space >> str("Annex") >> space >> annex_letter_value >>
+        base_without_language.as(:base_identifier) >>
+          space >> str("Annex") >> space >> match("[A-Z]").as(:annex_letter) >>
           ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
           language_portion.maybe.as(:language)
       end
@@ -261,7 +160,7 @@ module Pubid
       end
 
       # Base identifier for recursion and standalone parsing
-      rule(:base) do
+      rule(:base_identifier) do
         publisher >>
           doc_type >>
           full_number >>

data/lib/pubid/oiml/scheme.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::BasicPublication,
+            Identifiers::Document,
+            Identifiers::ExpertReport,
+            Identifiers::Guide,
+            Identifiers::Recommendation,
+            Identifiers::SeminarReport,
+            Identifiers::Vocabulary,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [
+            Identifiers::Amendment,
+            Identifiers::Annex,
+          ].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= [].freeze
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= [].freeze
+        end
+
+        def locate_typed_stage_by_abbr(_abbr)
+          raise ArgumentError,
+                "OIML identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "OIML identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end