pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # SI Standard (Système International) identifier
+      # IEEE/ASTM SI standards for metric system
+      # Handles both:
+      # - SI: Published standards (IEEE/ASTM SI 10-1997)
+      # - PSI: Proposed SI (drafts: IEEE/ASTM PSI 10/D2, October 2015)
+      class SiStandard < Base
+        # TYPED_STAGES for SI standards
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["SI"],
+            type_code: "SI",
+            stage_code: "published",
+          ),
+          Components::TypedStage.new(
+            abbr: ["PSI"],
+            type_code: "SI",
+            stage_code: "draft",
+          ),
+        ].freeze
+
+        # SI standards always have IEEE/ASTM publisher
+        # Format: "IEEE/ASTM SI 10-1997" (published)
+        #     or: "IEEE/ASTM PSI 10/D2, October 2015" (draft)
+
+        # Use proper Draft component (Lutaml::Model object)
+        attr_accessor :draft_obj
+
+        def to_s
+          parts = []
+
+          # Publisher (IEEE/ASTM)
+          parts << "IEEE/ASTM"
+
+          # Type (SI or PSI based on typed_stage)
+          parts << if typed_stage&.abbr&.include?("PSI")
+                     "PSI"
+                   else
+                     "SI"
+                   end
+
+          # Code (number) with draft version for PSI
+          code_part = code.to_s
+          if draft_obj
+            # Use Draft component's version attribute
+            code_part += "/D#{draft_obj.version}"
+          end
+          parts << code_part if code
+
+          # Date
+          if month && year
+            parts << ", #{month} #{year}"
+          elsif year
+            parts << "-#{year}"
+          end
+
+          # Relationships (if present)
+          result = parts.join(" ")
+          if relationships && !relationships.empty?
+            rel_strs = relationships.map(&:to_s)
+            result += " (#{rel_strs.join(' / ')})"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Standard identifier for IEEE standards
+      #
+      # Represents published IEEE standards with the standard format:
+      # "IEEE Std XXX-YYYY"
+      #
+      # @example Standard IEEE identifier
+      #   std = Pubid::Ieee.parse("IEEE Std 802.3-2018")
+      #   std.code.to_s  # => "802.3"
+      #   std.year       # => "2018"
+      #
+      # @example With co-publisher
+      #   std = Pubid::Ieee.parse("ANSI/IEEE Std 500-1984")
+      #   std.publisher        # => "IEEE"
+      #   std.copublisher     # => ["ANSI"]
+      class Standard < Base
+        # TYPED_STAGES for published IEEE standards
+        # Standards use "Std" abbreviation for published state
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["Std"],
+            type_code: "standard",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :std, title: "Standard", short: "Std" }
+        end
+
+        # Render standard IEEE format
+        #
+        # @return [String] IEEE Std XXX-YYYY format
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Base class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
+      # Supplements modify or add to a base document
+      class SupplementIdentifier < Base
+        attribute :base_identifier, Base, polymorphic: true
+
+        # Delegate publisher to base_identifier
+        def publisher
+          base_identifier&.publisher
+        end
+
+        # Delegate code to base_identifier if not overridden
+        def code
+          base_identifier&.code
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      autoload :AdoptedStandard, "#{__dir__}/identifiers/adopted_standard"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :ConformanceIdentifier,
+               "#{__dir__}/identifiers/conformance_identifier"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :CsaDualPublished, "#{__dir__}/identifiers/csa_dual_published"
+      autoload :DualIdentifier, "#{__dir__}/identifiers/dual_identifier"
+      autoload :DualPublished, "#{__dir__}/identifiers/dual_published"
+      autoload :IecIeeeCopublished,
+               "#{__dir__}/identifiers/iec_ieee_copublished"
+      autoload :InterpretationIdentifier,
+               "#{__dir__}/identifiers/interpretation_identifier"
+      autoload :JointDevelopment, "#{__dir__}/identifiers/joint_development"
+      autoload :MultiNumberedIdentifier,
+               "#{__dir__}/identifiers/multi_numbered_identifier"
+      autoload :Nesc, "#{__dir__}/identifiers/nesc"
+      autoload :ParentheticalIdentifier,
+               "#{__dir__}/identifiers/parenthetical_identifier"
+      autoload :ProjectDraftIdentifier,
+               "#{__dir__}/identifiers/project_draft_identifier"
+      autoload :RedlinedStandard, "#{__dir__}/identifiers/redlined_standard"
+      autoload :SiStandard, "#{__dir__}/identifiers/si_standard"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :SupplementIdentifier,
+               "#{__dir__}/identifiers/supplement_identifier"
+    end
+  end
+end

data/lib/pubid/ieee/ire/builder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Ire
+      # Builder for IRE identifiers
+      class Builder
+        def build(parsed)
+          attributes = {}
+
+          # Extract publisher
+          attributes[:publisher] = extract_value(parsed[:publisher])
+
+          # Extract type
+          attributes[:type] = extract_value(parsed[:type])
+
+          # Extract number
+          number_str = extract_value(parsed[:number])
+          if number_str
+            attributes[:number] = Components::Code.parse(number_str)
+          end
+
+          # Extract year - handle both short (52) and full (1952) formats
+          year_str = extract_value(parsed[:year])
+          if year_str
+            year_int = year_str.to_i
+            # Convert 2-digit years to 4-digit (12-63 => 1912-1963)
+            if year_int.between?(12, 63)
+              year_int += 1900
+            end
+            attributes[:year] = year_int
+          end
+
+          # Override with full_year if present
+          full_year_str = extract_value(parsed[:full_year])
+          if full_year_str
+            attributes[:year] = full_year_str.to_i
+          end
+
+          # Create identifier
+          Identifier.new(**attributes)
+        end
+
+        private
+
+        def extract_value(value)
+          return nil if value.nil?
+          return nil if value.is_a?(Array) && value.empty?
+
+          if value.is_a?(Array)
+            joined = value.join
+            return joined.length.positive? ? joined : nil
+          end
+
+          str_value = value.to_s.strip
+          str_value.length.positive? ? str_value : nil
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/ire/identifier.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Ire
+      # Base class for IRE identifiers
+      # IRE (Institute of Radio Engineers): 1912-1963
+      class Identifier < Lutaml::Model::Serializable
+        attribute :publisher, :string, default: -> { "IRE" }
+        attribute :type, :string # "Trans.", "Standard", "Std"
+        attribute :number, Components::Code
+        attribute :year, :integer
+
+        def initialize(**args)
+          super()
+
+          # Handle number as string or Code object
+          if args[:number].is_a?(String)
+            self.number = Components::Code.parse(args[:number])
+          elsif args[:number]
+            self.number = args[:number]
+          end
+
+          # Set other attributes
+          attrs = self.class.attributes
+          args.each do |key, value|
+            next if key == :number
+
+            setter = :"#{key}="
+            public_send(setter, value) if attrs.key?(key)
+          end
+        end
+
+        # Parse IRE identifier string
+        def self.parse(input)
+          parsed = Parser.new.parse(input)
+          builder = Builder.new
+          builder.build(parsed)
+        end
+
+        def to_s
+          parts = []
+          # Year comes FIRST in IRE format - render as 2-digit short year
+          if year
+            short_year = year.between?(1900, 1999) ? year - 1900 : year
+            parts << short_year.to_s
+          end
+          parts << publisher
+          parts << type if type
+          parts << number.to_s if number
+          parts.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/ire/parser.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ieee
+    module Ire
+      # Parser for IRE (Institute of Radio Engineers) identifiers
+      # Historical period: 1912-1963 (merged into IEEE in 1963)
+      class Parser < Parslet::Parser
+        # Basic building blocks
+        rule(:space) { str(" ") }
+        rule(:space?) { space.maybe }
+        rule(:dash) { str("-") }
+        rule(:dot) { str(".") }
+        rule(:digit) { match("[0-9]") }
+        rule(:digits) { digit.repeat(1) }
+        rule(:letter) { match("[A-Za-z]") }
+        rule(:upper) { match("[A-Z]") }
+
+        # Year pattern - handle both 2-digit (52 = 1952) and 4-digit (1952) formats
+        rule(:year_short) do
+          # 2-digit year: 12-63 (1912-1963 IRE period)
+          match("[1-6]") >> digit
+        end
+
+        rule(:year_full) do
+          # 4-digit year for IRE period: 1912-1963
+          (str("191") >> digit.repeat(1, 1)) | # 1912-1919
+            (str("19") >> (str("2") | str("3") | str("4") | str("5")) >> digit) | # 1920-1959
+            (str("196") >> match("[0-3]")) # 1960-1963
+        end
+
+        rule(:year) { year_full | year_short }
+
+        # IRE prefix variations
+        rule(:ire_prefix) do
+          (
+            str("IEEE-IRE") | # Transitional period (1963-1965)
+            str("IRE")
+          ).as(:publisher)
+        end
+
+        # Document types
+        rule(:ire_type) do
+          (
+            str("Trans.") |       # IRE Trans. PGI-7
+            str("Standard") |     # IRE Standard
+            str("Std")            # IRE Std
+          ).as(:type)
+        end
+
+        # Number formats
+        rule(:number) do
+          (
+            # Complex format with spaces: 28 S1, 15.S1, 7.S2
+            (digits >> (space | dot) >> upper >> digits) |
+
+            # Complex format: 1.IRE62.1S1
+            (digits >> dot >> str("IRE") >> digits >> dot >> digits >> upper >> digits) |
+
+            # Transaction format: PGI-7, PGAP-4
+            (upper.repeat(2, 4) >> dash >> digits) |
+
+            # Simple number: 56, 123
+            digits
+          ).as(:number)
+        end
+
+        # Date (year only for IRE)
+        rule(:date) do
+          (space? >> (dash | str(",")).maybe >> space? >> year.as(:year)).maybe
+        end
+
+        # Complete IRE identifier - YEAR FIRST format
+        rule(:ire_identifier) do
+          # Format: "52 IRE 7.S2" or "1952 IRE 7.S2"
+          year.as(:year) >>
+            space >>
+            ire_prefix >>
+            space >>
+            (ire_type >> space).maybe >>
+            number >>
+            (space? >> (dash | str(",")).maybe >> space? >> year_full.as(:full_year)).maybe
+        end
+
+        root(:ire_identifier)
+      end
+    end
+  end
+end

data/lib/pubid/ieee/ire.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Ire
+      autoload :Builder, "#{__dir__}/ire/builder"
+      autoload :Identifier, "#{__dir__}/ire/identifier"
+      autoload :Parser, "#{__dir__}/ire/parser"
+    end
+  end
+end

data/lib/pubid/ieee/nesc/builder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Nesc
+      # Builder for NESC identifier objects
+      #
+      # Transforms parsed hash into appropriate NESC identifier class instances.
+      # Determines the correct identifier type based on parsed attributes and
+      # constructs the object with proper components.
+      #
+      # @example Build standard NESC
+      #   builder = Builder.new
+      #   parsed = { code: "C2", year: "1997" }
+      #   identifier = builder.build(parsed)
+      #   # => #<Pubid::Ieee::Identifiers::Nesc::Standard>
+      #
+      # @example Build handbook
+      #   parsed = { year: "2017", variant: "Handbook", edition: "Premier Edition" }
+      #   identifier = builder.build(parsed)
+      #   # => #<Pubid::Ieee::Identifiers::Nesc::Handbook>
+      class Builder
+        # Build NESC identifier from parsed hash
+        #
+        # @param parsed_hash [Hash] Hash from parser
+        # @return [Identifiers::Nesc::Base] Appropriate NESC identifier instance
+        def build(parsed_hash)
+          # Determine identifier type based on parsed attributes
+          identifier_class = determine_identifier_class(parsed_hash)
+
+          identifier = identifier_class.new
+
+          # Set code if present (C2)
+          if parsed_hash[:code]
+            code_str = parsed_hash[:code].to_s
+            identifier.code = Pubid::Ieee::Components::Code.new(
+              prefix: code_str[0], # "C" from "C2"
+              number: code_str[1..], # "2" from "C2"
+            )
+          end
+
+          # Set year (required for all NESC identifiers)
+          if parsed_hash[:year]
+            identifier.year = Pubid::Components::Date.new(
+              year: parsed_hash[:year].to_s.to_i,
+            )
+          end
+
+          # Set variant (Handbook, Redline, etc.)
+          if parsed_hash[:variant]
+            identifier.variant = parsed_hash[:variant].to_s
+          end
+
+          # Set edition (for handbooks)
+          if parsed_hash[:edition]
+            identifier.edition = parsed_hash[:edition].to_s
+          end
+
+          # Set draft flag
+          if parsed_hash[:draft]
+            identifier.draft = true
+          end
+
+          # Set month (for drafts)
+          if parsed_hash[:month]
+            identifier.month = parsed_hash[:month].to_s
+          end
+
+          identifier
+        end
+
+        private
+
+        # Determine the appropriate identifier class
+        #
+        # @param parsed_hash [Hash] Parsed attributes
+        # @return [Class] Identifier class to instantiate
+        def determine_identifier_class(parsed_hash)
+          # Draft identifiers
+          return Identifiers::Nesc::Draft if parsed_hash[:draft]
+
+          # Variant-based identifiers
+          if parsed_hash[:variant]
+            case parsed_hash[:variant].to_s
+            when "Handbook"
+              return Identifiers::Nesc::Handbook
+            when "Redline"
+              return Identifiers::Nesc::Redline
+            end
+          end
+
+          # C2 code means standard NESC
+          return Identifiers::Nesc::Standard if parsed_hash[:code]
+
+          # Fallback to base class
+          Identifiers::Nesc::Base
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/nesc/parser.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ieee
+    module Nesc
+      # Parser for National Electrical Safety Code (NESC) identifiers
+      #
+      # Handles multiple NESC identifier formats including:
+      # - Standard C2-YYYY format
+      # - Year-first YYYY NESC format
+      # - Draft format
+      # - Handbook and Redline variations
+      #
+      # @example Parse C2 standard
+      #   parser = Parser.new
+      #   result = parser.parse("C2-1997 National Electric Safety Code")
+      #
+      # @example Parse handbook
+      #   parser = Parser.new
+      #   result = parser.parse("2017 NESC Handbook, Premier Edition")
+      class Parser < Parslet::Parser
+        root(:nesc_identifier)
+
+        rule(:space) { str(" ") }
+        rule(:comma) { str(",") }
+        rule(:digit) { match("[0-9]") }
+        rule(:year) { digit.repeat(4, 4) }
+        rule(:dash) { str("-") }
+
+        # C2 code designation
+        rule(:c2_code) do
+          str("C2").as(:code)
+        end
+
+        # NESC name variations
+        rule(:nesc_full_name) do
+          str("National Electrical Safety Code(R)") |
+            str("National Electrical Safety Code") |
+            str("National Electric Safety Code") # Typo variation
+        end
+
+        rule(:nesc_abbr) do
+          str("NESC(R)") | str("NESC")
+        end
+
+        rule(:nesc_name) do
+          nesc_full_name | nesc_abbr
+        end
+
+        # Registered trademark notation
+        rule(:registered) do
+          str("(R)").maybe
+        end
+
+        # Edition notations
+        rule(:edition) do
+          (
+            str("Premier Edition") |
+            str("First Edition") |
+            str("Second Edition") |
+            str("Third Edition") |
+            str("Fourth Edition") |
+            str("Fifth Edition") |
+            str("Sixth Edition") |
+            str("Seventh Edition") |
+            str("Eighth Edition") |
+            str("Ninth Edition") |
+            str("Tenth Edition")
+          ).as(:edition)
+        end
+
+        # Variant types (Handbook, Redline)
+        rule(:variant) do
+          (
+            str("Handbook") |
+            str("Redline")
+          ).as(:variant)
+        end
+
+        # Month names for drafts
+        rule(:month) do
+          (
+            str("January") | str("February") | str("March") |
+            str("April") | str("May") | str("June") |
+            str("July") | str("August") | str("September") |
+            str("October") | str("November") | str("December")
+          ).as(:month)
+        end
+
+        # Pattern 1: C2-YYYY Standard format
+        # Examples: "C2-1997 National Electric Safety Code (NESC)"
+        #           "C2-2012 National Electrical Safety Code"
+        rule(:c2_standard) do
+          c2_code >>
+            dash >>
+            year.as(:year) >>
+            (comma.maybe >> space).maybe >>
+            nesc_full_name >>
+            (space >> str("(") >> nesc_abbr >> str(")")).maybe
+        end
+
+        # Pattern 2: YYYY NESC format (year-first)
+        # Examples: "2017 NESC(R) Handbook, Premier Edition"
+        #           "2017 National Electrical Safety Code(R) (NESC(R))"
+        #           "2012 NESC Handbook"
+        rule(:year_first) do
+          year.as(:year) >>
+            space >>
+            (
+              # Full name with optional (NESC) suffix
+              (nesc_full_name >> registered >>
+               (space >> str("(") >> nesc_abbr >> registered >> str(")")).maybe) |
+              # Just NESC abbreviation
+              (nesc_abbr >> registered)
+            ) >>
+            (space >> variant).maybe >>
+            (comma >> space >> edition).maybe
+        end
+
+        # Pattern 3: Name-first format
+        # Examples: "National Electrical Safety Code, C2-2012"
+        #           "National Electrical Safety Code, C2-2012 - Redline"
+        rule(:name_first) do
+          nesc_full_name >>
+            comma >>
+            space >>
+            c2_code >>
+            dash >>
+            year.as(:year) >>
+            (space >> str("-") >> space >> variant.as(:variant)).maybe
+        end
+
+        # Pattern 4: Draft format
+        # Examples: "Draft National Electrical Safety Code, January 2016"
+        #           "Draft NESC, June 2011"
+        rule(:draft_nesc) do
+          str("Draft").as(:draft) >>
+            space >>
+            nesc_name >>
+            comma >> space >>
+            month >> space >> year.as(:year)
+        end
+
+        # Main identifier rule - try patterns in order
+        # Put most specific patterns first
+        rule(:nesc_identifier) do
+          draft_nesc | name_first | c2_standard | year_first
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/nesc.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Nesc
+      autoload :Builder, "#{__dir__}/nesc/builder"
+      autoload :Parser, "#{__dir__}/nesc/parser"
+    end
+  end
+end