pubid 1.15.18 → 2.0.0.pre.alpha.1

data/lib/pubid/amca/identifiers/interpretation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    module Identifiers
+      # Interpretation identifier for ACMA interpretations
+      # Examples:
+      # - AMCA 99 JW Interp
+      # - AMCA 204 – 1
+      # - ANSI/AMCA 204 Interp
+      class Interpretation < Base
+        attr_reader :interpretation_code
+
+        def initialize(code:, year: nil, copublisher: nil, suffix: nil,
+reaffirmed: nil, interpretation_code: nil)
+          @code = Components::Code.new(value: code.to_s)
+          @year = Components::Date.new(year: year.to_s) if year
+          @copublisher = copublisher
+          @suffix = suffix
+          @reaffirmed = reaffirmed
+          @interpretation_code = interpretation_code
+        end
+
+        def self.type
+          { key: :interpretation, title: "Interpretation", short: "Interp" }
+        end
+
+        def type
+          Interpretation.type
+        end
+
+        # @return [String] the rendered interpretation identifier
+        def to_s
+          parts = []
+          parts << @copublisher if @copublisher
+          parts << @code.to_s
+
+          if @interpretation_code
+            parts << "– #{@interpretation_code}"
+          elsif @year
+            parts << "-#{@year}"
+          end
+
+          parts << " #{@suffix}" if @suffix
+
+          parts.join(" ").squeeze(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    module Identifiers
+      # Publication identifier for ACMA publications
+      # Examples:
+      # - AMCA Publication 211-22 (Rev. 01-23)
+      # - AMCA Publication 311-16
+      # - AMCA Publication 1011-03 (R2010)
+      class Publication < Base
+        attr_reader :revision
+
+        def initialize(code:, year:, copublisher: nil, suffix: nil,
+reaffirmed: nil, revision: nil)
+          @code = Components::Code.new(value: code.to_s)
+          @year = Components::Date.new(year: year.to_s) if year
+          @copublisher = copublisher
+          @suffix = suffix
+          @reaffirmed = reaffirmed
+          @revision = revision
+        end
+
+        def self.type
+          { key: :publication, title: "Publication", short: nil }
+        end
+
+        def type
+          Publication.type
+        end
+
+        # @return [String] the rendered publication identifier
+        def to_s
+          parts = []
+          parts << @copublisher if @copublisher
+          parts << "Publication"
+          parts << @code.to_s
+          parts << "-#{@year}" if @year
+          parts << " (Rev. #{@revision})" if @revision
+          parts << " (#{@reaffirmed})" if @reaffirmed && !@revision
+
+          parts.join(" ").squeeze(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    module Identifiers
+      # Standard identifier for ACMA standards
+      # Examples:
+      # - ANSI/AMCA 210-16
+      # - ANSI/AMCA Standard 99-25
+      # - AMCA Standard 803-02 (R2008)
+      class Standard < Base
+        def self.type
+          { key: :standard, title: "Standard", short: nil }
+        end
+
+        def type
+          Standard.type
+        end
+      end
+    end
+  end
+end

data/lib/pubid/amca/identifiers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Interpretation, "#{__dir__}/identifiers/interpretation"
+      autoload :Publication, "#{__dir__}/identifiers/publication"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/amca/parser.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Parser class for ACMA identifiers
+    # Single Responsibility: Parsing ACMA identifier syntax
+    class Parser < Parslet::Parser
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+      rule(:dot) { str(".") }
+
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Za-z]") }
+
+      # Year pattern (2 digits starting with 0-1, or 4 digits starting with 19 or 20)
+      rule(:year_digits) do
+        ((str("19") | str("20")) >> digit.repeat(2, 2)) |
+          digit.repeat(2, 2)
+      end
+
+      # Copublisher (ANSI/AMCA or AMCA)
+      rule(:copublisher) do
+        (str("ANSI") >> slash >> str("AMCA")) |
+          str("AMCA")
+      end
+
+      # Additional copublisher after year (e.g., /ASHRAE 51-16)
+      rule(:additional_copublisher) do
+        slash >> letter.repeat(2,
+                               10) >> space >> digits >> (dash >> digits).maybe
+      end
+
+      # Code pattern (e.g., 210, 500-D, 99, 204)
+      rule(:code) do
+        (
+          digits >> # Main number
+          (dash >> letter).maybe >> # Optional letter suffix (500-D)
+          (dot >> digits).maybe # Optional decimal (not in fixtures but possible)
+        ).as(:code)
+      end
+
+      # Type (Standard or Publication)
+      rule(:type) do
+        str("Standard") | str("Publication")
+      end
+
+      # Reaffirmation year (R2008, R2010, etc.)
+      rule(:reaffirmation) do
+        lparen >> str("R") >> digits.as(:reaffirmed) >> rparen
+      end
+
+      # Suffix
+      rule(:suffix) do
+        str("R") | str("P")
+      end
+
+      # Publication revision (Rev. 01-23)
+      rule(:revision) do
+        lparen >> str("Rev") >> dot.maybe >> space >> digits.as(:revision_year) >> dash >> digits >> rparen
+      end
+
+      # Interpretation code (JW, KB, RG, AW, AH, or just a number)
+      rule(:interpretation_code) do
+        letter.repeat(2).as(:interpretation_code) | # Two-letter code
+          digits.as(:interpretation_code) # Number
+      end
+
+      # Interpretation keyword
+      rule(:interp_keyword) do
+        space >> str("Interp")
+      end
+
+      # Main identifier rule
+      rule(:identifier) do
+        # Interpretation patterns (must come first as they're more specific)
+        interpretation_identifier |
+          # Publication patterns
+          publication_identifier |
+          # Standard patterns (must come last as they're the most general)
+          standard_identifier
+      end
+
+      # Interpretation pattern (e.g., AMCA 99 JW Interp, AMCA 204 – 1)
+      rule(:interpretation_identifier) do
+        (
+          copublisher.as(:copublisher).maybe >> space >>
+          code >>
+          space >>
+          # Either a letter code (JW, KB, etc.) or a dash-number pattern
+          (
+            (interpretation_code >> interp_keyword) |
+            ((str("–") | str("-")) >> digits.as(:interpretation_year) >> interp_keyword.maybe)
+          )
+        ).as(:interpretation) |
+          # Simple interpretation: AMCA 511 Interp
+          (
+            copublisher.as(:copublisher).maybe >> space >>
+            code >>
+            interp_keyword
+          ).as(:interpretation)
+      end
+
+      # Publication pattern (e.g., AMCA Publication 211-22 (Rev. 01-23))
+      rule(:publication_identifier) do
+        (
+          copublisher.as(:copublisher).maybe >> space >>
+          str("Publication").as(:publication_keyword) >> space >>
+          code >>
+          (dash >> year_digits.as(:year)).maybe >>
+          (space >> revision).maybe >>
+          (space >> reaffirmation).maybe
+        ).as(:publication)
+      end
+
+      # Standard pattern (e.g., ANSI/AMCA 210-16, ANSI/AMCA Standard 99-25)
+      rule(:standard_identifier) do
+        (
+          copublisher.as(:copublisher).maybe >> space >>
+          type.as(:type).maybe >> space.maybe >>
+          code >>
+          (dash >> year_digits.as(:year)).maybe >>
+          (space >> additional_copublisher).maybe >>
+          suffix.maybe >>
+          (space >> reaffirmation).maybe
+        ).as(:standard)
+      end
+
+      root(:identifier)
+
+      def self.parse(string)
+        # Strip leading/trailing whitespace
+        cleaned = string.strip
+
+        # Normalize multiple spaces to single space
+        cleaned = cleaned.gsub(/\s+/, " ")
+
+        # Normalize en dash to regular dash
+        cleaned = cleaned.gsub("–", "-")
+
+        # Remove trailing periods and commas
+        cleaned = cleaned.gsub(/[,.]$/, "")
+
+        new.parse(cleaned)
+      end
+    end
+  end
+end

data/lib/pubid/amca/scheme.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Scheme class for ACMA identifier configuration
+    class Scheme < Pubid::Scheme
+      def initialize
+        @identifiers = [
+          Identifiers::Standard,
+          Identifiers::Publication,
+          Identifiers::Interpretation,
+        ].freeze
+      end
+    end
+  end
+end

data/lib/pubid/amca/single_identifier.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Base class for single (non-supplement) ACMA identifiers
+    # Includes: Standard, Publication
+    class SingleIdentifier < Identifiers::Base
+      def to_s
+        parts = []
+        parts << copublisher if copublisher
+        # type is a hash, get the title
+        t = self.class.attributes.key?(:type) ? type : nil
+        if t.is_a?(Hash) && t[:title]
+          parts << t[:title].to_s
+        end
+        parts << code.to_s
+        parts << "-#{year}" if year
+
+        result = parts.compact.join(" ")
+
+        # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
+        if copublisher&.include?("/") && year
+          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
+          result = "#{copublisher} #{type_title} #{code}-#{year}"
+        end
+
+        result += " (#{reaffirmed})" if reaffirmed
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/amca/urn_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.to_s
+      end
+
+      def urn_year
+        return nil unless identifier.year
+
+        identifier.year.to_s
+      end
+
+      def urn_suffix
+        identifier.suffix&.to_s&.downcase
+      end
+
+      def urn_reaffirmed
+        "reaff.#{identifier.reaffirmed}" if identifier.reaffirmed
+      end
+
+      def urn_copublisher
+        "copub.#{identifier.copublisher.to_s.downcase}" if identifier.copublisher
+      end
+
+      def urn_type
+        identifier.type&.to_s&.downcase
+      end
+
+      def generate
+        parts = ["urn", "amca"]
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << urn_suffix if urn_suffix
+        parts << urn_reaffirmed if urn_reaffirmed
+        parts << urn_copublisher if urn_copublisher
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts << urn_type if urn_type
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/amca.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    autoload :Identifier, "#{__dir__}/amca/identifier"
+    autoload :Identifiers, "#{__dir__}/amca/identifiers"
+    autoload :Builder, "#{__dir__}/amca/builder"
+    autoload :Parser, "#{__dir__}/amca/parser"
+    autoload :Scheme, "#{__dir__}/amca/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/amca/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/amca/urn_generator"
+
+    # 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 [Parslet::ParseFailed] If parsing fails
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    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,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    class Builder < Pubid::Builder::Base
+      def initialize(scheme)
+        @scheme = scheme
+        super(Identifiers::Standard)
+      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: Components::Code.new(value: main_number),
+            part: part_number ? Components::Code.new(value: part_number) : nil,
+          }.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,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Base ANSI identifier class
+    class Identifier < ::Pubid::Identifier
+      def self.parse(string)
+        parsed = Pubid::Ansi::Parser.new.parse(string)
+        Pubid::Ansi::Builder.new(Pubid::Ansi::Scheme).build(parsed)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "american_national_standard"
+
+module Pubid
+  module Ansi
+    module Identifiers
+      # American National Standard identifier
+      class Standard < SingleIdentifier
+        def self.type
+          { key: :ans, 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 < 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