pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/cen_cenelec/scheme.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    class Scheme < Pubid::Scheme
+      # TYPED_STAGES_REGISTRY for native CEN types
+      TYPED_STAGES_REGISTRY = [
+        # European Norm (EN)
+        Pubid::Components::TypedStage.new(
+          code: :puben,
+          stage_code: :published,
+          type_code: :en,
+          abbr: ["EN"],
+          name: "European Norm",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+        Pubid::Components::TypedStage.new(
+          code: :pren,
+          stage_code: :proposal,
+          type_code: :en,
+          abbr: ["prEN"],
+          name: "Proposal European Norm",
+          harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+        ),
+        Pubid::Components::TypedStage.new(
+          code: :fpren,
+          stage_code: :final_proposal,
+          type_code: :en,
+          abbr: ["FprEN"],
+          name: "Final Proposal European Norm",
+          harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+        ),
+
+        # Technical Specification (TS)
+        Pubid::Components::TypedStage.new(
+          code: :pubts,
+          stage_code: :published,
+          type_code: :ts,
+          abbr: ["TS"],
+          name: "Technical Specification",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+        Pubid::Components::TypedStage.new(
+          code: :prts,
+          stage_code: :proposal,
+          type_code: :ts,
+          abbr: ["prTS"],
+          name: "Proposal Technical Specification",
+          harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+        ),
+
+        # Technical Report (TR)
+        Pubid::Components::TypedStage.new(
+          code: :pubtr,
+          stage_code: :published,
+          type_code: :tr,
+          abbr: ["TR"],
+          name: "Technical Report",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # CEN Workshop Agreement (CWA)
+        Pubid::Components::TypedStage.new(
+          code: :pubcwa,
+          stage_code: :published,
+          type_code: :cwa,
+          abbr: ["CWA"],
+          name: "CEN Workshop Agreement",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # Guide
+        Pubid::Components::TypedStage.new(
+          code: :pubguide,
+          stage_code: :published,
+          type_code: :guide,
+          abbr: ["Guide"],
+          name: "Guide",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # Harmonization Document (HD)
+        Pubid::Components::TypedStage.new(
+          code: :pubhd,
+          stage_code: :published,
+          type_code: :hd,
+          abbr: ["HD"],
+          name: "Harmonization Document",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # European Specification (ES)
+        Pubid::Components::TypedStage.new(
+          code: :pubes,
+          stage_code: :published,
+          type_code: :es,
+          abbr: ["ES"],
+          name: "European Specification",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # CEN Report (CR)
+        Pubid::Components::TypedStage.new(
+          code: :pubcr,
+          stage_code: :published,
+          type_code: :cr,
+          abbr: ["CR"],
+          name: "CEN Report",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+
+        # European Prestandard (ENV)
+        Pubid::Components::TypedStage.new(
+          code: :pubenv,
+          stage_code: :published,
+          type_code: :env,
+          abbr: ["ENV"],
+          name: "European Prestandard",
+          harmonized_stages: %w[60.00 60.60],
+        ),
+      ].freeze
+
+      # Map type codes to identifier classes
+      IDENTIFIER_CLASS_MAP = {
+        en: "Identifiers::EuropeanNorm",
+        ts: "Identifiers::TechnicalSpecification",
+        tr: "Identifiers::TechnicalReport",
+        cwa: "Identifiers::CenWorkshopAgreement",
+        guide: "Identifiers::Guide",
+        hd: "Identifiers::HarmonizationDocument",
+        es: "Identifiers::EuropeanSpecification",
+        cr: "Identifiers::CenReport",
+        env: "Identifiers::EuropeanPrestandard",
+      }.freeze
+
+      # Default typed stage for when no match is found
+      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+        code: :puben,
+        stage_code: :published,
+        type_code: :en,
+        abbr: ["EN"],
+        name: "European Norm",
+        harmonized_stages: %w[60.00 60.60],
+      ).freeze
+
+      def locate_typed_stage_by_abbr(abbr)
+        abbr_str = abbr.to_s.strip
+        TYPED_STAGES_REGISTRY.find do |ts|
+          ts.abbr.include?(abbr_str)
+        end || DEFAULT_TYPED_STAGE
+      end
+
+      def locate_identifier_klass_by_type_code(type_code)
+        class_name = IDENTIFIER_CLASS_MAP[type_code.to_sym]
+        return Identifiers::EuropeanNorm unless class_name
+
+        # Convert string to actual class
+        class_name.split("::").reduce(Pubid::CenCenelec) do |mod, name|
+          mod.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/single_identifier.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    class SingleIdentifier < Pubid::Identifier
+      attribute :publisher, Components::Publisher, default: -> {
+        Components::Publisher.new(body: "EN")
+      }
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def to_s(lang: :en, lang_single: false)
+        parts = []
+
+        # Check if we have a draft stage (prEN, FprEN) - these include both stage and type
+        is_draft_stage = typed_stage&.abbr && %w[prEN
+                                                 FprEN].include?(typed_stage.abbr.first)
+
+        # Get type short name - for draft stages, extract base type
+        type_short = if is_draft_stage
+                       typed_stage.type_code.to_s.upcase # :en => "EN"
+                     elsif type.is_a?(Components::Type)
+                       type.abbr
+                     elsif self.class.respond_to?(:type) && self.class.type.is_a?(Hash)
+                       self.class.type[:short]
+                     else
+                       "EN" # Default
+                     end
+
+        # Track if we should use slash before type
+        use_slash_before_type = false
+
+        # For CWA/HD, they act as publisher (not EN)
+        if %w[CWA HD CR].include?(type_short)
+          # Stage prefix OR type as publisher
+          parts << if typed_stage&.abbr && typed_stage.abbr.first != type_short
+                     typed_stage.abbr.first
+                   else
+                     type_short
+                   end
+        elsif is_draft_stage
+          # Draft stage prefix (prEN, FprEN) OR regular publisher
+          parts << typed_stage.abbr.first
+        elsif publisher
+          parts << (publisher.is_a?(Components::Publisher) ? publisher.body : publisher.to_s)
+          use_slash_before_type = true # When publisher present, use slash before type
+        end
+
+        # Copublishers - add to last part (publisher) with slash
+        if copublishers&.any?
+          copub_str = copublishers.map do |cp|
+            cp.is_a?(Components::Publisher) ? cp.body : cp.to_s
+          end.join("/")
+          unless copub_str.empty?
+            if parts.any?
+              parts[-1] = "#{parts[-1]}/#{copub_str}"
+            else
+              parts << copub_str
+            end
+          end
+        end
+
+        # Type for non-EN documents (TS, TR) - but not CWA/HD or Guide
+        if type_short != "EN" && !%w[CWA HD CR Guide].include?(type_short)
+          if use_slash_before_type && parts.any?
+            # Use slash separator for publisher/type combination (TS, TR only)
+            parts << "/#{type_short}"
+          else
+            parts << type_short
+          end
+        elsif type_short == "Guide"
+          # Guide uses SPACE separator, not slash
+          parts << "Guide"
+        end
+
+        # Number with part (which may be multi-level like "5-1-1")
+        if number
+          number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+          if part
+            part_val = part.is_a?(Components::Code) ? part.value : part
+            number_str += "-#{part_val}"
+          end
+          parts << number_str
+        end
+
+        # Join parts - but handle slash prefix for type
+        result = ""
+        parts.each_with_index do |part, idx|
+          if idx.positive? && !part.start_with?("/")
+            result += " "
+          end
+          result += part
+        end
+
+        # Date
+        if date
+          year_val = date.is_a?(Components::Date) ? date.year : date.to_i
+          result += ":#{year_val}"
+        end
+
+        result
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SingleIdentifier)
+
+        # Compare by number first
+        num_cmp = number.to_s <=> other.number.to_s
+        return num_cmp unless num_cmp.zero?
+
+        # Then by part
+        part_cmp = (part || Components::Code.new(value: "0")).to_s <=> (other.part || Components::Code.new(value: "0")).to_s
+        return part_cmp unless part_cmp.zero?
+
+        # Then by date
+        if date && other.date
+          date.to_s <=> other.date.to_s
+        elsif date
+          1
+        elsif other.date
+          -1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/supplement_identifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
+      attribute :number, Components::Code
+      attribute :date, Components::Date
+      attribute :stage, Components::Stage
+      attribute :type, Components::Type
+      attribute :typed_stage, Components::TypedStage
+
+      # Delegate methods to base_identifier for convenient access
+      def publisher
+        base_identifier&.publisher
+      end
+
+      def copublishers
+        base_identifier&.copublishers
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SupplementIdentifier)
+
+        # Compare base identifiers first
+        base_cmp = base_identifier <=> other.base_identifier
+        return base_cmp unless base_cmp.zero?
+
+        # Then compare numbers
+        num_cmp = (number || Components::Code.new(value: "0")).to_s <=> (other.number || Components::Code.new(value: "0")).to_s
+        return num_cmp unless num_cmp.zero?
+
+        # Finally compare dates
+        if date && other.date
+          date.to_s <=> other.date.to_s
+        elsif date
+          1
+        elsif other.date
+          -1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(CenCenelec::SupplementIdentifier)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "cen"]
+
+        if identifier.publisher
+          pub = identifier.publisher.to_s
+          parts << pub.to_s.downcase
+        else
+          parts << "en"
+        end
+
+        copubs = maybe(:copublishers)
+        if copubs&.any?
+          cp = copubs.map(&:to_s)
+          parts[-1] = "#{parts[-1]}-#{cp.join('-').downcase}"
+        end
+
+        type_comp = type_component
+        parts << type_comp if type_comp
+
+        if identifier.number
+          number = identifier.number.to_s
+          parts << number
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          parts[-1] = "#{parts[-1]}-#{p}"
+        end
+
+        subpart = maybe(:subpart)
+        if subpart
+          sp = subpart.to_s
+          parts[-1] = "#{parts[-1]}-#{sp}"
+        end
+
+        date = maybe(:date)
+        if date
+          year = date.year
+          parts << year.to_s
+        elsif identifier.year
+          parts << identifier.year.to_s
+        end
+
+        typed_stage = maybe(:typed_stage)
+        if typed_stage
+          stage_code = typed_stage.stage_code
+          if stage_code && stage_code != :published
+            parts << "stage.#{stage_code}"
+          end
+        end
+
+        languages = maybe(:languages)
+        if languages&.any?
+          lang_codes = languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "cen"]
+
+        base_id = maybe(:base_identifier)
+        if base_id
+          base_gen = self.class.new(base_id)
+          base_urn = base_gen.generate_base_urn
+
+          base_part = base_urn.sub(/^urn:cen:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+
+          typed_stage = maybe(:typed_stage)
+          if typed_stage
+            supp_type = typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          amendment_number = maybe(:amendment_number)
+          if amendment_number
+            parts << amendment_number.to_s
+          elsif identifier.number
+            number = identifier.number.to_s
+            parts << number
+          end
+
+          amendment_year = maybe(:amendment_year)
+          if amendment_year
+            parts << amendment_year.to_s
+          elsif identifier.date
+            year = identifier.date.year
+            parts << year.to_s
+          end
+        else
+          parts << "unknown"
+        end
+
+        parts.join(":")
+      end
+
+      def type_component
+        typed_stage = maybe(:typed_stage)
+        return nil unless typed_stage
+
+        type_code = typed_stage.type_code
+        return nil if !type_code || type_code.to_s == "en"
+
+        type_code.to_s
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    autoload :Builder, "#{__dir__}/cen_cenelec/builder"
+    autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
+    autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
+    autoload :Parser, "#{__dir__}/cen_cenelec/parser"
+    autoload :Scheme, "#{__dir__}/cen_cenelec/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
+    autoload :SupplementIdentifier,
+             "#{__dir__}/cen_cenelec/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"
+
+    def self.parse(identifier)
+      CenCenelec::Identifier.parse(identifier)
+    end
+  end
+end
+
+Pubid::Registry.register(:cen_cenelec, Pubid::CenCenelec)