pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/cen_cenelec/renderer.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # Human-readable renderer for CEN/CENELEC identifiers.
+    #
+    # Produces strings like:
+    #   "EN 196-3:2005"
+    #   "EN ISO 8601:2019"
+    #   "prEN 12345:2020"
+    #   "CEN/TS 12345:2005"
+    #   "EN 196-3:2005+A1:2008"
+    #   "EN 60038/AC1:2012"
+    #   "ENV ISO 8601"
+    #
+    # The renderer is registered as the +:human+ format in the CEN/CENELEC format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::AdoptedEuropeanNorm
+          render_adopted_european_norm(id)
+        when Identifiers::Amendment
+          render_amendment(id)
+        when Identifiers::Corrigendum
+          render_corrigendum(id)
+        when Identifiers::ConsolidatedIdentifier
+          render_consolidated(id)
+        when Identifiers::Fragment
+          render_fragment(id)
+        when Identifiers::EuropeanPrestandard
+          render_european_prestandard(id, **opts)
+        when Identifiers::Base
+          # CEN identifiers::Base hierarchy (Amendment, Corrigendum, etc. handled above)
+          render_cen_base(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      # SingleIdentifier (EN, Guide, TR, TS, CWA, HD, etc.):
+      # Complex rendering with draft stages, copublishers, typed stages
+      def render_single(id)
+        parts = []
+
+        # Check if we have a draft stage (prEN, FprEN) - these include both stage and type
+        is_draft_stage = id.typed_stage&.abbr && %w[prEN
+                                                     FprEN].include?(id.typed_stage.abbr.first)
+
+        # Get type short name - for draft stages, extract base type
+        type_short = if is_draft_stage
+                       id.typed_stage.type_code.to_s.upcase # :en => "EN"
+                     elsif id.type.is_a?(Components::Type)
+                       id.type.abbr
+                     elsif id.class.type.is_a?(Hash)
+                       id.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 id.typed_stage&.abbr && id.typed_stage.abbr.first != type_short
+                     id.typed_stage.abbr.first
+                   else
+                     type_short
+                   end
+        elsif is_draft_stage
+          # Draft stage prefix (prEN, FprEN) OR regular publisher
+          parts << id.typed_stage.abbr.first
+        elsif id.publisher
+          parts << id.publisher.render(context: @context)
+          use_slash_before_type = true # When publisher present, use slash before type
+        end
+
+        # Copublishers - add to last part (publisher) with slash
+        if id.copublishers&.any?
+          copub_str = id.copublishers.map { |cp| cp.render(context: @context) }.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 id.number
+          number_str = id.number
+          if id.part
+            number_str += "-#{id.part}"
+          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 id.date
+          year_val = id.date.is_a?(::Pubid::Components::Date) ? id.date.render(context: @context) : id.date.to_i
+          result += ":#{year_val}"
+        end
+
+        result
+      end
+
+      # CEN Identifiers::Base: simple key-value model
+      # Format: {PUBLISHER} NUMBER[-PART]:YEAR
+      def render_cen_base(id)
+        result = ""
+
+        # Stage or Publisher
+        if id.stage
+          result += id.stage
+        elsif id.publisher&.any?
+          result += id.publisher.join("/")
+        end
+
+        # If we have adopted_identifier, render it (contains all info)
+        if id.adopted_identifier
+          result += " #{id.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 id.type
+            sep = id.type == "Guide" ? " " : "/"
+            result += "#{sep}#{id.type}"
+          end
+
+          result += " #{id.number}"
+          result += id.parts.map { |p| "-#{p}" }.join if id.parts&.any?
+          result += ":#{id.year}" if id.year
+
+          # Supplements
+          if id.supplements&.any?
+            id.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#{id.edition}" if id.edition
+        end
+
+        result
+      end
+
+      # AdoptedEuropeanNorm: "EN ISO 8601:2019"
+      def render_adopted_european_norm(id)
+        result = id.publisher.is_a?(Array) ? id.publisher.join("/") : id.publisher.join("/")
+        result += " #{id.adopted_identifier}" if id.adopted_identifier
+        result
+      end
+
+      # Amendment: "EN 196-3:2005/A1:2008"
+      def render_amendment(id)
+        result = if id.base
+                   "#{id.base}/A#{id.amendment_number}"
+                 else
+                   "/A#{id.amendment_number}"
+                 end
+        result += ":#{id.amendment_year}" if id.amendment_year
+        result
+      end
+
+      # Corrigendum: "EN 60038/AC1:2012"
+      def render_corrigendum(id)
+        if id.base
+          result = id.base.to_s
+          result += "/AC"
+          result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
+        else
+          result = "/AC#{id.corrigendum_number}"
+        end
+        if id.corrigendum_year
+          result += ":#{id.corrigendum_year}"
+          result += "-#{id.corrigendum_month}" if id.corrigendum_month && !id.corrigendum_month.empty?
+        end
+        result
+      end
+
+      # ConsolidatedIdentifier: "EN 196-3:2005+A1:2008"
+      def render_consolidated(id)
+        id.identifiers.map.with_index do |sub_id, idx|
+          if idx.zero?
+            # First identifier renders normally
+            sub_id.to_s
+          elsif sub_id.is_a?(Identifiers::Amendment)
+            # Supplements render with "+" prefix (bundled/consolidated format)
+            result = "+A#{sub_id.amendment_number}"
+            result += ":#{sub_id.amendment_year}" if sub_id.amendment_year
+            result
+          # Only render the amendment portion, not the full id.to_s
+          elsif sub_id.is_a?(Identifiers::Corrigendum)
+            # Only render the corrigendum portion
+            result = "+AC"
+            result += sub_id.corrigendum_number if sub_id.corrigendum_number && !sub_id.corrigendum_number.empty?
+            if sub_id.corrigendum_year
+              result += ":#{sub_id.corrigendum_year}"
+              result += "-#{sub_id.corrigendum_month}" if sub_id.corrigendum_month && !sub_id.corrigendum_month.empty?
+            end
+            result
+          else
+            # Other identifiers (should not happen in typical bundles) render with +
+            "+#{sub_id}"
+          end
+        end.compact.join
+      end
+
+      # Fragment: "EN 60038 AMD1 FRAG2"
+      def render_fragment(id)
+        "#{id.base} FRAG#{id.fragment_number}"
+      end
+
+      # EuropeanPrestandard: "ENV ISO 8601" or falls through to SingleIdentifier
+      def render_european_prestandard(id, **opts)
+        if id.adopted_identifier
+          "ENV #{id.adopted_identifier}"
+        else
+          render_single(id)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/single_identifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # The second of CEN/CENELEC's two identifier roots (the other is
+    # Identifiers::Base); both descend from Pubid::CenCenelec::Identifier so every
+    # concrete type is `is_a?` it.
+    class SingleIdentifier < Pubid::CenCenelec::Identifier
+      attribute :publisher, Components::Publisher, default: -> {
+        Components::Publisher.new(body: "EN")
+      }
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def self.type
+        nil
+      end
+
+      def to_s(lang: :en, lang_single: false, **opts)
+        render(format: :human, lang: lang, lang_single: lang_single, **opts)
+      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 || "0").to_s <=> (other.part || "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,47 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base, Identifiers::Base, polymorphic: true
+      attribute :date, Components::Date
+      attribute :stage, Components::Stage
+      attribute :type, Components::Type
+      attribute :typed_stage, Components::TypedStage
+
+      # Delegate methods to base for convenient access
+      def publisher
+        base&.publisher
+      end
+
+      def copublishers
+        base&.copublishers
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SupplementIdentifier)
+
+        # Compare base identifiers first
+        base_cmp = base <=> other.base
+        return base_cmp unless base_cmp.zero?
+
+        # Then compare numbers
+        num_cmp = (number || "0").to_s <=> (other.number || "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&.is_a?(::Pubid::Components::Date) && date.present?
+          parts << date.render(context: URN_CONTEXT)
+        elsif date
+          parts << date.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)
+        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&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+            parts << identifier.date.render(context: URN_CONTEXT)
+          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/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # Parses CEN/CENELEC URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:cen:{type}:{number}:{year}` where type is
+    # the lowercase document class (en, etsg, ts, tr).
+    #
+    # Examples:
+    # - urn:cen:en:9001:2015 → EN 9001:2015
+    class UrnParser < Pubid::UrnParser::Base
+      # UrnGenerator uses "cen" rather than "cencenelec" as the namespace.
+      def flavor_name
+        "cen"
+      end
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        type_token, number, year = parts
+        text = "#{type_token.upcase} #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end