pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/oiml/builder.rb

@@ -77,14 +77,21 @@ module Pubid
       end
 
       def build_supplement(parsed_hash)
-        # Determine supplement type
+        marker = parsed_hash[:trailing_marker].to_s if parsed_hash[:trailing_marker]
+
+        # Determine supplement type. The trailing word ("Amendment"/"Errata")
+        # selects the class; the concrete class then carries the word via
+        # #supplement_type, so only the `trailing` flag needs storing.
         supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
                              Identifiers::Annex
+                           elsif marker == "Errata"
+                             Identifiers::Errata
                            else
                              Identifiers::Amendment
                            end
 
         supplement = supplement_class.new
+        supplement.trailing = true if marker
 
         # Recursively parse base identifier
         if parsed_hash[:base_identifier]
@@ -103,6 +110,13 @@ module Pubid
         supplement.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
         supplement.letter = parsed_hash[:annex_letter].to_s if parsed_hash[:annex_letter]
 
+        # Annex with no year of its own but a dated base ("R 60:2017 Annexes"):
+        # the year belongs to the base and must render glued to it.
+        if supplement.is_a?(Identifiers::Annex) && !year_value &&
+            supplement.base_identifier&.date
+          supplement.year_on_base = true
+        end
+
         # Track if supplement itself was parsed with Edition format
         if parsed_hash[:edition_format]
           supplement.parsed_format = "long"
@@ -119,8 +133,8 @@ module Pubid
 
         identifier = identifier_class.new
 
-        # Handle code (number-part-subpart) specially
-        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart]
+        # Handle code (number-part-subpart-suffix) specially
+        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart] || parsed_hash[:code_suffix]
           code_attrs = {}
           if parsed_hash[:number]
             code_attrs[:number] =
@@ -131,6 +145,10 @@ module Pubid
             code_attrs[:subpart] =
               parsed_hash[:subpart].to_s
           end
+          if parsed_hash[:code_suffix]
+            code_attrs[:suffix] = parsed_hash[:code_suffix].to_s
+            code_attrs[:space_suffix] = true if parsed_hash.key?(:space_suffix)
+          end
           identifier.code = Components::Code.new(**code_attrs)
         end
 

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

@@ -3,17 +3,34 @@
 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,53 @@
 module Pubid
   module Oiml
     class Identifier < Pubid::Identifier
-      def to_urn
-        UrnGenerator.new(self).generate
-      end
-
-      # Factory mirroring pubid 1.x's `Pubid::Oiml::Identifier.create` API.
-      # Default subclass is {Identifiers::Recommendation}.
-      TYPE_KEY_TO_KLASS = {
-        recommendation:    "Recommendation",
-        document:          "Document",
-        guide:             "Guide",
-        vocabulary:        "Vocabulary",
-        basic_publication: "BasicPublication",
-        expert_report:     "ExpertReport",
-        seminar_report:    "SeminarReport",
-        annex:             "Annex",
+      # 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: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
 
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Recommendation if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown OIML type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
+      # 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
 
-      def self.coerce_create_attrs(opts)
-        attrs = { publisher: (opts[:publisher] || "OIML").to_s }
-
-        if opts[:code].is_a?(Pubid::Oiml::Components::Code)
-          attrs[:code] = opts[:code]
-        elsif opts[:code] || opts[:number]
-          attrs[:code] = Pubid::Oiml::Components::Code.new(
-            number:  (opts[:number] || opts[:code])&.to_s,
-            part:    opts[:part]&.to_s,
-            subpart: opts[:subpart]&.to_s,
-          )
+      # 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_identifier), 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
 
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        %i[stage iteration language edition].each do |k|
-          attrs[k] = opts[k].to_s unless opts[k].nil?
-        end
-        attrs
+      def to_urn
+        UrnGenerator.new(self).generate
       end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

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

@@ -4,57 +4,24 @@ module Pubid
   module Oiml
     module Identifiers
       class Annex < SupplementIdentifier
-        attribute :letter, :string # For "Annex A", "Annex B", etc.
+        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
 
         def supplement_type
           letter ? "Annex #{letter}" : "Annexes"
         end
 
-        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
+        def to_s(format: nil, **opts)
+          @requested_format = format
+          render(format: :human, **opts)
         end
       end
     end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Errata supplement, used by the trailing-word shorthand
+      # "OIML R 126:2015 Errata" (the publication year lives on the base).
+      class Errata < SupplementIdentifier
+        def supplement_type
+          "Errata"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -5,9 +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 :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

@@ -18,7 +18,8 @@ module Pubid
 
       # Main identifier pattern - check supplements first
       rule(:identifier) do
-        amendment_identifier | amendment_short | annex_letter_identifier | annex_identifier | base_identifier
+        amendment_identifier | amendment_short | annex_letter_identifier |
+          annex_identifier | trailing_supplement_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -30,14 +31,33 @@ module Pubid
       # Number with optional part and subpart
       rule(:number_only) { digits.as(:number) }
 
-      rule(:part_number) { dash >> digits.as(:part) }
+      # 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(: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) |
-          (number_only >> part_number) |
-          number_only
+        (number_only >> part_number >> subpart_number >> named_suffix.maybe) |
+          (number_only >> part_number >> named_suffix.maybe) |
+          (number_only >> named_suffix.maybe)
       end
 
       # Edition number - ordinal numbers
@@ -82,8 +102,18 @@ 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("[EFRX]") # Single letter: E, F, R, X
+        match("[EFRXDSCAU]")
+      end
+
+      rule(:lang_multi_oiml) do
+        str("PO") | str("PT") | str("PE") | str("SR")
       end
 
       rule(:lang_multi) do
@@ -93,8 +123,9 @@ module Pubid
       rule(:language_code) do
         (
           (lang_single >> slash >> lang_single) | # E/F
-          lang_single |                          # E, F
-          lang_multi                             # en, fr
+          lang_multi_oiml |                        # PO, PT, PE, SR
+          lang_single |                            # E, F, D, R, S, C, A, U, X
+          lang_multi                               # en, fr
         ).as(:language)
       end
 
@@ -131,21 +162,37 @@ module Pubid
           language_portion.maybe.as(:language)
       end
 
-      # Annex identifier - "BASE Annexes Edition YYYY" or "BASE Annexes:YYYY"
+      # 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_identifier) >>
+          space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
+          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).
       rule(:annex_identifier) do
         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 with letter - "BASE Annex A Edition YYYY"
+      # 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"
       rule(:annex_letter_identifier) do
         base_without_language.as(:base_identifier) >>
-          space >> str("Annex") >> space >> match("[A-Z]").as(:annex_letter) >>
+          space >> str("Annex") >> space >> annex_letter_value >>
           ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
           language_portion.maybe.as(:language)
       end

data/lib/pubid/oiml/renderer.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    # Human-readable renderer for OIML identifiers.
+    #
+    # Produces strings like:
+    #   "OIML R 60:2000"
+    #   "OIML R 60 Edition 2013"
+    #   "OIML R 60 Annex A Edition 2013 (E)"
+    #   "OIML R 60 Annexes:2021 (E)"
+    #
+    # The renderer is registered as the `:human` format in the OIML format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::Annex
+          render_annex(id)
+        when SupplementIdentifier
+          render_supplement(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          id.to_s
+        end
+      end
+
+      private
+
+      def effective_format(id)
+        id.requested_format ||
+          (id.parsed_format == "long" ? :long : :short)
+      end
+
+      # Strip a trailing language group "(...)" from a rendered base string so
+      # the supplement can re-attach its own language at the end.
+      def strip_language(str)
+        str.sub(/\s*\([^)]+\)\s*$/, "").strip
+      end
+
+      def render_single(id)
+        format = effective_format(id)
+
+        result = "#{id.publisher} #{id.type_string} #{id.code}"
+
+        using_edition_format = false
+
+        if id.edition && id.date
+          result += " #{id.edition} Edition #{id.date.render(context: @context)}"
+          using_edition_format = true
+        elsif id.edition
+          result += " #{id.edition}"
+          using_edition_format = true
+        elsif id.date
+          if format == :long
+            result += " Edition #{id.date.render(context: @context)}"
+            using_edition_format = true
+          else
+            result += ":#{id.date.render(context: @context)}"
+          end
+        end
+
+        if id.stage || id.iteration
+          result += " "
+          result += id.iteration.to_s if id.iteration
+          result += id.stage.to_s if id.stage
+        end
+
+        if id.language
+          result += if using_edition_format || id.parsed_format == "short_with_space"
+                      " (#{id.language})"
+                    else
+                      "(#{id.language})"
+                    end
+        end
+
+        result
+      end
+
+      def render_supplement(id)
+        format = effective_format(id)
+
+        # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
+        # publication year kept on the base identifier. The word comes from the
+        # concrete supplement class.
+        if id.trailing
+          base_str = strip_language(id.base_identifier.to_s)
+          result = "#{base_str} #{id.supplement_type}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
+        base_format = if format && format != :short
+                        format
+                      elsif id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        base_str = if id.base_identifier.is_a?(SingleIdentifier)
+                     id.base_identifier.to_s(format: base_format)
+                   else
+                     id.base_identifier.to_s
+                   end
+        base_str = strip_language(base_str)
+
+        result = "#{id.supplement_type} (#{id.year}) to #{base_str}"
+        result += " (#{id.language})" if id.language
+
+        result
+      end
+
+      def render_annex(id)
+        format = effective_format(id)
+
+        # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
+        # carries none. Keep the base date instead of stripping it.
+        if id.year_on_base
+          base_str = strip_language(id.base_identifier.to_s)
+          marker = id.letter ? "Annex #{id.letter}" : "Annexes"
+          result = "#{base_str} #{marker}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
+        base_format = if id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        annex_format = if format
+                         format
+                       elsif id.class.attributes.key?(:parsed_format) && id.parsed_format == "long"
+                         :long
+                       else
+                         :short
+                       end
+
+        base_str = if id.base_identifier.is_a?(SingleIdentifier)
+                     id.base_identifier.to_s(format: base_format)
+                   else
+                     id.base_identifier.to_s
+                   end
+        result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
+          /\(.*\)/, ""
+        ).strip
+
+        if id.letter
+          result += " Annex #{id.letter}"
+          result += " Edition #{id.year}" if id.year
+        else
+          result += " Annexes"
+          if id.year
+            result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
+          elsif id.base_identifier.date
+            result += annex_format == :long ? " Edition #{id.base_identifier.date.render(context: @context)}" : ":#{id.base_identifier.date.render(context: @context)}"
+          end
+        end
+
+        result += " (#{id.language})" if id.language
+        result
+      end
+    end
+  end
+end