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

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -4,28 +4,28 @@ module Pubid
   module Ccsds
     # Base class for CCSDS supplements (corrigenda, amendments, etc.).
     # Descends from the abstract root (not the concrete Base) and points
-    # `base_identifier` at the root, so the polymorphic attribute never
+    # `base` at the root, so the polymorphic attribute never
     # resolves to its own superclass — which is what prevents lutaml from
     # recursing forever while building a supplement from a hash.
     class SupplementIdentifier < Identifier
-      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :base, Identifier, polymorphic: true
 
       # Serialize the supplemented identifier under "base" (matches ISO/JIS).
-      # The key stays `base_identifier` for the attribute/getter, which
+      # The key stays `base` for the attribute/getter, which
       # relaton-index's get_id_number relies on. A supplement's own code
       # attributes (number/part/edition/...) stay nil — they live inside
       # `base` — so the merged root key_value omits them here, keeping the
       # serialization lean and non-duplicated.
       key_value do
-        map "base", to: :base_identifier
+        map "base", to: :base
       end
 
       def <=>(other)
         return nil unless other.is_a?(SupplementIdentifier)
 
         # Compare base identifiers first
-        if base_identifier && other.base_identifier
-          base_cmp = base_identifier <=> other.base_identifier
+        if base && other.base
+          base_cmp = base <=> other.base
           return base_cmp unless base_cmp.zero?
         end
 

data/lib/pubid/ccsds/urn_generator.rb

@@ -91,14 +91,14 @@ module Pubid
 
         while current.is_a?(SupplementIdentifier)
           supplement_chain.unshift(current)
-          current = current.base_identifier
+          current = current.base
         end
 
         base_gen = self.class.new(current)
         base_urn = base_gen.generate_base_urn
 
-        base_identifier_part = base_urn.sub(/^urn:ccsds:/, "")
-        parts << base_identifier_part
+        base_part = base_urn.sub(/^urn:ccsds:/, "")
+        parts << base_part
 
         supplement_chain.each do |supp|
           if supp.number && !supp.number.to_s.empty?

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,27 +50,41 @@ 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)
+        # 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
+        # range (1-59999) is intentionally NOT mapped here — too many
+        # existing CEN publications (EN Guide N, EN N as a real CEN-assigned
+        # number) would change type. Callers who want explicit adoption
+        # 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 — 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)
@@ -56,19 +92,19 @@ module Pubid
         base_data.delete(:amendment_number)
         base_data.delete(:fragment_number)
 
-        base_identifier = locate_identifier_klass(base_data).new
-        assign_attributes(base_identifier, base_data)
+        base = locate_identifier_klass(base_data).new
+        assign_attributes(base, base_data)
 
         # Build Amendment identifier wrapping the base
         amendment = Identifiers::Amendment.new(
-          base_identifier: base_identifier,
-          amendment_number: data[:amendment_number].to_s,
+          base: base,
+          number: data[:amendment_number].to_s,
         )
 
         # Build Fragment wrapping the amendment
         Identifiers::Fragment.new(
-          base_identifier: amendment,
-          fragment_number: data[:fragment_number].to_s,
+          base: amendment,
+          number: data[:fragment_number].to_s,
         )
       end
 
@@ -78,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
@@ -116,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
@@ -126,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
@@ -186,24 +222,55 @@ 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(**attrs)
+      end
+
+      # Implicit adoption by number range. Returns an AdoptedEuropeanNorm
+      # wrapping the IEC identifier that the EN number implies, or nil if the
+      # 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
+        num_str = number.to_s.strip
+        return nil unless num_str.match?(/\A\d{1,6}\z/)
+
+        num = num_str.to_i
+        return nil unless (60_000..79_999).cover?(num)
 
+        # The publisher is the "EN" default.
         Identifiers::AdoptedEuropeanNorm.new(
-          publisher: publishers,
-          adopted_identifier: adopted_id,
+          adopted: Pubid::Iec.parse("IEC #{num_str}"),
         )
       end
 
@@ -220,32 +287,35 @@ 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
 
-      def wrap_with_consolidated(base_identifier, supplements_data)
+      # 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_identifier: base_identifier,
-              amendment_number: supp[:number],
-              amendment_year: supp[:year]&.to_i,
+              number: present_string(supp[:number]),
+              year: present_string(supp[:year]),
             )
           else
-            corr_attrs = {
-              base_identifier: base_identifier,
-              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
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base_identifier] + supplement_ids,
+          identifiers: [base] + supplement_ids,
         )
       end
 
@@ -290,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_identifier = locate_identifier_klass(base_data).new
-        assign_attributes(base_identifier, 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
@@ -305,22 +369,17 @@ module Pubid
         # Build appropriate supplement identifier
         if supp_data[:amd_number]
           Identifiers::Amendment.new(
-            base_identifier: base_identifier,
-            amendment_number: supp_data[:amd_number].to_s,
-            amendment_year: supp_data[:amd_year]&.to_i,
+            base: base,
+            number: supp_data[:amd_number].to_s,
+            year: present_string(supp_data[:amd_year]),
           )
         else
-          corr_attrs = {
-            base_identifier: base_identifier,
-            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)
+          Identifiers::Corrigendum.new(
+            base: base,
+            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_identifier, 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_identifier&.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

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

@@ -12,20 +12,19 @@ module Pubid
 
         attribute :publisher, :string, collection: true # EN, CEN, CLC, etc.
         attribute :type, :string # TR, TS, Guide
-        attribute :number, :string
+        # `number` is inherited as a :string from Pubid::CenCenelec::Identifier;
+        # a same-type redeclaration here is the determinism landmine in
+        # miniature, and it moves the generated accessor onto this class.
         attribute :parts, :string, collection: true
         attribute :year, :integer
         attribute :stage, :string # prEN, FprEN
         attribute :supplements, :string, collection: true # Amendments and corrigenda
-        attribute :adopted_identifier, Base, polymorphic: true # Nested identifier object (ISO, IEC, etc.)
+        # Nested identifier object (ISO, IEC, etc.)
+        attribute :adopted, Base, polymorphic: true
         attribute :edition, :string # Edition number
-
-        def ==(other)
-          return false unless other.is_a?(Base)
-
-          publisher == other.publisher && number == other.number &&
-            parts == other.parts && year == other.year
-        end
+        # No custom `==`: the one that was here compared only publisher,
+        # number, parts and year, so every amendment equalled every other.
+        # lutaml's attribute-wise `==` compares the whole identifier.
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class CenReport < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -5,7 +5,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class CenWorkshopAgreement < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(