pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/iec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+  end
+end
+
+# Require scheme first
+require_relative "scheme"
+
+# Require all identifier classes
+require_relative "iec/identifiers/international_standard"
+require_relative "iec/identifiers/technical_report"
+require_relative "iec/identifiers/technical_specification"
+require_relative "iec/identifiers/publicly_available_specification"
+require_relative "iec/identifiers/guide"
+require_relative "iec/identifiers/test_report_form"
+require_relative "iec/identifiers/interpretation_sheet"
+require_relative "iec/identifiers/systems_reference_document"
+require_relative "iec/identifiers/working_document"
+require_relative "iec/identifiers/amendment"
+require_relative "iec/identifiers/corrigendum"
+
+# Wrapper identifier types
+require_relative "iec/identifiers/vap_identifier"
+require_relative "iec/identifiers/sheet_identifier"
+require_relative "iec/identifiers/consolidated_identifier"
+require_relative "iec/identifiers/fragment_identifier"
+
+# Additional document types
+require_relative "iec/identifiers/component_specification"
+require_relative "iec/identifiers/operational_document"
+require_relative "iec/identifiers/societal_technology_trend_report"
+require_relative "iec/identifiers/white_paper"
+
+module Pubid
+  module Iec
+    # Primary document types (not supplements)
+    IDENTIFIER_TYPES = [
+      Identifiers::InternationalStandard,
+      Identifiers::TechnicalReport,
+      Identifiers::TechnicalSpecification,
+      Identifiers::PubliclyAvailableSpecification,
+      Identifiers::Guide,
+      Identifiers::TestReportForm,
+      Identifiers::InterpretationSheet,
+      Identifiers::SystemsReferenceDocument,
+      Identifiers::WorkingDocument,
+    ].freeze
+
+    # Supplement types (can appear with / notation)
+    SUPPLEMENT_IDENTIFIER_TYPES = [
+      Identifiers::Amendment,
+      Identifiers::Corrigendum,
+      Identifiers::InterpretationSheet, # ISH can act as supplement (/ISH1:1996)
+      Identifiers::FragmentIdentifier,  # FRAG wraps amendments/corrigenda
+    ].freeze
+
+    # Create the Scheme registry with all identifier types
+    Scheme = Pubid::Scheme.new(
+      identifiers: IDENTIFIER_TYPES,
+      supplement_identifiers: SUPPLEMENT_IDENTIFIER_TYPES,
+    )
+
+    # Main entry point for IEC identifiers
+    def self.parse(identifier_string)
+      parsed = Parser.new.parse(identifier_string)
+      Builder.new(Scheme).build(parsed)
+    end
+
+    # Parse an IEC URN string
+    # @param urn [String] the URN string to parse
+    # @return [Identifier] the parsed identifier
+    # @raise [Errors::ParseError] if URN is invalid
+    def self.parse_urn(urn)
+      UrnParser.parse(urn)
+    end
+  end
+end
+
+require_relative "iec/urn_parser"
+require_relative "iec/builder"
+require_relative "iec/parser"
+
+Pubid::Registry.register(:iec, Pubid::Iec)

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Aiee
+      # Builder for AIEE identifiers
+      class Builder
+        def build(parsed)
+          attributes = {}
+
+          # Extract and normalize publisher
+          # All AIEE variants (AIEE, A.I.E.E., A. I. E. E., IEEE-AIEE) normalize to "AIEE"
+          attributes[:publisher] = "AIEE"
+
+          # Extract and normalize type
+          type_str = extract_value(parsed[:type])
+          # Normalize compound types like "Standard No." to "No"
+          # Also normalize "Standard No" (without dot) to "No"
+          attributes[:type] = if type_str&.start_with?("Standard")
+                                "No"
+                              else
+                                type_str
+                              end
+
+          # Extract code
+          code_str = extract_value(parsed[:number])
+          if code_str
+            attributes[:code] = Components::Code.parse(code_str)
+          end
+
+          # Extract year (convert to string for consistency)
+          year_str = extract_value(parsed[:year])
+          attributes[:year] = year_str&.to_s
+
+          # Extract month
+          month_str = extract_value(parsed[:month])
+          attributes[:month] = month_str if month_str
+
+          # Extract separator (for rendering distinction)
+          separator_str = extract_value(parsed[:separator])
+          attributes[:separator] = separator_str if separator_str
+
+          # Set original format based on parsed data
+          attributes[:original_format] = if separator_str || month_str
+                                           "long"
+                                         else
+                                           "short"
+                                         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/aiee/identifier.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Aiee
+      # Base class for AIEE identifiers
+      # AIEE (American Institute of Electrical Engineers): 1884-1963
+      class Identifier < Lutaml::Model::Serializable
+        attribute :publisher, :string, default: -> { "AIEE" }
+        attribute :type, :string # "No.", "No", "Standard", "Trans."
+        attribute :code, Components::Code
+        attribute :year, :string
+        attribute :month, :string
+        attribute :separator, :string # "," or "." for long form dates
+        attribute :original_format, :string # "short" or "long" (preserves parsed format)
+        attribute :relationships, Pubid::Ieee::Components::Relationship,
+                  collection: true
+
+        def initialize(**args)
+          super()
+
+          # Handle number/code as string or Code object
+          # Builder passes :code, but also support :number for backward compatibility
+          code_value = args[:code] || args[:number]
+          if code_value.is_a?(String)
+            self.code = Components::Code.parse(code_value)
+          elsif code_value
+            self.code = code_value
+          end
+
+          # Set other attributes
+          attrs = self.class.attributes
+          args.each do |key, value|
+            next if %i[code number].include?(key)
+
+            setter = :"#{key}="
+            public_send(setter, value) if attrs.key?(key)
+          end
+        end
+
+        # Provide number accessor for backward compatibility
+        # Returns the string representation of the code
+        def number
+          code&.to_s
+        end
+
+        # Parse AIEE identifier string
+        def self.parse(input)
+          parsed = Parser.new.parse(input)
+          builder = Builder.new
+          builder.build(parsed)
+        end
+
+        def to_s(date_format: nil)
+          result = [publisher]
+          result << type if type
+          result << code.to_s if code
+
+          base = result.join(" ")
+
+          # Determine which format to use
+          # Priority: explicit parameter > original_format > default (long if month/separator, short otherwise)
+          format = date_format&.to_s || original_format
+
+          if !format
+            # Auto-detect from parsed attributes
+            format = month || separator ? "long" : "short"
+          end
+
+          # Date formatting based on format parameter
+          if year
+            case format
+            when "short", :short
+              # Short form: dash + year
+              base += "-#{year}"
+            when "long", :long
+              # Long form: separator + optional month + year
+              sep = separator || "," # Default to comma for long form
+              base += "#{sep} #{"#{month} " if month}#{year}"
+            else
+              # Preserve original format (backward compatibility)
+              base += if separator
+                        "#{separator} #{"#{month} " if month}#{year}"
+                      elsif month
+                        ", #{month} #{year}"
+                      else
+                        "-#{year}"
+                      end
+            end
+          end
+
+          # Add relationships if present
+          if relationships && !relationships.empty?
+            relationship_str = relationships.join(" / ")
+            base += " (#{relationship_str})"
+          end
+
+          base
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ieee
+    module Aiee
+      # Parser for AIEE (American Institute of Electrical Engineers) identifiers
+      # Historical period: 1884-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 (for AIEE period: 1884-1963)
+        rule(:year) do
+          (str("18") >> digit.repeat(2, 2)) | # 1884-1899
+            (str("19") >> (str("0") | str("1") | str("2") | str("3") | str("4") | str("5")) >> digit) | # 1900-1959
+            (str("196") >> match("[0-3]")) # 1960-1963
+        end
+
+        # Month patterns
+        rule(:month_name) 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") |
+            str("Jan") | str("Feb") | str("Mar") | str("Apr") | str("Jun") |
+            str("Jul") | str("Aug") | str("Sep") | str("Sept") | str("Oct") | str("Nov") | str("Dec")
+        end
+
+        # AIEE prefix variations
+        rule(:aiee_prefix) do
+          (
+            str("IEEE-AIEE") |  # Transitional period (1963-1965)
+            str("A.I.E.E.") |   # With dots variant (no spaces)
+            str("A. I. E. E.") | # With dots and spaces variant
+            str("AIEE")
+          ).as(:publisher)
+        end
+
+        # Document types
+        rule(:aiee_type) do
+          (
+            str("Standard No.") |  # AIEE Standard No. 19-1938 (compound type)
+            str("Standard No") |   # AIEE Standard No 19-1938 (compound type, no dot)
+            str("Std No.") |       # AIEE Std No. 800
+            str("Std No") |        # AIEE Std No 800 (no dot)
+            str("Std") |           # AIEE Std 800
+            str("Nos") |          # NEW Session 171: Plural variant (e.g., "Nos 72 and 73")
+            str("No.") |          # AIEE No. 56
+            str("No") |           # AIEE No 18 (can be followed by space)
+            str("no") |           # AIEE no 700 (lowercase variant)
+            str("Standard") |     # AIEE Standard 56
+            str("Trans.")         # AIEE Trans. PAS-84
+          ).as(:type)
+        end
+
+        # Number formats
+        rule(:number) do
+          (
+            # Transaction format: PAS-84, PGI-7
+            (upper.repeat(2, 3) >> dash >> digits) |
+
+            # Complex with letter suffix: 27A, 22A, 1E - allow space before dash
+            # But don't match if it's actually "Nos 72 and 73" pattern
+            (digits >> upper >> (space >> str("and")).absent?) |
+
+            # Decimal number: 750.1, 750.11, 750.5
+            (digits >> dot >> digits) |
+
+            # Number with parenthetical variant: 431 (105)
+            # Pattern: main number followed by alternate number in parentheses
+            (digits.as(:main_number) >> space >> (str("(") >> digits.as(:alt_number) >> str(")")).as(:parenthetical)) |
+
+            # Simple number: 56, 123, 18, 552
+            (digits >>
+
+            # Handle "Nos X and Y" pattern - we only capture first number
+            (space >> str("and") >> space >> digits).absent?)
+          ).as(:number)
+        end
+
+        # Date formats
+        # Long form: ", 1956" or ", November 1955" or ". December 1958" or " -1957" (with space)
+        # NEW: Also support "May-1928" (month dash year, no comma)
+        rule(:date_long) do
+          space? >>
+            (
+              # Format 1: ", Month Year" or ". Month Year"
+              ((str(",") | dot).as(:separator) >> space? >>
+               (month_name.as(:month) >> space).maybe >> year.as(:year)) |
+              # Format 2: " -Year" (space dash year)
+              ((space >> dash).as(:separator) >> space? >> year.as(:year)) |
+              # Format 3: "Month-Year" (NEW - month dash year, no comma/dot/space prefix)
+              (month_name.as(:month) >> dash >> year.as(:year))
+            )
+        end
+
+        # Short form: "-1962" (directly after number) or " -1958" (with space)
+        # ENHANCED: Allow leading space for patterns like "431 (105) -1958"
+        rule(:date_short) do
+          space.maybe >> dash >> year.as(:year)
+        end
+
+        # Combined date rule
+        # Try short form first to avoid matching empty prefix in date_long
+        rule(:date) do
+          (date_short | date_long).maybe
+        end
+
+        # Complete AIEE identifier
+        rule(:aiee_identifier) do
+          aiee_prefix >>
+            space >>
+            (aiee_type >> space).maybe >>
+            number >>
+            date
+        end
+
+        root(:aiee_identifier)
+      end
+    end
+  end
+end

data/lib/pubid/ieee/aiee.rb

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