pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    extend Pubid::PrefixesSupport
+
+    # Sole CCSDS publisher token (see the parser's `ccsds_prefix` rule).
+    PREFIXES = ["CCSDS"].freeze
+
+    autoload :Builder, "#{__dir__}/ccsds/builder"
+    autoload :Identifier, "#{__dir__}/ccsds/identifier"
+    autoload :Identifiers, "#{__dir__}/ccsds/identifiers"
+    autoload :Parser, "#{__dir__}/ccsds/parser"
+    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
+
+# Register Uccsds flavor with the registry
+Pubid::Registry.register(:ccsds, Pubid::Ccsds)

data/lib/pubid/cen_cenelec/builder.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    class Builder < Pubid::Builder::Base
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+
+        # Store data for access in cast method
+        @data = data
+
+        # Check if this is a fragment identifier (AMD + FRAG)
+        if data[:fragment_number]
+          return build_fragment_identifier(data)
+        end
+
+        # Check if this is an adopted identifier (EN ISO, EN IEC, etc.)
+        if data[:adopted_string]
+          # Special case: ENV can adopt ISO/IEC standards
+          if data[:publisher]&.to_s == "ENV"
+            return build_env_adopted_identifier(data)
+          end
+
+          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
+        # 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.
+        if data[:publisher]&.to_s == "EN" && !data[:adopted_string] &&
+           data[:parts].to_a.empty? &&
+           (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)
+
+        # Wrap with consolidated if supplements present (plus/bundled only)
+        if supplements_data.any?
+          wrap_with_consolidated(identifier, supplements_data)
+        else
+          identifier
+        end
+      end
+
+      private
+
+      def build_fragment_identifier(data)
+        # Build base identifier first (without amendment/fragment)
+        base_data = data.dup
+        base_data.delete(:amendment_number)
+        base_data.delete(:fragment_number)
+
+        base = locate_identifier_klass(base_data).new
+        assign_attributes(base, base_data)
+
+        # Build Amendment identifier wrapping the base
+        amendment = Identifiers::Amendment.new(
+          base: base,
+          amendment_number: data[:amendment_number].to_s,
+        )
+
+        # Build Fragment wrapping the amendment
+        Identifiers::Fragment.new(
+          base: amendment,
+          fragment_number: data[:fragment_number].to_s,
+        )
+      end
+
+      def locate_identifier_klass(parsed_hash)
+        # Special case: Use adopted_european_norm for adopted identifiers
+        return Identifiers::AdoptedEuropeanNorm if parsed_hash[:adopted_string]
+
+        # 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 = 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 the module's registry
+        type_or_stage = parsed_hash[:type_with_stage] || parsed_hash[:type] || parsed_hash[:stage] || ""
+        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 = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
+          {
+            stage: typed_stage.to_stage,
+            type: typed_stage.to_type,
+            typed_stage: typed_stage,
+          }
+
+        when :publisher
+          Components::Publisher.new(body: value.to_s)
+
+        when :copublisher
+          # Map singular :copublisher to :copublishers array
+          { copublishers: [Components::Publisher.new(body: value.to_s)] }
+
+        when :copublishers
+          # Handle array of copublishers
+          Array(value).map do |v|
+            Components::Publisher.new(body: v[:copublisher].to_s)
+          end
+
+        when :number
+          value.to_s
+
+        when :parts
+          # Extract first part, preserve full multi-level part string
+          parts_array = Array(value)
+          if parts_array.any?
+            # Get the part string - it may contain multiple dashes like "5-1-1"
+            part_str = parts_array.first[:part].to_s
+
+            # Store the full part value for multi-level parts
+            { part: part_str }
+          end
+
+        when :part
+          value[:part].to_s if value.is_a?(Hash)
+
+        when :year, :date
+          # Check if month is present in the data and include it
+          month_val = @data[:month]&.to_s
+          date_attrs = { year: value.to_s }
+          date_attrs[:month] = month_val if month_val && !month_val.empty?
+          { date: Components::Date.new(**date_attrs) }
+
+        when :month
+          # Month is handled together with year, so skip it here
+          nil
+
+        when :type
+          Components::Type.new(abbr: value.to_s)
+
+        when :stage
+          # Lookup stage in TYPED_STAGES register
+          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
+          {
+            stage: typed_stage.to_stage,
+            typed_stage: typed_stage,
+          }
+
+        when :edition
+          value.to_s
+
+        when :adopted_string
+          # Don't cast here, handled in build_adopted_identifier
+          nil
+
+        when :supplements
+          # Handled separately by extract_supplements
+          nil
+
+        else
+          value
+        end
+      end
+
+      def build_adopted_identifier(data)
+        # Parse the adopted identifier string with appropriate flavor
+        adopted_str = data[:adopted_string]&.to_s&.strip
+        return nil unless adopted_str && !adopted_str.empty?
+
+        adopted_id = if adopted_str.start_with?("ISO/IEC") || adopted_str.include?("ISO/IEC")
+                       Pubid::Iso.parse(adopted_str)
+                     elsif adopted_str.start_with?("ISO")
+                       Pubid::Iso.parse(adopted_str)
+                     elsif adopted_str.start_with?("IEC")
+                       Pubid::Iec.parse(adopted_str)
+                     elsif adopted_str.start_with?("CISPR")
+                       # CISPR might need specific handling
+                       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
+          end
+        elsif data[:copublisher]
+          publishers << data[:copublisher].to_s
+        end
+
+        publishers = ["EN"] if publishers.empty?
+
+        Identifiers::AdoptedEuropeanNorm.new(
+          publisher: publishers,
+          adopted_identifier: adopted_id,
+        )
+      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 —
+      # 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)
+
+        Identifiers::AdoptedEuropeanNorm.new(
+          publisher: ["EN"],
+          adopted_identifier: Pubid::Iec.parse("IEC #{num_str}"),
+        )
+      end
+
+      def build_env_adopted_identifier(data)
+        # Parse the adopted identifier string
+        adopted_str = data[:adopted_string]&.to_s&.strip
+        return nil unless adopted_str && !adopted_str.empty?
+
+        adopted_id = if adopted_str.start_with?("ISO/IEC") || adopted_str.include?("ISO/IEC")
+                       Pubid::Iso.parse(adopted_str)
+                     elsif adopted_str.start_with?("ISO")
+                       Pubid::Iso.parse(adopted_str)
+                     elsif adopted_str.start_with?("IEC")
+                       Pubid::Iec.parse(adopted_str)
+                     end
+
+        Identifiers::EuropeanPrestandard.new(
+          adopted_identifier: adopted_id,
+        )
+      end
+
+      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,
+            )
+          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)
+          end
+        end
+
+        Identifiers::ConsolidatedIdentifier.new(
+          identifiers: [base] + supplement_ids,
+        )
+      end
+
+      def extract_supplements(data)
+        return [] unless data[:supplements]
+
+        supps_array = data[:supplements]
+        return [] if supps_array.empty?
+
+        # Only extract supplements with PLUS separator (bundled)
+        # Slash-separated supplements are standalone identifiers, not bundled
+        supps_array.select do |s|
+          supp_data = s.is_a?(Hash) && s[:supplement] ? s[:supplement] : s
+          # Only include if it has plus separator
+          supp_data[:amd_sep_plus]
+        end.map do |s|
+          supp_data = s.is_a?(Hash) && s[:supplement] ? s[:supplement] : s
+
+          # Extract year and month if present
+          year_val = (supp_data[:amd_year] || supp_data[:year])&.to_s
+          month_val = supp_data[:month]&.to_s
+
+          {
+            type: supp_data[:amd_number] ? :amendment : :corrigendum,
+            number: (supp_data[:amd_number] || supp_data[:cor_number])&.to_s,
+            year: year_val,
+            month: month_val,
+          }
+        end
+      end
+
+      def has_slash_supplements?(data)
+        return false unless data[:supplements]
+
+        supps_array = data[:supplements]
+        return false if supps_array.empty?
+
+        # Check if any supplement has slash separator
+        supps_array.any? do |s|
+          supp_data = s.is_a?(Hash) && s[:supplement] ? s[:supplement] : s
+          supp_data[:amd_sep_slash]
+        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)
+
+        # Get the first supplement (slash means only one supplement)
+        supp_array = data[:supplements]
+        supp_data = supp_array.first
+        supp_data = supp_data[:supplement] if supp_data.is_a?(Hash) && supp_data[:supplement]
+
+        # Build appropriate supplement identifier
+        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,
+          )
+        else
+          corr_attrs = {
+            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)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # 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
+      # `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
+
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.new.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # AdoptedEuropeanNorm wraps ISO/IEC identifiers
+      # Example: "EN ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
+      class AdoptedEuropeanNorm < EuropeanNorm
+        attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC/IEEE object
+
+        # 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
+        def number
+          adopted_identifier&.number
+        end
+
+        def year
+          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    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
+
+        def publisher
+          base&.publisher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Base CEN identifier (one of two roots; see Pubid::CenCenelec::Identifier).
+      # Format: {PUBLISHER} NUMBER[-PART]:YEAR
+      class Base < Pubid::CenCenelec::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        attribute :publisher, :string, collection: true # EN, CEN, CLC, etc.
+        attribute :type, :string # TR, TS, Guide
+        # `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.)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenReport < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubcr,
+            stage_code: :published,
+            type_code: :cr,
+            abbr: ["CR"],
+            name: "CEN Report",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cr,
+            web: :cen_report, title: "CEN Report", short: "CR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenWorkshopAgreement < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubcwa,
+            stage_code: :published,
+            type_code: :cwa,
+            abbr: ["CWA"],
+            name: "CEN Workshop Agreement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cwa,
+            web: :cen_workshop_agreement, title: "CEN Workshop Agreement", short: "CWA" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenelecHarmonizationDocument < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubhd,
+            stage_code: :published,
+            type_code: :hd,
+            abbr: ["HD"],
+            name: "CENELEC Harmonization Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :hd, title: "CENELEC Harmonization Document", short: "HD" }
+        end
+      end
+    end
+  end
+end