pubid 1.15.21 → 2.0.0.alpha.10

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 < ::Pubid::Parser::Grammar
+        # 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,114 @@
+# 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
+        # The NESC's own designation (ANSI/IEEE C2). Used as the index code for
+        # the year-first forms, which print no code of their own.
+        #
+        # CAVEAT: this files the whole NESC family — including the Handbook and
+        # Redline, which are companions of the code rather than the code itself
+        # — under one `prefix "C"` + `number "2"` index key. That is deliberate:
+        # relaton narrows on `root.number` and then matches the full hash, so
+        # `_type` (and `variant`) keep the documents distinct; the alternative
+        # was an empty key, which silently defeats the binary search. Revisit if
+        # relaton ever treats `prefix + number` alone as an identity.
+        DEFAULT_CODE = "C2"
+
+        # 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)
+
+          # The code travels through the base initializer as `code:` so it lands
+          # in `code_obj` and the CodeNumber mixin hoists the flat split columns
+          # relaton indexes on. Every NESC document is the C2-designated code
+          # (or a companion of it), so the year-first forms — which print no
+          # code — still key under "C2" rather than leaving `root.number` empty.
+          identifier = identifier_class.new(
+            code: parsed_hash[:code]&.to_s || DEFAULT_CODE,
+          )
+
+          # Set year (required for all NESC identifiers)
+          if parsed_hash[:year]
+            identifier.year = parsed_hash[:year].to_s
+          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 month (for drafts)
+          if parsed_hash[:month]
+            identifier.month = parsed_hash[:month].to_s
+          end
+
+          # Registered-trademark "(R)" marks and the "(NESC(R))" abbreviation
+          # suffix (year-first forms) — see Identifiers::Nesc::Base#name_portion.
+          identifier.registered = true if parsed_hash[:name_registered] ||
+            parsed_hash[:abbr_registered]
+          if parsed_hash[:paren_abbr]
+            identifier.abbr_suffix = true
+            identifier.abbr_suffix_registered = true if parsed_hash[:paren_registered]
+          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]
+
+          # Plain year-first edition. Never the abstract Nesc::Base — only
+          # concrete leaves carry the CodeNumber `number` column.
+          Identifiers::Nesc::Edition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# 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 < ::Pubid::Parser::Grammar
+        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 (the "(R)" registered mark is captured
+        # separately by the `registered` rule so it can be round-tripped)
+        rule(:nesc_full_name) do
+          str("National Electrical Safety Code") |
+            str("National Electric Safety Code") # Typo variation
+        end
+
+        rule(:nesc_abbr) do
+          str("NESC")
+        end
+
+        rule(:nesc_name) do
+          nesc_full_name | nesc_abbr
+        end
+
+        # Registered trademark notation
+        rule(:registered) do
+          str("(R)")
+        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 >> registered.maybe >>
+            (space >> str("(") >> nesc_abbr >> registered.maybe >> 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) abbreviation suffix
+              (nesc_full_name.as(:full_name) >> registered.as(:name_registered).maybe >>
+               (space >> str("(") >> nesc_abbr.as(:paren_abbr) >>
+                registered.as(:paren_registered).maybe >> str(")")).maybe) |
+              # Just the NESC abbreviation (e.g. "2017 NESC(R) Handbook")
+              (nesc_abbr.as(:abbr) >> registered.as(:abbr_registered).maybe)
+            ) >>
+            (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 >> registered.maybe >>
+            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 >> registered.maybe >>
+            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