pubid 2.0.1 → 2.0.2

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

@@ -1,130 +0,0 @@
-# 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 < ::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 (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/ire/parser.rb

@@ -1,109 +0,0 @@
-# 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_year_first) 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
-
-        # Prefix-first format: "IRE 7.S2-1952" (pubid#316 family 2) — the
-        # year trails the designation instead of leading the identifier.
-        # The renderer always emits the year-first short-year form, so this
-        # spelling canonicalizes onto it ("IRE 7.S2-1952" → "52 IRE 7.S2").
-        rule(:ire_identifier_prefix_first) do
-          ire_prefix >>
-            space >>
-            (ire_type >> space).maybe >>
-            number >>
-            date
-        end
-
-        # Year-first is tried first so the original spellings keep their
-        # match; prefix-first claims only what year-first cannot.
-        rule(:ire_identifier) do
-          ire_identifier_year_first | ire_identifier_prefix_first
-        end
-
-        root(:ire_identifier)
-      end
-    end
-  end
-end

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

@@ -1,155 +0,0 @@
-# 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/iho/parser.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Iho
-    # Parser class for IHO identifiers
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space)  { str(" ") }
-      rule(:dash)   { str("-") }
-      rule(:dot)    { str(".") }
-      rule(:digits) { match("[0-9]").repeat(1) }
-
-      rule(:series) do
-        (str("S") | str("P") | str("M") | str("B") | str("C")).as(:type)
-      end
-
-      rule(:number_suffix) do
-        (str(":") >> digits) | (str("/") >> digits) | (dash >> digits) | match("[A-Z]")
-      end
-
-      rule(:number) do
-        (digits >> number_suffix.maybe).as(:number)
-      end
-
-      rule(:appendix) do
-        space >> (str("Appendix") | str("Ap.")) >> space >>
-          (
-            (match("[A-Z]") >> dash >> digits) |
-            digits |
-            match("[A-Z]")
-          ).as(:appendix)
-      end
-
-      rule(:part) do
-        space >> str("Part") >> space >>
-          (
-            (digits >> match("[a-zA-Z]").repeat).as(:part) |
-            match("[A-Z]").as(:part)
-          )
-      end
-
-      rule(:annex) do
-        space >> str("Annex") >> space >> match("[A-Z]").as(:annex)
-      end
-
-      rule(:supplement) do
-        space >> str("Suppl") >> space >> digits.as(:supplement)
-      end
-
-      rule(:version) do
-        space >> (digits >> dot >> digits >> dot >> digits).as(:version)
-      end
-
-      rule(:identifier) do
-        (str("IHO") >> space).maybe >>
-          series >> dash >> number >>
-          appendix.maybe >> part.maybe >> annex.maybe >> supplement.maybe >> version.maybe
-      end
-
-      root :identifier
-
-      def self.parse(string)
-        new.parse(string.strip)
-      end
-    end
-  end
-end

data/lib/pubid/parser/common_parse_methods.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Parser
-    module CommonParseMethods
-      def array_to_str(array)
-        array.reduce(str(array.first)) do |acc, value|
-          acc | str(value)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/parser/common_parse_rules.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Parser
-    module CommonParseRules
-      def self.included(base)
-        base.class_eval do
-          rule(:space) { str(" ") }
-          rule(:space?) { space.maybe }
-
-          rule(:digits) do
-            match('\d').repeat(1)
-          end
-
-          rule(:year) do
-            match('\d').repeat(4, 4).as(:year)
-          end
-
-          rule(:comma) { str(", ") }
-          rule(:comma?) { comma.maybe }
-          rule(:comma_space) { comma | space }
-          rule(:dash) { str("-") }
-          rule(:dot) { str(".") }
-          rule(:words_digits) { match('[\dA-Za-z]').repeat(1) }
-          rule(:words) { match("[A-Za-z]").repeat(1) }
-          rule(:words?) { words.maybe }
-          rule(:year_digits) do
-            (str("19") | str("20")) >> match('\d').repeat(2,
-                                                          2) >> digits.absent?
-          end
-
-          rule(:month_digits) do
-            match('\d').repeat(2, 2)
-          end
-
-          rule(:day_digits) do
-            match('\d').repeat(2, 2)
-          end
-
-          rule(:originator) do
-            organization.as(:publisher) >>
-              (space? >> str("/") >> organization.as(:copublisher)).repeat
-          end
-
-          rule(:comma_month_year) do
-            comma >> words.as(:month) >> space >> year_digits.as(:year)
-          end
-
-          rule(:year_month) do
-            year_digits >> dash >> month_digits
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pubid/parser/grammar.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Parser
-    # The superclass of every flavor grammar.
-    #
-    # Its only job is to keep parslet out of pubid's public contract. Every
-    # grammar failure originates in `Parslet::Atoms::Base#parse`, which
-    # `Parslet::Parser` does not override, so one override here covers all 46
-    # grammars, both public entry points of every flavor, and the cross-flavor
-    # delegation routes (`Pubid::Iso.parse("ITU-T G.711")` runs ITU's grammar)
-    # — without touching the 131 `parse` methods.
-    #
-    # The name is `Grammar`, not `Base`, because {Pubid::Parsers::Base} already
-    # exists and means something unrelated (the MR-string parser).
-    #
-    # Known limit: a rule atom parsed directly, `Parser.new.<rule>.parse(str)`,
-    # bypasses this and raises a bare `Parslet::ParseFailed`. Nothing in the
-    # gem does that.
-    class Grammar < ::Parslet::Parser
-      # A trailing "(all parts)" marks the reference as the whole document.
-      # The flavor grammars that carry their own rule consume it inside
-      # parslet; this shared strip gives every other flavor the same read:
-      # the suffix never reaches the flavor grammar, and the parsed tree
-      # carries :all_parts for the builder to wrap (see Builder::Base).
-      ALL_PARTS_SUFFIX = "(all parts)".freeze
-
-      # @param io [String, IO]
-      # @param options [Hash] passed through to parslet
-      # @raise [Pubid::Errors::ParseError]
-      def parse(io, options = {})
-        if io.is_a?(String) && io.end_with?(ALL_PARTS_SUFFIX)
-          base = io.sub(/\s*\(all parts\)\s*\z/, "")
-          return mark_all_parts(super(base, options))
-        end
-
-        super
-      rescue ::Pubid::Errors::ParseError
-        # A nested grammar already wrapped it. Keep the inner flavor and input.
-        raise
-      rescue ::Parslet::ParseFailed => e
-        raise wrap_parse_failure(e, io)
-      end
-
-      private
-
-      # Carry the stripped suffix into the tree. Parslet tops are a Hash or
-      # an Array of Hashes; the marker joins either shape, and every builder
-      # (Builder::Base and the standalone ones) routes it to #to_all_parts.
-      def mark_all_parts(tree)
-        case tree
-        when Hash then tree.merge(all_parts: true)
-        when Array then tree.map { |t| t.merge(all_parts: true) }
-        else tree
-        end
-      end
-
-      # @param error [Parslet::ParseFailed]
-      # @param io [String, IO] what was handed to {#parse}
-      # @return [Pubid::Errors::ParseError]
-      def wrap_parse_failure(error, io)
-        ::Pubid::Errors::ParseError.new(
-          error.message,
-          error.parse_failure_cause,
-          input: io.is_a?(String) ? io : nil,
-          flavor: pubid_flavor_name,
-        )
-      end
-
-      # "Pubid::Iso::Parser" -> "iso"; "Pubid::Ieee::Aiee::Parser" -> "ieee".
-      #
-      # Resolved through {Pubid::Registry} rather than taken from the module
-      # name, because the two disagree: `Pubid::Tgpp` registers as `"3gpp"`,
-      # and `Pubid::CenCenelec` registers twice (`"cen_cenelec"` first, then
-      # the `"cen"` alias). Reporting the registered name is what lets a caller
-      # feed `error.flavor` straight back to `Pubid::Registry.get`.
-      # @return [String, nil]
-      def pubid_flavor_name
-        parts = self.class.name.to_s.split("::")
-        return nil unless parts[0] == "Pubid" && parts.length > 1
-
-        registered_flavor_name(parts[1]) || parts[1].downcase
-      end
-
-      # @param module_name [String] e.g. "Tgpp"
-      # @return [String, nil] the registered name, nil if not registered
-      def registered_flavor_name(module_name)
-        ::Pubid::Registry.canonical_name(::Pubid.const_get(module_name))
-      rescue ::NameError
-        nil
-      end
-    end
-  end
-end