pubid 1.15.18 → 2.0.0.pre.alpha.1

data/lib/pubid/api/urn_generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        "std"
+      end
+
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.value.to_s
+      end
+
+      def urn_part
+        return nil unless identifier.part
+
+        "-#{identifier.part}"
+      end
+
+      def urn_year
+        return identifier.year.to_s if identifier.year
+
+        nil
+      end
+
+      def generate
+        parts = ["urn", "api"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_year if urn_year
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/api.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "api/identifier"
+require_relative "api/scheme"
+
+module Pubid
+  module Api
+    def self.parse(input)
+      Identifier.parse(input)
+    end
+  end
+
+  # Register this flavor with the Pubid registry
+end
+
+# Register Uapi flavor with the registry
+Pubid::Registry.register(:api, Pubid::Api)

data/lib/pubid/ashrae/builder.rb

@@ -0,0 +1,498 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Builder class for constructing ASHRAE identifier scheme from parsed data
+    # Single Responsibility: Transform parsed data into Scheme objects
+    class Builder
+      attr_reader :identifier_class
+
+      def initialize(identifier_class = Identifiers::Base)
+        @identifier_class = identifier_class
+      end
+
+      # Build a scheme object from parsed data
+      # @param parsed [Hash, Array] the parsed identifier data
+      # @return [Scheme] 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
+
+        # Check for supplement identifiers first
+        if parsed_hash[:errata_keyword]
+          return build_errata(parsed_hash)
+        elsif parsed_hash[:interpretation_identifier]
+          return build_interpretation(parsed_hash[:interpretation_identifier])
+        elsif parsed_hash[:combined_addenda]
+          return build_combined_addenda(parsed_hash[:combined_addenda])
+        elsif parsed_hash[:addenda_package]
+          return build_addenda_package(parsed_hash[:addenda_package])
+        elsif parsed_hash[:addendum_identifier]
+          return build_addendum_from_identifier(parsed_hash[:addendum_identifier])
+        elsif parsed_hash[:publisher_addendum]
+          return build_publisher_addendum(parsed_hash[:publisher_addendum])
+        elsif parsed_hash[:publisher_addendum_copublisher]
+          return build_publisher_addendum_copublisher(parsed_hash[:publisher_addendum_copublisher])
+        elsif parsed_hash[:publisher_addendum_copublisher_no_type]
+          return build_publisher_addendum_copublisher_no_type(parsed_hash[:publisher_addendum_copublisher_no_type])
+        elsif parsed_hash[:addendum_no_type]
+          return build_addendum_no_type(parsed_hash[:addendum_no_type])
+        elsif parsed_hash[:standard_addendum]
+          return build_standard_addendum(parsed_hash[:standard_addendum])
+        end
+
+        # Handle base identifier
+        if parsed_hash[:base]
+          parsed_hash = parsed_hash[:base]
+        end
+
+        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 [Identifiers::Base] 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 Scheme
+      def extract_attributes(parsed)
+        attributes = {}
+
+        # Extract publisher
+        if parsed[:publisher]
+          attributes[:publisher] =
+            extract_value(parsed[:publisher])
+        end
+
+        # Extract type - default to "Standard" if not present
+        attributes[:type] = extract_value(parsed[:type]) || "Standard"
+
+        # Extract code (from code or code_with_year format)
+        if parsed[:code_with_year]
+          # code_with_year contains both code and year
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            attributes[:code] =
+              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[:code] = 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 (R or P)
+        attributes[:suffix] = extract_value(parsed[:suffix]) if parsed[:suffix]
+
+        # Extract reaffirmed year
+        if parsed[:reaffirmed]
+          attributes[:reaffirmed] =
+            extract_value(parsed[:reaffirmed])
+        end
+
+        # Extract copublisher
+        if parsed[:copublisher]
+          attributes[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+
+        attributes
+      end
+
+      # Determine which identifier class to use based on attributes
+      def determine_identifier_class(attributes)
+        type_value = attributes[:type]
+
+        # Use type to determine class
+        if type_value == "Guideline"
+          Identifiers::Guideline
+        elsif type_value == "Standard"
+          Identifiers::Standard
+        else
+          # Default to Standard
+          Identifiers::Standard
+        end
+      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 Errata identifier from parsed errata data
+      # @param parsed [Hash] the parsed errata data
+      # @return [Identifiers::Errata] the constructed errata identifier
+      def build_errata(parsed)
+        base_attrs = extract_base_attributes(parsed)
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        errata_date = extract_errata_date(parsed[:errata_date])
+
+        Identifiers::Errata.new(
+          base_identifier: base_identifier,
+          errata_date: errata_date,
+        )
+      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)
+        base_attrs = extract_base_attributes(parsed)
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        Identifiers::Interpretation.new(
+          base_identifier: base_identifier,
+        )
+      end
+
+      # Build an Addendum identifier from "Addendum X to Standard" format
+      # @param parsed [Hash] the parsed addendum data
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_addendum_from_identifier(parsed)
+        base_attrs = extract_base_attributes(parsed)
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build an Addendum identifier from "ASHRAE Addendum X to Standard" format
+      # @param parsed [Hash] the parsed publisher addendum data
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_publisher_addendum(parsed)
+        base_attrs = {
+          type: extract_value(parsed[:type]),
+          code: extract_value(parsed[:code]),
+          year: extract_value(parsed[:year]),
+        }
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build an Addendum identifier from "ASHRAE Addendum X to ANSI/ASHRAE Standard Y-YYYY" format
+      # @param parsed [Hash] the parsed publisher addendum with copublisher data
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_publisher_addendum_copublisher(parsed)
+        base_attrs = {
+          copublisher: extract_value(parsed[:copublisher]),
+          type: extract_value(parsed[:type]) || "Standard",
+          code: extract_value(parsed[:code]),
+          year: extract_value(parsed[:year]),
+        }
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build an Addendum identifier from "ANSI/ASHRAE Addendum X to ANSI/ASHRAE 34-2024" (no type) format
+      # @param parsed [Hash] the parsed addendum data with code_with_year
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_addendum_no_type(parsed)
+        # Extract copublisher and code_with_year data
+        base_attrs = {}
+        if parsed[:copublisher]
+          base_attrs[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+        base_attrs[:type] = "Standard" # Default to Standard when type is missing
+
+        # Extract code and year from code_with_year
+        if parsed[:code_with_year]
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            base_attrs[:code] =
+              extract_value(code_year_data[:code])
+          end
+          if code_year_data && code_year_data[:year]
+            base_attrs[:year] =
+              extract_value(code_year_data[:year])
+          end
+        end
+
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build an Addendum identifier from "ASHRAE Addendum X to ANSI/ASHRAE 62.1-2022" (publisher + copublisher, no type) format
+      # @param parsed [Hash] the parsed publisher addendum with copublisher and code_with_year data
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_publisher_addendum_copublisher_no_type(parsed)
+        # Extract copublisher and code_with_year data
+        base_attrs = {}
+        if parsed[:copublisher]
+          base_attrs[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+        base_attrs[:type] = "Standard" # Default to Standard when type is missing
+
+        # Extract code and year from code_with_year
+        if parsed[:code_with_year]
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            base_attrs[:code] =
+              extract_value(code_year_data[:code])
+          end
+          if code_year_data && code_year_data[:year]
+            base_attrs[:year] =
+              extract_value(code_year_data[:year])
+          end
+        end
+
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build an Addendum identifier from "Standard X Addendum a" format
+      # @param parsed [Hash] the parsed standard addendum data
+      # @return [Identifiers::Addendum] the constructed addendum identifier
+      def build_standard_addendum(parsed)
+        base_attrs = extract_base_attributes(parsed)
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        addendum_code = extract_value(parsed[:addendum_code])
+        addendum_date = extract_addendum_date(parsed[:addendum_year])
+
+        Identifiers::Addendum.new(
+          base_identifier: base_identifier,
+          addendum_code: addendum_code,
+          addendum_date: addendum_date,
+        )
+      end
+
+      # Build a CombinedAddenda identifier from "ASHRAE Addenda X and Y to Standard Z-YYYY" format
+      # @param parsed [Hash] the parsed combined addenda data
+      # @return [Identifiers::CombinedAddenda] the constructed combined addenda identifier
+      def build_combined_addenda(parsed)
+        # Extract base identifier attributes
+        # Handle code_with_year format (used in Formats 5 and 6)
+        base_attrs = {}
+
+        if parsed[:code_with_year]
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            base_attrs[:code] =
+              extract_value(code_year_data[:code])
+          end
+          if code_year_data && code_year_data[:year]
+            base_attrs[:year] =
+              extract_value(code_year_data[:year])
+          end
+        else
+          base_attrs[:type] = extract_value(parsed[:type]) || "Standard"
+          base_attrs[:code] = extract_value(parsed[:code])
+          base_attrs[:year] = extract_value(parsed[:year])
+        end
+
+        if parsed[:copublisher]
+          base_attrs[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+        if parsed[:publisher]
+          base_attrs[:publisher] =
+            extract_value(parsed[:publisher])
+        end
+
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        # Build the addendum_codes string from first code and additional codes
+        first_code = extract_value(parsed[:addendum_code])
+        additional_codes = parsed[:additional_codes]
+
+        # Handle Format 4: "ASHRAE Addenda to Standard" (no specific codes)
+        if first_code.nil? && additional_codes.nil?
+          # No codes specified - return nil or empty string for addendum_codes
+          addendum_codes_str = nil
+        else
+          addendum_codes_str = first_code || ""
+          if additional_codes
+            # additional_codes is an array that can contain:
+            # - hashes: {:addendum_code=>"f"}
+            # - strings: "a", "b", etc.
+            # We need to format them as comma-separated
+            code_list = []
+            additional_codes.each do |code|
+              code_str = if code.is_a?(Hash)
+                           # Extract from {:addendum_code=>"f"}
+                           extract_value(code[:addendum_code])
+                         else
+                           # Direct string value
+                           extract_value(code)
+                         end
+              code_list << code_str if code_str && code_str != "and"
+            end
+            # Join with commas
+            addendum_codes_str += ", #{code_list.join(', ')}" unless code_list.empty?
+          end
+        end
+
+        Identifiers::CombinedAddenda.new(
+          base_identifier: base_identifier,
+          addendum_codes: addendum_codes_str,
+        )
+      end
+
+      # Build an AddendaPackage identifier from "ASHRAE Standard X-YYYY: Addenda Supplement Package" format
+      # @param parsed [Hash] the parsed addenda package data
+      # @return [Identifiers::AddendaPackage] the constructed addenda package identifier
+      def build_addenda_package(parsed)
+        base_attrs = extract_base_attributes(parsed)
+        base_class = determine_identifier_class(base_attrs)
+        base_identifier = base_class.new(**base_attrs)
+
+        package_description = extract_value(parsed[:package_description])
+
+        Identifiers::AddendaPackage.new(
+          base_identifier: base_identifier,
+          package_description: package_description,
+        )
+      end
+
+      # Extract base identifier attributes from parsed data
+      # @param parsed [Hash] the parsed data
+      # @return [Hash] attributes for base identifier
+      def extract_base_attributes(parsed)
+        attributes = {}
+
+        if parsed[:publisher]
+          attributes[:publisher] =
+            extract_value(parsed[:publisher])
+        end
+        if parsed[:copublisher]
+          attributes[:copublisher] =
+            extract_value(parsed[:copublisher])
+        end
+        # Default to "Standard" if type is not present
+        attributes[:type] = extract_value(parsed[:type]) || "Standard"
+
+        # Handle code_with_year format
+        if parsed[:code_with_year]
+          code_year_data = parsed[:code_with_year]
+          if code_year_data && code_year_data[:code]
+            attributes[:code] =
+              extract_value(code_year_data[:code])
+          end
+          if code_year_data && code_year_data[:year]
+            attributes[:year] =
+              extract_value(code_year_data[:year])
+          end
+        else
+          attributes[:code] = extract_value(parsed[:code]) if parsed[:code]
+          attributes[:year] = extract_value(parsed[:year]) if parsed[:year]
+        end
+
+        attributes[:suffix] = extract_value(parsed[:suffix]) if parsed[:suffix]
+        if parsed[:reaffirmed]
+          attributes[:reaffirmed] =
+            extract_value(parsed[:reaffirmed])
+        end
+
+        attributes
+      end
+
+      # Extract errata date from parsed errata_date data
+      # @param errata_date [Hash] the parsed errata_date hash
+      # @return [String, nil] the formatted errata date string
+      def extract_errata_date(errata_date)
+        return nil unless errata_date
+
+        # errata_date contains { month_name: "...", errata_year: "..." }
+        # We need to format this as "Month Day, Year"
+        extract_value(errata_date[:month_name])
+        extract_value(errata_date[:errata_year])
+        # Note: day is captured as digit.repeat(1,2) but not named in the parser
+        # We'll need to reconstruct from the raw string or enhance parser
+        nil # For now, return nil - parser enhancement needed
+      end
+
+      # Extract addendum date from parsed addendum_year data
+      # @param addendum_year [String, Hash] the parsed addendum year data
+      # @return [String, nil] the formatted addendum date string
+      def extract_addendum_date(addendum_year)
+        return nil unless addendum_year
+
+        # Date extraction would require more detailed parser
+        nil
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/identifier.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    module Identifier
+      # Parse an ASHRAE identifier string into an identifier object
+      # @param identifier [String] The ASHRAE identifier string to parse
+      # @return [Identifiers::Base] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ASHRAE identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/identifiers/addenda_package.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ashrae
+    module Identifiers
+      # AddendaPackage identifier for ASHRAE addenda collection packages
+      # Represents packages that contain multiple addendums
+      # Examples:
+      # - ASHRAE Standard 52.2-1999: Addenda Supplement Package (Contains Addendum a)
+      # - ASHRAE Standard 52.2-2007 Addenda Supplement Package (Contains Addendum b)
+      # - ASHRAE Standard 62.2-2004: Addenda Supplement Package (Contains Addendum g) (PDF)
+      class AddendaPackage < SupplementIdentifier
+        attribute :package_description, :string # e.g., "Addenda Supplement Package"
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["Addenda Supplement Package", "Addenda Package"],
+            type_code: "addenda_package",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :addenda_package, title: "ASHRAE Addenda Package",
+            short: "Addenda Package" }
+        end
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: ASHRAE Standard 52.2-1999: Addenda Supplement Package
+          result = "ASHRAE #{base_identifier.type || 'Standard'} #{base_identifier.code}"
+          result += "-#{base_identifier.year}" if base_identifier.year
+          result += ": Addenda #{package_description}" if package_description
+          result
+        end
+
+        def copublisher
+          base_identifier&.copublisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/identifiers/addendum.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ashrae
+    module Identifiers
+      # Addendum identifier for ASHRAE standards and guidelines
+      # Examples:
+      # - ASHRAE Addendum a to Standard 15-2001
+      # - ASHRAE Addendum a to Guideline 1.4-2019
+      # - ANSI/ASHRAE Addendum a to ANSI/ASHRAE Standard 15-2019
+      # - ASHRAE Standard 15-2013 Addendum a
+      class Addendum < SupplementIdentifier
+        attribute :addendum_code, :string  # a, b, c, ..., aa, ab, ..., ba, etc.
+        attribute :addendum_date, :string  # Optional date (January 22, 2019)
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["Addendum", "Addenda"],
+            type_code: "addendum",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :addendum, title: "ASHRAE Addendum", short: "Addendum" }
+        end
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Determine base type name for rendering
+          base_type = base_identifier.type || "Standard"
+
+          if copublisher
+            # Format: ANSI/ASHRAE Addendum a to ANSI/ASHRAE Standard 15-2019
+            result = "#{copublisher} Addendum #{addendum_code} to #{base_identifier}"
+          else
+            # Format: ASHRAE Addendum a to Standard 15-2001
+            result = "ASHRAE Addendum #{addendum_code} to #{base_type} #{base_identifier.code}"
+            result += "-#{base_identifier.year}" if base_identifier.year
+          end
+
+          result += " (#{addendum_date})" if addendum_date
+          result
+        end
+
+        def copublisher
+          base_identifier&.copublisher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    module Identifiers
+      # Base class for all ASHRAE identifiers
+      class Base < Pubid::Identifier
+        attribute :publisher, :string, default: "ASHRAE"
+        attribute :code, :string
+        attribute :year, :string
+        attribute :type, :string
+        attribute :suffix, :string # R (revision), P (proposed), etc.
+        attribute :amendment, :string
+        attribute :reaffirmed, :string
+        attribute :copublisher, :string
+
+        def self.parse(string)
+          Ashrae::Identifier.parse(string)
+        end
+      end
+    end
+  end
+end