pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/amca/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Parses AMCA URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:amca:{number}:{year}[:{copub.publisher}[:{other tokens}]]
+    #
+    # The current generator can leak the Type Hash literal into the URN
+    # (e.g., `copub.amca:{:key => :standard, ...}`). This parser filters
+    # any token containing `{` so round-trip works for the common case.
+    #
+    # Examples:
+    # - urn:amca:210:08              → AMCA 210-08
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.include?("{") }
+
+        number, year = parts
+        text = "AMCA #{number}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/amca.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    extend Pubid::PrefixesSupport
+
+    # AMCA publisher token; the ANSI/AMCA joint form comes from
+    # Pubid::JOINT_PREFIXES.
+    PREFIXES = ["AMCA"].freeze
+
+    autoload :Identifier, "#{__dir__}/amca/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/amca/identifiers"
+    autoload :Builder, "#{__dir__}/amca/builder"
+    autoload :Parser, "#{__dir__}/amca/parser"
+    autoload :Renderer, "#{__dir__}/amca/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/amca/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/amca/urn_generator"
+    autoload :UrnParser, "#{__dir__}/amca/urn_parser"
+
+    # Parse an ACMA identifier string into an identifier object
+    # @param identifier [String] The ACMA identifier string to parse
+    # @return [Pubid::Amca::Identifier] The appropriate identifier object
+    # @raise [Pubid::Errors::ParseError] If parsing fails
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Amca::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+
+  # Register this flavor with the Pubid registry
+end
+
+# Register Uamca flavor with the registry
+Pubid::Registry.register(:amca, Pubid::Amca)

data/lib/pubid/ansi/builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    class Builder < Pubid::Builder::Base
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        identifier = default_identifier_class.new
+        assign_attributes(identifier, data)
+        identifier
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::Standard
+      end
+
+      def cast(type, value)
+        case type
+        when :publisher
+          Components::Publisher.new(body: value)
+        when :std_keyword
+          !value.nil? && !value.empty?
+        when :copublishers
+          if value.nil? || value.empty?
+            nil
+          else
+            value.map do |copublisher|
+              Components::Publisher.new(body: copublisher[:copublisher])
+            end
+          end
+        when :number_with_part
+          original_value = value.to_s
+          main_and_parts = original_value.split("-")
+          main_number = main_and_parts[0]
+          part_number = main_and_parts[1]
+          {
+            number: main_number,
+            part: part_number,
+          }.compact
+        when :date
+          Components::Date.new(year: value.to_s)
+        when :languages
+          value.to_s.split(",").map do |lang|
+            Components::Language.new(code: lang.strip)
+          end
+        else
+          raise ArgumentError, "Unknown parameter type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ansi/identifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Base ANSI identifier class
+    class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: ANSI stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
+      def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Pubid::Ansi::Parser.new.parse(string)
+        Pubid::Ansi::Builder.new.build(parsed)
+      end
+    end
+  end
+end

data/lib/pubid/ansi/identifiers/american_national_standard.rb

@@ -0,0 +1,13 @@
+module Pubid
+  module Ansi
+    module Identifiers
+      # American National Standard identifier
+      class AmericanNationalStandard < SingleIdentifier
+        def self.type
+          { key: :ans, web: :american_national_standard,
+            title: "American National Standard", short: "ANS" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    module Identifiers
+      # American National Standard identifier
+      class Standard < SingleIdentifier
+        def self.type
+          { key: :ans, web: :standard,
+            title: "American National Standard", short: "ANS" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ansi/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    module Identifiers
+      autoload :AmericanNationalStandard,
+               "#{__dir__}/identifiers/american_national_standard"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

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 < ::Pubid::Parser::Grammar
+      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/renderer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Human-readable renderer for ANSI identifiers.
+    #
+    # Produces strings like:
+    #   "ANSI X3.4"
+    #   "ANSI/ISO 9899"
+    #   "ANSI X9.8-1:2007"
+    #
+    # The renderer is registered as the `:human` format in the ANSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        parts = []
+        parts << publisher_portion(id, context)
+        parts << number_portion(id, context)
+        result = parts.compact.join(" ")
+
+        result << language_portion(id) if id.languages&.any?
+
+        result
+      end
+
+      private
+
+      def publisher_portion(id, context)
+        if id.copublishers&.any?
+          ([id.publisher] + id.copublishers).map { |p| p.render(context:) }.join("/")
+        else
+          id.publisher.render(context:)
+        end
+      end
+
+      def number_portion(id, context)
+        [
+          id.number,
+          (id.part ? "-#{id.part}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+
+      def language_portion(id)
+        return "" unless id.languages&.any?
+
+        "(#{id.languages.map(&:code).join(',')})"
+      end
+    end
+  end
+end

data/lib/pubid/ansi/single_identifier.rb

@@ -0,0 +1,16 @@
+# 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(**opts)
+        render(format: :human, **opts)
+      end
+    end
+  end
+end

data/lib/pubid/ansi/urn_generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      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.render(context: URN_CONTEXT)
+        end
+
+        if identifier.copublishers&.any?
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
+        end
+
+        if identifier.languages&.any?
+          parts << identifier.languages.map(&:code).join(",")
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ansi/urn_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Parses ANSI URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ansi:{code}:{year}` where the code carries
+    # the alpha-numeric designation (e.g., "X3.4").
+    #
+    # Examples:
+    # - urn:ansi:X3.4:1963 → ANSI X3.4:1963
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code, year = parts
+        text = "ANSI #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ansi.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    extend Pubid::PrefixesSupport
+
+    # ANSI publisher token; ANSI/ASHRAE and ANSI/AMCA joint forms come from
+    # Pubid::JOINT_PREFIXES. Parser::ORGANIZATIONS are co-publishers, not
+    # leading ANSI tokens, so they are excluded.
+    PREFIXES = ["ANSI"].freeze
+
+    autoload :Builder, "#{__dir__}/ansi/builder"
+    autoload :Identifier, "#{__dir__}/ansi/identifier"
+    autoload :Identifiers, "#{__dir__}/ansi/identifiers"
+    autoload :Parser, "#{__dir__}/ansi/parser"
+    autoload :Renderer, "#{__dir__}/ansi/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/ansi/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/ansi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ansi/urn_parser"
+
+    # Parse an ANSI identifier string
+    # @param identifier [String] the identifier string to parse
+    # @return [Identifier] the parsed identifier
+    # Delegate to the class method rather than repeating the parser/builder
+    # sequence, so the input guards live in one place and the two entry points
+    # cannot drift apart.
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Ansi::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # ANSI does not define typed stages; typed_stage lookup is not used by
+    # the builder. Provided here for API consistency with other flavors.
+    # @return [Array] always empty for ANSI
+    def self.all_typed_stages
+      []
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param _abbr [String, Symbol] unused; ANSI has no typed stages
+    # @return [nil] always nil for ANSI
+    def self.locate_stage(_abbr)
+      nil
+    end
+  end
+end
+
+# Register ANSI flavor with the registry
+Pubid::Registry.register(:ansi, Pubid::Ansi)

data/lib/pubid/api/builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    class Builder < Pubid::Builder::Base
+      TYPE_CLASS_MAP = {
+        "BULL" => Identifiers::Bulletin,
+        "MPMS" => Identifiers::Mpms,
+        "RP" => Identifiers::RecommendedPractice,
+        "SPEC" => Identifiers::Specification,
+        "STD" => Identifiers::Standard,
+        "TR" => Identifiers::TechnicalReport,
+        "COS" => Identifiers::ContinuousOperationsStandard,
+        "PUBL" => Identifiers::Publication,
+      }.freeze
+
+      private
+
+      def default_identifier_class
+        Identifiers::TypelessStandard
+      end
+
+      def select_class(data)
+        TYPE_CLASS_MAP[data[:type]&.to_s] || default_identifier_class
+      end
+
+      def cast(key, value)
+        case key
+        # `:type` is consumed only by select_class for dispatch; it is not an
+        # identifier attribute (the concrete class is pinned by `_type`). Drop it
+        # so the raw Parslet::Slice never lands in the inherited :type attribute.
+        when :type then nil
+        when :reaffirmation
+          value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
+        # Every remaining key is a bare scalar. `:chapter` is a PARSE-TREE key
+        # and keeps its name in the grammar; the ATTRIBUTE it feeds is `number`
+        # (see handle_key below), which this branch retyped from
+        # Components::Code to :string — so it now casts like the rest.
+        when :number, :chapter, :part, :section, :subsection, :year
+          value.to_s
+        else
+          super
+        end
+      end
+
+      # Route the MPMS chapter into the `number` attribute. The shared
+      # assign_attributes loop uses the parse-tree key as the setter name and
+      # silently skips a key that is not an attribute, so without this the
+      # chapter would simply vanish once `attribute :chapter` was removed.
+      def handle_key(identifier, key, value)
+        return super unless key.to_sym == :chapter
+
+        identifier.number = value
+        true
+      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,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Common base class for all API identifiers. SingleIdentifier and the
+    # concrete Identifiers::* types descend from it, so every API identifier is
+    # `is_a?(Pubid::Api::Identifier)` natively and gets the shared polymorphic
+    # `from_hash` (no facade needed).
+    class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: API stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      # `code` keeps its Components::Code type on SingleIdentifier - it is not
+      # one of the three attributes the shared base declares.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
+      def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        # There used to be a `return nil if input.start_with?("#")` here, to
+        # skip the comment lines of a fixture file. A comment is not an
+        # identifier, so it must be rejected like any other unparseable string:
+        # this was the one public parse in the gem that could return nil, which
+        # a caller reading `id.to_s` sees as a NoMethodError far from the cause.
+        # Both API fixture loaders already drop `#` lines themselves.
+        tree = Parser.new.parse(input)
+        Builder.new.build(tree)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      # Base class for all API identifiers.
+      # Inherits common attributes from SingleIdentifier.
+      class Base < SingleIdentifier
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class ContinuousOperationsStandard < Base
+        def type_string
+          "COS"
+        end
+      end
+    end
+  end
+end