pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/cen_cenelec/renderer.rb

@@ -1,261 +0,0 @@
-# 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/urn_parser.rb

@@ -1,28 +0,0 @@
-# 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

data/lib/pubid/cie/identifiers/code_attributes.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Cie
-    module Identifiers
-      # Shared document-code attributes + rendering for the CIE identifier
-      # types that carry a code (Standard, Identical, JointPublished,
-      # DualPublished).
-      #
-      # The code fields live *flat* on the identifier (no nested
-      # Components::Code), so the serialized hash stays compact:
-      #   {style:, year:, ..., number: "018", iteration: "2"}
-      # rather than nesting them under a code: {number:, iteration:, style:}.
-      #
-      # +code.style+ is intentionally gone: it always equalled the identifier's
-      # own +style+ (the builder set both from one value), so #code_string reads
-      # the identifier's +style+ directly for the part-separator fallback.
-      module CodeAttributes
-        def self.included(base)
-          base.class_eval do
-            attribute :number, :string        # "018", "170", "11664"
-            attribute :part, :string          # "1", "2", "4"
-            attribute :iteration, :string     # "2" in "018.2"
-            attribute :part_separator, :string # "slash" | "dash" (original sep)
-          end
-        end
-
-        # Render the code portion: "018.2", "170-1", "19/2.1", "11664-1".
-        # Uses +part_separator+ when set, otherwise falls back to the
-        # identifier's +style+ (legacy -> "/", current -> "-").
-        def code_string
-          return nil unless number
-
-          result = number.dup
-          if part && iteration
-            result += "/#{part}.#{iteration}"
-          elsif iteration
-            result += ".#{iteration}"
-          elsif part
-            separator = case part_separator
-                        when "slash" then "/"
-                        when "dash" then "-"
-                        else style == "current" ? "-" : "/"
-                        end
-            result += "#{separator}#{part}"
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/lib/pubid/cie/identifiers/proceedings.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Cie
-    module Identifiers
-      # Proceedings paper identifier for CIE conference papers.
-      #
-      # Two surface forms share this type:
-      #   x-prefixed (attached to a conference): "CIE x043-OP01"
-      #   standalone (with a page range):        "CIE OP02 1-5"
-      #
-      # The paper itself is the document, so its identity (code + running
-      # number, e.g. "OP01") is stored flat as +number+ for BOTH forms. This
-      # gives every proceedings row a non-empty relaton-index binary-search key
-      # (see index_number_spec). The x-form's parent conference lives in
-      # +conference+; the standalone form's +page+ range is its locality.
-      # No-default values so absent keys drop from to_hash (round-trip).
-      class Proceedings < SingleIdentifier
-        # The paper identity "OP01" / "P03". :string overrides the base
-        # ::Pubid::Identifier Components::Code type.
-        attribute :number, :string
-        # The parent conference "043" (x-form only; nil for standalone).
-        attribute :conference, :string
-        # Page range "1-5" (standalone form only).
-        attribute :page, :string
-
-        def to_s(**opts)
-          result = if conference
-                     "CIE x#{conference}-#{number}"
-                   else
-                     "CIE #{number} #{page}"
-                   end
-
-          annotate_plain_render(result, **opts)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/cie/urn_parser.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Cie
-    # Parses CIE URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:cie:cie:{code}:{year}:sep.colon
-    #
-    # The trailing `sep.colon` token records the code/year separator used
-    # in the human-readable form (`:`). The leading `cie` after the
-    # namespace is the lowercase publisher.
-    #
-    # Examples:
-    # - urn:cie:cie:015:2018:sep.colon → CIE 015:2018
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body).reject { |p| p.start_with?("sep.") }
-
-        _publisher, code, year = parts
-        text = "CIE #{code}"
-        text += ":#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/components/adoption.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Components
-    # Adoption component — captures the metadata when one identifier adopts
-    # another. Originally surfaced as BSI's AdoptedInternationalStandard /
-    # AdoptedEuropeanNorm and CEN-CENELEC's AdoptedEuropeanNorm; the same
-    # shape applies to CSA adoptions and IEEE Adopted-Standard relationships.
-    #
-    # Shape (union across BSI, CEN-CENELEC, CSA, IEEE):
-    # - base:                     the adopted document (polymorphic Identifier).
-    # - adopter_publisher:        the publisher doing the adopting (BS, EN,
-    #                             CAN/, CSA, IEEE).
-    # - edition:                  edition of the adoption (BSI-only).
-    # - date:                     adoption date (replaces ad-hoc year attrs).
-    # - translation_lang:         translation language code (BSI-only).
-    # - translation_upper:        upper-case translation marker (BSI-only).
-    # - translation_suffix_type:  "version" or "Translation" (BSI-only).
-    # - reaffirmation_year:       "(R2004)" reaffirmation notation (BSI, CSA).
-    # - expert_commentary:        true when the adoption ships with commentary
-    #                             (BSI-only).
-    # - expert_commentary_topic:  topic of the commentary (BSI-only).
-    # - publisher_prefix:         CSA-specific dash-vs-space prefix.
-    #
-    # Render delegates to the base identifier; the adopter's renderer decides
-    # the prefix and any suffix notation (translation, reaffirmation,
-    # commentary) by calling adoption.render(context:).
-    class Adoption < Lutaml::Model::Serializable
-      attribute :base, ::Pubid::Identifier, polymorphic: true
-      attribute :adopter_publisher, ::Pubid::Components::Publisher
-      attribute :edition, :string
-      attribute :date, ::Pubid::Components::Date
-      attribute :translation_lang, :string
-      attribute :translation_upper, :string
-      attribute :translation_suffix_type, :string
-      attribute :reaffirmation_year, :string
-      attribute :expert_commentary, :boolean
-      attribute :expert_commentary_topic, :string
-      attribute :publisher_prefix, :string
-
-      IDENTITY_FIELDS = %i[
-        base adopter_publisher edition date translation_lang translation_upper
-        translation_suffix_type reaffirmation_year expert_commentary
-        expert_commentary_topic publisher_prefix
-      ].freeze
-
-      def present?
-        IDENTITY_FIELDS.any? { |f| present_value?(public_send(f)) }
-      end
-
-      def render(context: nil)
-        return "" unless base
-
-        body = base.to_s
-        body += translation_suffix if translation_lang
-        body += reaffirmation_suffix if reaffirmation_year
-        body += commentary_suffix if expert_commentary
-        body
-      end
-
-      def to_s(**opts)
-        render(context: opts[:context])
-      end
-
-      def ==(other)
-        return false unless other.is_a?(self.class)
-
-        IDENTITY_FIELDS.all? { |f| public_send(f) == other.public_send(f) }
-      end
-
-      alias eql? ==
-
-      def hash
-        @hash ||= [self.class, *IDENTITY_FIELDS.map { |f| public_send(f) }].hash
-      end
-
-      private
-
-      def present_value?(value)
-        return false if value.nil?
-        return value if [true, false].include?(value)
-
-        value.is_a?(String) ? !value.empty? : !value.nil?
-      end
-
-      def translation_suffix
-        type = translation_suffix_type || "Translation"
-        lang = translation_lang&.upcase
-        " #{lang}#{type}"
-      end
-
-      def reaffirmation_suffix
-        " (R#{reaffirmation_year})"
-      end
-
-      def commentary_suffix
-        topic = expert_commentary_topic
-        topic ? " (Commentary: #{topic})" : " (Commentary)"
-      end
-    end
-  end
-end

data/lib/pubid/components/iteration.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Components
-    # Stage iteration component — the numeric suffix on a stage (e.g., "WD.2").
-    #
-    # Renders as the bare number; the caller decides the separator (".")
-    # because URN, MR, and human formats position iteration differently
-    # relative to the stage abbreviation.
-    class Iteration < Lutaml::Model::Serializable
-      attribute :number, :string
-
-      def to_s
-        number.to_s
-      end
-
-      def render(context: nil)
-        number.to_s
-      end
-
-      def hash
-        @hash ||= number.hash
-      end
-
-      def eql?(other)
-        return false unless other.is_a?(self.class)
-
-        number == other.number
-      end
-    end
-  end
-end