pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/amca/builder.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Builder class for constructing ACMA identifier scheme from parsed data
+    # Single Responsibility: Transform parsed data into identifier objects
+    class Builder
+      attr_reader :identifier_class
+
+      def initialize(identifier_class = Identifier)
+        @identifier_class = identifier_class
+      end
+
+      # Build a scheme object from parsed data
+      # @param parsed [Hash, Array] the parsed identifier data
+      # @return [identifier] the constructed scheme object
+      def build(parsed)
+        # Parslet can return array of hashes - merge them
+        parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
+
+        # Handle base identifier wrapper
+        if parsed_hash[:base]
+          parsed_hash = parsed_hash[:base]
+        end
+
+        # Check for publication identifier (must come before standard check)
+        if parsed_hash[:publication] || parsed_hash[:publication_keyword] || parsed_hash[:revision]
+          return build_publication(parsed_hash[:publication] || parsed_hash)
+        end
+
+        # Check for interpretation identifier
+        if parsed_hash[:interpretation] || parsed_hash[:interpretation_code] || parsed_hash[:interp_keyword]
+          return build_interpretation(parsed_hash[:interpretation] || parsed_hash)
+        end
+
+        # Handle standard identifier
+        if parsed_hash[:standard]
+          return build_standard(parsed_hash[:standard])
+        end
+
+        # Default: extract attributes and create identifier
+        attributes = extract_attributes(parsed_hash)
+        identifier_class = determine_identifier_class(attributes)
+        identifier_class.new(**attributes)
+      end
+
+      # Class method to build an identifier from parsed data
+      # @param parsed [Hash, Array] the parsed identifier data
+      # @return [Identifier] the constructed identifier object
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      # Merge an array of parsed hashes into a single hash
+      # @param parsed_array [Array<Hash>] array of parsed hashes
+      # @return [Hash] merged hash
+      def merge_parsed_array(parsed_array)
+        parsed_array.inject({}) do |result, hash|
+          result.merge(hash)
+        end
+      end
+
+      # Extract and normalize attributes from parsed data
+      # @param parsed [Hash] the parsed data
+      # @return [Hash] normalized attributes for Identifier
+      def extract_attributes(parsed)
+        attributes = {}
+
+        # Extract copublisher
+        if parsed[:copublisher]
+          attributes[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+
+        # Extract code
+        if parsed[:code_with_year]
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            attributes[:number] =
+              extract_value(code_year_data[:code])
+          end
+          if code_year_data && code_year_data[:year]
+            attributes[:year] =
+              extract_value(code_year_data[:year])
+          end
+        elsif parsed[:code]
+          attributes[:number] = extract_value(parsed[:code])
+        end
+
+        # Extract year if not already extracted from code_with_year
+        attributes[:year] ||= extract_value(parsed[:year]) if parsed[:year]
+
+        # Extract suffix
+        attributes[:suffix] = extract_value(parsed[:suffix]) if parsed[:suffix]
+
+        # Extract reaffirmed year (R2008, R2010, etc.)
+        if parsed[:reaffirmed]
+          attributes[:reaffirmed] =
+            extract_value(parsed[:reaffirmed])
+        end
+
+        attributes
+      end
+
+      # Determine which identifier class to use based on attributes
+      # @param attributes [Hash] the extracted attributes
+      # @return [Class] the identifier class
+      def determine_identifier_class(_attributes)
+        # Default to Standard for ACMA
+        Identifiers::Standard
+      end
+
+      # Extract a simple value from parsed data
+      # @param value [Object] the value to extract
+      # @return [String, nil] the extracted string value
+      def extract_value(value)
+        return nil if value.nil?
+        return nil if value.is_a?(Array) && value.empty?
+
+        if value.is_a?(Array)
+          joined = value.join
+          return joined.length.positive? ? joined : nil
+        end
+
+        str_value = value.to_s.strip
+        str_value.length.positive? ? str_value : nil
+      end
+
+      # Build an Interpretation identifier from parsed interpretation data
+      # @param parsed [Hash] the parsed interpretation data
+      # @return [Identifiers::Interpretation] the constructed interpretation identifier
+      def build_interpretation(parsed)
+        attributes = extract_attributes(parsed)
+
+        # Extract interpretation code (JW, KB, RG, AW, AH, or number)
+        if parsed[:interpretation_code]
+          attributes[:interpretation_code] =
+            extract_value(parsed[:interpretation_code])
+        end
+
+        # Interpretations may not have a year
+        attributes[:year] ||= extract_value(parsed[:interpretation_year]) if parsed[:interpretation_year]
+
+        Identifiers::Interpretation.new(**attributes)
+      end
+
+      # Build a Publication identifier from parsed publication data
+      # @param parsed [Hash] the parsed publication data
+      # @return [Identifiers::Publication] the constructed publication identifier
+      def build_publication(parsed)
+        attributes = extract_attributes(parsed)
+
+        # Extract revision (Rev. 01-23)
+        if parsed[:revision]
+          revision_data = parsed[:revision]
+          if revision_data && revision_data[:revision_year]
+            attributes[:revision] =
+              extract_value(revision_data[:revision_year])
+          end
+        end
+
+        Identifiers::Publication.new(**attributes)
+      end
+
+      # Build a Standard identifier from parsed standard data
+      # @param parsed [Hash] the parsed standard data
+      # @return [Identifiers::Standard] the constructed standard identifier
+      def build_standard(parsed)
+        attributes = extract_attributes(parsed)
+        Identifiers::Standard.new(**attributes)
+      end
+    end
+  end
+end

data/lib/pubid/amca/identifier.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Pubid::Amca::Identifier is the AMCA base class (a real Pubid::Identifier
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Base identifier class for AMCA identifiers. Canonical name
+    # Pubid::Amca::Identifier; common
+    # functionality for all AMCA identifier types.
+    class Identifier < ::Pubid::Identifier
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+
+      # Stored as a plain string (always "AMCA") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute and raise.
+      attribute :publisher, :string, default: -> { "AMCA" }
+      attribute :copublisher, :string
+      # The document number used to live in AMCA's own `code` attribute, leaving
+      # the `number` inherited from ::Pubid::Identifier nil — so relaton-index,
+      # which sorts and bsearches on `id.root.number.to_s`, keyed every AMCA row
+      # on "". `code` is gone; each LEAF now declares `attribute :number,
+      # :string` (see standard.rb / publication.rb / interpretation.rb).
+      #
+      # It is declared on the leaves, never here: this class is inherited by all
+      # three of them, and redefining the parent's Components::Code-typed
+      # `number` on an inherited-from class resolves nondeterministically under
+      # multi-flavor load. Do not reintroduce `code`, and do not move `number`
+      # up here.
+      #
+      # A bare 2-digit edition year ("21", "02"). Declared :string, not
+      # Components::Date: the builder assigns a String and lutaml does not cast
+      # it, so a Date declaration left the PARSE path holding a String while
+      # from_hash produced a Components::Date — making
+      # `parse(x) == from_hash(parse(x).to_hash)` false for every AMCA id and
+      # breaking #matches?, which is built on ==. to_hash and to_s agreed, so
+      # the relaton index gate never caught it.
+      attribute :year, :string
+      attribute :suffix, :string
+      attribute :reaffirmed, :string
+
+      # Explicit key_value mapping: only these keys serialize (the inherited
+      # Pubid::Identifier attributes — including :type, which subclasses expose
+      # as a class-metadata Hash via `self.type` — are intentionally dropped).
+      # Every mapped attribute is a plain scalar, so no custom converters are
+      # needed; the canonical to_hash already drops empty and default values.
+      key_value do
+        map "_type", to: :_type
+        map "publisher", to: :publisher
+        map "copublisher", to: :copublisher
+        map "number", to: :number
+        map "year", to: :year
+        map "suffix", to: :suffix
+        map "reaffirmed", to: :reaffirmed
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+
+      # AMCA models its document type as class metadata (`self.type`), not as a
+      # `typed_stage`, so the base `mr_type` hook found nothing. Without it an
+      # interpretation and the standard it interprets share a slug — and
+      # `to_slug` is an output FILENAME. Before the index columns landed the
+      # whole flavor collapsed onto two slugs ("amca" and "").
+      def mr_type
+        return nil unless self.class.respond_to?(:type)
+
+        self.class.type[:key]&.to_s
+      end
+
+      # AMCA keeps the edition in its own `year` string, not in the inherited
+      # `date`, so the base `mr_year` hook read nil and two editions of one
+      # standard — "ANSI/AMCA 300-14" and "ANSI/AMCA Standard 300-24" —
+      # produced the same slug. Same shape as the BIPM year recorded in
+      # CLAUDE.md.
+      def mr_year
+        year&.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 < Identifier
+        attribute :number, :string
+
+        # See Publication: the hand-written keyword initializer bypassed lutaml,
+        # costing this class its `_type`, its `publisher` default and the
+        # serialization of `interpretation_code`.
+        attribute :interpretation_code, :string
+
+        key_value do
+          map "interpretation_code", to: :interpretation_code
+        end
+
+        # The interpretation letter is what distinguishes one interpretation of
+        # a standard from another ("AMCA 99 JW Interp" vs "AMCA 99 KB Interp" —
+        # different documents, and #== agrees). It is in `==` and in `to_s`, so
+        # it must reach the slug too, or three interpretations of standard 99
+        # share one filename.
+        def mr_number_with_part
+          mr_join(super, interpretation_code&.to_s&.downcase)
+        end
+
+        def self.type
+          { key: :interpretation, title: "Interpretation", short: "Interp" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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 < Identifier
+        attribute :number, :string
+
+        # Was a hand-written keyword initializer assigning ivars directly,
+        # which bypassed lutaml entirely. Three things broke as a result: no
+        # `_type` was emitted (so Identifier.from_hash could not route back to
+        # this class), the `publisher` default never materialised, and
+        # `revision` was a plain attr_reader that to_hash dropped. Removing it
+        # — and making `revision` a real attribute — is the AIEE/IRE/NESC
+        # migration applied here; the builder already calls `new(**attributes)`
+        # exactly as it does for Standard, which never had this problem.
+        attribute :revision, :string
+
+        key_value do
+          map "revision", to: :revision
+        end
+
+        def self.type
+          { key: :publication, title: "Publication", short: nil }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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 < Identifier
+        attribute :number, :string
+
+        def self.type
+          { key: :standard, title: "Standard", short: nil }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/amca/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    module Identifiers
+      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 < ::Pubid::Parser::Grammar
+      # 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/renderer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Human-readable renderer for AMCA identifiers.
+    #
+    # Produces strings like:
+    #   "AMCA Standard 210-16"
+    #   "AMCA Publication 211-22 (Rev. 01-23)"
+    #   "ANSI/AMCA 204 Interp"
+    #   "AMCA 99 JW Interp"
+    #
+    # The renderer is registered as the `:human` format in the AMCA format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Publication
+          render_publication(id)
+        when Identifiers::Interpretation
+          render_interpretation(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        t = id.class.respond_to?(:type) ? id.class.type : nil
+        if t.is_a?(Hash) && t[:title]
+          parts << t[:title].to_s
+        end
+        parts << id.number.to_s
+        parts << "-#{id.year}" if id.year
+
+        result = parts.compact.join(" ")
+
+        if id.copublisher&.include?("/") && id.year
+          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
+          result = "#{id.copublisher} #{type_title} #{id.number}-#{id.year}"
+        end
+
+        result += " (#{id.reaffirmed})" if id.reaffirmed
+
+        result
+      end
+
+      def render_publication(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << "Publication"
+        parts << id.number.to_s
+        parts << "-#{id.year}" if id.year
+        parts << " (Rev. #{id.revision})" if id.revision
+        parts << " (#{id.reaffirmed})" if id.reaffirmed && !id.revision
+
+        parts.join(" ").squeeze(" ")
+      end
+
+      def render_interpretation(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << id.number.to_s
+
+        if id.interpretation_code
+          parts << "– #{id.interpretation_code}"
+        elsif id.year
+          parts << "-#{id.year}"
+        end
+
+        parts << " #{id.suffix}" if id.suffix
+
+        parts.join(" ").squeeze(" ")
+      end
+    end
+  end
+end

data/lib/pubid/amca/single_identifier.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Base class for single (non-supplement) ACMA identifiers
+    # Includes: Standard, Publication
+    class SingleIdentifier < Identifier
+    end
+  end
+end

data/lib/pubid/amca/urn_generator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.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.class.respond_to?(:type) ? identifier.class.type : nil)
+          &.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