pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/ashrae/scheme.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Guideline,
+            Identifiers::Standard,
+            Identifiers::Addendum,
+            Identifiers::Interpretation,
+            Identifiers::Errata,
+            Identifiers::CombinedAddenda,
+            Identifiers::AddendaPackage,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "ASHRAE" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = identifiers.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/single_identifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Base class for single (non-supplement) ASHRAE identifiers
+    # Includes: Guideline, Standard
+    class SingleIdentifier < Identifiers::Base
+      def to_s
+        parts = []
+        parts << publisher if publisher
+        parts << type.to_s if type
+        result = parts.join(" ")
+        result += " " if result.length.positive?
+        result += code.to_s
+        result += "-#{year}" if year
+        result += " (#{amendment})" if amendment
+        result += suffix if suffix
+        result += " (RA#{reaffirmed})" if reaffirmed
+        result
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/supplement_identifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ashrae
+    # Base class for supplement identifiers (addendums, errata, interpretations)
+    # Supplements modify or add to a base document
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
+
+      # Delegate publisher to base_identifier
+      def publisher
+        base_identifier&.publisher
+      end
+
+      # Delegate code to base_identifier
+      def code
+        base_identifier&.code
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/urn_generator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.to_s
+      end
+
+      def urn_year
+        if identifier.year
+          return identifier.year.to_s
+        end
+
+        nil
+      end
+
+      def urn_suffix
+        identifier.suffix&.to_s&.downcase
+      end
+
+      def urn_amendment
+        "amd.#{identifier.amendment}" if identifier.amendment
+      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_addendum
+        val = maybe(:addendum)
+        "add.#{val}" if val
+      end
+
+      def generate
+        parts = ["urn", "ashrae"]
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << identifier.type.to_s.downcase if identifier.type
+        parts << urn_suffix if urn_suffix
+        parts << urn_amendment if urn_amendment
+        parts << urn_reaffirmed if urn_reaffirmed
+        parts << urn_copublisher if urn_copublisher
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts << urn_addendum if urn_addendum
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ashrae.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    autoload :Builder, "#{__dir__}/ashrae/builder"
+    autoload :Identifier, "#{__dir__}/ashrae/identifier"
+    autoload :Identifiers, "#{__dir__}/ashrae/identifiers"
+    autoload :Parser, "#{__dir__}/ashrae/parser"
+    autoload :Scheme, "#{__dir__}/ashrae/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/ashrae/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/ashrae/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/ashrae/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+  end
+end
+
+# Register Uashrae flavor with the registry
+Pubid::Registry.register(:ashrae, Pubid::Ashrae)

data/lib/pubid/asme/builder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Builder
+      def build(parsed_hash)
+        identifier = Identifiers::Standard.new
+
+        # Handle joint publishers
+        if parsed_hash[:joint_publisher]
+          identifier.joint_publisher = parsed_hash[:joint_publisher].to_s
+          identifier.publisher = parsed_hash[:joint_publisher].to_s
+        elsif parsed_hash[:first_publisher]
+          # CSA/ASME or API/ASME format
+          identifier.first_publisher = parsed_hash[:first_publisher].to_s
+          identifier.first_code = parsed_hash[:first_code].to_s
+          identifier.second_publisher = parsed_hash[:second_publisher].to_s
+          identifier.publisher = "#{parsed_hash[:first_publisher]}/#{parsed_hash[:second_publisher]}"
+        else
+          # Standard ASME
+          identifier.publisher = "ASME"
+        end
+
+        # Build code component
+        if parsed_hash[:designator]
+          identifier.code = build_code(parsed_hash)
+        end
+
+        # Set PTC suffix
+        if parsed_hash[:ptc_suffix]
+          identifier.ptc_suffix = parsed_hash[:ptc_suffix].to_s
+        end
+
+        # Set year
+        if parsed_hash[:year]
+          identifier.year = parsed_hash[:year].to_s
+        end
+
+        # Set draft year
+        if parsed_hash[:draft_year]
+          identifier.draft_year = parsed_hash[:draft_year].to_s
+        end
+
+        # Set reaffirmation
+        if parsed_hash[:reaffirmation]
+          identifier.reaffirmation = "R#{parsed_hash[:reaffirmation]}"
+        end
+
+        # Set language (including lang_suffix from BPVC)
+        if parsed_hash[:language]
+          identifier.language = parsed_hash[:language].to_s
+        elsif parsed_hash[:lang_suffix]
+          identifier.language = parsed_hash[:lang_suffix].to_s
+        end
+
+        # Set CSA number (for ASME/CSA format)
+        if parsed_hash[:csa_number]
+          identifier.csa_number = parsed_hash[:csa_number].to_s
+        end
+
+        # Set handbook flag
+        if parsed_hash[:handbook]
+          identifier.handbook = true
+        end
+
+        # Set revision note
+        if parsed_hash[:revision_note]
+          identifier.revision_note = "[#{parsed_hash[:revision_note]}]"
+        end
+
+        # Set parenthetical revision
+        if parsed_hash[:ref_standard]
+          # Extract the type of revision (Revision/Proposed revision)
+          ref = parsed_hash[:ref_standard].to_s
+          if parsed_hash[:ref_standard].to_s =~ /^(Proposed revision|Revision) of (.+)$/
+            identifier.parenthetical_revision = "(#{$1} of #{$2})"
+          else
+            identifier.parenthetical_revision = "(Revision of #{ref})"
+          end
+        end
+
+        identifier
+      end
+
+      private
+
+      def build_code(parsed_hash)
+        # Handle BPVC subdivision
+        if parsed_hash[:designator].is_a?(Hash) && parsed_hash[:designator][:bpvc_code]
+          bpvc_data = parsed_hash[:designator][:bpvc_code]
+
+          # Build BPVC designator string
+          designator_str = "BPVC"
+
+          if bpvc_data[:special]
+            # BPVC COMPLETE CODE BIND
+            designator_str = "BPVC COMPLETE CODE BIND"
+          elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:ssc_code]
+            # BPVC.SSC.XI.II.V.IX pattern
+            ssc_sections = bpvc_data[:subdivision][:ssc_sections]
+            sections_str = if ssc_sections.is_a?(Array)
+                             ssc_sections.join(".")
+                           else
+                             ssc_sections.to_s
+                           end
+            designator_str = "BPVC.SSC.#{sections_str}"
+          elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:case_code]
+            # BPVC.CC.BPV or BPVC.CC.NC.XI - extract from subdivision hash
+            cc = bpvc_data[:subdivision][:case_code].to_s
+            case_sub = bpvc_data[:subdivision][:case_sub]&.to_s
+
+            designator_str = case_sub && !case_sub.empty? ? "BPVC.CC.#{cc}.#{case_sub}" : "BPVC.CC.#{cc}"
+          elsif bpvc_data[:case_code]
+            # Dash notation: BPVC-CC-BPV
+            cc = bpvc_data[:case_code].to_s
+            designator_str = "BPVC-CC-#{cc}"
+          elsif bpvc_data[:subdivision]
+            # Standard subdivision
+            section = bpvc_data[:subdivision][:section].to_s
+            subsection = bpvc_data[:subdivision][:subsection].to_s
+            sub_subsection = bpvc_data[:subdivision][:sub_subsection].to_s
+            lang_suffix = bpvc_data[:subdivision][:lang_suffix].to_s
+
+            parts = [section, subsection, sub_subsection].reject do |p|
+              p.nil? || p.empty?
+            end
+            designator_str = "BPVC.#{parts.join('.')}"
+            designator_str += "_#{lang_suffix}" if !lang_suffix.empty?
+          else
+            # Fallback (shouldn't reach here)
+            designator_str = "BPVC"
+          end
+          number_str = ""
+
+          return Components::Code.new(designator: designator_str,
+                                      number: number_str)
+        end
+
+        # For joint published, handle special cases
+        designator_str = parsed_hash[:designator].to_s
+
+        # Normalize "V V" to "V&V"
+        designator_str = "V&V" if designator_str == "V V"
+
+        # Existing code for non-BPVC designators
+        code = Components::Code.new
+        code.designator = designator_str
+        code.number = parsed_hash[:number].to_s if parsed_hash[:number]
+        code
+      end
+    end
+  end
+end

data/lib/pubid/asme/components/code.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Asme
+    module Components
+      class Code < Lutaml::Model::Serializable
+        attribute :designator, :string    # B, Y, BPVC, etc.
+        attribute :number, :string        # 16.5, 14.43, III.1.NB, etc.
+
+        def to_s
+          "#{designator}#{number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/asme/identifier.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Identifier < Pubid::Identifier
+      def self.parse(str)
+        parser = Parser.new
+        builder = Builder.new
+
+        parsed = parser.parse(str)
+        builder.build(parsed)
+      end
+
+      # Factory that builds an ASME identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}. ASME's Code Component has
+      # `:designator` (leading letters, e.g. "B") and `:number` (rest,
+      # e.g. "16.34"); `.create` accepts either an already-split pair or
+      # a combined `:code` string which it splits at the first digit.
+      def self.create(**opts)
+        Identifiers::Standard.new(**coerce_create_attrs(opts))
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { publisher: (opts[:publisher] || "ASME").to_s }
+
+        if opts[:designator] || opts[:number]
+          attrs[:code] = Pubid::Asme::Components::Code.new(
+            designator: opts[:designator]&.to_s,
+            number:     opts[:number]&.to_s,
+          )
+        elsif (combined = opts[:code])
+          designator, number = split_asme_code(combined.to_s)
+          attrs[:code] = Pubid::Asme::Components::Code.new(
+            designator: designator,
+            number:     number,
+          )
+        end
+
+        %i[year reaffirmation language csa_number draft_year
+           revision_note parenthetical_revision ptc_suffix
+           joint_publisher first_publisher first_code].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        attrs[:handbook] = opts[:handbook] if opts.key?(:handbook)
+        attrs
+      end
+
+      # ASME codes pair a letter designator with a numeric/dotted number.
+      # Split at the first digit. "B16.34" → ["B", "16.34"]; "Y14.5" →
+      # ["Y", "14.5"]; "BPVC.III.1.NB" → ["BPVC.III.1.NB", nil] (no
+      # leading all-letters before the first digit — pass through).
+      def self.split_asme_code(str)
+        match = str.match(/\A([A-Za-z]+)(\d.*)\z/)
+        return match.captures if match
+
+        [str, nil]
+      end
+      private_class_method :coerce_create_attrs, :split_asme_code
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      class Base < SingleIdentifier
+        def to_s
+          # Handle joint published identifiers
+          parts = []
+          if first_publisher && first_code
+            # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
+            parts << first_publisher
+            parts << first_code
+            parts << "/#{second_publisher}" if second_publisher
+            parts << code.to_s if code && code.to_s != ""
+
+          elsif joint_publisher
+            # ISO/ASME or ASME/ANS format
+            parts << joint_publisher
+            parts << code.to_s if code && code.to_s != ""
+
+          else
+            # Standard ASME format
+            parts << publisher if publisher
+            parts << code.to_s if code
+
+          end
+          result = parts.join(" ")
+
+          # PTC suffix (space-separated)
+          if ptc_suffix
+            result += " #{ptc_suffix}"
+          end
+
+          # CSA dual-published (for ASME/CSA format)
+          if csa_number
+            result += "/CSA #{csa_number}"
+          end
+
+          # Handbook keyword
+          if handbook
+            result += " Handbook"
+          end
+
+          # Year
+          if draft_year
+            result += "-#{draft_year}"
+          elsif year
+            result += "-#{year}"
+          end
+
+          # Parenthetical revision (comes after year)
+          result += " #{parenthetical_revision}" if parenthetical_revision
+
+          # Language (can appear in rendered output)
+          result += " (#{language})" if language
+
+          # Reaffirmation
+          result += " (#{reaffirmation})" if reaffirmation
+
+          # Revision note
+          result += " #{revision_note}" if revision_note
+
+          # Normalize all em-dashes (–, —) and en-dashes to regular dash (-)
+          result.gsub(/[–—]/, "-")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      class Standard < Base
+        # Standard extends Base with no additional attributes
+        # All functionality inherited from Base
+      end
+    end
+  end
+end

data/lib/pubid/asme/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end