pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/ieee/scheme.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "typed_stages"
+
+module Pubid
+  module Ieee
+    # Scheme provides registry access for IEEE identifiers
+    # Following the proven ISO/IEC/CEN/BSI pattern
+    #
+    # This class is the single source of truth for:
+    # - TypedStage lookup by abbreviation
+    # - TypedStage lookup by IEEE draft notation
+    # - TypedStage lookup by ISO stage code
+    # - Identifier class selection based on type code
+    class Scheme < Pubid::Scheme
+      class << self
+        # Locate typed stage by abbreviation
+        # @param abbr [String, nil] stage abbreviation (e.g., "D1", "FDIS", "Std")
+        # @return [Components::TypedStage] matching typed stage
+        def locate_typed_stage_by_abbr(abbr)
+          return TypedStages::DEFAULT_TYPED_STAGE if abbr.nil? || abbr.to_s.strip.empty?
+
+          # Normalize abbreviation
+          abbr_str = abbr.to_s.strip
+
+          # Find typed stage that includes this abbreviation
+          typed_stage = TypedStages::TYPED_STAGES.find { |ts| ts.abbr.include?(abbr_str) }
+
+          # Fall back to default if not found
+          typed_stage || TypedStages::DEFAULT_TYPED_STAGE
+        end
+
+        # Locate typed stage by IEEE draft notation
+        # @param draft [String] IEEE draft notation (e.g., "D1", "D5", "P")
+        # @return [Components::TypedStage, nil] matching typed stage
+        def locate_typed_stage_by_ieee_draft(draft)
+          return nil if draft.nil? || draft.to_s.strip.empty?
+
+          draft_str = draft.to_s.strip
+
+          # Try exact match on abbreviation first
+          ts = TypedStages::TYPED_STAGES.find { |t| t.abbr.include?(draft_str) }
+          return ts if ts
+
+          # Try match on ieee_draft_equivalent
+          TypedStages::TYPED_STAGES.find { |t| t.ieee_draft_equivalent == draft_str }
+        end
+
+        # Locate typed stage by ISO stage code
+        # @param stage [String] ISO stage code (e.g., "WD", "CD", "DIS", "FDIS")
+        # @return [Components::TypedStage, nil] matching typed stage
+        def locate_typed_stage_by_iso_stage(stage)
+          return nil if stage.nil? || stage.to_s.strip.empty?
+
+          TypedStages::TYPED_STAGES.find { |ts| ts.iso_stage_equivalent == stage.to_s.strip }
+        end
+
+        # Locate identifier class by type code
+        # @param type_code [String, Symbol] type code (:standard, :draft, :std, :P, etc.)
+        # @return [Class] identifier class
+        def locate_identifier_klass_by_type_code(type_code)
+          type_str = type_code.to_s
+
+          case type_str
+          when "draft", "Draft Std", "Draft", "P"
+            # "P" indicates project draft status - maps to ProjectDraftIdentifier
+            Identifiers::ProjectDraftIdentifier
+          when "standard", "Std", "std"
+            Identifiers::Standard
+          else
+            # Default to base identifier
+            Identifiers::Base
+          end
+        end
+
+        # Get all typed stages
+        # @return [Array<Components::TypedStage>] all registered typed stages
+        def typed_stages
+          TypedStages::TYPED_STAGES
+        end
+
+        # Get default typed stage (published standard)
+        # @return [Components::TypedStage] default typed stage
+        def default_typed_stage
+          TypedStages::DEFAULT_TYPED_STAGE
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/typed_stages.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # Registry of all IEEE typed stages
+    # Single source of truth for stage/type combinations
+    #
+    # IEEE has three approval levels:
+    # 1. Unapproved Draft (D1-D6): Working drafts
+    # 2. Approved Draft (D7-D9): Board-approved but unpublished
+    # 3. Published: Final standards (no P prefix, no D number)
+    #
+    # For joint development with ISO/IEC, both IEEE and ISO stages may appear
+    module TypedStages
+      TYPED_STAGES = [
+        # Published Standards (no P prefix, no draft notation)
+        Components::TypedStage.new(
+          abbr: ["Std"],
+          stage_code: "published",
+          type_code: "standard",
+          approval_status: "published",
+          project_status: false,
+        ),
+
+        # IEEE Draft Stages (P prefix, unapproved)
+        # D1 - Initial working draft
+        Components::TypedStage.new(
+          abbr: ["D1"],
+          stage_code: "working_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D1",
+          iso_stage_equivalent: "WD",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        # D2, D3 - Committee draft stages
+        Components::TypedStage.new(
+          abbr: ["D2", "D3"],
+          stage_code: "committee_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D2-D3",
+          iso_stage_equivalent: "CD",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        # D4, D5, D6 - Draft standard stages
+        Components::TypedStage.new(
+          abbr: ["D4", "D5", "D6"],
+          stage_code: "draft_standard",
+          type_code: "draft",
+          ieee_draft_equivalent: "D4-D6",
+          iso_stage_equivalent: "DIS",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        # IEEE Draft Stages (P prefix, approved but unpublished)
+        # D7, D8, D9 - Final draft (board-approved)
+        Components::TypedStage.new(
+          abbr: ["D7", "D8", "D9"],
+          stage_code: "final_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D7-D9",
+          iso_stage_equivalent: "FDIS",
+          approval_status: "approved",
+          project_status: true,
+        ),
+
+        # ISO Stages (for joint development with ISO/IEC/IEEE)
+        # These stages appear in joint development identifiers
+        Components::TypedStage.new(
+          abbr: ["PWI"],
+          stage_code: "preliminary",
+          type_code: "draft",
+          ieee_draft_equivalent: "P",
+          iso_stage_equivalent: "PWI",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        Components::TypedStage.new(
+          abbr: ["NP"],
+          stage_code: "new_proposal",
+          type_code: "draft",
+          ieee_draft_equivalent: "P",
+          iso_stage_equivalent: "NP",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        Components::TypedStage.new(
+          abbr: ["WD"],
+          stage_code: "working_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D1",
+          iso_stage_equivalent: "WD",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        Components::TypedStage.new(
+          abbr: ["CD", "CD2", "CD3"],
+          stage_code: "committee_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D2-D3",
+          iso_stage_equivalent: "CD",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        Components::TypedStage.new(
+          abbr: ["DIS"],
+          stage_code: "draft_international_standard",
+          type_code: "draft",
+          ieee_draft_equivalent: "D5",
+          iso_stage_equivalent: "DIS",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        Components::TypedStage.new(
+          abbr: ["FDIS"],
+          stage_code: "final_draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "D8",
+          iso_stage_equivalent: "FDIS",
+          approval_status: "approved",
+          project_status: true,
+        ),
+
+        # Historical stages (AIEE, IRE)
+        # "No" or "No." for AIEE standards
+        Components::TypedStage.new(
+          abbr: ["No", "No."],
+          stage_code: "published",
+          type_code: "standard",
+          approval_status: "published",
+          project_status: false,
+        ),
+
+        # Generic "P" prefix for drafts (when specific D number not known)
+        Components::TypedStage.new(
+          abbr: ["P"],
+          stage_code: "draft",
+          type_code: "draft",
+          ieee_draft_equivalent: "P",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
+        # Draft without specific version (legacy)
+        Components::TypedStage.new(
+          abbr: ["Draft"],
+          stage_code: "draft",
+          type_code: "draft",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+      ].freeze
+
+      # Default typed stage for published standards
+      DEFAULT_TYPED_STAGE = TYPED_STAGES.first
+    end
+
+    # Backward compatibility aliases at module level
+    # These allow code expecting Pubid::Ieee::TYPED_STAGES to still work
+    TYPED_STAGES = TypedStages::TYPED_STAGES
+    DEFAULT_TYPED_STAGE = TypedStages::DEFAULT_TYPED_STAGE
+  end
+end

data/lib/pubid/ieee/urn_generator.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "ieee"]
+
+        parts << publisher_component
+
+        special_type = special_identifier_type_component
+        parts << special_type if special_type
+
+        tc = type_component
+        parts << tc if tc
+
+        cc = code_component
+        parts << cc if cc
+
+        parts << identifier.year if identifier.year
+
+        dc = draft_component
+        parts << dc if dc
+
+        ec = edition_component
+        parts << ec if ec
+
+        md = month_day_component
+        parts << md if md
+
+        ds = draft_status_component
+        parts << ds if ds
+
+        if !special_type && identifier.redline
+          parts << "redline"
+        end
+
+        if !special_type && identifier.interpretation
+          parts << "int"
+        end
+
+        if special_type != "conformance" && identifier.conf_number
+          conf = "conf.#{identifier.conf_number}"
+          conf += "-#{identifier.conf_year}" if identifier.conf_year
+          parts << conf
+        end
+
+        if identifier.ashrae_number
+          ashrae = "ashrae.#{identifier.ashrae_number}"
+          ashrae += "-#{identifier.ashrae_year}" if identifier.ashrae_year
+          parts << ashrae
+        end
+
+        if identifier.crossref
+          parts << "xref.#{identifier.crossref}"
+        end
+
+        if identifier.relationships&.any?
+          rel = identifier.relationships.join("/")
+          parts << "rel.#{rel}"
+        end
+
+        if identifier.revision_of
+          parts << "revof.#{identifier.revision_of}"
+        end
+
+        if identifier.amendment_to
+          parts << "amdto.#{identifier.amendment_to}"
+        end
+
+        if identifier.adoption
+          parts << "adopt.#{identifier.adoption}"
+        end
+
+        reaffirmed = maybe(:reaffirmed)
+        if reaffirmed
+          parts << "reaff.#{reaffirmed}"
+        end
+
+        if identifier.note
+          parts << "note.#{identifier.note}"
+        end
+
+        if identifier.nickname
+          parts << "nick.#{identifier.nickname}"
+        end
+
+        parts.join(":")
+      end
+
+      private
+
+      def special_identifier_type_component
+        class_name = identifier.class.name.to_s
+
+        case class_name
+        when /RedlinedStandard/
+          "redlined"
+        when /SiStandard/
+          "si"
+        when /ConformanceIdentifier/
+          "conformance"
+        when /InterpretationIdentifier/
+          "interpretation"
+        when /SupplementIdentifier/
+          if identifier.typed_stage
+            type_code = identifier.typed_stage.type_code
+            case type_code.to_s
+            when "amd"
+              "amendment"
+            when "cor"
+              "corrigendum"
+            when "errata"
+              "errata"
+            else
+              type_code.to_s
+            end
+          end
+        else
+          if identifier.typed_stage
+            type_code = identifier.typed_stage.type_code
+            case type_code.to_s
+            when "SI"
+              "si"
+            end
+          end
+        end
+      end
+
+      def publisher_component
+        pub = identifier.publisher || "IEEE"
+        pub = pub.to_s.downcase
+
+        if identifier.copublisher&.any?
+          copubs = identifier.copublisher.map(&:to_s).map(&:downcase)
+          pub = [pub, *copubs].join("-")
+        end
+
+        pub
+      end
+
+      def type_component
+        return nil unless identifier.type
+
+        type = identifier.type
+        return nil if !type || type.to_s.strip.empty? || type.to_s == "Std"
+
+        type.to_s.downcase.gsub(" ", ".")
+      end
+
+      def code_component
+        return nil unless identifier.code_obj
+
+        identifier.code_obj.to_s
+      end
+
+      def draft_component
+        return nil unless identifier.draft_obj
+
+        "draft.#{identifier.draft_obj}"
+      end
+
+      def edition_component
+        return nil unless identifier.edition
+
+        "ed.#{identifier.edition}"
+      end
+
+      def month_day_component
+        parts = []
+
+        parts << identifier.month if identifier.month
+        parts << identifier.day if identifier.day
+
+        return nil if parts.empty?
+
+        parts.join("-")
+      end
+
+      def draft_status_component
+        return nil unless identifier.draft_status
+
+        status = identifier.draft_status.downcase
+        status.gsub(" ", ".")
+      end
+    end
+  end
+end

data/lib/pubid/ieee.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    autoload :Aiee, "#{__dir__}/ieee/aiee"
+    autoload :Builder, "#{__dir__}/ieee/builder"
+    autoload :Identifier, "#{__dir__}/ieee/identifier"
+    autoload :Identifiers, "#{__dir__}/ieee/identifiers"
+    autoload :Ire, "#{__dir__}/ieee/ire"
+    autoload :Nesc, "#{__dir__}/ieee/nesc"
+    autoload :Parser, "#{__dir__}/ieee/parser"
+    autoload :Scheme, "#{__dir__}/ieee/scheme"
+    autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
+    autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
+
+    # Components submodule
+    module Components
+      autoload :Code, "#{__dir__}/ieee/components/code"
+      autoload :Draft, "#{__dir__}/ieee/components/draft"
+      autoload :Relationship, "#{__dir__}/ieee/components/relationship"
+      autoload :TypedStage, "#{__dir__}/ieee/components/typed_stage"
+    end
+
+    class << self
+      def parse(input)
+        Identifier.parse(input)
+      end
+    end
+  end
+end
+
+Pubid::Registry.register(:ieee, Pubid::Ieee)

data/lib/pubid/ieee_debug.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    autoload :Aiee, "#{__dir__}/aiee"
+    autoload :Builder, "#{__dir__}/builder"
+    autoload :Identifier,
+             "#{__dir__}/identifier (DEBUG: __dir__ is \#{__dir__})"
+    autoload :Identifiers, "#{__dir__}/identifiers"
+    autoload :Ire, "#{__dir__}/ire"
+    autoload :Nesc, "#{__dir__}/nesc"
+    autoload :Parser, "#{__dir__}/parser"
+    autoload :Scheme, "#{__dir__}/scheme"
+    autoload :TypedStages, "#{__dir__}/typed_stages"
+    autoload :UrnGenerator, "#{__dir__}/urn_generator"
+
+    # Components submodule
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :Draft, "#{__dir__}/components/draft"
+      autoload :Relationship, "#{__dir__}/components/relationship"
+      autoload :TypedStage, "#{__dir__}/components/typed_stage"
+    end
+
+    class << self
+      def parse(input)
+        Identifier.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/iho/builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Build IHO identifier objects from parslet parse output.
+    class Builder
+      def build(parsed)
+        hash = parsed.is_a?(Array) ? parsed.reduce({}, :merge) : parsed
+        type_letter = stringify(hash[:type])
+
+        attrs = {
+          code: stringify(hash[:code]),
+          appendix: stringify(hash[:appendix]),
+          part: stringify(hash[:part]),
+          annex: stringify(hash[:annex]),
+          supplement: stringify(hash[:supplement]),
+          version: stringify(hash[:version]),
+        }.compact
+
+        Scheme.identifier_klass_for_type_letter(type_letter).new(**attrs)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Entry point for parsing IHO identifiers.
+    module Identifier
+      # Parse an IHO identifier string into an identifier object
+      # @param identifier [String] The IHO identifier string to parse
+      # @return [Pubid::Iho::Identifiers::Base] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # Base class for all IHO identifiers.
+      #
+      # IHO identifiers have the form:
+      #   IHO {S|P|M|B|C}-{code}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
+      #
+      # The leading IHO publisher prefix is optional on input but always
+      # emitted on output.
+      class Base < Pubid::Identifier
+        attribute :publisher,  :string, default: "IHO"
+        attribute :code,       :string
+        attribute :appendix,   :string
+        attribute :part,       :string
+        attribute :annex,      :string
+        attribute :supplement, :string
+        attribute :version,    :string
+
+        def self.parse(string)
+          Iho::Identifier.parse(string)
+        end
+
+        # Render the identifier as a string in canonical IHO form.
+        # @return [String]
+        def to_s
+          letter = type.is_a?(Hash) ? type[:short].to_s : type.to_s
+          rendered = "#{publisher} #{letter}-#{code}"
+          rendered << " Ap. #{appendix}" if appendix
+          rendered << " Part #{part}"    if part
+          rendered << " Annex #{annex}"  if annex
+          rendered << " Suppl #{supplement}" if supplement
+          rendered << " #{version}" if version
+          rendered
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers/bibliographic.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Bibliographic Publication (B series).
+      # Example: IHO B-4 2.19.0.
+      class Bibliographic < Base
+        def self.type
+          { key: :bibliographic, title: "Bibliographic Publication",
+            short: "B" }
+        end
+
+        def type
+          self.class.type
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers/circular_letter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Circular Letter (C series).
+      # Example: IHO C-13 1.0.0.
+      class CircularLetter < Base
+        def self.type
+          { key: :circular_letter, title: "Circular Letter", short: "C" }
+        end
+
+        def type
+          self.class.type
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers/miscellaneous.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Miscellaneous Publication (M series).
+      # Example: IHO M-3 2.0.0.
+      class Miscellaneous < Base
+        def self.type
+          { key: :miscellaneous, title: "Miscellaneous Publication",
+            short: "M" }
+        end
+
+        def type
+          self.class.type
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers/publication.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Publication (P series).
+      # Examples: IHO P-1 1.0.0, IHO P-1/21 1.0.0, IHO P-6-3 1.0.0.
+      class Publication < Base
+        def self.type
+          { key: :publication, title: "Publication", short: "P" }
+        end
+
+        def type
+          self.class.type
+        end
+      end
+    end
+  end
+end