pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/ansi/parser.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Parser for ANSI (American National Standards Institute) identifiers
+    # Examples: ANSI X3.4-1986, ANSI C63.4-2014, ANSI/ISO 9899:1990
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      root :identifier
+
+      # ANSI as sole publisher
+      rule(:publisher) do
+        str("ANSI").as(:publisher)
+      end
+
+      # Copublishers: ISO, IEEE, IEC, etc.
+      ORGANIZATIONS = %w[ISO IEC IEEE SAE ASME ASTM].freeze
+      rule(:copublishers) do
+        (str("/") >> space? >> array_to_str(ORGANIZATIONS).as(:copublisher)).repeat(1).as(:copublishers)
+      end
+
+      # Optional "Std" keyword
+      rule(:std_keyword) do
+        (str("Std") >> space).maybe
+      end
+
+      # Number with optional parts and subparts
+      # Examples:
+      # - X3.4-1986 (letter prefix, one dot, year)
+      # - C63.4-2014 (letter prefix, one dot, year)
+      # - C37.06.1-2000 (letter prefix, two dots, year)
+      # - C57.12.10-1988 (letter prefix, three dots, year)
+      # - N323A-1997 (letter prefix, number, letter suffix, year)
+      # - N42.49A-2011 (letter prefix, dot, number, letter suffix, year)
+      # - 9899 (just digits)
+      # - 802.3-2012 (digits with dot and year)
+      # - 802.1b-1995 (digits, dot, digits, letter, year)
+      rule(:number_with_part) do
+        (
+          # Letter prefix with multiple dots and optional letter suffix
+          # C37.06.1, C57.12.10, C63.25.1, N323A, N42.49A
+          (match["A-Z"].repeat(1) >>
+           digits >>
+           (str(".") >> digits).repeat(0, 3) >> # Allow up to 3 additional dot-separated parts
+           match["A-Z"].maybe >>                  # Optional letter suffix (A, B, etc.)
+           (str("-") >> digits).maybe) |          # Optional dash-year part
+          # Just digits with optional dots and letter suffix: 9899, 802.3-2012, 802.1b-1995
+          (digits >>
+           (str(".") >> digits >> match["a-z"].maybe).repeat(0, 2) >> # Dots with optional lowercase letter
+           (str("-") >> digits).maybe)
+        ).as(:number_with_part)
+      end
+
+      # Date - year only
+      rule(:date) do
+        str(":") >> year_digits.as(:date)
+      end
+
+      # Language codes
+      rule(:language) do
+        str("(") >>
+          (match["a-z"].repeat(2) >> str(",").maybe).repeat.as(:languages) >>
+          str(")")
+      end
+
+      # Main identifier for ANSI with copublishers
+      # ANSI/ISO 9899:1990, ANSI/IEEE Std 1-1986
+      rule(:identifier_with_copublishers) do
+        publisher >> copublishers >>
+          space >> std_keyword >>
+          number_with_part >>
+          date.maybe >> language.maybe
+      end
+
+      # Main identifier for ANSI alone
+      # ANSI X3.4-1986, ANSI Std C63.4-1991
+      rule(:identifier_sole) do
+        publisher >> space >>
+          std_keyword >>
+          number_with_part >>
+          date.maybe >> language.maybe
+      end
+
+      rule(:identifier) do
+        identifier_with_copublishers | identifier_sole
+      end
+    end
+  end
+end

data/lib/pubid/ansi/scheme.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Scheme configuration for ANSI identifiers
+    IDENTIFIER_TYPES = [
+      Identifiers::Standard,
+    ].freeze
+
+    Scheme = Pubid::Scheme.new(
+      identifiers: IDENTIFIER_TYPES,
+      supplement_identifiers: [],
+    )
+  end
+end

data/lib/pubid/ansi/single_identifier.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Single ANSI identifier (non-bundled)
+    class SingleIdentifier < Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def to_s(lang: :en)
+        [].tap do |parts|
+          parts << publisher_portion
+          parts << number_portion
+        end.compact.join(" ").tap do |s|
+          s << language_portion if languages&.any?
+        end
+      end
+
+      def publisher_portion
+        if copublishers&.any?
+          # ANSI/ISO 9899
+          ([publisher] + copublishers).map(&:body).join("/")
+        else
+          # ANSI X3.4
+          publisher.body
+        end
+      end
+
+      def number_portion
+        [
+          number.value,
+          (part ? "-#{part.value}" : ""),
+          (date ? ":#{date.year}" : ""),
+        ].join
+      end
+
+      def language_portion
+        return "" unless languages&.any?
+
+        "(#{languages.map(&:code).join(',')})"
+      end
+    end
+  end
+end

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,68 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+require_relative "builder"
+require_relative "single_identifier"
+require_relative "scheme"
+
+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
+
+      # Factory that builds an API identifier from a hash of primitives.
+      # Dispatch on `:type` to the matching subclass; default is
+      # {Identifiers::Standard}.
+      #
+      # API identifiers have a hardcoded "API" publisher (via
+      # SingleIdentifier#publisher method) so the `:publisher` kwarg is
+      # silently dropped.
+      TYPE_KEY_TO_KLASS = {
+        std:      "Standard",
+        rp:       "RecommendedPractice",
+        spec:     "Specification",
+        tr:       "TechnicalReport",
+        bull:     "Bulletin",
+        mpms:     "Mpms",
+        cos:      "ContinuousOperationsStandard",
+        publ:     "Publication",
+        typeless: "TypelessStandard",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown API type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Api::Components::Code.new(value: v.to_s)
+        end
+        %i[part year reaffirmation].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        # TODO(create-shim): :publisher silently dropped (API hardcoded).
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+    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