pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/ansi/urn_generator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.value.to_s
+      end
+
+      def urn_part
+        return nil unless identifier.part
+
+        "-#{identifier.part.value}"
+      end
+
+      def urn_subpart
+        return nil unless identifier.subpart
+
+        "-#{identifier.subpart.value}"
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        identifier.year&.to_s
+      end
+
+      def urn_edition
+        return nil unless identifier.edition
+
+        num = identifier.edition.number
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
+      def urn_typed_stage
+        return nil unless identifier.typed_stage
+
+        type_code = identifier.typed_stage.type_code
+        return nil if type_code && type_code.to_s == "ans"
+
+        type_code&.to_s
+      end
+
+      def generate
+        parts = ["urn", "ansi"]
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_subpart if urn_subpart
+        parts << urn_year if urn_year
+        parts << urn_edition if urn_edition
+        parts << urn_typed_stage if urn_typed_stage
+
+        if identifier.publisher
+          parts[1] = identifier.publisher.body.to_s.downcase
+        end
+
+        if identifier.copublishers&.any?
+          copubs = identifier.copublishers.map(&:body)
+          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
+        end
+
+        if identifier.languages&.any?
+          parts << identifier.languages.map(&:code).join(",")
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ansi.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    autoload :Builder, "#{__dir__}/ansi/builder"
+    autoload :Identifier, "#{__dir__}/ansi/identifier"
+    autoload :Identifiers, "#{__dir__}/ansi/identifiers/standard"
+    autoload :Parser, "#{__dir__}/ansi/parser"
+    autoload :Scheme, "#{__dir__}/ansi/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/ansi/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/ansi/urn_generator"
+
+    # Parse an ANSI identifier string
+    # @param identifier [String] the identifier string to parse
+    # @return [Identifier] the parsed identifier
+    def self.parse(identifier)
+      parser = Parser.new
+      builder = Builder.new(Scheme)
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    end
+  end
+end
+
+# Register ANSI flavor with the registry
+Pubid::Registry.register(:ansi, Pubid::Ansi)

data/lib/pubid/api/builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "components/code"
+require_relative "identifiers/bulletin"
+require_relative "identifiers/mpms"
+require_relative "identifiers/recommended_practice"
+require_relative "identifiers/specification"
+require_relative "identifiers/standard"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/continuous_operations_standard"
+require_relative "identifiers/publication"
+require_relative "identifiers/typeless_standard"
+
+module Pubid
+  module Api
+    class Builder
+      def build(parsed_hash)
+        # Determine identifier class based on type
+        identifier_class = case parsed_hash[:type]&.to_s
+                           when "BULL"
+                             Identifiers::Bulletin
+                           when "MPMS"
+                             Identifiers::Mpms
+                           when "RP"
+                             Identifiers::RecommendedPractice
+                           when "SPEC"
+                             Identifiers::Specification
+                           when "STD"
+                             Identifiers::Standard
+                           when "TR"
+                             Identifiers::TechnicalReport
+                           when "COS"
+                             Identifiers::ContinuousOperationsStandard
+                           when "PUBL"
+                             Identifiers::Publication
+                           else
+                             # No type = typeless standard
+                             Identifiers::TypelessStandard
+                           end
+
+        identifier = identifier_class.new
+
+        # Number (for non-MPMS)
+        if parsed_hash[:number]
+          identifier.code = Components::Code.new(value: parsed_hash[:number].to_s)
+        end
+
+        # Part
+        if parsed_hash[:part]
+          identifier.part = parsed_hash[:part].to_s
+        end
+
+        # MPMS-specific attributes
+        if parsed_hash[:chapter]
+          identifier.chapter = parsed_hash[:chapter].to_s
+        end
+
+        if parsed_hash[:section]
+          identifier.section = parsed_hash[:section].to_s
+        end
+
+        if parsed_hash[:subsection]
+          identifier.subsection = parsed_hash[:subsection].to_s
+        end
+
+        # Year
+        if parsed_hash[:year]
+          identifier.year = parsed_hash[:year].to_s
+        end
+
+        # Reaffirmation (nested hash with year inside)
+        if parsed_hash[:reaffirmation]
+          reaffirm_data = parsed_hash[:reaffirmation]
+          identifier.reaffirmation = if reaffirm_data.is_a?(Hash) && reaffirm_data[:year]
+                                       reaffirm_data[:year].to_s
+                                     else
+                                       reaffirm_data.to_s
+                                     end
+        end
+
+        identifier
+      end
+    end
+  end
+end

data/lib/pubid/api/components/code.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Components
+      Code = Pubid::Components::Code
+    end
+  end
+end

data/lib/pubid/api/identifier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+require_relative "builder"
+require_relative "single_identifier"
+
+module Pubid
+  module Api
+    class Identifier
+      def self.parse(input)
+        # Filter out comments
+        return nil if input.start_with?("#")
+
+        tree = Parser.new.parse(input)
+        Builder.new.build(tree)
+      rescue Parslet::ParseFailed => e
+        raise e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../single_identifier"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Base < SingleIdentifier
+        # Base class for all API identifiers
+        # Inherits common attributes from SingleIdentifier
+
+        # Include type_string in serialization for round-trip compatibility
+        def base_hash
+          hash = super
+          if self.class.attributes.key?(:type_string) && type_string
+            hash[:type] =
+              type_string
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/bulletin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Bulletin < Base
+        def type_string
+          "BULL"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/continuous_operations_standard.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class ContinuousOperationsStandard < Base
+        def type_string
+          "COS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/mpms.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Mpms < Base
+        attribute :chapter, :string
+        attribute :section, :string
+        attribute :subsection, :string
+
+        def type_string
+          "MPMS"
+        end
+
+        def to_s
+          parts = ["API", "MPMS"]
+
+          # Add chapter
+          parts << "CH #{chapter}" if chapter
+
+          # Add section/subsection
+          if section
+            parts << ".#{section}"
+            parts << ".#{subsection}" if subsection
+          end
+
+          # Add year
+          parts << "-#{year}" if year
+
+          parts.join(" ").gsub(" .", ".")
+        end
+
+        private
+
+        def code_portion
+          # Override - MPMS doesn't use code_portion
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Publication < Base
+        def type_string
+          "PUBL"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/recommended_practice.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class RecommendedPractice < Base
+        def type_string
+          "RP"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/specification.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Specification < Base
+        def type_string
+          "SPEC"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class Standard < Base
+        def type_string
+          "STD"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/technical_report.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class TechnicalReport < Base
+        def type_string
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/typeless_standard.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Api
+    module Identifiers
+      class TypelessStandard < Base
+        # No type_string method - renders without type
+        def to_s
+          parts = ["API"]
+
+          # Add code/number
+          parts << code_portion if code_portion
+
+          # Add year
+          parts << "-#{year}" if year
+
+          # Add reaffirmation
+          parts << " (R#{reaffirmation})" if reaffirmation
+
+          parts.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/parser.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Api
+    class Parser < Parslet::Parser
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:colon) { str(":") }
+      rule(:dot) { str(".") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Z]") }
+      rule(:letters) { letter.repeat(1) }
+
+      # Publisher
+      rule(:publisher) { str("API") >> space }
+
+      # Document types (longest first for proper matching)
+      rule(:doc_type) do
+        (
+          str("MPMS") |
+          str("BULL") |
+          str("SPEC") |
+          str("STD") |
+          str("RP") |
+          str("TR") |
+          str("COS") |
+          str("PUBL")
+        ).as(:type)
+      end
+
+      # Chapter notation for MPMS (e.g., "CH 10")
+      rule(:chapter_notation) do
+        space >> str("CH") >> space >> digits.as(:chapter)
+      end
+
+      # Number with optional part (e.g., "579-2", "1104", "6D", "D16", "17TR7")
+      # Allow any mix of digits and letters
+      rule(:number_with_part) do
+        match("[0-9A-Z]").repeat(1).as(:number) >>
+          (dash >> match("[0-9A-Z]").repeat(1).as(:part)).maybe
+      end
+
+      # Digits with optional letter suffix (for MPMS sections: 6.4A, 3.1A)
+      rule(:digits_with_letter) do
+        digits >> letter.maybe
+      end
+
+      # Year (4-digit)
+      rule(:year) { digit.repeat(4, 4).as(:year) }
+
+      # Date with dash (e.g., "-2023")
+      rule(:date_dash) { dash >> year }
+
+      # Date with colon (e.g., ":2023")
+      rule(:date_colon) { colon >> year }
+
+      # Reaffirmation notation (e.g., "(R2020)")
+      rule(:reaffirmation) do
+        space >> str("(R") >> year >> str(")")
+      end
+
+      # Part notation (e.g., ", Part 2")
+      rule(:part_notation) do
+        str(", Part ") >> digits.as(:part_number)
+      end
+
+      # Edition notation (e.g., ", 4th edition")
+      rule(:edition_notation) do
+        str(", ") >>
+          digits.as(:edition_number) >>
+          (str("st") | str("nd") | str("rd") | str("th")) >>
+          str(" edition")
+      end
+
+      # MPMS identifier (special format with CH)
+      rule(:mpms_identifier) do
+        publisher >>
+          str("MPMS").as(:type) >>
+          chapter_notation >>
+          (dot >> digits_with_letter.as(:section)).maybe >>
+          (dot >> digits_with_letter.as(:subsection)).maybe >>
+          (date_dash | date_colon).maybe
+      end
+
+      # Standard identifier with type
+      rule(:typed_identifier) do
+        publisher >>
+          doc_type >> space >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe >>
+          reaffirmation.maybe
+      end
+
+      # Typeless identifier (just API + number)
+      rule(:typeless_identifier) do
+        publisher >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe >>
+          reaffirmation.maybe
+      end
+
+      # Second identifier in combined (no API prefix, just type + number)
+      rule(:second_identifier) do
+        doc_type >> space >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe
+      end
+
+      # Combined identifier (two identifiers separated by slash)
+      rule(:combined_identifier) do
+        (mpms_identifier | typed_identifier | typeless_identifier).as(:first) >>
+          slash >>
+          second_identifier.as(:second) >>
+          edition_notation.maybe
+      end
+
+      # Main identifier (try combined first, then MPMS, then typed, then typeless)
+      rule(:identifier) do
+        combined_identifier | mpms_identifier | typed_identifier | typeless_identifier
+      end
+
+      root(:identifier)
+
+      # Preprocessing to normalize common typos
+      def parse(input)
+        # Normalize MPMP typo to MPMS
+        normalized = input.gsub("API MPMP", "API MPMS")
+        super(normalized)
+      end
+    end
+  end
+end

data/lib/pubid/api/scheme.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "identifiers/base"
+require_relative "identifiers/bulletin"
+require_relative "identifiers/continuous_operations_standard"
+require_relative "identifiers/mpms"
+require_relative "identifiers/publication"
+require_relative "identifiers/recommended_practice"
+require_relative "identifiers/specification"
+require_relative "identifiers/standard"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/typeless_standard"
+
+module Pubid
+  module Api
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Standard,
+            Identifiers::RecommendedPractice,
+            Identifiers::Specification,
+            Identifiers::TechnicalReport,
+            Identifiers::Bulletin,
+            Identifiers::Mpms,
+            Identifiers::ContinuousOperationsStandard,
+            Identifiers::Publication,
+            Identifiers::TypelessStandard,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "API" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = identifiers.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/single_identifier.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    class SingleIdentifier < Pubid::Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def publisher
+        "API"
+      end
+
+      attribute :code, Components::Code
+      attribute :part, :string
+      attribute :year, :string
+      attribute :reaffirmation, :string
+
+      def to_s
+        parts = ["API"]
+
+        # Add type if available
+        parts << type_string if self.class.attributes.key?(:type_string) && type_string
+
+        # Add code/number with part as one token
+        parts << code_portion if code_portion
+
+        # Build result - join with space, then add dash+year as one token
+        result = parts.join(" ")
+        result += "-#{year}" if year
+        result += " (R#{reaffirmation})" if reaffirmation
+        result
+      end
+
+      private
+
+      def code_portion
+        return nil unless code
+
+        code_str = code.to_s
+        code_str += "-#{part}" if part
+        code_str
+      end
+    end
+  end
+end