pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/ieee/components/code.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Components
+      # IEEE document code (number with parts/subparts)
+      # Handles formats like:
+      #   802          - simple numbers
+      #   802.15.4     - dotted parts
+      #   C57.12.00    - prefix with parts
+      #   11073-10404  - dashed parts
+      class Code < Lutaml::Model::Serializable
+        attribute :prefix, :string             # C, P for some identifiers
+        attribute :number, :string             # Main number (802, 1234, etc.)
+        attribute :parts, :string, collection: true # Array of part strings
+        attribute :original_separator, :string # Original separator (. or -) from parsing
+
+        def initialize(prefix: nil, number: nil, parts: nil,
+original_separator: nil)
+          super()
+          self.prefix = prefix
+          self.number = number
+          self.parts = parts || []
+          self.original_separator = original_separator
+        end
+
+        # Parse code string into components
+        def self.parse(code_str)
+          return nil if code_str.nil? || code_str.empty?
+
+          # Extract prefix if present (C, P)
+          prefix_match = code_str.match(/^([A-Z])/)
+          prefix = prefix_match ? prefix_match[1] : nil
+
+          # Remove prefix for number parsing
+          remainder = prefix ? code_str[prefix.length..] : code_str
+
+          # Detect the separator used
+          separator = nil
+          if remainder.include?(".")
+            separator = "."
+          elsif remainder.include?("-")
+            separator = "-"
+          end
+
+          # Split by dots or dashes to get number and parts
+          components = remainder.split(/[.-]/)
+          number = components.shift
+
+          new(
+            prefix: prefix,
+            number: number,
+            parts: components.empty? ? nil : components,
+            original_separator: separator,
+          )
+        end
+
+        def to_s
+          result = ""
+          result += prefix if prefix
+          result += number if number # Guard against nil number (e.g., "ANSI X")
+
+          if parts && !parts.empty?
+            # Use original separator if available
+            if original_separator
+              separator = original_separator
+            elsif prefix == "P" || (!prefix && parts.first && parts.first.length > 3)
+              # Fallback to heuristics when original separator unknown
+              # Determine separator based on prefix and pattern:
+              # - Letter prefix (C, etc.) codes use dots: C37.111
+              # - P-prefix codes typically use dashes: P11073-10404
+              # - Pure numeric codes with 5+ digits use dashes: 61523-4 (IEC style)
+              # - Traditional IEEE codes like 802.11 use dots
+              #
+              # Heuristic:
+              # 1. P-prefix or long part (>3 chars) → dash
+              # 2. Letter prefix (except P) → dot
+              # 3. Long number (5+ digits) → dash (IEC pattern)
+              # 4. Default → dot (traditional IEEE)
+              separator = "-"
+            elsif prefix && prefix != "P"
+              separator = "."
+            elsif !prefix && number && number.length >= 5
+              separator = "-"
+            else
+              # Default to dot for traditional IEEE codes like 802.11
+              separator = "."
+            end
+
+            parts.each do |part|
+              result += separator + part
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/components/draft.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Components
+      # IEEE draft version
+      # Handles formats like:
+      #   /D5              - version only
+      #   /D3.4            - version with revision
+      #   /D7, July 2019   - with date
+      class Draft < Lutaml::Model::Serializable
+        attribute :version, :string       # D5, D3, etc.
+        attribute :revision, :string      # .4, .2 in D3.4
+        attribute :year, :string
+        attribute :month, :string
+        attribute :day, :string
+        attribute :original_month, :string # Store original month format
+        attribute :comma_before_month, :boolean, default: -> {
+          false
+        } # Track if comma was in input
+
+        # Month name to number mapping
+        MONTH_NAMES = {
+          "January" => "1", "February" => "2", "March" => "3", "April" => "4",
+          "May" => "5", "June" => "6", "July" => "7", "August" => "8",
+          "September" => "9", "October" => "10", "November" => "11", "December" => "12",
+          "Jan" => "1", "Feb" => "2", "Mar" => "3", "Apr" => "4",
+          "Jun" => "6", "Jul" => "7", "Aug" => "8", "Sep" => "9", "Sept" => "9",
+          "Oct" => "10", "Nov" => "11", "Dec" => "12"
+        }.freeze
+
+        def initialize(version: nil, revision: nil, year: nil, month: nil,
+day: nil)
+          super()
+          self.version = version
+          self.revision = revision
+          self.year = year
+          self.original_month = month # Store original format
+          self.month = convert_month(month)
+          self.day = day
+        end
+
+        # Convert month name to numeric value
+        def convert_month(month_name)
+          return nil unless month_name
+
+          MONTH_NAMES[month_name] || month_name
+        end
+
+        # Access the numeric month value
+        def numeric_month
+          month
+        end
+
+        def to_s
+          result = "/D#{version}"
+          result += ".#{revision}" if revision
+
+          if year
+            # Use original month format to preserve abbreviated vs full names
+            display_month = original_month
+
+            if display_month
+              # Use comma_before_month flag if set, otherwise detect from month format
+              use_comma_before = if defined?(@comma_before_month) && !@comma_before_month.nil?
+                                   @comma_before_month
+                                 else
+                                   # Default: Full month names have comma, abbreviated don't
+                                   display_month.length > 4 && display_month != "Sept"
+                                 end
+
+              result += use_comma_before ? ", #{display_month}" : " #{display_month}"
+              result += " #{day}" if day
+
+              # Abbreviated months: " Year", Full months: ", Year"
+              result += if display_month.length <= 4 || display_month == "Sept"
+                          " #{year}"
+                        else
+                          ", #{year}"
+                        end
+            else
+              result += " #{year}"
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/components/relationship.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Components
+      # Represents a relationship between IEEE identifiers
+      # E.g., "Revision of IEEE Std X, Y" or "incorporates A, B, C"
+      #
+      # Relationships capture metadata about how identifiers relate to each other:
+      # - Revision relationships (one standard revises another)
+      # - Amendment relationships (amendments to base standards)
+      # - Incorporation relationships (one standard incorporates others)
+      # - Adoption relationships (adopting external standards)
+      #
+      # Example usage:
+      #   relationship = Relationship.new(
+      #     relationship_type: Relationship::REVISION_OF,
+      #     related_identifiers: [Base.parse("IEEE Std 802.11-2012")]
+      #   )
+      #   relationship.to_s  # => "Revision of IEEE Std 802.11-2012"
+      class Relationship < Lutaml::Model::Serializable
+        # Relationship type constants
+        REVISION_OF = "revision_of"
+        AMENDMENT_TO = "amendment_to"
+        CORRIGENDUM_TO = "corrigendum_to"
+        INCORPORATES = "incorporates"
+        INCORPORATING = "incorporating" # Synonym for 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" # NEW Session 171: For "Includes IEEE Std X" pattern
+
+        # All valid relationship types
+        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, # NEW Session 171
+        ].freeze
+
+        # Attributes
+        attribute :relationship_type, :string
+
+        # Use regular Ruby attributes to avoid circular dependency
+        # related_identifiers: Array of Base identifiers
+        # intermediate_amendments: Array of Base identifiers (for "as amended by" clause)
+        attr_accessor :related_identifiers, :intermediate_amendments,
+                      :approved_amendments_flag
+
+        # Validation
+        def initialize(**args)
+          # Extract our non-Lutaml attributes before calling super
+          @related_identifiers = args.delete(:related_identifiers)
+          @intermediate_amendments = args.delete(:intermediate_amendments)
+          @approved_amendments_flag = args.delete(:approved_amendments_flag)
+
+          # Let Lutaml handle relationship_type
+          super
+
+          # Normalize INCORPORATING to INCORPORATES for consistent rendering
+          if relationship_type == INCORPORATING
+            self.relationship_type = INCORPORATES
+          end
+
+          # Validate after initialization
+          validate_relationship_type if relationship_type
+        end
+
+        def validate_relationship_type
+          unless VALID_TYPES.include?(relationship_type)
+            raise ArgumentError, "Invalid relationship type: #{relationship_type}. " \
+                                 "Valid types: #{VALID_TYPES.join(', ')}"
+          end
+        end
+
+        # Rendering
+        def to_s
+          return "" if related_identifiers.nil? || related_identifiers.empty?
+
+          # Format: "Relationship Type IEEE Std X, IEEE Std Y, and IEEE Std Z"
+          prefix = format_relationship_prefix
+          ids = format_identifier_list(related_identifiers)
+
+          # Add intermediate amendments if present (for "as amended by" clause)
+          if intermediate_amendments && !intermediate_amendments.empty?
+            amendments = format_identifier_list(intermediate_amendments)
+            "#{prefix} #{ids} as amended by #{amendments}"
+          elsif approved_amendments_flag
+            # "and its approved amendments" clause (no specific list)
+            "#{prefix} #{ids} and its approved amendments"
+          else
+            "#{prefix} #{ids}"
+          end
+        end
+
+        private
+
+        # Get the human-readable prefix for the relationship type
+        def format_relationship_prefix
+          case relationship_type
+          when REVISION_OF then "Revision of"
+          when AMENDMENT_TO then "Amendment to"
+          when CORRIGENDUM_TO then "Corrigendum to"
+          when INCORPORATES, INCORPORATING then "incorporates"
+          when ADOPTION_OF then "Adoption of"
+          when SUPPLEMENT_TO then "Supplement to"
+          when DRAFT_AMENDMENT_TO then "Draft Amendment to"
+          when DRAFT_REVISION_OF then "Draft Revision of"
+          when REAFFIRMATION_OF then "Reaffirmation of"
+          when REDESIGNATION_OF then "Redesignation of"
+          when SUPERSEDES then "Supersedes"
+          when PREVIOUSLY_DESIGNATED_AS then "Previously designated as"
+          when INCLUDES then "Includes" # NEW Session 171
+          else relationship_type
+          end
+        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"
+        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
+            # X, Y, and Z format (Oxford comma)
+            last = identifiers.last
+            others = identifiers[0..-2]
+            "#{others.join(', ')}, and #{last}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/components/typed_stage.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Components
+      # TypedStage combines type and stage information for IEEE identifiers
+      # Following the proven ISO/IEC/CEN/BSI pattern
+      #
+      # IEEE has unique requirements:
+      # - Draft stages (D1-D9) with different approval levels
+      # - "P" (Project) prefix for drafts only
+      # - ISO stage equivalents for joint development (ISO/IEC/IEEE)
+      # - Bidirectional format conversion capability
+      #
+      # Key IEEE stage distinctions:
+      # - Unapproved Draft: Working drafts (D1-D6)
+      # - Approved Draft: Board-approved but unpublished (D7-D9)
+      # - Published: Final standards (no P prefix)
+      class TypedStage < Lutaml::Model::Serializable
+        # All recognized abbreviations for this stage
+        # First in array is canonical abbreviation
+        attribute :abbr, :string, collection: true
+
+        # IEEE-specific stage code
+        # Values: published, working_draft, committee_draft, draft_standard,
+        #         final_draft, preliminary, new_proposal
+        attribute :stage_code, :string
+
+        # Document type code
+        # Values: standard, draft
+        attribute :type_code, :string
+
+        # ISO stage equivalent for joint development (optional)
+        # Values: PWI, NP, WD, CD, DIS, FDIS, or nil
+        attribute :iso_stage_equivalent, :string
+
+        # IEEE draft notation equivalent (optional)
+        # Values: D1, D2-D3, D4-D6, D7-D9, P, or nil
+        attribute :ieee_draft_equivalent, :string
+
+        # Approval status
+        # Values: unapproved, approved, published
+        attribute :approval_status, :string
+
+        # Whether "P" (Project) prefix applies
+        # true for all draft stages, false for published
+        attribute :project_status, :boolean, default: -> { false }
+
+        # Convert to IEEE format representation
+        # @return [String] IEEE format abbreviation
+        def to_ieee_format
+          return abbr.first unless project_status
+
+          ieee_draft_equivalent || "P"
+        end
+
+        # Convert to ISO format representation
+        # @return [String] ISO format stage code
+        def to_iso_format
+          iso_stage_equivalent || abbr.first
+        end
+
+        # Get canonical abbreviation (first in list)
+        # @return [String] canonical abbreviation
+        def canonical_abbreviation
+          abbr.first
+        end
+
+        # Check if this is a draft stage
+        # @return [Boolean] true if draft, false if published
+        def draft?
+          project_status || approval_status != "published"
+        end
+
+        # Check if board-approved
+        # @return [Boolean] true if approved or published
+        def approved?
+          ["approved", "published"].include?(approval_status)
+        end
+
+        # Get display name for stage
+        # @return [String] human-readable stage name
+        def name
+          case stage_code
+          when "published" then "Published Standard"
+          when "working_draft" then "Working Draft"
+          when "committee_draft" then "Committee Draft"
+          when "draft_standard" then "Draft Standard"
+          when "final_draft" then "Final Draft"
+          when "preliminary" then "Preliminary Work Item"
+          when "new_proposal" then "New Work Item Proposal"
+          else stage_code.to_s.split("_").map(&:capitalize).join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifier.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifier
+      class << self
+        def parse(input)
+          Identifiers::Base.parse(input)
+        end
+
+        # Factory mirroring pubid 1.x's `Pubid::Ieee::Identifier.create` API.
+        # Dispatches via {Pubid::Ieee::Scheme.locate_identifier_klass_by_type_code}.
+        # Default subclass (no `type:`) is Identifiers::Standard — the
+        # canonical class produced by parsing typical IEEE identifiers.
+        def create(type: nil, **opts)
+          klass = type ?
+                  Scheme.locate_identifier_klass_by_type_code(type) :
+                  Identifiers::Standard
+          attrs = coerce_create_attrs(opts)
+          # ProjectDraftIdentifier renders the "P" prefix from typed_stage,
+          # not from `type`. Set both so the output matches a parsed form.
+          if klass == Identifiers::ProjectDraftIdentifier
+            attrs[:type] = "P"
+            attrs[:typed_stage] ||= Scheme.locate_typed_stage_by_abbr("P")
+          end
+          klass.new(**attrs)
+        end
+
+        private
+
+        def coerce_create_attrs(opts)
+          attrs = {}
+          attrs[:publisher] = opts[:publisher].to_s if opts[:publisher]
+          if opts[:copublisher]
+            attrs[:copublisher] =
+              Array(opts[:copublisher]).map(&:to_s)
+          end
+          # :code or :number alias
+          if (v = opts[:code] || opts[:number])
+            attrs[:code] = v.to_s
+          end
+          %i[year edition month day draft_status].each do |k|
+            v = opts[k]
+            attrs[k] = v.to_s unless v.nil?
+          end
+          attrs[:redline] = opts[:redline] if opts.key?(:redline)
+          # TODO(create-shim): amendments/corrigenda/revision_of/incorporates
+          # are nested Base relations; not yet wired through.
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/adopted_standard.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Adopted Standard Identifier
+      # IEEE's adoption of another organization's standard
+      # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
+      # This means IEEE adopted ANSI's standard C55.1-1968 as their Std No 18-1968
+      class AdoptedStandard < Base
+        # IEEE's identifier for this adopted standard
+        attribute :ieee_identifier, Base, polymorphic: true
+
+        # Original identifiers from ANSI/ISO/IEC/etc (array for multi-part adoptions)
+        attribute :adopted_identifiers, Base, polymorphic: true,
+                                              collection: true
+
+        def to_s
+          result = ieee_identifier.to_s
+          if adopted_identifiers && !adopted_identifiers.empty?
+            adopted_strs = adopted_identifiers.map(&:to_s)
+            result += " (#{adopted_strs.join(' and ')})"
+          end
+          result
+        end
+
+        def publisher
+          ieee_identifier&.publisher || "IEEE"
+        end
+      end
+    end
+  end
+end