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

data/lib/pubid/oiml/single_identifier.rb

@@ -5,6 +5,7 @@ module Pubid
     class SingleIdentifier < Identifier
       # Base class for OIML single identifiers (non-supplements)
       attribute :publisher, :string
+      attribute :code, Oiml::Components::Code
       attribute :date, Pubid::Components::Date
       attribute :edition, :string
       attribute :stage, :string
@@ -14,49 +15,56 @@ module Pubid
         "short"
       } # Track parsed format
 
-      # 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
-      # intentionally omitted (recomputed from the class on load).
-      #
-      # The code columns (number/part/subpart/suffix/space_suffix) are NOT
-      # here: they are declared, and mapped, by Identifiers::CodeNumber on each
-      # 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.
-      key_value do
-        map "publisher", to: :publisher
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
-        map "edition", to: :edition
-        map "stage", to: :stage
-        map "iteration", to: :iteration
+      # Type is determined by the subclass
+      def type
+        type_string
       end
 
-      # --- date flattened to a top-level year ---
-      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
+      def to_s(format: nil)
+        # Use parsed format if not explicitly overridden
+        format ||= (parsed_format == "long" ? :long : :short)
 
-      def year_from_kv(model, value)
-        (model.date ||= Pubid::Components::Date.new).year = value.to_s
-      end
+        result = "#{publisher} #{type_string} #{code}"
 
-      def emit_kv(doc, key, value)
-        return if value.nil? || value.to_s.empty?
+        # Track if we're using Edition format for language spacing
+        using_edition_format = false
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
-      end
+        # Add edition/date portion
+        if edition && date
+          # Has edition number: "6th Edition 2015"
+          result += " #{edition} Edition #{date.year}"
+          using_edition_format = true
+        elsif edition
+          # Edition without year (shouldn't happen but handle it)
+          result += " #{edition}"
+          using_edition_format = true
+        elsif date
+          # Date without edition number
+          if format == :long
+            result += " Edition #{date.year}"
+            using_edition_format = true
+          else
+            result += ":#{date.year}"
+          end
+        end
 
-      attr_reader :requested_format
+        # Add draft stage if present (iteration + stage)
+        if stage || iteration
+          result += " "
+          result += iteration.to_s if iteration
+          result += stage.to_s if stage
+        end
 
-      # Type is determined by the subclass
-      def type
-        type_string
-      end
+        # Add language portion - depends on format
+        if language
+          result += if using_edition_format || parsed_format == "short_with_space"
+                      " (#{language})"
+                    else
+                      "(#{language})"
+                    end
+        end
 
-      def to_s(format: nil, **opts)
-        # Store requested format so the renderer can access it
-        @requested_format = format
-        render(format: :human, **opts)
+        result
       end
 
       def edition_portion
@@ -76,37 +84,6 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement type_string"
       end
 
-      # OIML keeps identity in the code columns and `type_string` (e.g. "R",
-      # "V", "D"), not in the inherited `typed_stage` — the generic MrString
-      # renderer would otherwise drop both and produce `OIML.<year>`.
-      # Losslessness for issue #142 requires the type letter and document
-      # number to appear in MR.
-      #
-      # Reads through `code`, which every code-bearing leaf composes from its
-      # split columns (Identifiers::CodeNumber); Bulletin has no code and
-      # returns nil here, keeping its (year, issue, sequence) slug.
-      def mr_number_with_part
-        segments = []
-        segments << code&.number&.to_s if code&.number
-        segments << code&.part&.to_s if code&.part
-        segments << code&.subpart&.to_s if code&.subpart
-        segments << code&.suffix&.to_s if code&.suffix
-        return nil if segments.empty?
-
-        segments.join("-")
-      end
-
-      # Bulletin overrides `code`; every other leaf gets it from
-      # Identifiers::CodeNumber. Returning nil here keeps #== , the renderer
-      # and the URN generator total for the abstract class itself.
-      def code
-        nil
-      end
-
-      def mr_type
-        type_string&.downcase
-      end
-
       # Subclasses override this
     end
   end

data/lib/pubid/oiml/supplement_identifier.rb

@@ -5,78 +5,33 @@ module Pubid
     class SupplementIdentifier < Identifier
       # Base class for OIML supplements (amendments, annexes)
       # These wrap a base identifier like ISO amendments
-      attribute :base, Oiml::Identifier, polymorphic: true
+      attribute :base_identifier, Oiml::Identifier
       attribute :year, :string
       attribute :language, :string
-
-      # Delegate the document code to the wrapped standard, mirroring
-      # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
-      #
-      # PRE-EXISTING BUG this closes: `UrnGenerator#urn_number` calls
-      # `identifier.code` for every non-Bulletin type, but a supplement
-      # descends from Oiml::Identifier directly — it is a SIBLING of
-      # SingleIdentifier, which is where `code` used to live — so it inherited
-      # no `code` at all and `to_urn` raised NoMethodError for every Amendment,
-      # Errata and Annex. Verified against a baseline captured on main: all
-      # five supplement fixtures already raised there, so this is a fix, not a
-      # regression introduced by the move to split index columns.
-      #
-      # It stayed hidden because spec/pubid/oiml/urn_spec.rb only exercises a
-      # bare Recommendation and spec/pubid/oiml/fixtures_spec.rb globs a bad
-      # path and runs 0 examples (hand-off: ten-dead-fixture-specs).
-      # `iteration` is the same story: declared on SingleIdentifier, read
-      # unconditionally by UrnGenerator#urn_iteration, absent from the
-      # supplement branch of the hierarchy. (`stage` escapes because
-      # ::Pubid::Identifier declares one, so it merely returns nil.)
-      def code
-        base&.code
-      end
-
-      def iteration
-        base&.iteration
-      end
-      # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
-      # where the supplement word is appended after a dated base instead of the
-      # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
-      # concrete class (#supplement_type), so only this flag is stored.
-      attribute :trailing, :boolean, default: false
-      # True for the plus-joined form ("OIML B 10:2011+Amendment:2012") where
-      # both the base and the supplement carry their own year, joined by "+".
-      attribute :joined, :boolean, default: false
       attribute :parsed_format, :string, default: -> {
         "short"
       } # Track supplement's parsed format
 
-      # Serialization delta on top of Oiml::Identifier's shared block. The
-      # nested base is (de)serialized recursively through the
-      # polymorphic router so its own `_type` selects the right subclass.
-      key_value do
-        map "base",
-            with: { to: :base_to_kv, from: :base_from_kv }
-        map "year", to: :year
-        map "trailing", to: :trailing
-        map "joined", to: :joined
-      end
-
-      def base_to_kv(model, doc)
-        base = model.base
-        return unless base
+      def to_s(format: :short)
+        # Determine base format: explicit parameter takes priority, else use parsed format
+        base_format = if format && format != :short
+                        format # Use explicit override
+                      elsif base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
 
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("base",
-                                                   base.to_hash),
-        )
-      end
+        # Render base with determined format (preserves Edition vs colon)
+        base_str = base_identifier.to_s(format: base_format)
+        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip # Remove language from base
 
-      def base_from_kv(model, value)
-        model.base = ::Pubid::Oiml::Identifier.from_hash(value) if value
-      end
+        result = "#{supplement_type} (#{year}) to #{base_str}"
 
-      attr_reader :requested_format
+        # Supplements ALWAYS add space before their language
+        result += " (#{language})" if language
 
-      def to_s(format: nil, **opts)
-        @requested_format = format
-        render(format: :human, **opts)
+        result
       end
 
       # Subclasses override this

data/lib/pubid/oiml/urn_generator.rb

@@ -15,6 +15,14 @@ module Pubid
         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
@@ -28,17 +36,6 @@ module Pubid
       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
-        # formatted, so we always emit the structured YYYY-II-SS form even
-        # when the identifier was parsed from a citation string.
-        if identifier.is_a?(Identifiers::Bulletin)
-          parts = ["urn", "oiml", "bulletin"]
-          parts << bulletin_locator if identifier.date&.present?
-          parts << urn_language if urn_language
-          return parts.join(":")
-        end
-
         parts = ["urn", "oiml"]
         parts << urn_type
         parts << urn_number if urn_number
@@ -62,17 +59,6 @@ module Pubid
 
         parts.join(":")
       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.
-      def bulletin_locator
-        locator = identifier.date.year.to_s
-        locator += "-#{identifier.issue}" if identifier.issue
-        locator += "-#{identifier.sequence}" if identifier.sequence
-        locator
-      end
     end
   end
 end

data/lib/pubid/oiml.rb

@@ -2,78 +2,23 @@
 
 module Pubid
   module Oiml
-    extend Pubid::PrefixesSupport
-
-    # Sole OIML publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["OIML"].freeze
-
     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 :Renderer, "#{__dir__}/oiml/renderer"
+    autoload :Scheme, "#{__dir__}/oiml/scheme"
     autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
-    autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     def self.parse(identifier)
-      unless identifier.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       parser = Parser.new
       builder = Builder.new
 
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Oiml::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
-        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
   end
 end
 

data/lib/pubid/parser.rb

@@ -2,7 +2,6 @@
 
 module Pubid
   module Parser
-    autoload :Grammar, "pubid/parser/grammar"
     autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
     autoload :CommonParseRules, "pubid/parser/common_parse_rules"
   end

data/lib/pubid/parsers/mr_string.rb

@@ -2,28 +2,6 @@
 
 module Pubid
   module Parsers
-    # Parses a machine-readable (MR) identifier string back into an Identifier.
-    #
-    # The MR format produced by `Renderers::MrString` mirrors the human form,
-    # lowercased and filename-safe:
-    #
-    #   iso.9001.2015                              → ISO 9001:2015
-    #   iso-iec.17031-1.2020                       → ISO/IEC 17031-1:2020
-    #   iso.1234-1-2-3.2020                        → ISO 1234-1-2-3:2020
-    #   iso.tr.14627.2017                          → ISO/TR 14627:2017
-    #   iso.16634.--                               → ISO 16634:--
-    #   iso.9001.2015_amd.1.2020                   → ISO 9001:2015/Amd 1:2020
-    #   iso-iec.13818-1.2015_amd.3.2016_cor.1.2017 → ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
-    #
-    # Copublishers join with `-` (`iso-iec`), supplements append with `_`
-    # (`iso.9001.2015_amd.1.2020`). Both round-trip back to `/` here. The
-    # flavor's own parser is case-insensitive on the type/publisher tokens
-    # we emit, so the lowercased slug re-parses cleanly.
-    #
-    # Note: NIST, CSA, IEEE, JIS, and SAE emit their own MR shapes that this
-    # parser does not attempt to reverse (their `to_s` already round-trips
-    # through the flavor's own parser, so callers should use that path for
-    # those flavors).
     class MrString < Base
       FLAVOR_MAP = {
         "ISO" => :iso,
@@ -81,14 +59,6 @@ module Pubid
         ccsds: :Ccsds,
       }.freeze
 
-      # Lower-case type codes the renderer emits as a separate MR segment
-      # (e.g. `iso.tr.14627`). When the parser sees one of these in the
-      # second position, it splits it back out as `/TYPE`.
-      TYPE_CODES = %w[
-        tr ts pas is amd cor suppl add ext guide spec
-        standard corrigendum amendment
-      ].freeze
-
       def self.parse(mr_string)
         flavor = detect_flavor(mr_string)
 
@@ -101,106 +71,23 @@ module Pubid
         raise ArgumentError, "Unknown flavor: #{flavor}" unless flavor_module
 
         identifier_string = convert_to_human_readable(mr_string)
-
-        # Refuse to hand the flavor a string this parser did not change.
-        #
-        # `detect_flavor` falls back to `:iso` for any publisher it does not
-        # know, and `Pubid::Iso.parse` sends an MR-shaped string straight back
-        # here — so a string that survives conversion unchanged recurses
-        # forever. `ECMA-426 ed1` is the standing example: "ECMA" is absent
-        # from FLAVOR_MAP, the string matches the MR shape heuristic
-        # (`/\A[A-Z]{2,}[.-]/`), and conversion is a fixed point.
-        # `Pubid::Iso.parse("ECMA-426 ed1")` raised SystemStackError.
-        #
-        # A fixed point means "this was never an MR string", which is a parse
-        # failure — the class the cross-flavor contract requires, and the one
-        # `Pubid.parse` treats as "try the next flavor".
-        if identifier_string == mr_string && flavor_module == Pubid::Iso
-          raise Parslet::ParseFailed,
-                "#{mr_string.inspect} is not an MR string"
-        end
-
         flavor_module.parse(identifier_string)
       end
 
       def self.detect_flavor(mr_string)
-        publisher = mr_string.split(/[._-]/).first.to_s.upcase
+        publisher = mr_string.split(".").first.upcase
         FLAVOR_MAP[publisher] || :iso
       end
 
-      # Convert the MR slug back to a human-readable identifier string the
-      # flavor's own parser will accept. Splits on `_` first so each segment
-      # (head + each supplement) is converted independently, then re-joined
-      # with `/`. Within the head, the copublisher separator `-` (first
-      # segment only) is restored to `/`.
       def self.convert_to_human_readable(mr_string)
-        head, *supplements = mr_string.split("_")
-        human = convert_head(head)
-        return human if supplements.empty?
-
-        supplements.inject(human) do |acc, supp|
-          "#{acc}/#{convert_supplement(supp)}"
+        parts = mr_string.split(".")
+        if parts.size > 2
+          year_part = parts.pop
+          parts.join(" ") + ":#{year_part}"
+        else
+          parts.join(" ")
         end
       end
-
-      # Converts a head segment like `iso-iec.13818-1.2015` to
-      # `ISO/IEC 13818-1:2015`.
-      def self.convert_head(head)
-        parts = head.split(".")
-        return parts.join(" ").upcase if parts.length <= 1
-
-        publisher, *rest = parts
-
-        # Optional type code segment (iso.tr.14627.2017 → ISO/TR 14627:2017).
-        type_segment = nil
-        if rest.first && TYPE_CODES.include?(rest.first.downcase)
-          type_segment = rest.shift.upcase
-        end
-
-        # Trailing language segment — bare language code(s) with no parens.
-        # Detect by length <= 5 and all-alpha (en, fr, en-fr, ru).
-        language_segment = nil
-        if rest.last&.match?(/\A[a-z]{2}(-[a-z]{2})*\z/)
-          language_segment = rest.pop
-        end
-
-        # Trailing year segment (may be `--` for undated, or YYYY[-MM[-DD]]).
-        year_segment = nil
-        if rest.any? && rest.last.match?(/\A(?:\d{4}(?:-\d{2}){0,2}|--)\z/)
-          year_segment = rest.pop
-        end
-
-        # Copublishers in the first segment: `iso-iec` → `ISO/IEC`. Multi-word
-        # publisher bodies (e.g. `cen-cenelec`) round-trip the same way.
-        publisher_part = publisher.split("-").map(&:upcase).join("/")
-        publisher_part = "#{publisher_part}/#{type_segment}" if type_segment
-
-        number_part = rest.join(" ")
-        result = publisher_part
-        result += " #{number_part}" unless number_part.empty?
-        result += ":#{year_segment}" if year_segment
-        if language_segment
-          langs = language_segment.split("-").join(",")
-          result += "(#{langs})"
-        end
-        result
-      end
-
-      # Converts a supplement segment like `amd.1.2020` to `Amd 1:2020`.
-      # The first token is the lowercase type code; remaining tokens are
-      # number and optional year.
-      def self.convert_supplement(supp)
-        tokens = supp.split(".")
-        type = tokens.shift&.upcase
-        year = tokens.last&.match?(/\A\d{4}\z/) ? tokens.pop : nil
-        number = tokens.join(" ")
-
-        result = type.to_s
-        result += " #{number}" unless number.empty?
-        result += ":#{year}" if year
-        result
-      end
     end
   end
 end
-

data/lib/pubid/plateau/builder.rb

@@ -9,7 +9,7 @@ module Pubid
 
       def build(parsed)
         # Check for annex supplement first
-        if parsed[:base] && parsed[:annex_letter]
+        if parsed[:base_identifier] && parsed[:annex_letter]
           return build_annex(parsed)
         end
 
@@ -29,11 +29,7 @@ module Pubid
         }
 
         params[:annex] = parsed[:annex].to_s.to_i if parsed[:annex]
-        # Only Handbook carries an edition; a legacy Latin TR captures the
-        # edition slice via the shared handbook rule, so drop it here.
-        if parsed[:edition] && klass == Identifiers::Handbook
-          params[:edition] = parsed[:edition].to_s
-        end
+        params[:edition] = parsed[:edition].to_s if parsed[:edition]
 
         klass.new(**params)
       end
@@ -42,10 +38,10 @@ module Pubid
 
       def build_annex(parsed)
         # Recursively parse base identifier
-        base = build(parsed[:base])
+        base = build(parsed[:base_identifier])
 
         Identifiers::Annex.new(
-          base: base,
+          base_identifier: base,
           letter: parsed[:annex_letter].to_s,
         )
       end

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

@@ -2,54 +2,50 @@
 
 module Pubid
   module Plateau
-    # Base class for all PLATEAU identifiers. Canonical name
-    # Pubid::Plateau::Identifier.
-    class Identifier < ::Pubid::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
-
-      attribute :number, :integer
-      attribute :annex, :integer, default: -> {}
-
-      # Stored as a plain string (always "PLATEAU") so it round-trips through
-      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
-      # serialize a String against the Components::Publisher attribute.
-      attribute :publisher, :string, default: -> { "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
+        # Subclasses must implement type_string
+        def type_string
+          raise NotImplementedError, "Subclasses must implement type_string"
+        end
 
-      def formatted_number
-        "#%02d" % number
-      end
+        def formatted_number
+          "#%02d" % number
+        end
 
-      def formatted_annex
-        annex ? "-#{annex}" : ""
-      end
+        def formatted_annex
+          annex ? "-#{annex}" : ""
+        end
 
-      def ==(other)
-        return false unless other.class == self.class
+        def ==(other)
+          return false unless other.class == self.class
 
-        number == other.number &&
-          annex == other.annex
-      end
+          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
+        # 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
-        hash[:annex] = annex if annex
-        hash
       end
     end
-
   end
 end