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

data/lib/pubid/components/relationship.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Components
-    # Relationship component — captures how one identifier relates to others.
-    #
-    # Originally modeled as IEEE's Components::Relationship; promoted to the
-    # shared namespace because the same relationship vocabulary applies to
-    # ISO, IEC, and other flavors that need to express "revises", "amends",
-    # "incorporates", "adopts", etc.
-    #
-    # Shape:
-    # - relationship_type: one of the VALID_TYPES constants below.
-    # - related_identifiers: array of identifier objects the relationship
-    #   points at (e.g., the standards being revised).
-    # - intermediate_amendments: optional array of identifiers that amended
-    #   the related identifier between its original publication and the
-    #   current revision (renders as "... as amended by ...").
-    # - approved_amendments_flag: when true and no intermediate_amendments
-    #   are listed, renders "... and its approved amendments".
-    class Relationship < Lutaml::Model::Serializable
-      REVISION_OF = "revision_of"
-      AMENDMENT_TO = "amendment_to"
-      CORRIGENDUM_TO = "corrigendum_to"
-      INCORPORATES = "incorporates"
-      INCORPORATING = "incorporating"
-      ADOPTION_OF = "adoption_of"
-      SUPPLEMENT_TO = "supplement_to"
-      DRAFT_AMENDMENT_TO = "draft_amendment_to"
-      DRAFT_REVISION_OF = "draft_revision_of"
-      REAFFIRMATION_OF = "reaffirmation_of"
-      REDESIGNATION_OF = "redesignation_of"
-      SUPERSEDES = "supersedes"
-      PREVIOUSLY_DESIGNATED_AS = "previously_designated_as"
-      INCLUDES = "includes"
-
-      VALID_TYPES = [
-        REVISION_OF,
-        AMENDMENT_TO,
-        CORRIGENDUM_TO,
-        INCORPORATES,
-        INCORPORATING,
-        ADOPTION_OF,
-        SUPPLEMENT_TO,
-        DRAFT_AMENDMENT_TO,
-        DRAFT_REVISION_OF,
-        REAFFIRMATION_OF,
-        REDESIGNATION_OF,
-        SUPERSEDES,
-        PREVIOUSLY_DESIGNATED_AS,
-        INCLUDES,
-      ].freeze
-
-      attribute :relationship_type, :string
-
-      attr_accessor :related_identifiers, :intermediate_amendments,
-                    :approved_amendments_flag
-
-      PREFIXES = {
-        REVISION_OF => "Revision of",
-        AMENDMENT_TO => "Amendment to",
-        CORRIGENDUM_TO => "Corrigendum to",
-        INCORPORATES => "incorporates",
-        ADOPTION_OF => "Adoption of",
-        SUPPLEMENT_TO => "Supplement to",
-        DRAFT_AMENDMENT_TO => "Draft Amendment to",
-        DRAFT_REVISION_OF => "Draft Revision of",
-        REAFFIRMATION_OF => "Reaffirmation of",
-        REDESIGNATION_OF => "Redesignation of",
-        SUPERSEDES => "Supersedes",
-        PREVIOUSLY_DESIGNATED_AS => "Previously designated as",
-        INCLUDES => "Includes",
-      }.freeze
-
-      def initialize(**args)
-        @related_identifiers = args.delete(:related_identifiers)
-        @intermediate_amendments = args.delete(:intermediate_amendments)
-        @approved_amendments_flag = args.delete(:approved_amendments_flag)
-        super
-        normalize_incorporating!
-        validate_relationship_type if relationship_type
-      end
-
-      def normalize_incorporating!
-        return unless relationship_type == INCORPORATING
-
-        self.relationship_type = INCORPORATES
-      end
-
-      def validate_relationship_type
-        return if VALID_TYPES.include?(relationship_type)
-
-        raise ArgumentError,
-              "Invalid relationship type: #{relationship_type}. " \
-              "Valid types: #{VALID_TYPES.join(', ')}"
-      end
-
-      def to_s
-        return "" if related_identifiers.nil? || related_identifiers.empty?
-
-        prefix = format_relationship_prefix
-        ids = format_identifier_list(related_identifiers)
-        return "#{prefix} #{ids}" unless intermediate_clause?
-
-        "#{prefix} #{ids} #{intermediate_clause}"
-      end
-
-      def render(context: nil)
-        to_s
-      end
-
-      private
-
-      def intermediate_clause?
-        (intermediate_amendments && !intermediate_amendments.empty?) ||
-          approved_amendments_flag
-      end
-
-      def intermediate_clause
-        if intermediate_amendments && !intermediate_amendments.empty?
-          "as amended by #{format_identifier_list(intermediate_amendments)}"
-        else
-          "and its approved amendments"
-        end
-      end
-
-      def format_relationship_prefix
-        PREFIXES.fetch(relationship_type, relationship_type)
-      end
-
-      # Format a list of identifiers using proper English grammar:
-      # - Single: "IEEE Std X"
-      # - Two: "IEEE Std X and IEEE Std Y"
-      # - Three+: "IEEE Std X, IEEE Std Y, and IEEE Std Z" (Oxford comma)
-      def format_identifier_list(identifiers)
-        return "" if identifiers.nil? || identifiers.empty?
-
-        case identifiers.length
-        when 1
-          identifiers.first.to_s
-        when 2
-          "#{identifiers.first} and #{identifiers.last}"
-        else
-          "#{identifiers[0..-2].join(', ')}, and #{identifiers.last}"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/components/supplement.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Components
-    # Supplement component — a structured value-object representing the
-    # supplement-specific data (number, date, stage, iteration, type) of a
-    # supplement identifier.
-    #
-    # Union shape across flavors:
-    # - type:    "amd" (amendment), "cor" (corrigendum), "err" (errata),
-    #            "sup" (supplement), or a flavor-specific marker.
-    # - number:  bare sequence number (string preserves leading zeros, "1A"
-    #            combos, etc.).
-    # - date:    publication date of the supplement (Components::Date).
-    # - range_end_date: end of a date range; presence of this marks the
-    #            supplement as a range. (NIST/NBS uses supJan1924-Jun1925.)
-    # - stage:   the stage the supplement is in (e.g., WD Amd, CD Amd).
-    # - iteration: stage iteration (e.g., the ".2" in "WD.2 Amd").
-    # - has_revision: "suprev" marker — supplement that itself carries a
-    #            revision. (NIST-specific.)
-    # - suffix:  escape hatch for patterns not yet modeled.
-    #
-    # Format-aware via render(context:). The human form stacks fields in the
-    # order they appear in the printed supplement; the URN form joins number
-    # and year with ":".
-    class Supplement < Lutaml::Model::Serializable
-      DEFAULT_TYPE = "sup"
-
-      attribute :type, :string, default: -> { DEFAULT_TYPE }
-      attribute :number, :string
-      attribute :date, Date
-      attribute :range_end_date, Date
-      attribute :stage, Stage
-      attribute :iteration, Components::Iteration
-      attribute :has_revision, :boolean, default: false
-      attribute :suffix, :string
-
-      IDENTITY_FIELDS = %i[
-        type number date range_end_date stage iteration has_revision suffix
-      ].freeze
-
-      # Fields whose presence indicates the supplement carries data.
-      # `type` is excluded — it always has a value (the default "sup") but
-      # doesn't mean the supplement carries content.
-      CONTENT_FIELDS = %i[
-        number date range_end_date stage iteration has_revision suffix
-      ].freeze
-
-      # True when the supplement carries any data. Distinguishes a present-
-      # but-empty supplement (bare marker, "sup") from no supplement at all.
-      def present?
-        CONTENT_FIELDS.any? { |f| present_value?(public_send(f)) }
-      end
-
-      # True when this supplement spans a date range (start + end set).
-      def range?
-        date&.present? && range_end_date&.present?
-      end
-
-      def render(context: nil)
-        return render_urn if context&.format == :urn
-
-        render_human
-      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 identity_fields
-        IDENTITY_FIELDS
-      end
-
-      def non_empty?(value)
-        return false if value.nil?
-
-        value.is_a?(String) ? !value.empty? : value.present?
-      end
-
-      def present_value?(value)
-        return value if [true, false].include?(value)
-        return false if value.nil?
-
-        value.is_a?(String) ? !value.empty? : value.present?
-      end
-
-      def number?
-        non_empty?(number)
-      end
-
-      def suffix?
-        non_empty?(suffix)
-      end
-
-      def stage_abbr
-        return nil if stage.nil? || stage.abbr.nil?
-
-        abbr = stage.abbr.to_s
-        abbr.empty? ? nil : abbr
-      end
-
-      # Human / mr: stack fields in canonical order.
-      #   "1924"            (year)
-      #   "Jan1924"         (month + year)
-      #   "3/1926"          (number + year)
-      #   "1"               (number)
-      #   "A"               (suffix)
-      #   "Jan1924-Jun1925" (range)
-      def render_human
-        return early_marker if has_revision || suffix?
-        return date_range_string if range?
-
-        assemble_body
-      end
-
-      def early_marker
-        has_revision ? "rev" : suffix.to_s
-      end
-
-      def assemble_body
-        body = number_or_date_string
-        body += iteration_suffix if include_iteration?
-        stage_abbr ? "#{stage_abbr}#{body}" : body
-      end
-
-      def include_iteration?
-        iteration && stage_abbr.nil?
-      end
-
-      def render_urn
-        return "" unless present?
-
-        [number&.to_s, date&.year&.to_s].compact.reject(&:empty?).join(":")
-      end
-
-      def iteration_suffix
-        "-#{iteration.number}"
-      end
-
-      def date_range_string
-        "#{date_string(date)}-#{date_string(range_end_date)}"
-      end
-
-      def number_or_date_string
-        return date_string(date) unless number?
-
-        date&.present? ? "#{number}/#{date_string(date)}" : number.to_s
-      end
-
-      # Render the body of a date fragment preserving the original month
-      # abbreviation when month is a non-numeric string. Falls back to
-      # Components::Date#render when month is numeric.
-      def date_string(date_value)
-        return "" unless date_value&.present?
-
-        if month_abbreviation?(date_value)
-          "#{date_value.month}#{date_value.year}"
-        else
-          date_value.render(context: nil)
-        end
-      end
-
-      def month_abbreviation?(date_value)
-        date_value.month && !date_value.month.match?(/^\d+$/)
-      end
-    end
-  end
-end

data/lib/pubid/csa/renderer.rb

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Csa
-    # Human-readable renderer for CSA identifiers that extend Pubid::Identifier.
-    #
-    # Produces strings like:
-    #   "CSA B149.1:20"
-    #   "CAN/CSA-C22.2 NO. 60601-1-9:15"
-    #   "CSA C22.2 NO. 286:23"
-    #   "CSA MH SERIES 3.14:20"
-    #
-    # The renderer is registered as the +:human+ format in the CSA format
-    # registry and invoked via +render(format: :human)+.
-    #
-    # Note: Some CSA identifier types (Bundled, Combined, CanadianAdopted,
-    # CsaAdopted, Package) extend Lutaml::Model::Serializable directly,
-    # not Pubid::Identifier, so they keep their own to_s implementations.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
-        id = @id
-        @context = context
-
-        case id
-        when Identifiers::Series
-          render_series(id)
-        when Identifiers::Cec
-          render_cec(id)
-        else
-          render_base(id)
-        end
-      end
-
-      private
-
-      # Base rendering: "CSA B149.1:20", "CAN/CSA-C22.2-05"
-      def render_base(id)
-        prefix = publisher_prefix_for(id)
-
-        # Handle code_only identifiers (empty string means no prefix)
-        if prefix == ""
-          # No prefix for code_only identifiers
-          parts = []
-        else
-          # Determine if we need space after prefix
-          # CAN/CSA- and CAN3- end with dash, so no space needed
-          needs_space = !prefix.end_with?("-")
-
-          parts = []
-          parts << prefix
-        end
-
-        # Code and year together
-        code_part = id.number.to_s if id.number
-
-        # NO. keyword
-        if id.no_number
-          code_part += " NO. #{id.no_number}"
-        end
-
-        # Series prefix and keyword (before year)
-        if id.series_prefix
-          code_part += " #{id.series_prefix} SERIES"
-        elsif id.series
-          # SERIES without prefix
-          code_part += " SERIES"
-        end
-
-        parts << code_part if code_part
-
-        # Year with proper format (colon or dash)
-        if id.year
-          # Use dash if year_format is dash, otherwise colon
-          separator = id.year_format == "dash" ? "-" : ":"
-          year_part = separator
-          year_part += id.year_prefix if id.year_prefix # Add M or F prefix
-          year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
-          # Convert 4-digit year back to 2-digit for M/F prefix preservation
-          # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
-          # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
-          year_str = id.year.to_s
-          year_part += if id.original_year_4digit
-                         # Preserve 4-digit format (e.g., "M1981" stays "M1981")
-                         year_str
-                       elsif id.year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
-                         # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
-                         year_str[2..3]
-                       elsif year_str.length == 4 && year_str.start_with?("20")
-                         # 2000s → just last 2 digits
-                         year_str[2..3]
-                       elsif year_str.length == 4 && year_str.start_with?("19") && !id.original_year_4digit
-                         # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
-                         # Convert back to 2-digit
-                         year_str[2..3]
-                       else
-                         # Other formats - keep as-is
-                         year_str
-                       end
-          parts[-1] += year_part
-        end
-
-        result = if prefix == ""
-                   # No prefix, just join parts
-                   parts.join(" ")
-                 elsif !prefix.end_with?("-")
-                   parts.join(" ")
-                 elsif parts.length == 2
-                   # No space after dash-ending prefix - join first two parts directly
-                   # If there are more parts after code, they should still have spaces
-                   parts.join
-                 else
-                   # More than 2 parts shouldn't happen in current design
-                   parts.join
-                 end
-
-        # Reaffirmation - preserve original format and determine spacing
-        if id.reaffirmation && !id.reaffirmation.to_s.empty?
-          result += render_reaffirmation(id)
-        end
-
-        # Package (already has leading space from parser)
-        if id.package
-          result += id.package
-        end
-
-        result
-      end
-
-      # CEC rendering: "CSA C22.2 NO. 286:23"
-      def render_cec(id)
-        parts = []
-
-        # Publisher prefix (CSA, CAN/CSA-, CAN3-)
-        prefix = publisher_prefix_for(id)
-
-        # Determine if we need space after prefix
-        # CAN/CSA- and CAN3- end with dash, so no space needed
-        needs_space = !prefix.end_with?("-")
-
-        parts << prefix unless prefix == ""
-
-        # CEC Part (C22.2, C22.3, etc.)
-        parts << id.cec_part.render(context: @context) if id.cec_part
-
-        # NO. notation - this is the key semantic component
-        parts << "NO."
-
-        # Number after NO.
-        parts << id.no_number.render(context: @context) if id.no_number
-
-        # Determine separator based on prefix ending
-        result = if prefix == ""
-                   parts.join(" ")
-                 elsif needs_space
-                   parts.join(" ")
-                 elsif parts.length <= 2
-                   # No space after dash-ending prefix (CAN/CSA-, CAN3-)
-                   # Join first two parts directly, rest with spaces
-                   parts.join
-                 else
-                   parts[0] + parts[1..].join(" ")
-                 end
-
-        # Year with proper format (colon or dash)
-        if id.year
-          # Use dash if year_format is dash, otherwise colon
-          separator = id.year_format == "dash" ? "-" : ":"
-          year_part = separator
-
-          # Convert 4-digit year back to 2-digit for display
-          year_str = id.year.to_s
-          display_year = if year_str.length == 4 && year_str.start_with?("20")
-                           year_str[2..3]
-                         elsif year_str.length == 4 && year_str.start_with?("19")
-                           year_str[2..3]
-                         else
-                           year_str
-                         end
-
-          # Add prefix if present
-          year_part += if id.year_prefix
-                         id.year_prefix + display_year
-                       elsif id.french && id.year_format != "dash"
-                         # Only add F if no prefix already set
-                         "F#{display_year}"
-                       else
-                         display_year
-                       end
-
-          result += year_part
-        end
-
-        # Reaffirmation
-        if id.reaffirmation && !id.reaffirmation.to_s.empty?
-          result += render_reaffirmation(id)
-        end
-
-        result
-      end
-
-      # Series rendering: "CSA MH SERIES 3.14:20"
-      def render_series(id)
-        result = series_publisher_prefix_portion(id)
-
-        # Add code FIRST (before SERIES keyword)
-        result += id.number.to_s
-
-        # Add space before series prefix/SERIES keyword
-        result += " "
-
-        # Add series prefix if present
-        result += "#{id.series_prefix} " if id.series_prefix && !id.series_prefix.empty?
-
-        # Add SERIES keyword
-        result += "SERIES"
-
-        # Add year
-        result += series_year_portion(id)
-
-        # Add reaffirmation
-        result += render_reaffirmation(id) if id.reaffirmation && !id.reaffirmation.to_s.empty?
-
-        result
-      end
-
-      private
-
-      # Reaffirmation rendering helper - shared across Base, Cec, and Series
-      def render_reaffirmation(id)
-        # Check if year was originally 2-digit (original_year_4digit flag)
-        year_was_2digit = !id.original_year_4digit
-
-        # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-        reaffirmation_was_4digit = id.original_reaffirmation_4digit
-
-        # Preserve original reaffirmation format
-        reaffirmation_str = if reaffirmation_was_4digit
-                              # Original was 4-digit, keep as-is
-                              id.reaffirmation.to_s
-                            elsif id.reaffirmation.to_s.length == 4 && id.reaffirmation.to_s.start_with?("19", "20")
-                              # Original was 2-digit, convert 4-digit storage back to 2-digit
-                              id.reaffirmation.to_s[2..3]
-                            else
-                              # Already 2-digit or other format
-                              id.reaffirmation.to_s
-                            end
-
-        # Determine spacing based on original formats
-        if year_was_2digit && reaffirmation_was_4digit
-          # Year was 2-digit, reaffirmation was 4-digit → add space
-          " (R#{reaffirmation_str})"
-        else
-          # Both 2-digit, both 4-digit, or other cases → no space
-          "(R#{reaffirmation_str})"
-        end
-      end
-
-      # The publisher prefix to print. A code_only identifier printed none, so
-      # it must not gain the default "CSA" — see SingleIdentifier#code_only.
-      def publisher_prefix_for(id)
-        return "" if id.respond_to?(:code_only) && id.code_only
-
-        id.publisher_prefix || "CSA"
-      end
-
-      def series_publisher_prefix_portion(id)
-        prefix = publisher_prefix_for(id)
-
-        # Handle code_only identifiers (empty string means no prefix)
-        return "" if prefix == ""
-
-        # Determine if we need space after prefix
-        # CAN/CSA- and CAN3- end with dash, so no space needed
-        needs_space = !prefix.end_with?("-")
-
-        needs_space ? "#{prefix} " : prefix
-      end
-
-      def series_year_portion(id)
-        return "" unless id.year
-
-        # Use dash if year_format is dash, otherwise colon
-        separator = id.year_format == "dash" ? "-" : ":"
-        year_part = separator
-        year_part += id.year_prefix if id.year_prefix # Add M or F prefix
-        year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
-
-        # Convert 4-digit year back to 2-digit
-        year_str = id.year.to_s
-        year_part += if year_str.length == 4 && year_str.start_with?("20")
-                       year_str[2..3]
-                     else
-                       year_str
-                     end
-
-        year_part
-      end
-    end
-  end
-end

data/lib/pubid/csa/urn_parser.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Csa
-    # Parses CSA URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:csa:{publisher}:{code}:{year}:format.{format}
-    #
-    # The trailing `format.X` token records the year-separator style used
-    # in the human-readable form (`dash` for `-`, `colon` for `:`).
-    #
-    # Examples:
-    # - urn:csa:csa:Z240.2.1:16:format.dash → CSA Z240.2.1-16
-    class UrnParser < Pubid::UrnParser::Base
-      YEAR_SEPARATOR = { "dash" => "-", "colon" => ":" }.freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        format_token = parts.find { |p| p.start_with?("format.") }
-        separator = YEAR_SEPARATOR.fetch(format_token&.split(".")&.last, "-")
-
-        payload = parts.reject { |p| p.start_with?("format.") }
-        _publisher, code, year = payload
-        text = "CSA #{code}"
-        text += "#{separator}#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/doi/builder.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Doi
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        Identifiers::Resource.new(
-          prefix: "10.#{data[:prefix]}",
-          suffix: data[:suffix].to_s,
-        )
-      end
-    end
-  end
-end