pubid 1.15.19 → 2.0.0.pre.alpha.1

data/lib/pubid/ccsds/urn_generator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(SupplementIdentifier)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "ccsds"]
+
+        identifier_parts = []
+
+        series = maybe(:series)
+        if series
+          s = series.to_s
+          identifier_parts << s if s && !s.empty?
+        end
+
+        if identifier.number
+          number = identifier.number.to_s
+          identifier_parts << number if number && !number.empty?
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          identifier_parts << ".#{p}" if p && !p.empty?
+        end
+
+        book_color = maybe(:book_color)
+        if book_color
+          bc = book_color.to_s
+          identifier_parts << "-#{bc}" if bc && !bc.empty?
+        elsif identifier.type
+          t = identifier.type.to_s
+          identifier_parts << "-#{t}" if t && !t.empty?
+        end
+
+        edition = maybe(:edition)
+        if edition
+          e = if edition.is_a?(Pubid::Components::Edition)
+                edition.number || edition.value
+              else
+                edition.to_s
+              end
+          identifier_parts << "-#{e}" if e && !e.to_s.empty?
+        end
+
+        retired = maybe(:retired)
+        if retired
+          identifier_parts << "-S"
+        else
+          suffix = maybe(:suffix)
+          if suffix
+            s = suffix.to_s
+            identifier_parts << "-#{s}" if s && !s.empty?
+          end
+        end
+
+        parts << identifier_parts.join unless identifier_parts.empty?
+
+        language = maybe(:language)
+        if language
+          lang_code = if language&.code
+                        language.code
+                      elsif language.is_a?(String)
+                        language
+                      else
+                        language.to_s
+                      end
+          lang_code = lang_code.gsub(/ Translated$/, "").downcase if lang_code
+          parts << lang_code if lang_code && !lang_code.empty?
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "ccsds"]
+
+        current = identifier
+        supplement_chain = []
+
+        while current.is_a?(SupplementIdentifier)
+          supplement_chain.unshift(current)
+          current = current.base_identifier
+        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
+
+        supplement_chain.each do |supp|
+          if supp.number&.value
+            parts << "cor.#{supp.number.value}"
+          elsif supp.typed_stage
+            parts << supp.typed_stage.type_code.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ccsds.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    autoload :Builder, "#{__dir__}/ccsds/builder"
+    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"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    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,330 @@
+# frozen_string_literal: true
+
+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)
+      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
+
+        # Extract supplements before building base identifier (only plus/bundled)
+        supplements_data = extract_supplements(data)
+
+        # Determine identifier class using Scheme
+        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_identifier = locate_identifier_klass(base_data).new
+        assign_attributes(base_identifier, base_data)
+
+        # Build Amendment identifier wrapping the base
+        amendment = Identifiers::Amendment.new(
+          base_identifier: base_identifier,
+          amendment_number: data[:amendment_number].to_s,
+        )
+
+        # Build Fragment wrapping the amendment
+        Identifiers::Fragment.new(
+          base_identifier: 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 = @scheme.locate_typed_stage_by_abbr(publisher_str)
+          return @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        end
+
+        # Use type or stage to determine class via Scheme
+        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)
+      end
+
+      def cast(type, value)
+        case type
+        when :type_with_stage
+          # Lookup from register
+          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
+          {
+            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
+          Components::Code.new(value: 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: Components::Code.new(value: part_str) }
+          end
+
+        when :part
+          Components::Code.new(value: 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 = @scheme.locate_typed_stage_by_abbr(value.to_s)
+          {
+            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
+
+      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_identifier, 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,
+            )
+          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)
+          end
+        end
+
+        Identifiers::ConsolidatedIdentifier.new(
+          identifiers: [base_identifier] + 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_identifier = locate_identifier_klass(base_data).new
+        assign_attributes(base_identifier, 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_identifier: base_identifier,
+            amendment_number: supp_data[:amd_number].to_s,
+            amendment_year: supp_data[:amd_year]&.to_i,
+          )
+        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)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifier
+      def self.parse(identifier)
+        scheme = Scheme.new
+        parsed = Parser.parse(identifier)
+        Builder.new(scheme).build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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
+
+        def to_s
+          result = publisher.is_a?(Array) ? publisher.join("/") : publisher.join("/")
+          result += " #{adopted_identifier}" if adopted_identifier
+          result
+        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,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    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
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Base CEN identifier
+      # Format: {PUBLISHER} NUMBER[-PART]:YEAR
+      class Base < Pubid::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
+        attribute :number, :string
+        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 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)
+
+          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,28 @@
+# 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, title: "CEN Report", short: "CR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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, title: "CEN Workshop Agreement", short: "CWA" }
+        end
+      end
+    end
+  end
+end