pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

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

@@ -33,49 +33,43 @@ module Pubid
         # carried in the structured form and the roman volume in citations.
         BASE_YEAR_OFFSET = 1959
 
-        # Zero-padded issue number within the year ("01".."04", plus "07"/"10"
-        # for the online-bulletin series). Always 2 digits.
-        attribute :issue, :string
+        # The issue: the zero-padded number within the volume ("01".."04",
+        # plus "07"/"10" for the online-bulletin series). Always 2 digits. The
+        # year is the volume and the issue is the number, as in the citation
+        # form "LXVII(2)".
+        #
+        # Declared as `number`, so it is the relaton index key
+        # (`id.root.number.to_s`) and every index row with an issue shows a
+        # `number`. The key puts the same issue number of all volumes in one
+        # bucket; the MR slug keeps each article distinct.
+        #
+        # Declared on this LEAF, which has no subclasses. It redefines the
+        # `Components::Code number` of ::Pubid::Identifier as a :string, and a
+        # redefinition on a class that other classes inherit is the
+        # multi-flavor determinism landmine (see Identifiers::CodeNumber).
+        #
+        # nil for a volume ("OIML Bulletin 1960") and for the bare periodical
+        # reference "OIML Bulletin", which name no issue.
+        attribute :number, :string
         # Zero-padded sequence within the issue ("00" = editorial, "01"+ for
         # articles). Always 2 digits.
         attribute :sequence, :string
 
         key_value do
-          map "issue", to: :issue
+          map "number", to: :number
           map "sequence", to: :sequence
         end
 
-        # relaton-index keys on `id.root.number.to_s`. Bulletin is the one OIML
-        # leaf with no code (it does not include Identifiers::CodeNumber), so
-        # it derives the key from the year it already stores: every issue and
-        # article of a volume clusters into one bucket, with per-article
-        # distinctness coming from the MR slug instead. That is the BIPM
-        # Metrologia-volume precedent recorded in CLAUDE.md.
-        #
-        # A DERIVED READER, deliberately not an attribute: storing it would
-        # duplicate `year` in every row, and the key_value block above maps no
-        # "number", so nothing is added to the wire format. Safe as a plain
-        # method because Bulletin declares no `number` attribute of its own
-        # (the ITU itu/identifiers/base.rb precedent).
-        #
-        # nil for the bare periodical reference "OIML Bulletin", which names no
-        # year — a deliberate gap, pinned in spec/pubid/oiml/root_number_spec.rb.
-        def number
-          date&.year&.to_s
-        end
-
-        # The index key above is deliberately coarse — a whole volume in one
-        # bucket — which is only defensible because the MR slug stays
-        # per-article. The inherited hook reads through `code`, which Bulletin
-        # does not have, so it would return nil and collapse every article of a
-        # year onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so
-        # that is an overwrite. Emit the rest of the locator instead.
+        # The inherited hook reads through `code`, which Bulletin does not
+        # have, so it would return nil and collapse every article of a year
+        # onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so that
+        # is an overwrite. Emit the rest of the locator instead.
         #
         # The year is deliberately NOT included: Renderers::MrString already
         # gives it its own segment (`mr_year`), so repeating it here would
         # render `oiml.bulletin.1960-03-01.1960`.
         def mr_number_with_part
-          segments = [issue, sequence].compact
+          segments = [number, sequence].compact
           return nil if segments.empty?
 
           segments.join("-")
@@ -96,18 +90,18 @@ module Pubid
         # Volume as a roman-numeral string ("LXVII"), derived from the year.
         # nil when the year is absent.
         def volume_roman
-          number = volume_arabic&.to_i
-          return nil unless number&.positive?
+          volume = volume_arabic&.to_i
+          return nil unless volume&.positive?
 
-          self.class.to_roman(number)
+          self.class.to_roman(volume)
         end
 
         # 8-digit oiml.org article id ("20260211"). Composed by concatenating
-        # year + issue + sequence. nil unless all three are present.
+        # year + issue (number) + sequence. nil unless all three are present.
         def article_id
-          return nil unless date&.year && issue && sequence
+          return nil unless date&.year && number && sequence
 
-          "#{date.year}#{issue}#{sequence}"
+          "#{date.year}#{number}#{sequence}"
         end
 
         class << self

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML-CS certification-system documents ("OIML-CS PD-05 Edition 6").
+      # The number keeps its printed zero padding ("05"); family is the
+      # PD/OD/CID document class; the print states "Edition N" instead of a
+      # year, and may carry a parenthesized trailing amendment.
+      class CertificationSystem < SingleIdentifier
+        attribute :number, :string
+        attribute :family, :string
+        attribute :amendment, :string
+        # "PD 05" prints space-separated where "PD-05" is dash-joined.
+        attribute :space_separator, :boolean, default: false
+
+        key_value do
+          map "number", to: :number
+          map "family", to: :family
+          map "amendment", to: :amendment
+          map "space_separator", to: :space_separator
+        end
+
+        def self.subset_ignored_attributes
+          super + [:space_separator]
+        end
+
+        def type_string
+          "CS"
+        end
+      end
+    end
+  end
+end

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

@@ -28,12 +28,13 @@ module Pubid
       #
       # Bulletin deliberately does NOT include this module. It carries no code
       # at all (its locator is the year/issue/sequence tuple), so it would only
-      # gain a permanently-nil `number` and a `number` key that never appears.
-      # It derives its index key from the year instead; see bulletin.rb.
+      # gain permanently-nil part/subpart/suffix columns. It declares its own
+      # `number` (the issue) instead; see bulletin.rb.
       module CodeNumber
         def self.included(base)
           install_attributes(base)
           install_mappings(base)
+          install_subset_rules(base)
         end
 
         def self.install_attributes(base)
@@ -53,6 +54,13 @@ module Pubid
           base.attribute :space_suffix, :boolean, default: -> { false }
         end
 
+        # A nil `part`, `subpart` or `suffix` means the document has none of
+        # them: `OIML R 138` is not `OIML R 138-Amend`, which is its
+        # amendment. Declared on each leaf, beside the columns it governs.
+        def self.install_subset_rules(base)
+          base.subset_strict :part, :subpart, :suffix
+        end
+
         # Merged by lutaml with the block SingleIdentifier declares, which
         # carries publisher/year/edition/stage/iteration.
         def self.install_mappings(base)

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML sometimes co-publishes a document jointly with another SDO
+      # (ISO confirmed so far, per pubid issue #437). The printed reference
+      # carries both identifiers, joined by a bare "|":
+      #
+      #   ISO 4064-1:2024|OIML R 49-1:2024
+      #
+      # A sibling of SingleIdentifier/SupplementIdentifier — like
+      # SupplementIdentifier, it inherits NOTHING from SingleIdentifier and
+      # must delegate every identity-bearing reader (code/type/stage/
+      # iteration/publisher, the mr_* MR-slug hooks, #root) itself. Without
+      # the mr_* delegations, #to_mr_string would silently come out "" (the
+      # same filename-collision gap already documented for
+      # Amendment/Errata/Annex in lib/pubid/oiml/CLAUDE.md) — this class closes
+      # that gap from day one instead of repeating it.
+      #
+      # `first`/`second` hold the two sides in their original left-to-right
+      # print order, each a real, independently-typed `::Pubid::Identifier`
+      # (never an attr_accessor — see IEEE's CsaDualPublished for the bug
+      # that pattern causes: to_hash/from_hash/#exclude silently drop it).
+      # Either side may be OIML; `#oiml_identifier`/`#external_identifier`
+      # pick the OIML-typed one out of the pair regardless of order.
+      class DualPublished < Identifier
+        attribute :first, ::Pubid::Identifier, polymorphic: true
+        attribute :second, ::Pubid::Identifier, polymorphic: true
+
+        # Declared locally (rather than left to the inherited default)
+        # because Oiml::Identifier's shared key_value block maps "language"
+        # and "parsed_format" to real attributes — without a local
+        # declaration here, to_hash/from_hash would call a getter/setter
+        # this class never defines. Mirrors SingleIdentifier/
+        # SupplementIdentifier, which do the same for the same reason.
+        attribute :language, :string
+        attribute :parsed_format, :string, default: -> { "short" }
+
+        key_value do
+          map "first", with: { to: :first_to_kv, from: :first_from_kv }
+          map "second", with: { to: :second_to_kv, from: :second_from_kv }
+        end
+
+        # Either side may belong to any flavor, so (de)serialization goes
+        # through the generic top-level Pubid.from_hash/#to_hash, not the
+        # OIML-scoped Identifier.from_hash (which only resolves OIML types).
+        def first_to_kv(model, doc)
+          value = model.first
+          return unless value
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("first", value.to_hash),
+          )
+        end
+
+        def first_from_kv(model, value)
+          model.first = ::Pubid.from_hash(value) if value
+        end
+
+        def second_to_kv(model, doc)
+          value = model.second
+          return unless value
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("second", value.to_hash),
+          )
+        end
+
+        def second_from_kv(model, value)
+          model.second = ::Pubid.from_hash(value) if value
+        end
+
+        # The member that belongs to THIS flavor, wherever print order put
+        # it. relaton-index sorts on this side's root.number.
+        def oiml_identifier
+          [first, second].find { |member| member.is_a?(Oiml::Identifier) }
+        end
+
+        # The other SDO's identifier for the same document.
+        def external_identifier
+          [first, second].find { |member| !member.is_a?(Oiml::Identifier) }
+        end
+
+        def root
+          oiml_identifier ? oiml_identifier.root : self
+        end
+
+        def code
+          oiml_identifier&.code
+        end
+
+        def type
+          oiml_identifier&.type
+        end
+
+        def stage
+          oiml_identifier&.stage
+        end
+
+        def iteration
+          oiml_identifier&.iteration
+        end
+
+        def publisher
+          oiml_identifier&.publisher
+        end
+
+        def mr_publisher
+          oiml_identifier&.mr_publisher
+        end
+
+        def mr_type
+          oiml_identifier&.mr_type
+        end
+
+        def mr_number_with_part
+          oiml_identifier&.mr_number_with_part
+        end
+
+        def mr_year
+          oiml_identifier&.mr_year
+        end
+
+        # Splits `identifier` on "|" and, if it looks like an OIML dual-
+        # published reference (exactly two non-empty sides, exactly one of
+        # which starts with an OIML prefix), parses each side through its
+        # own flavor and returns the wrapper. Returns nil for anything else,
+        # so the caller (Pubid::Oiml.parse) falls through to the ordinary
+        # grammar, which raises the standard Parslet::ParseFailed for a
+        # string containing "|" (the grammar defines no rule for it).
+        def self.build(identifier)
+          sides = split_sides(identifier)
+          return nil unless sides
+
+          left, right = parse_sides(*sides)
+          return nil unless left && right
+
+          new(first: left, second: right)
+        end
+
+        # Two non-empty, stripped sides, or nil if `identifier` isn't
+        # shaped like "A|B".
+        def self.split_sides(identifier)
+          parts = identifier.split("|").map(&:strip)
+          return nil unless parts.length == 2
+          return nil if parts.any?(&:empty?)
+
+          parts
+        end
+        private_class_method :split_sides
+
+        # Parses each side through its own flavor, provided exactly one side
+        # looks like OIML (by prefix, not position). [nil, nil] otherwise.
+        def self.parse_sides(left, right)
+          left_is_oiml = Oiml::PREFIXES.any? { |p| left.start_with?(p) }
+          right_is_oiml = Oiml::PREFIXES.any? { |p| right.start_with?(p) }
+          return [nil, nil] if left_is_oiml == right_is_oiml
+
+          [parse_side(left, oiml: left_is_oiml),
+           parse_side(right, oiml: right_is_oiml)]
+        end
+        private_class_method :parse_sides
+
+        def self.parse_side(str, oiml:)
+          oiml ? Oiml.parse(str) : ::Pubid.parse(str)
+        rescue Parslet::ParseFailed, Pubid::Errors::InvalidInputError
+          nil
+        end
+        private_class_method :parse_side
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -7,8 +7,10 @@ module Pubid
       autoload :Annex, "#{__dir__}/identifiers/annex"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
       autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :CertificationSystem, "#{__dir__}/identifiers/certification_system"
       autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Document, "#{__dir__}/identifiers/document"
+      autoload :DualPublished, "#{__dir__}/identifiers/dual_published"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
       autoload :Guide, "#{__dir__}/identifiers/guide"

data/lib/pubid/oiml/parser.rb

@@ -20,14 +20,17 @@ module Pubid
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
           annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | bulletin_identifier | base
+          trailing_supplement_identifier | cs_identifier |
+          bulletin_identifier | base
       end
 
       # Publisher - always "OIML"
       rule(:publisher) { str("OIML").as(:publisher) >> space }
 
-      # Document type - single letter
-      rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
+      # Document type - single letter. Strict family set: OIML publishes
+      # R D B G E V S documents (the estate grammar's family letters);
+      # any other letter is a rejection, not a flavor.
+      rule(:doc_type) { match("[BDEGRSV]").as(:type) >> space }
 
       # Bulletin locator — structured form. Year optionally followed by
       # 2-digit issue and 2-digit sequence:
@@ -122,9 +125,14 @@ module Pubid
         ).as(:edition_format) # Wrap entire match to capture that Edition was used
       end
 
-      # Date - year after colon OR edition portion (with optional space before year)
+      # Date - year after colon, the VIM's paren-year form ("OIML V 2-200
+      # (2000)" — space + (YYYY) instead of :YYYY, the shape #342 flags as
+      # the one real-world spelling that did not parse), OR edition portion
+      # (with optional space before year)
       rule(:date) do
-        edition_portion | (colon >> space.maybe >> year_digits.as(:year))
+        edition_portion |
+          (space.maybe >> colon >> space.maybe >> year_digits.as(:year)) |
+          (space.maybe >> lparen >> year_digits.as(:year) >> rparen)
       end
 
       # Draft stage - WD or CD with optional iteration
@@ -162,10 +170,22 @@ module Pubid
         match("[a-z]").repeat(2, 2) # Two letters: en, fr, etc.
       end
 
+      # Full-word language markers as OIML prints them ("(Fra)", "(Eng)"),
+      # three or more letters, any case. Kept verbatim on the identifier;
+      # the URN lowercases.
+      rule(:lang_word) do
+        match("[A-Za-z]").repeat(3)
+      end
+
       rule(:language_code) do
         (
           (lang_single >> slash >> lang_single) | # E/F
           lang_multi_oiml |                        # PO, PT, PE, SR
+          lang_word |                              # Fra, eng, rus — before
+                                                   # the letter rules: a
+                                                   # committed "F" of "(Fra)"
+                                                   # or "fr" of "(fra)" would
+                                                   # never fall through
           lang_single |                            # E, F, D, R, S, C, A, U, X
           lang_multi                               # en, fr
         ).as(:language)
@@ -211,9 +231,25 @@ module Pubid
       rule(:trailing_supplement_identifier) do
         base_without_language.as(:base) >>
           space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
+          (space >> digits.as(:number)).maybe >>
           language_portion.maybe.as(:language)
       end
 
+      # OIML-CS certification-system documents. Two head spellings
+      # ("OIML-CS" / "OIML CS") and two family-number separators
+      # ("PD-05" / "PD 05"), an "Edition N" instead of a year, and an
+      # optional parenthesized trailing amendment - "(Amendment 1)".
+      rule(:cs_identifier) do
+        str("OIML").as(:publisher) >>
+          (dash >> str("CS") | space >> str("CS")).as(:cs_series) >> space >>
+          (str("PD") | str("OD") | str("CID")).as(:cs_family) >>
+          (dash | space).as(:cs_separator) >>
+          digits.as(:number) >>
+          space >> str("Edition") >> space >> digits.as(:edition) >>
+          (space >> lparen >> str("Amendment") >> space >>
+            digits.as(:cs_amendment) >> rparen).maybe
+      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").

data/lib/pubid/oiml/renderer.rb

@@ -18,10 +18,14 @@ module Pubid
         @context = context
 
         case id
+        when Identifiers::DualPublished
+          render_dual_published(id)
         when Identifiers::Annex
           render_annex(id)
         when Identifiers::Bulletin
           render_bulletin(id)
+        when Identifiers::CertificationSystem
+          render_cs(id)
         when SupplementIdentifier
           render_supplement(id)
         when SingleIdentifier
@@ -33,6 +37,16 @@ module Pubid
 
       private
 
+      # Certification-system document: "OIML-CS PD-05 Edition 6 (Amendment 1)".
+      # The family-number separator keeps the parsed spelling; OIML CS
+      # documents state an edition instead of a year.
+      def render_cs(id)
+        result = "#{id.publisher}-CS #{id.family}" \
+                 "#{id.space_separator ? ' ' : '-'}#{id.number} Edition #{id.edition}"
+        result += " (Amendment #{id.amendment})" if id.amendment
+        result
+      end
+
       # Render the Bulletin in the requested or parsed form. Default is the
       # structured "YYYY-II-SS" form (the dataset's primary docid). The
       # citation form ("LXVII(2) 20260211") is emitted when the user asks
@@ -65,7 +79,7 @@ module Pubid
         result = "#{id.publisher} Bulletin"
         if id.date&.year
           result += " #{id.date.year}"
-          result += "-#{id.issue}" if id.issue
+          result += "-#{id.number}" if id.number
           result += "-#{id.sequence}" if id.sequence
         end
         result += " (#{id.language})" if id.language
@@ -77,9 +91,9 @@ module Pubid
       # structured since OIML's citation format doesn't define volume-only
       # or issue-only variants.
       def render_bulletin_citation(id)
-        return render_bulletin_structured(id) unless id.date&.year && id.issue && id.sequence
+        return render_bulletin_structured(id) unless id.date&.year && id.number && id.sequence
 
-        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.issue.to_i}) #{id.article_id}"
+        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.number.to_i}) #{id.article_id}"
       end
 
       def effective_format(id)
@@ -93,6 +107,12 @@ module Pubid
         str.sub(/\s*\([^)]+\)\s*$/, "").strip
       end
 
+      # Bare "|", original left-to-right print order, e.g.
+      # "ISO 4064-1:2024|OIML R 49-1:2024".
+      def render_dual_published(id)
+        "#{id.first}|#{id.second}"
+      end
+
       def render_single(id)
         format = effective_format(id)
 
@@ -147,10 +167,12 @@ module Pubid
 
         # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
         # publication year kept on the base identifier. The word comes from the
-        # concrete supplement class.
+        # concrete supplement class; an ordinal, when printed ("Amendment 1"),
+        # follows it.
         if id.trailing
           base_str = strip_language(id.base.to_s)
           result = "#{base_str} #{id.supplement_type}"
+          result += " #{id.number}" if id.number
           result += " (#{id.language})" if id.language
           return result
         end

data/lib/pubid/oiml/single_identifier.rb

@@ -14,6 +14,10 @@ module Pubid
         "short"
       } # Track parsed format
 
+      # A nil `language` means the document states none: `OIML R 126:2015
+      # Errata` is not `OIML R 126:2015 Errata (E)`, its English edition.
+      subset_strict :language
+
       # Serialization delta on top of Oiml::Identifier's shared block. The
       # `date` (year) component is flattened to a top-level key rather than a
       # nested hash, mirroring ISO (lib/pubid/iso/identifier.rb). `type` is
@@ -24,7 +28,7 @@ module Pubid
       # concrete leaf, because redefining the inherited `number` on this class
       # — which every leaf inherits — is the multi-flavor determinism landmine.
       # Keeping the mapping with the attribute is also what lets Bulletin, the
-      # one leaf with no code, omit both.
+      # one leaf with no code, declare its own `number` (the issue) and map it.
       key_value do
         map "publisher", to: :publisher
         map "year", with: { to: :year_to_kv, from: :year_from_kv }

data/lib/pubid/oiml/supplement_identifier.rb

@@ -7,8 +7,14 @@ module Pubid
       # These wrap a base identifier like ISO amendments
       attribute :base, Oiml::Identifier, polymorphic: true
       attribute :year, :string
+      # Ordinal of the trailing-word form ("OIML R 138:2009 Amendment 1").
+      attribute :number, :string
       attribute :language, :string
 
+      # A nil `language` means the document states none, mirroring
+      # SingleIdentifier's rule.
+      subset_strict :language
+
       # Delegate the document code to the wrapped standard, mirroring
       # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
       #
@@ -54,6 +60,7 @@ module Pubid
         map "base",
             with: { to: :base_to_kv, from: :base_from_kv }
         map "year", to: :year
+        map "number", to: :number
         map "trailing", to: :trailing
         map "joined", to: :joined
       end

data/lib/pubid/oiml/urn_generator.rb

@@ -27,6 +27,25 @@ module Pubid
         identifier.language&.to_s&.downcase
       end
 
+      # DualPublished declares no `date` attribute of its own (it lives on
+      # whichever side is OIML), so the shared Base#urn_year — which gates
+      # on `identifier.class.attributes.key?(:date)` — would silently drop
+      # the year. Read it through the OIML side instead.
+      def urn_year
+        if identifier.is_a?(Identifiers::DualPublished)
+          oiml_date = identifier.oiml_identifier&.date
+          return oiml_date&.year&.to_s
+        end
+
+        year = super
+        return year if year
+
+        # The trailing-word form keeps the publication year on the base
+        # ("R 138:2009 Amendment 1"); the supplement itself carries only the
+        # ordinal.
+        identifier.base&.date&.year&.to_s if identifier.is_a?(SupplementIdentifier)
+      end
+
       def generate
         # Bulletin issues carry no code; the (year, issue, sequence) tuple
         # is the locator. URNs are canonical regardless of how the input was
@@ -39,6 +58,15 @@ module Pubid
           return parts.join(":")
         end
 
+        # Certification-system documents: the family-number pair is the
+        # document identity ("cs:pd-05"); the printed edition and trailing
+        # amendment are print states, not URN segments.
+        if identifier.is_a?(Identifiers::CertificationSystem)
+          parts = ["urn", "oiml", "cs",
+                   "#{identifier.family.downcase}-#{identifier.number}"]
+          return parts.join(":")
+        end
+
         parts = ["urn", "oiml"]
         parts << urn_type
         parts << urn_number if urn_number
@@ -64,12 +92,12 @@ module Pubid
       end
 
       # Structured locator "YYYY-II-SS" (or "YYYY-II" / "YYYY") for a Bulletin.
-      # Built directly from the date year and the issue/sequence attributes so
-      # the URN is identical regardless of whether the input was the structured
-      # or citation form.
+      # Built directly from the date year and the number (the issue) and
+      # sequence attributes so the URN is identical regardless of whether the
+      # input was the structured or citation form.
       def bulletin_locator
         locator = identifier.date.year.to_s
-        locator += "-#{identifier.issue}" if identifier.issue
+        locator += "-#{identifier.number}" if identifier.number
         locator += "-#{identifier.sequence}" if identifier.sequence
         locator
       end

data/lib/pubid/oiml.rb

@@ -29,6 +29,11 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
+      if identifier.include?("|")
+        dual = Identifiers::DualPublished.build(identifier)
+        return dual if dual
+      end
+
       parser = Parser.new
       builder = Builder.new