pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/ccsds/identifier.rb

@@ -2,7 +2,57 @@
 
 module Pubid
   module Ccsds
-    module Identifier
+    # Abstract root for every CCSDS identifier AND the flavor's parse entry
+    # point — mirrors Pubid::Iso::Identifier / Pubid::Jis::Identifier. Concrete
+    # identifiers (Identifiers::Base, Identifiers::Corrigendum) descend from this
+    # class, so a parsed CCSDS id is an instance of Pubid::Ccsds::Identifier and
+    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
+    #
+    # Keeping the root abstract (it is never itself a serialized type, so it is
+    # absent from CCSDS_TYPE_MAP) is what breaks the polymorphic recursion a
+    # supplement's `base_identifier` would otherwise hit if it pointed at a
+    # concrete type that is also its own superclass.
+    class Identifier < ::Pubid::Identifier
+      # CCSDS stores every code component as a plain string (the Builder passes
+      # strings, never Components::Code/Edition objects), so override the
+      # inherited Components::Code/Edition attribute types with :string. This
+      # both matches the runtime values and yields a lean, round-trippable
+      # key_value (`to_hash`) serialization instead of nested component hashes.
+      # `type` (single book-color letter B/G/M/R/Y/O), `suffix`, and `language`
+      # are likewise CCSDS-specific plain strings.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :edition, :string
+      attribute :type, :string
+      attribute :suffix, :string
+      attribute :language, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization,
+      # mapping each concrete class's polymorphic_name to its class name.
+      CCSDS_TYPE_MAP = {
+        "pubid:ccsds:base" => "Pubid::Ccsds::Identifiers::Base",
+        "pubid:ccsds:corrigendum" => "Pubid::Ccsds::Identifiers::Corrigendum",
+      }.freeze
+
+      # The shared Pubid::Identifier no longer auto-maps attributes, so the
+      # flavor's root declares the full key_value mapping; subclasses
+      # (SupplementIdentifier/Corrigendum) merge their own blocks on top. Every
+      # value is a plain string, so a direct `to:` map round-trips.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: CCSDS_TYPE_MAP
+        map "number", to: :number
+        map "part", to: :part
+        map "edition", to: :edition
+        map "type", to: :type
+        map "suffix", to: :suffix
+        map "language", to: :language
+      end
+
+      def publisher
+        "CCSDS"
+      end
+
+      # Parse a CCSDS identifier string into the appropriate identifier object.
       def self.parse(identifier)
         # Apply legacy update_codes normalization first
         normalized = Core::UpdateCodes.apply(identifier, :ccsds)
@@ -12,73 +62,8 @@ module Pubid
         raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
       end
 
-      # Factory that builds a CCSDS identifier from a hash of primitives.
-      #
-      # Accepts the field shape used by relaton-data-ccsds index entries:
-      # `:publisher`, `:number`, `:series`, `:part`, `:book_color`,
-      # `:retired`, `:edition`, plus the parsed-shape fields `:type`,
-      # `:suffix`, `:language`. CCSDS 2.x maps these as:
-      #
-      #   * `:series` + `:number`  → combined number ("A" + "20" → "A20")
-      #   * `:book_color`          → `:type`            (B/G/M/R/Y/O)
-      #   * `:publisher`           → ignored (hardcoded "CCSDS")
-      #   * `:retired`             → ignored (no 2.x field)
-      #
-      # Supplement subclasses (currently just Corrigendum, via `type: :cor`)
-      # raise ArgumentError until `base:` kwarg is wired through.
-      def self.create(type: nil, **opts)
-        if type
-          type_sym = type.to_sym
-          base_type_key = Identifiers::Base.type[:key].to_sym
-
-          if type_sym != base_type_key
-            supplement = supplement_klass_for(type_sym)
-            if supplement
-              # TODO(create-shim): supplement subclasses (Corrigendum)
-              # require a base_identifier. Wire `base:` kwarg through once
-              # a caller needs it.
-              raise ArgumentError, "#{supplement} requires a " \
-                                   "base_identifier; Identifier.create " \
-                                   "cannot build supplements yet"
-            end
-
-            # Not a class-dispatch key — treat as book_color data
-            # (e.g. `type: "G"` for Green Book) and merge back into opts.
-            opts = opts.merge(type: type)
-          end
-        end
-
-        Identifiers::Base.new(**coerce_create_attrs(opts))
-      end
-
-      def self.supplement_klass_for(type_sym)
-        Scheme.supplement_identifiers.find do |k|
-          k.type[:key].to_sym == type_sym
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-
-        if opts[:number]
-          num = opts[:number].to_s
-          attrs[:number] =
-            opts[:series] ? "#{opts[:series]}#{num}" : num
-        end
-
-        attrs[:type] = opts[:book_color].to_s if opts[:book_color]
-        # Allow caller to pass :type as data when no :book_color given
-        # (parsed identifiers expose it via Base#type attribute).
-        attrs[:type] = opts[:type].to_s if opts[:type] && !attrs[:type]
-
-        %i[part edition suffix language].each do |k|
-          v = opts[k]
-          attrs[k] = v.to_s unless v.nil?
-        end
-
-        attrs
-      end
-      private_class_method :supplement_klass_for, :coerce_create_attrs
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # CCSDS_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

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

@@ -3,12 +3,15 @@
 module Pubid
   module Ccsds
     module Identifiers
-      # CCSDS identifier
-      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX]
-      # Example: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S
-      class Base < Lutaml::Model::Serializable
-        # CCSDS uses a simple architecture without typed stages
-        # TYPED_STAGES includes default stage for base identifiers
+      # CCSDS base identifier (a published standard).
+      #
+      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX][ - LANGUAGE Translated]
+      # Examples: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S, CCSDS 551.1-O-2 - Russian Translated
+      #
+      # Attributes, the key_value mapping and from_hash dispatch live on the
+      # abstract root Pubid::Ccsds::Identifier; this concrete type only carries
+      # its typed stage and rendering.
+      class Base < Pubid::Ccsds::Identifier
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             abbr: [""],
@@ -17,72 +20,19 @@ module Pubid
           ),
         ].freeze
 
-        # Type information for this identifier class
-        #
-        # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :base, title: "Base Standard", short: nil }
+          { key: :base, web: :base, title: "Base Standard", short: nil }
         end
 
-        # Return a copy of this identifier with the named attributes
-        # nil'd. Mirrors the {Pubid::Identifier#exclude} convenience.
-        # CCSDS Base extends Lutaml::Model::Serializable directly (not
-        # Pubid::Identifier), so the method is defined here too.
-        def exclude(*args)
-          attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
-            h[name] = args.include?(name) ? nil : send(name)
-          end
-          self.class.new(attrs)
-        end
-
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-
-        # Include CCSDS-specific attributes in serialization
-        def base_hash
-          hash = super
-          # CCSDS uses plain strings for type, edition, suffix
-          hash[:type] = type if type
-          hash[:suffix] = suffix if suffix
-          hash[:language] = language if language
-          hash
-        end
-
-        attribute :number, :string
-        attribute :part, :string
-        attribute :type, :string # B, G, M, R, Y, O, etc.
-        attribute :edition, :string
-        attribute :suffix, :string # Optional suffix like -S
-        attribute :language, :string # Language metadata (e.g., "French", "Russian")
-
-        def publisher
-          "CCSDS"
-        end
-
-        def to_s
+        def to_s(**_opts)
           result = "#{publisher} #{number}"
           result += ".#{part}" if part
           result += "-#{type}" if type
           result += "-#{edition}" if edition
           result += "-#{suffix}" if suffix
-
-          # Add language metadata
           result += " - #{language} Translated" if language
-
           result
         end
-
-        def ==(other)
-          return false unless other.is_a?(Base)
-
-          number == other.number &&
-            part == other.part &&
-            type == other.type &&
-            edition == other.edition &&
-            suffix == other.suffix &&
-            language == other.language
-        end
       end
     end
   end

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

@@ -17,21 +17,22 @@ module Pubid
         #
         # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :cor, title: "Corrigendum", short: "Cor" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "Cor" }
         end
 
-        attribute :cor_number, :integer
-
+        # 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
           base_str = base_identifier.to_s
-          "#{base_str} Cor. #{cor_number}"
+          "#{base_str} Cor. #{number}"
         end
 
         def ==(other)
           return false unless other.is_a?(Corrigendum)
 
-          base_identifier == other.base_identifier &&
-            cor_number == other.cor_number
+          base_identifier == other.base_identifier && number == other.number
         end
       end
     end

data/lib/pubid/ccsds/parser.rb

@@ -25,8 +25,10 @@ module Pubid
       # Type (all possible type letters)
       rule(:type) { dash >> match["A-Z"].as(:type) }
 
-      # Edition (can have dots like 4.1)
-      rule(:edition) { dash >> match["0-9."].repeat(1).as(:edition) }
+      # Edition (can have dots like 4.1, and a trailing draft letter like 1.99h)
+      rule(:edition) do
+        dash >> (match["0-9."].repeat(1) >> match["A-Za-z"].maybe).as(:edition)
+      end
 
       # Suffix (like -S)
       rule(:suffix) { dash >> match["A-Z"].as(:suffix) }

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -2,18 +2,22 @@
 
 module Pubid
   module Ccsds
-    # Base class for CCSDS supplements (corrigenda, amendments, etc.)
-    # Following ISO pattern: inherits from Base and uses Lutaml::Model
-    class SupplementIdentifier < Identifiers::Base
-      attribute :base_identifier, Identifiers::Base, polymorphic: true
+    # 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
+    # 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
 
-      # Delegate methods to base_identifier for convenient access
-      def publisher
-        base_identifier&.publisher
-      end
-
-      def number
-        base_identifier&.number
+      # Serialize the supplemented identifier under "base" (matches ISO/JIS).
+      # The key stays `base_identifier` 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
       end
 
       def <=>(other)

data/lib/pubid/ccsds/urn_generator.rb

@@ -47,7 +47,7 @@ module Pubid
         edition = maybe(:edition)
         if edition
           e = if edition.is_a?(Pubid::Components::Edition)
-                edition.number || edition.value
+                edition.number
               else
                 edition.to_s
               end
@@ -101,8 +101,8 @@ module Pubid
         parts << base_identifier_part
 
         supplement_chain.each do |supp|
-          if supp.number&.value
-            parts << "cor.#{supp.number.value}"
+          if supp.number && !supp.number.to_s.empty?
+            parts << "cor.#{supp.number}"
           elsif supp.typed_stage
             parts << supp.typed_stage.type_code.to_s
           end

data/lib/pubid/ccsds/urn_parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    # Parses CCSDS URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ccsds:{code}` where the code is the full
+    # identifier suffix after "CCSDS " (e.g., "120.0-G-4").
+    #
+    # Examples:
+    # - urn:ccsds:120.0-G-4  → CCSDS 120.0-G-4
+    # - urn:ccsds:100.0-G-1-S → CCSDS 100.0-G-1-S
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        flavor_parse("CCSDS #{body}")
+      end
+    end
+  end
+end

data/lib/pubid/ccsds.rb

@@ -6,14 +6,52 @@ module Pubid
     autoload :Identifier, "#{__dir__}/ccsds/identifier"
     autoload :Identifiers, "#{__dir__}/ccsds/identifiers"
     autoload :Parser, "#{__dir__}/ccsds/parser"
-    autoload :Scheme, "#{__dir__}/ccsds/scheme"
     autoload :SingleIdentifier, "#{__dir__}/ccsds/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/ccsds/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/ccsds/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ccsds/urn_parser"
 
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # CCSDS identifier classes extend Lutaml::Model::Serializable directly
+    # but do define self.type returning a Hash.
+    # @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/cen_cenelec/builder.rb

@@ -3,12 +3,8 @@
 module Pubid
   module CenCenelec
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
-      def self.build(parsed_data, scheme = Scheme.new)
-        new(scheme).build(parsed_data)
+      def self.build(parsed_data)
+        new.build(parsed_data)
       end
 
       def build(data)
@@ -40,7 +36,7 @@ module Pubid
         # Extract supplements before building base identifier (only plus/bundled)
         supplements_data = extract_supplements(data)
 
-        # Determine identifier class using Scheme
+        # Determine identifier class using the module's lookup helpers
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -83,21 +79,23 @@ 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)
-          typed_stage = @scheme.locate_typed_stage_by_abbr(publisher_str)
-          return @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+          typed_stage = CenCenelec.locate_stage(publisher_str)
+          if (klass = CenCenelec.locate_type(typed_stage.type_code))
+            return klass
+          end
         end
 
-        # Use type or stage to determine class via Scheme
+        # Use type or stage to determine class via the module's registry
         type_or_stage = parsed_hash[:type_with_stage] || parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = @scheme.locate_typed_stage_by_abbr(type_or_stage)
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        typed_stage = CenCenelec.locate_stage(type_or_stage) || CenCenelec::DEFAULT_TYPED_STAGE
+        CenCenelec.locate_type(typed_stage.type_code) || Identifiers::EuropeanNorm
       end
 
       def cast(type, value)
         case type
         when :type_with_stage
           # Lookup from register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
+          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,
@@ -150,7 +148,7 @@ module Pubid
 
         when :stage
           # Lookup stage in TYPED_STAGES register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value.to_s)
+          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             typed_stage: typed_stage,

data/lib/pubid/cen_cenelec/identifier.rb

@@ -1,52 +1,23 @@
 # frozen_string_literal: true
 
-require_relative "../components/factory"
-
 module Pubid
   module CenCenelec
-    module Identifier
+    # Common base class for all CEN/CENELEC identifiers. CEN/CENELEC has a split
+    # hierarchy — some concrete types descend from Identifiers::Base, others from
+    # SingleIdentifier — so this class is the shared parent of BOTH, making every
+    # CEN/CENELEC identifier `is_a?(Pubid::CenCenelec::Identifier)` natively (and
+    # giving them the shared polymorphic `from_hash`). No facade needed.
+    class Identifier < ::Pubid::Identifier
       def self.parse(identifier)
-        scheme = Scheme.new
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(identifier)
-        Builder.new(scheme).build(parsed)
+        Builder.new.build(parsed)
       rescue Parslet::ParseFailed => e
         raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Cen::Identifier.create` API.
-      # Dispatches via {Pubid::CenCenelec::Scheme}'s IDENTIFIER_CLASS_MAP
-      # and TYPED_STAGES_REGISTRY. Default is EuropeanNorm.
-      def self.create(type: nil, stage: nil, **opts)
-        klass = resolve_create_class(type: type, stage: stage)
-        attrs = ::Pubid::Components::Factory.from_hash(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        attrs[:typed_stage] = ts if ts
-        klass.new(**attrs)
-      end
-
-      def self.resolve_create_class(type:, stage:)
-        scheme = Scheme.new
-        klass = nil
-        if type
-          klass = scheme.locate_identifier_klass_by_type_code(type)
-        elsif stage
-          ts = scheme.locate_typed_stage_by_abbr(stage.to_s)
-          klass = scheme.locate_identifier_klass_by_type_code(ts.type_code) if ts
-        end
-        klass || Identifiers::EuropeanNorm
-      end
-
-      def self.resolve_create_typed_stage(klass, stage)
-        if stage
-          Scheme.new.locate_typed_stage_by_abbr(stage.to_s)
-        elsif klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code.to_sym == :published
-          end
-        end
-      end
-      private_class_method :resolve_create_class,
-                           :resolve_create_typed_stage
     end
   end
 end

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

@@ -8,10 +8,15 @@ module Pubid
       class AdoptedEuropeanNorm < EuropeanNorm
         attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC/IEEE object
 
-        def to_s
-          result = publisher.is_a?(Array) ? publisher.join("/") : publisher.join("/")
-          result += " #{adopted_identifier}" if adopted_identifier
-          result
+        # Override self.type to return nil so that AdoptedEuropeanNorm is NOT
+        # registered as a type in CenCenelec.identifier_types. The class is a
+        # polymorphic wrapper that wraps an adopted ISO/IEC identifier under an
+        # EN publisher; it is constructed explicitly by Builder#build_adopted_identifier,
+        # not selected via type-code lookup. Returning nil here prevents
+        # identifier_types auto-discovery from shadowing EuropeanNorm (which
+        # also reports :en) in CenCenelec.locate_type(:en).
+        def self.type
+          nil
         end
 
         # Delegate common methods to adopted identifier

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

@@ -10,16 +10,6 @@ module Pubid
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
 
-        def to_s
-          result = if base_identifier
-                     "#{base_identifier}/A#{amendment_number}"
-                   else
-                     "/A#{amendment_number}"
-                   end
-          result += ":#{amendment_year}" if amendment_year
-          result
-        end
-
         def publisher
           base_identifier&.publisher
         end

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

@@ -3,9 +3,9 @@
 module Pubid
   module CenCenelec
     module Identifiers
-      # Base CEN identifier
+      # Base CEN identifier (one of two roots; see Pubid::CenCenelec::Identifier).
       # Format: {PUBLISHER} NUMBER[-PART]:YEAR
-      class Base < Pubid::Identifier
+      class Base < Pubid::CenCenelec::Identifier
         # Generate URN for this identifier
         #
         # @return [String] URN representation
@@ -20,49 +20,6 @@ module Pubid
         attribute :adopted_identifier, Base, polymorphic: true # Nested identifier object (ISO, IEC, etc.)
         attribute :edition, :string # Edition number
 
-        def to_s
-          result = ""
-
-          # Stage or Publisher
-          if stage
-            result += stage
-          elsif publisher&.any?
-            result += publisher.join("/")
-          end
-
-          # If we have adopted_identifier, render it (contains all info)
-          if adopted_identifier
-            result += " #{adopted_identifier}"
-            # Don't add our own number/parts/year - they're in adopted_identifier
-          else
-            # Only render our own fields if no adoption
-            # Type - use space for Guide, slash for TR/TS
-            if type
-              sep = type == "Guide" ? " " : "/"
-              result += "#{sep}#{type}"
-            end
-
-            result += " #{number}"
-            result += parts.map { |p| "-#{p}" }.join if parts&.any?
-            result += ":#{year}" if year
-
-            # Supplements
-            if supplements&.any?
-              supplements.each do |supp|
-                sep = supp[:type] == :amendment ? "/" : "+"
-                result += "#{sep}#{supp[:type] == :amendment ? 'A' : 'AC'}"
-                result += supp[:number] if supp[:number] && !supp[:number].empty?
-                result += ":#{supp[:year]}" if supp[:year]
-              end
-            end
-
-            # Edition
-            result += " ED#{edition}" if edition
-          end
-
-          result
-        end
-
         def ==(other)
           return false unless other.is_a?(Base)
 

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

@@ -20,7 +20,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cr, title: "CEN Report", short: "CR" }
+          { key: :cr,
+            web: :cen_report, title: "CEN Report", short: "CR" }
         end
       end
     end

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

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cwa, title: "CEN Workshop Agreement", short: "CWA" }
+          { key: :cwa,
+            web: :cen_workshop_agreement, title: "CEN Workshop Agreement", short: "CWA" }
         end
       end
     end