pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -4,14 +4,76 @@ module Pubid
   module CenCenelec
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        if identifier.is_a?(CenCenelec::SupplementIdentifier)
-          generate_supplement_urn
+        urn_for(identifier)
+      end
+
+      protected
+
+      # The URN of +id+, walking the wrapper structure:
+      #   EN 13250:2000/A1:2005    urn:cen:en:13250:2000:amd:1:2005
+      #   EN 285:2015+A1:2021      urn:cen:en:285:2015:plus:amd:1:2021
+      #   EN 60038 AMD1 FRAG2      urn:cen:en:60038:amd:1:frag:2
+      #   CEN ISO/TS 21003-7:2019  urn:cen:cen:iso:ts:21003-7:2019
+      #   ENV ISO 11079:1999       urn:cen:env:iso:11079:1999
+      #   prEN ISO 1234:2020       urn:cen:en:iso:1234:2020:stage.proposal
+      # The "plus" marker keeps a consolidated identifier apart from the
+      # standalone amendment with the same number and year.
+      def urn_for(id)
+        case id
+        when nil
+          "urn:cen"
+        when Identifiers::Amendment, Identifiers::Corrigendum,
+             Identifiers::Fragment
+          [urn_for(id.base), *supplement_segments(id)].join(":")
+        when Identifiers::ConsolidatedIdentifier
+          base, *supplements = id.identifiers
+          [urn_for(base), *supplements.flat_map do |s|
+            ["plus", *supplement_segments(s)]
+          end].join(":")
         else
-          generate_base_urn
+          if adoption?(id)
+            # The publisher, then the adopted document's MR string with its
+            # dot and underscore separators as colons, then a draft stage as
+            # the base URN writes it.
+            body = [id.mr_publisher, id.adopted&.to_mr_string]
+              .compact.reject(&:empty?).join(".").tr("._", "::")
+            ["urn:cen:#{body}", *stage_segment(id)].join(":")
+          else
+            self.class.new(id).generate_base_urn
+          end
         end
       end
 
-      protected
+      # "EN ISO 8601:2019" or "ENV ISO 11079:1999": the document identity is
+      # on the adopted ISO/IEC identifier, not on this one.
+      def adoption?(id)
+        id.is_a?(Identifiers::AdoptedEuropeanNorm) ||
+          (id.is_a?(Identifiers::EuropeanPrestandard) && id.adopted)
+      end
+
+      # ["stage.proposal"] for a draft stage, [] for a published document.
+      def stage_segment(id)
+        code = id.typed_stage&.stage_code
+        return [] if code.nil? || code.to_s == "published"
+
+        ["stage.#{code}"]
+      end
+
+      # The segments that a supplement adds to its base: type, number (none
+      # for an unnumbered "/AC"), then the date.
+      def supplement_segments(id)
+        segments = case id
+                   when Identifiers::Amendment
+                     ["amd", id.number, id.year]
+                   when Identifiers::Corrigendum
+                     ["cor", id.number, id.supplement_date]
+                   when Identifiers::Fragment
+                     ["frag", id.number]
+                   else
+                     []
+                   end
+        segments.map(&:to_s).reject(&:empty?)
+      end
 
       def generate_base_urn
         parts = ["urn", "cen"]
@@ -75,46 +137,6 @@ module Pubid
         parts.join(":")
       end
 
-      def generate_supplement_urn
-        parts = ["urn", "cen"]
-
-        base_id = maybe(:base_identifier)
-        if base_id
-          base_gen = self.class.new(base_id)
-          base_urn = base_gen.generate_base_urn
-
-          base_part = base_urn.sub(/^urn:cen:/, "")
-          base_parts = base_part.split(":")
-
-          parts.concat(base_parts)
-
-          typed_stage = maybe(:typed_stage)
-          if typed_stage
-            supp_type = typed_stage.type_code.to_s
-            parts << supp_type if supp_type
-          end
-
-          amendment_number = maybe(:amendment_number)
-          if amendment_number
-            parts << amendment_number.to_s
-          elsif identifier.number
-            number = identifier.number.to_s
-            parts << number
-          end
-
-          amendment_year = maybe(:amendment_year)
-          if amendment_year
-            parts << amendment_year.to_s
-          elsif identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-            parts << identifier.date.render(context: URN_CONTEXT)
-          end
-        else
-          parts << "unknown"
-        end
-
-        parts.join(":")
-      end
-
       def type_component
         typed_stage = maybe(:typed_stage)
         return nil unless typed_stage

data/lib/pubid/cen_cenelec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module CenCenelec
     extend Pubid::PrefixesSupport
@@ -9,130 +10,137 @@ module Pubid
     # are excluded — they route to their own SDOs, not to CEN.
     PREFIXES = %w[EN CEN CLC CWA HD ES CR ENV].freeze
 
+    # Publisher tokens that are also the document type. "CWA 14050" has no
+    # separate type token, so the builder picks the class from the publisher
+    # and the renderer prints the token once, not as "CWA/CWA 14050".
+    PUBLISHER_TYPES = %w[CWA HD ES CR ENV].freeze
+
     autoload :Builder, "#{__dir__}/cen_cenelec/builder"
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
     autoload :Renderer, "#{__dir__}/cen_cenelec/renderer"
     autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
-    autoload :SupplementIdentifier,
-             "#{__dir__}/cen_cenelec/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"
     autoload :UrnParser, "#{__dir__}/cen_cenelec/urn_parser"
 
     # TYPED_STAGES_REGISTRY for native CEN types
+    # Covers the CEN PROJEX stage-code table per issue #251.
     TYPED_STAGES_REGISTRY = [
-      # European Norm (EN)
+      # === European Norm (EN) lifecycle ===
+      # Preliminary (pWI EN): proposal/WI stages
       Pubid::Components::TypedStage.new(
-        code: :puben,
-        stage_code: :published,
-        type_code: :en,
-        abbr: ["EN"],
-        name: "European Norm",
-        harmonized_stages: %w[60.00 60.60],
+        code: :pwien, stage_code: :preliminary, type_code: :en,
+        abbr: ["pWI EN"], name: "Preliminary Work Item EN",
+        harmonized_stages: %w[00.60 10.98 10.99 20.60],
       ),
+      # Proposal (prEN): working draft stages
       Pubid::Components::TypedStage.new(
-        code: :pren,
-        stage_code: :proposal,
-        type_code: :en,
-        abbr: ["prEN"],
-        name: "Proposal European Norm",
-        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+        code: :pren, stage_code: :proposal, type_code: :en,
+        abbr: ["prEN"], name: "Proposal European Norm",
+        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.97 30.98 30.99],
+      ),
+      # Final Proposal (FprEN): enquiry stages
+      Pubid::Components::TypedStage.new(
+        code: :fpren, stage_code: :final_proposal, type_code: :en,
+        abbr: ["FprEN"], name: "Final Proposal European Norm",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.97 40.98 40.99],
+      ),
+      # Formal Vote (FV prEN): COCOR + FV dispatch
+      Pubid::Components::TypedStage.new(
+        code: :fven, stage_code: :formal_vote, type_code: :en,
+        abbr: ["FV prEN"], name: "Formal Vote EN",
+        harmonized_stages: %w[43.20 43.60 43.97 43.98 45.97 45.98 45.99],
+      ),
+      # Vote (vEN): enquiry/vote
+      Pubid::Components::TypedStage.new(
+        code: :ven, stage_code: :vote, type_code: :en,
+        abbr: ["vEN"], name: "Vote EN",
+        harmonized_stages: %w[50.20 50.60 50.97 50.98],
+      ),
+      # Published (EN): ratification + publication milestones
+      Pubid::Components::TypedStage.new(
+        code: :puben, stage_code: :published, type_code: :en,
+        abbr: ["EN"], name: "European Norm",
+        harmonized_stages: %w[60.00 60.55 60.60 65.31 65.51 65.62],
+      ),
+      # Review (rvEN): 2-year review
+      Pubid::Components::TypedStage.new(
+        code: :rven, stage_code: :review, type_code: :en,
+        abbr: ["rvEN"], name: "Review EN",
+        harmonized_stages: %w[90.00 90.20 90.60 90.92 90.93 90.98],
+      ),
+      # Reactivation (racEN)
+      Pubid::Components::TypedStage.new(
+        code: :racen, stage_code: :reactivation, type_code: :en,
+        abbr: ["racEN"], name: "Re-activated EN",
+        harmonized_stages: %w[96.60],
       ),
+      # Withdrawn (wdEN)
       Pubid::Components::TypedStage.new(
-        code: :fpren,
-        stage_code: :final_proposal,
-        type_code: :en,
-        abbr: ["FprEN"],
-        name: "Final Proposal European Norm",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+        code: :wden, stage_code: :withdrawn, type_code: :en,
+        abbr: ["wdEN"], name: "Withdrawn EN",
+        harmonized_stages: %w[99.60],
       ),
 
-      # Technical Specification (TS)
+      # === Technical Specification (TS) ===
       Pubid::Components::TypedStage.new(
-        code: :pubts,
-        stage_code: :published,
-        type_code: :ts,
-        abbr: ["TS"],
-        name: "Technical Specification",
+        code: :pubts, stage_code: :published, type_code: :ts,
+        abbr: ["TS"], name: "Technical Specification",
         harmonized_stages: %w[60.00 60.60],
       ),
       Pubid::Components::TypedStage.new(
-        code: :prts,
-        stage_code: :proposal,
-        type_code: :ts,
-        abbr: ["prTS"],
-        name: "Proposal Technical Specification",
+        code: :prts, stage_code: :proposal, type_code: :ts,
+        abbr: ["prTS"], name: "Proposal Technical Specification",
         harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
       ),
 
-      # Technical Report (TR)
+      # === Technical Report (TR) ===
       Pubid::Components::TypedStage.new(
-        code: :pubtr,
-        stage_code: :published,
-        type_code: :tr,
-        abbr: ["TR"],
-        name: "Technical Report",
+        code: :pubtr, stage_code: :published, type_code: :tr,
+        abbr: ["TR"], name: "Technical Report",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # CEN Workshop Agreement (CWA)
+      # === CEN Workshop Agreement (CWA) ===
       Pubid::Components::TypedStage.new(
-        code: :pubcwa,
-        stage_code: :published,
-        type_code: :cwa,
-        abbr: ["CWA"],
-        name: "CEN Workshop Agreement",
+        code: :pubcwa, stage_code: :published, type_code: :cwa,
+        abbr: ["CWA"], name: "CEN Workshop Agreement",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # Guide
+      # === Guide ===
       Pubid::Components::TypedStage.new(
-        code: :pubguide,
-        stage_code: :published,
-        type_code: :guide,
-        abbr: ["Guide"],
-        name: "Guide",
+        code: :pubguide, stage_code: :published, type_code: :guide,
+        abbr: ["Guide"], name: "Guide",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # Harmonization Document (HD)
+      # === Harmonization Document (HD) ===
       Pubid::Components::TypedStage.new(
-        code: :pubhd,
-        stage_code: :published,
-        type_code: :hd,
-        abbr: ["HD"],
-        name: "Harmonization Document",
+        code: :pubhd, stage_code: :published, type_code: :hd,
+        abbr: ["HD"], name: "Harmonization Document",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # European Specification (ES)
+      # === European Specification (ES) ===
       Pubid::Components::TypedStage.new(
-        code: :pubes,
-        stage_code: :published,
-        type_code: :es,
-        abbr: ["ES"],
-        name: "European Specification",
+        code: :pubes, stage_code: :published, type_code: :es,
+        abbr: ["ES"], name: "European Specification",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # CEN Report (CR)
+      # === CEN Report (CR) ===
       Pubid::Components::TypedStage.new(
-        code: :pubcr,
-        stage_code: :published,
-        type_code: :cr,
-        abbr: ["CR"],
-        name: "CEN Report",
+        code: :pubcr, stage_code: :published, type_code: :cr,
+        abbr: ["CR"], name: "CEN Report",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # European Prestandard (ENV)
+      # === European Prestandard (ENV) ===
       Pubid::Components::TypedStage.new(
-        code: :pubenv,
-        stage_code: :published,
-        type_code: :env,
-        abbr: ["ENV"],
-        name: "European Prestandard",
+        code: :pubenv, stage_code: :published, type_code: :env,
+        abbr: ["ENV"], name: "European Prestandard",
         harmonized_stages: %w[60.00 60.60],
       ),
     ].freeze
@@ -148,8 +156,13 @@ module Pubid
     ).freeze
 
     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
 
       CenCenelec::Identifier.parse(identifier)
@@ -184,16 +197,25 @@ module Pubid
       abbr_str = abbr.to_s.upcase
       all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
     end
+
+    # Lookup: typed-stage code -> typed stage ("pren" -> the prEN entry).
+    # The serialized form of a draft stage is this code.
+    # @param code [String, Symbol] the typed-stage code to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage_by_code(code)
+      all_typed_stages.find { |s| s.code.to_s == code.to_s }
+    end
   end
 end
 
 Pubid::Registry.register(:cen_cenelec, Pubid::CenCenelec)
 Pubid::Registry.register(:cen, Pubid::CenCenelec)
 
-# Per-flavor format registry: inherits global formats, overrides :human
-# Register on both root hierarchies: SingleIdentifier and Identifiers::Base
-cen_renderer = Pubid::CenCenelec::Renderer
-Pubid::CenCenelec::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::SingleIdentifier.format_registry.register(:human, renderer: cen_renderer)
-Pubid::CenCenelec::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::Identifiers::Base.format_registry.register(:human, renderer: cen_renderer)
+# Per-flavor format registry: inherits global formats, overrides :human.
+# Registered on the shared parent of every CEN/CENELEC class, so it covers
+# SingleIdentifier, Identifiers::Base and the supplement wrappers, which
+# descend from neither.
+Pubid::CenCenelec::Identifier.format_registry =
+  Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::CenCenelec::Identifier.format_registry
+  .register(:human, renderer: Pubid::CenCenelec::Renderer)

data/lib/pubid/cie/builder.rb

@@ -14,12 +14,30 @@ module Pubid
         # Determine identifier class based on parsed content
         identifier_class = determine_class(parsed_hash)
 
+        # Supplement / Corrigendum wrap a nested base.
+        if identifier_class == Cie::Identifiers::Corrigendum
+          return build_corrigendum(parsed_hash)
+        end
+        if identifier_class == Cie::Identifiers::Supplement
+          return build_supplement(parsed_hash)
+        end
+
         # Extract attributes with style detection
         attributes = extract_attributes(parsed_hash)
 
-        # For Bundle identifier, store original string
+        # For Bundle, parse each comma-separated member and hoist a shared base.
         if parsed_hash[:bundle_items] && original_string
-          attributes[:identifiers_string] = original_string
+          attributes.merge!(build_bundle(original_string))
+        end
+
+        # `extract_attributes` builds one attribute hash for every CIE type,
+        # but the types do not share one attribute set — only Standard,
+        # DualPublished and Identical declare `s_prefix`, while Conference,
+        # Bundle, Proceedings and TutorialBundle do not. lutaml used to drop
+        # the surplus key without a word; the constructor now refuses it, so
+        # the builder has to stop offering it.
+        attributes = attributes.select do |key, _|
+          identifier_class.attributes.key?(key)
         end
 
         # Construct identifier
@@ -28,6 +46,85 @@ module Pubid
 
       private
 
+      # Build a Bundle's attributes from its printed form. Parse each member,
+      # then — since a CIE bundle is the parts of one supplement of one standard
+      # — hoist the shared base and keep only the differing supplement
+      # number/part in each doc. If the members don't share a base (not seen in
+      # practice, but the grammar allows it), keep each doc's own base instead.
+      def build_bundle(original_string)
+        members = split_bundle_members(original_string)
+        shared = common_base(members)
+        return { ids: members } unless shared
+
+        ids = members.map do |m|
+          Cie::Identifiers::Supplement.new(number: m.number, part: m.part)
+        end
+        { base: shared, ids: ids }
+      end
+
+      # The publisher prefix is written once, so only the first item carries
+      # "CIE "; prepend it to the rest before parsing each member.
+      def split_bundle_members(original_string)
+        original_string.split(",").each_with_index.map do |item, i|
+          ref = i.zero? ? item.strip : "CIE #{item.strip}"
+          Cie::Identifier.parse(ref)
+        end
+      end
+
+      # The base shared by every member, or nil if they differ (or any is
+      # base-less). Compared by canonical hash so structural equality holds.
+      def common_base(members)
+        bases = members.map(&:base)
+        return nil if bases.any?(&:nil?)
+
+        first = bases.first.to_hash
+        bases.all? { |b| b.to_hash == first } ? bases.first : nil
+      end
+
+      # Supplement: nest the base Standard (the stage/year/language belong to
+      # the base), keep only the -SPN number/part on the wrapper.
+      def build_supplement(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          stage: a[:stage],
+          s_prefix: a.fetch(:s_prefix, false),
+          language: a[:language],
+          year: a[:year],
+          style: "current", # supplements always use the colon style
+        )
+        Cie::Identifiers::Supplement.new(
+          base: base,
+          number: a[:supplement_number],
+          part: a[:supplement_part],
+        )
+      end
+
+      # Corrigendum: nest the base (a Standard, or a Supplement when the base
+      # itself carries -SPN), keep only the /CorN number/year on the wrapper.
+      def build_corrigendum(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base_std = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          year: a[:base_year],
+          style: "current",
+        )
+        base = if a[:base_supplement]
+                 Cie::Identifiers::Supplement.new(
+                   base: base_std,
+                   number: a[:base_supplement],
+                   part: a[:base_supplement_part],
+                 )
+               else
+                 base_std
+               end
+        Cie::Identifiers::Corrigendum.new(
+          base: base,
+          number: a[:cor_number],
+          year: a[:cor_year],
+        )
+      end
+
       # Determine which identifier class to use
       def determine_class(parsed_hash)
         # Tutorial Bundle (special text format)
@@ -50,6 +147,11 @@ module Pubid
           return Cie::Identifiers::Supplement
         end
 
+        # Proceedings paper (x-prefixed or standalone)
+        if parsed_hash[:paper_code]
+          return Cie::Identifiers::Proceedings
+        end
+
         # Conference (x-prefix)
         if parsed_hash[:conference]
           return Cie::Identifiers::Conference
@@ -179,47 +281,69 @@ module Pubid
           date_sep = "slash" # Special format for identical identifiers
         end
 
-        # Detect style from date separator
-        style = if date_sep == "colon"
-                  "current"
-                else
-                  (date_sep == "dash" ? "legacy" : detect_style_fallback(parsed_hash))
+        # Style is the sole separator field (no date_separator):
+        #   colon -> current (":")   dash -> legacy ("-")   slash -> slash ("/")
+        style = case date_sep
+                when "colon" then "current"
+                when "dash" then "legacy"
+                when "slash" then "slash"
+                else detect_style_fallback(parsed_hash)
                 end
         attributes[:style] = style
 
-        # Set year and separator if present
+        # Set year if present
         attributes[:year] = year_value if year_value
-        attributes[:date_separator] = date_sep if date_sep
 
-        # Extract code
+        # Extract code (flat number/part/iteration/part_separator on the
+        # identifier; the code's style is the identifier's own `style`).
         if parsed_hash[:number]
-          code_attrs = { number: extract_value(parsed_hash[:number]),
-                         style: style }
+          attributes[:number] = extract_value(parsed_hash[:number])
           if parsed_hash[:part]
-            code_attrs[:part] =
-              extract_value(parsed_hash[:part])
+            attributes[:part] = extract_value(parsed_hash[:part])
           end
           if parsed_hash[:iteration]
-            code_attrs[:iteration] =
-              extract_value(parsed_hash[:iteration])
+            attributes[:iteration] = extract_value(parsed_hash[:iteration])
           end
 
           # Detect part separator from parser markers
           if parsed_hash[:slash_sep]
-            code_attrs[:part_separator] = "slash"
+            attributes[:part_separator] = "slash"
           elsif parsed_hash[:dash_sep]
-            code_attrs[:part_separator] = "dash"
+            attributes[:part_separator] = "dash"
           end
-
-          attributes[:code] = Components::Code.new(**code_attrs)
         end
 
         # Conference number (separate from regular code)
         if parsed_hash[:conf_number]
-          attributes[:conference_number] =
+          attributes[:number] =
             extract_value(parsed_hash[:conf_number])
         end
 
+        # Proceedings paper: the paper itself is the document, so its identity
+        # (code + running number, e.g. "OP01") is the flat +number+ for both
+        # surface forms. The x-form's parent conference goes to
+        # +conference+; the standalone form keeps its +page+ range.
+        if parsed_hash[:paper_code]
+          attributes[:number] =
+            "#{extract_value(parsed_hash[:paper_code])}" \
+            "#{extract_value(parsed_hash[:paper_number])}"
+          if parsed_hash[:conf_number]
+            attributes[:conference] =
+              extract_value(parsed_hash[:conf_number])
+          end
+        end
+        if parsed_hash[:page_range]
+          attributes[:page] = extract_value(parsed_hash[:page_range])
+        end
+
+        # Conference /slug variant (opaque, verbatim)
+        if parsed_hash[:variant]
+          attributes[:variant] = extract_value(parsed_hash[:variant])
+        end
+
+        # D-series marker
+        attributes[:d_prefix] = true if parsed_hash[:d_prefix]
+
         # Extract language (direct lang_code for slash_colon format)
         lang_code = nil
         lang_format = nil
@@ -325,10 +449,11 @@ module Pubid
             extract_value(parsed_hash[:amd_number])
         end
 
-        # Extract bundle data
+        # Tutorial bundle: the ordinal is the bundle's own `number` (also its
+        # relaton-index key). A comma-list bundle instead keys via its `ids`
+        # members through #root, so it needs no stored number.
         if parsed_hash[:bundle_number]
-          attributes[:bundle_number] =
-            extract_value(parsed_hash[:bundle_number])
+          attributes[:number] = extract_value(parsed_hash[:bundle_number])
         end
 
         # Extract trailing language from legacy_code_with_year

data/lib/pubid/cie/identifier.rb

@@ -5,14 +5,23 @@ module Pubid
     # Base Identifier class for CIE.
     #
     # Inherits the shared Pubid::Identifier contract (format_registry, render,
-    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes
-    # such as +style+ ("legacy" vs "current" date separator).
+    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes.
+    #
+    # +style+ is the sole number<->year separator field (there is no separate
+    # date_separator): "current" -> ":", "legacy" -> "-", "slash" -> "/".
+    # It defaults to "current" (the dominant value), so canonicalize_hash drops
+    # it from the majority of rows and from_hash restores it.
     class Identifier < ::Pubid::Identifier
-      attribute :style, :string # "legacy" or "current"
+      attribute :style, :string, default: -> { "current" }
 
       def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if input.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(input)