pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/ccsds/identifiers/corrigendum.rb

@@ -24,9 +24,9 @@ module Pubid
         # The corrigendum sequence number is stored in the inherited `number`
         # attribute (mirroring ISO), so it serializes via Base's key_value as
         # { _type, number: '1', base: {...} } with no corrigendum-specific map.
-        def to_s
+        def to_s(**opts)
           base_str = base.to_s
-          "#{base_str} Cor. #{number}"
+          annotate_plain_render("#{base_str} Cor. #{number}", **opts)
         end
 
         def ==(other)

data/lib/pubid/ccsds/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Ccsds
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:alnum) { match["A-Za-z0-9"] }

data/lib/pubid/ccsds/single_identifier.rb

@@ -9,17 +9,21 @@ module Pubid
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "CCSDS")
       }
-      attribute :series, Components::Code
-      attribute :number, Components::Code
-      attribute :part, Components::Code
-      attribute :book_color, Components::Code
+      # Plain :string, like the live Pubid::Ccsds::Identifier hierarchy, which
+      # already declared these as strings. This class is otherwise
+      # unreferenced — nothing inherits it and no builder instantiates it — but
+      # it is public API, so it is retyped rather than deleted.
+      attribute :series, :string
+      attribute :number, :string
+      attribute :part, :string
+      attribute :book_color, :string
       attribute :edition, Components::Edition
       attribute :retired, :boolean, default: -> { false }
       attribute :language, Components::Language
       attribute :type, Components::Type
       attribute :typed_stage, Components::TypedStage
 
-      def to_s(lang: :en, lang_single: false)
+      def to_s(lang: :en, lang_single: false, **opts)
         result = ""
 
         # Publisher
@@ -29,14 +33,14 @@ module Pubid
         result += " "
 
         # Series (optional single letter before number)
-        result += series.value if series
+        result += series.to_s if series
 
         # Number with part (using dot notation)
-        result += number.value
-        result += ".#{part.value}" if part
+        result += number.to_s
+        result += ".#{part}" if part
 
         # Book color (required) - no space before dash
-        result += "-#{book_color.value}" if book_color
+        result += "-#{book_color}" if book_color
 
         # Edition (optional)
         result += "-#{edition.number}" if edition
@@ -47,18 +51,18 @@ module Pubid
         # Language (optional)
         result += " - #{language.code} Translated" if language
 
-        result
+        annotate_plain_render(result, **opts)
       end
 
       def <=>(other)
         return nil unless other.is_a?(SingleIdentifier)
 
         # Compare by number first
-        num_cmp = number.value.to_i <=> other.number.value.to_i
+        num_cmp = number.to_i <=> other.number.to_i
         return num_cmp unless num_cmp.zero?
 
         # Then by part
-        part_cmp = (part ? part.value.to_i : 0) <=> (other.part ? other.part.value.to_i : 0)
+        part_cmp = part.to_i <=> other.part.to_i
         return part_cmp unless part_cmp.zero?
 
         # Then by edition

data/lib/pubid/ccsds.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ccsds
     extend Pubid::PrefixesSupport

data/lib/pubid/cen_cenelec/builder.rb

@@ -18,6 +18,28 @@ module Pubid
           return build_fragment_identifier(data)
         end
 
+        # Every base document (an adopted norm, an ENV adoption, a plain
+        # identifier) goes through the same supplement wrapping. The adopted
+        # branches used to return early, so "CEN ISO/TS 21003-7:2008/A1:2010"
+        # lost its "/A1:2010".
+        base = build_base_document(data)
+
+        # A slash separator makes a standalone amendment/corrigendum; a plus
+        # separator makes a consolidated (bundled) identifier.
+        if has_slash_supplements?(data)
+          build_standalone_supplement(base, data)
+        elsif (supplements_data = extract_supplements(data)).any?
+          wrap_with_consolidated(base, supplements_data)
+        else
+          base
+        end
+      end
+
+      private
+
+      # The document that the supplements of +data+ apply to, or the whole
+      # identifier when there are no supplements.
+      def build_base_document(data)
         # Check if this is an adopted identifier (EN ISO, EN IEC, etc.)
         if data[:adopted_string]
           # Special case: ENV can adopt ISO/IEC standards
@@ -28,11 +50,6 @@ module Pubid
           return build_adopted_identifier(data)
         end
 
-        # Check if this is a standalone amendment/corrigendum (slash separator)
-        if has_slash_supplements?(data)
-          return build_standalone_supplement(data)
-        end
-
         # Implicit adoption: when an EN has no explicit "IEC" prefix but
         # the number falls in the IEC range (60000-79999), treat it as an
         # adoption of the corresponding IEC standard. The lower ISO-only
@@ -42,29 +59,32 @@ module Pubid
         # can still write "EN ISO 12345".
         # (https://github.com/pubid/pubid/issues/249)
         # Skip when parts are present — they would be lost when we rebuild
-        # the identifier from just the base number.
-        if data[:publisher]&.to_s == "EN" && !data[:adopted_string] &&
-           data[:parts].to_a.empty? &&
-           (adopted = build_implicit_adoption(data))
+        # the identifier from just the base number — and when supplements
+        # are present, which the adoption used to drop the same way.
+        if data[:publisher]&.to_s == "EN" && data[:parts].to_a.empty? &&
+            !supplements?(data) &&
+            (adopted = build_implicit_adoption(data))
           return adopted
         end
 
-        # Extract supplements before building base identifier (only plus/bundled)
-        supplements_data = extract_supplements(data)
-
         # Determine identifier class using the module's lookup helpers
-        identifier = locate_identifier_klass(data).new
-        assign_attributes(identifier, data)
+        base_data = data.except(:supplements)
+        identifier = locate_identifier_klass(base_data).new
+        assign_attributes(identifier, base_data)
+        identifier
+      end
 
-        # Wrap with consolidated if supplements present (plus/bundled only)
-        if supplements_data.any?
-          wrap_with_consolidated(identifier, supplements_data)
-        else
-          identifier
-        end
+      def supplements?(data)
+        has_slash_supplements?(data) || extract_supplements(data).any?
       end
 
-      private
+      # A number or month the grammar captured as an empty string is stored
+      # as nil: `to_hash` drops an empty string, so from_hash would give nil
+      # and the two identifiers would not be `==`.
+      def present_string(value)
+        str = value&.to_s
+        str unless str.nil? || str.empty?
+      end
 
       def build_fragment_identifier(data)
         # Build base identifier first (without amendment/fragment)
@@ -78,13 +98,13 @@ module Pubid
         # Build Amendment identifier wrapping the base
         amendment = Identifiers::Amendment.new(
           base: base,
-          amendment_number: data[:amendment_number].to_s,
+          number: data[:amendment_number].to_s,
         )
 
         # Build Fragment wrapping the amendment
         Identifiers::Fragment.new(
           base: amendment,
-          fragment_number: data[:fragment_number].to_s,
+          number: data[:fragment_number].to_s,
         )
       end
 
@@ -94,7 +114,7 @@ module Pubid
 
         # Check if publisher is actually a type code (CWA, HD, ES, CR, ENV act as publisher)
         publisher_str = parsed_hash[:publisher].to_s
-        if %w[CWA HD ES CR ENV].include?(publisher_str)
+        if CenCenelec::PUBLISHER_TYPES.include?(publisher_str)
           typed_stage = CenCenelec.locate_stage(publisher_str)
           if (klass = CenCenelec.locate_type(typed_stage.type_code))
             return klass
@@ -132,7 +152,7 @@ module Pubid
           end
 
         when :number
-          Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :parts
           # Extract first part, preserve full multi-level part string
@@ -142,11 +162,11 @@ module Pubid
             part_str = parts_array.first[:part].to_s
 
             # Store the full part value for multi-level parts
-            { part: Components::Code.new(value: part_str) }
+            { part: part_str }
           end
 
         when :part
-          Components::Code.new(value: value[:part].to_s) if value.is_a?(Hash)
+          value[:part].to_s if value.is_a?(Hash)
 
         when :year, :date
           # Check if month is present in the data and include it
@@ -202,30 +222,43 @@ module Pubid
                        nil
                      end
 
-        # Build publishers array (EN is default for adoptions)
-        publishers = []
-        publishers << data[:publisher].to_s if data[:publisher]
-
-        # Handle copublishers array
-        if data[:copublishers]
-          Array(data[:copublishers]).each do |copub|
-            publishers << copub[:copublisher].to_s
+        # The publisher is a Components::Publisher (EN is the default for
+        # adoptions); a second publisher ("CEN/CLC") is a copublisher.
+        copublishers = if data[:copublishers]
+                         Array(data[:copublishers]).map do |copub|
+                           copub[:copublisher].to_s
+                         end
+                       elsif data[:copublisher]
+                         [data[:copublisher].to_s]
+                       else
+                         []
+                       end
+
+        attrs = { adopted: adopted_id }
+        # "prEN ISO 1234:2020": the draft stage is on the CEN adoption. The
+        # parser captures it as type_with_stage and not as a publisher, and
+        # it used to be dropped here, so the identifier rendered as "EN ISO".
+        if data[:type_with_stage]
+          attrs.merge!(cast(:type_with_stage, data[:type_with_stage]))
+        end
+        if data[:publisher]
+          attrs[:publisher] =
+            Components::Publisher.new(body: data[:publisher].to_s)
+        end
+        # Only when present: an empty collection would not survive to_hash,
+        # and from_hash would then give nil where the parse gave [].
+        unless copublishers.empty?
+          attrs[:copublishers] = copublishers.map do |body|
+            Components::Publisher.new(body: body)
           end
-        elsif data[:copublisher]
-          publishers << data[:copublisher].to_s
         end
 
-        publishers = ["EN"] if publishers.empty?
-
-        Identifiers::AdoptedEuropeanNorm.new(
-          publisher: publishers,
-          adopted_identifier: adopted_id,
-        )
+        Identifiers::AdoptedEuropeanNorm.new(**attrs)
       end
 
       # Implicit adoption by number range. Returns an AdoptedEuropeanNorm
       # wrapping the IEC identifier that the EN number implies, or nil if the
-      # number doesn't fall in the IEC range. Limited to IEC range only —
+      # number does not fall in the IEC range. Limited to IEC range only —
       # see the call site comment for why the ISO range is excluded.
       def build_implicit_adoption(data)
         number = data[:number].to_s
@@ -235,9 +268,9 @@ module Pubid
         num = num_str.to_i
         return nil unless (60_000..79_999).cover?(num)
 
+        # The publisher is the "EN" default.
         Identifiers::AdoptedEuropeanNorm.new(
-          publisher: ["EN"],
-          adopted_identifier: Pubid::Iec.parse("IEC #{num_str}"),
+          adopted: Pubid::Iec.parse("IEC #{num_str}"),
         )
       end
 
@@ -254,27 +287,30 @@ module Pubid
                        Pubid::Iec.parse(adopted_str)
                      end
 
+        # The publisher is ENV, as for a plain "ENV 1613:1995"; the
+        # SingleIdentifier default is EN.
         Identifiers::EuropeanPrestandard.new(
-          adopted_identifier: adopted_id,
+          publisher: Components::Publisher.new(body: "ENV"),
+          adopted: adopted_id,
         )
       end
 
+      # The members after the first carry no `base`: the consolidated
+      # identifier holds the base document once, as its first member. With a
+      # `base` in each member, `to_hash` wrote the base again for every "+".
       def wrap_with_consolidated(base, supplements_data)
         supplement_ids = supplements_data.map do |supp|
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base: base,
-              amendment_number: supp[:number],
-              amendment_year: supp[:year]&.to_i,
+              number: present_string(supp[:number]),
+              year: present_string(supp[:year]),
             )
           else
-            corr_attrs = {
-              base: base,
-              corrigendum_number: supp[:number],
-              corrigendum_year: supp[:year]&.to_i,
-            }
-            corr_attrs[:corrigendum_month] = supp[:month] if supp[:month]
-            Identifiers::Corrigendum.new(**corr_attrs)
+            Identifiers::Corrigendum.new(
+              number: present_string(supp[:number]),
+              year: present_string(supp[:year]),
+              month: present_string(supp[:month]),
+            )
           end
         end
 
@@ -324,13 +360,7 @@ module Pubid
         end
       end
 
-      def build_standalone_supplement(data)
-        # Build base identifier first (without supplements)
-        base_data = data.dup
-        base_data.delete(:supplements)
-        base = locate_identifier_klass(base_data).new
-        assign_attributes(base, base_data)
-
+      def build_standalone_supplement(base, data)
         # Get the first supplement (slash means only one supplement)
         supp_array = data[:supplements]
         supp_data = supp_array.first
@@ -340,21 +370,16 @@ module Pubid
         if supp_data[:amd_number]
           Identifiers::Amendment.new(
             base: base,
-            amendment_number: supp_data[:amd_number].to_s,
-            amendment_year: supp_data[:amd_year]&.to_i,
+            number: supp_data[:amd_number].to_s,
+            year: present_string(supp_data[:amd_year]),
           )
         else
-          corr_attrs = {
+          Identifiers::Corrigendum.new(
             base: base,
-            corrigendum_number: supp_data[:cor_number]&.to_s,
-            corrigendum_year: (supp_data[:cor_year] || supp_data[:year])&.to_i,
-          }
-          month_val = supp_data[:month]&.to_s
-          if month_val && !month_val.empty?
-            corr_attrs[:corrigendum_month] =
-              month_val
-          end
-          Identifiers::Corrigendum.new(**corr_attrs)
+            number: present_string(supp_data[:cor_number]),
+            year: present_string(supp_data[:year]),
+            month: present_string(supp_data[:month]),
+          )
         end
       end
     end

data/lib/pubid/cen_cenelec/identifier.rb

@@ -8,15 +8,127 @@ module Pubid
     # CEN/CENELEC identifier `is_a?(Pubid::CenCenelec::Identifier)` natively (and
     # giving them the shared polymorphic `from_hash`). No facade needed.
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: CEN/CENELEC stores a bare string in every one of them.
+      # This class is the shared parent of BOTH branches, so one declaration
+      # here replaces the three that used to disagree (Identifiers::Base said
+      # :string, SingleIdentifier inherited Code, SupplementIdentifier declared
+      # Code again). Declaring here is safe because this body lives in one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
+      # The publisher serializes as a bare string ("publisher" => "CEN"), and
+      # the copublishers as a list of strings. The shared table does not do
+      # this for every flavor, because IEEE has a published index whose rows
+      # hold the nested {"body" => …} form.
+      def self.flat_scalar_components
+        super.merge(publisher: "publisher", copublishers: "copublishers")
+      end
+
+      def self.flat_scalar_fields
+        super.merge(publisher: :body, copublishers: :body)
+      end
+
+      # A draft stage serializes as its typed-stage code ("stage" => "pren"),
+      # as ISO ("dis") and IEC ("cd") do. The `type`, `stage` and
+      # `typed_stage` components all repeat one entry of the stage registry,
+      # so the code is enough, and #inflate_scalar_components rebuilds the
+      # three from it. The short form is written only when the three are
+      # exactly what the registry entry gives; any other combination keeps
+      # the nested components, so the round trip stays exact.
+      def self.compact_hash(model, hash)
+        stage = model.typed_stage
+        return unless stage && hash.key?("typed_stage")
+        return unless model.type == stage.to_type &&
+          model.stage == stage.to_stage
+
+        hash.delete("type")
+        hash.delete("typed_stage")
+        hash["stage"] = stage.code.to_s
+      end
+
+      # Reads the short stage form back; see #compact_hash. The nested form
+      # still reads as before.
+      def self.inflate_scalar_components(data)
+        data = super
+        return data unless data.is_a?(::Hash) && component_attribute?(:stage)
+
+        key = data.key?("stage") ? "stage" : :stage
+        value = data[key]
+        return data unless value.is_a?(::String) || value.is_a?(::Symbol)
+
+        stage = CenCenelec.locate_stage_by_code(value)
+        return data unless stage
+
+        data = data.dup
+        data.delete(key)
+        data["type"] = stage.to_type.to_hash
+        data["stage"] = stage.to_stage.to_hash
+        data["typed_stage"] = stage.to_hash
+        data
+      end
+
+      # The slug names a draft stage by its code ("en.pren.1234.2020"), so a
+      # prEN, an FprEN and an EN with one number and year get three slugs.
+      # The shared hook gave the type code "en" for all of them.
+      def mr_type
+        stage = typed_stage
+        return super unless stage && stage.stage_code.to_s != "published"
+
+        stage.code.to_s.downcase
+      end
+
+      # The attributes that hold a supplement's own date: `year`, and `month`
+      # on a corrigendum. Empty for a document. See #exclude.
+      def self.supplement_date_attributes
+        []
+      end
+
+      # The CEN year rule, as in BSI: `:year` removes only the base
+      # document's year ("EN 13250:2000/A1:2005" -> "EN 13250/A1:2005"), and
+      # the CEN key `:supplement_year` removes the supplement's own date
+      # ("EN 13250:2000/A1"). A supplement declares its date as a `year`
+      # attribute, which the base #exclude resets for `:year`, so the value is
+      # put back here. The month goes with the year, or a "/AC:2016-11" would
+      # keep a month with no year. The base #exclude passes every key on to
+      # the nested identifiers, so the members of a consolidated identifier
+      # follow the same rule.
+      def exclude(*args)
+        result = super
+        attrs = self.class.supplement_date_attributes
+        # `exclude(:amendment)` returns the base document, not a copy of self.
+        return result if attrs.empty? || !result.instance_of?(self.class)
+
+        drop = args.include?(:supplement_year)
+        attrs.each do |attr|
+          result.public_send(:"#{attr}=", drop ? nil : public_send(attr))
+        end
+        result
+      end
+
       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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.new.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
+      end
+
+      private
+
+      # "amd.1.2005" from ("amd", "1", 2005). A nil or blank segment is left
+      # out, so an unnumbered "/AC:2003" gives "cor.2003", not "cor..2003".
+      def mr_join_segments(*segments)
+        segments.map(&:to_s).reject(&:empty?).join(".").downcase
       end
     end
   end

data/lib/pubid/cen_cenelec/identifiers/adopted_european_norm.rb

@@ -5,8 +5,15 @@ module Pubid
     module Identifiers
       # AdoptedEuropeanNorm wraps ISO/IEC identifiers
       # Example: "EN ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
+      #
+      # `publisher` is the inherited Components::Publisher ("EN", "CEN",
+      # "CR", "HD"); a second publisher goes in `copublishers`. It used to be
+      # an Array of Strings in that Components::Publisher attribute, so
+      # `to_hash` raised on every adopted norm.
       class AdoptedEuropeanNorm < EuropeanNorm
-        attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC/IEEE object
+        # Typed to the root class: the adopted document is an ISO or IEC
+        # identifier, never a CEN one.
+        attribute :adopted, ::Pubid::Identifier, polymorphic: true
 
         # Override self.type to return nil so that AdoptedEuropeanNorm is NOT
         # registered as a type in CenCenelec.identifier_types. The class is a
@@ -19,25 +26,29 @@ module Pubid
           nil
         end
 
-        # Delegate common methods to adopted identifier
-        def number
-          adopted_identifier&.number
+        # Walk to the adopted document for the relaton-index key.
+        #
+        # This replaces reader methods named number, year, date, parts and
+        # part that delegated to the adopted document. `number`, `date` and
+        # `part` are lutaml attributes, so the serializer read the ISO values
+        # through them and wrote them again at the top level of the hash.
+        # `#root` is the documented wrapper shape (EuropeanPrestandard,
+        # ConsolidatedIdentifier).
+        def root
+          adopted ? adopted.root : self
         end
 
-        def year
-          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        # MR "cen.iso.ts.21003-7.2019": the CEN publisher ("cen" or
+        # "cen-clc"), then the adopted document's own MR string in place of a
+        # number. These are hooks and not a `to_mr_string` override, so the
+        # MR of an amendment on this norm renders its base the same way.
+        def mr_publisher
+          mr_join(*([publisher] + Array(copublishers)).compact
+            .map { |p| p.to_s.downcase })
         end
 
-        def date
-          adopted_identifier&.date if adopted_identifier&.methods&.include?(:date)
-        end
-
-        def parts
-          adopted_identifier&.parts if adopted_identifier&.methods&.include?(:parts)
-        end
-
-        def part
-          adopted_identifier&.part if adopted_identifier&.methods&.include?(:part)
+        def mr_number_with_part
+          adopted&.to_mr_string
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/amendment.rb

@@ -5,13 +5,53 @@ module Pubid
     module Identifiers
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
-      class Amendment < Base
-        attribute :base, Base, polymorphic: true
-        attribute :amendment_number, :string
-        attribute :amendment_year, :integer
+      #
+      # It descends from the shared Pubid::CenCenelec::Identifier, not from
+      # the legacy Identifiers::Base. That class declares publisher, year and
+      # parts attributes that an amendment does not have, and its `==` compared
+      # only those, so any two amendments were equal.
+      #
+      # The amendment number is the inherited `number`, and its year is a
+      # `year` string, so the hash uses the same keys as a document:
+      # {"base" => {…}, "number" => "1", "year" => "2005"}. The member of a
+      # consolidated identifier has no `base`; the consolidated identifier
+      # holds the base document once.
+      class Amendment < Pubid::CenCenelec::Identifier
+        # Typed to the shared parent: the base of an amendment is a
+        # SingleIdentifier ("EN 13250:2000"), an adopted norm
+        # ("CEN ISO/TS 21003-7:2008") or another supplement.
+        attribute :base, Pubid::CenCenelec::Identifier, polymorphic: true
+        attribute :year, :string
 
-        def publisher
-          base&.publisher
+        def self.supplement_date_attributes
+          %i[year]
+        end
+
+        def base_document
+          base&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base || self
+        end
+
+        # Uniform supplement interface (shared with Corrigendum and with BSI)
+        # so callers need not special-case the class.
+        def supplement_type
+          :amendment
+        end
+
+        def supplement_number
+          number
+        end
+
+        def supplement_year
+          year
+        end
+
+        def mr_supplement_suffix
+          mr_join_segments("amd", number, year)
         end
       end
     end