pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/amca/renderer.rb

@@ -1,82 +0,0 @@
-# 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/urn_parser.rb

@@ -1,28 +0,0 @@
-# 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/ansi/renderer.rb

@@ -1,53 +0,0 @@
-# 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/urn_parser.rb

@@ -1,23 +0,0 @@
-# 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/api/identifiers.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Api
-    module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
-      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
-      autoload :ContinuousOperationsStandard, "#{__dir__}/identifiers/continuous_operations_standard"
-      autoload :Mpms, "#{__dir__}/identifiers/mpms"
-      autoload :Publication, "#{__dir__}/identifiers/publication"
-      autoload :RecommendedPractice, "#{__dir__}/identifiers/recommended_practice"
-      autoload :Specification, "#{__dir__}/identifiers/specification"
-      autoload :Standard, "#{__dir__}/identifiers/standard"
-      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
-      autoload :TypelessStandard, "#{__dir__}/identifiers/typeless_standard"
-    end
-  end
-end

data/lib/pubid/api/renderer.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Api
-    # Human-readable renderer for API identifiers.
-    #
-    # Produces strings like:
-    #   "API Std 650"
-    #   "API MPMS CH 4.1"
-    #   "API 5L-2018"
-    #
-    # The renderer is registered as the +:human+ format in the API format
-    # registry and invoked via +render(format: :human)+.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        id = @id
-
-        case id
-        when Identifiers::Mpms
-          render_mpms(id)
-        when Identifiers::TypelessStandard
-          render_typeless(id)
-        else
-          render_default(id)
-        end
-      end
-
-      private
-
-      def render_default(id)
-        parts = ["API"]
-
-        # Add the type token (RP, STD, BULL, PUBL, SPEC, TR ...) if the leaf
-        # defines one. `type_string` is a plain METHOD on each leaf, never a
-        # lutaml attribute, so the old `attributes.key?(:type_string)` guard
-        # was always false and the token was dropped from every rendering.
-        parts << id.type_string if id.respond_to?(:type_string) && id.type_string
-
-        # Add code/number with part as one token
-        parts << code_portion(id) if code_portion(id)
-
-        result = parts.join(" ")
-        result += "-#{id.year}" if id.year
-        result += " (R#{id.reaffirmation})" if id.reaffirmation
-        result
-      end
-
-      def render_mpms(id)
-        parts = ["API", "MPMS"]
-
-        # Add chapter
-        parts << "CH #{id.number}" if id.number
-
-        # Add section/subsection
-        if id.section
-          parts << ".#{id.section}"
-          parts << ".#{id.subsection}" if id.subsection
-        end
-
-        # Add year
-        parts << "-#{id.year}" if id.year
-
-        parts.join(" ").gsub(" .", ".")
-      end
-
-      def render_typeless(id)
-        parts = ["API"]
-
-        # Add code/number
-        parts << code_portion(id) if code_portion(id)
-
-        # Add year
-        parts << "-#{id.year}" if id.year
-
-        # Add reaffirmation
-        parts << " (R#{id.reaffirmation})" if id.reaffirmation
-
-        parts.join(" ")
-      end
-
-      # The document number plus its part, as one token.
-      #
-      # This used to read a `code` attribute that NOTHING ever assigned — the
-      # parser emits no `:code` key and the builder never sets one — so it
-      # always returned nil and 163 of API's 193 corpus identifiers rendered
-      # as the bare publisher "API". That string is both the document number
-      # and the output filename, so they all collapsed onto each other.
-      # `number` is what Builder#cast actually populates.
-      def code_portion(id)
-        return nil unless id.number
-
-        code_str = id.number.to_s
-        code_str += "-#{id.part}" if id.part
-        code_str
-      end
-    end
-  end
-end

data/lib/pubid/api/urn_parser.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Api
-    # Parses API URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:api:{publisher}:{number}[-{part}]:{year}
-    # where slot[1] is the publisher (default "api"), slot[2] is the number
-    # with optional `-part` suffix, slot[3] is the optional year.
-    #
-    # Examples:
-    # - urn:api:api:1104              → API STD 1104
-    # - urn:api:api:1104-1:2020       → API STD 1104-1:2020
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        _type, number = parts
-        idx = 2
-        part = nil
-        if parts[idx]&.start_with?("-")
-          part = parts[idx]
-          idx += 1
-        end
-        year = parts[idx]
-
-        text = "API STD #{number}#{part}"
-        text += ":#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/ashrae/renderer.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ashrae
-    # Human-readable renderer for ASHRAE identifiers.
-    #
-    # Produces strings like:
-    #   "ASHRAE Standard 15-2024"
-    #   "ASHRAE Guideline 0-2019"
-    #   "ASHRAE Addendum a to Standard 15-2001"
-    #   "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
-    #   "ASHRAE Addenda c and d to Standard 15-1994"
-    #   "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
-    #   "Interpretations for Standard 15.2-2022"
-    #
-    # The renderer is registered as the +:human+ format in the ASHRAE format
-    # registry and invoked via +render(format: :human)+.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
-        id = @id
-
-        case id
-        when Identifiers::Addendum
-          render_addendum(id)
-        when Identifiers::AddendaPackage
-          render_addenda_package(id)
-        when Identifiers::CombinedAddenda
-          render_combined_addenda(id)
-        when Identifiers::Errata
-          render_errata(id)
-        when Identifiers::Interpretation
-          render_interpretation(id)
-        when SingleIdentifier
-          render_single(id)
-        else
-          render_single(id)
-        end
-      end
-
-      private
-
-      # SingleIdentifier (Standard, Guideline): "ASHRAE Standard 15-2024"
-      def render_single(id)
-        parts = []
-        parts << id.publisher if id.publisher
-        parts << id.type.to_s if id.type
-        result = parts.join(" ")
-        result += " " if result.length.positive?
-        result += id.number.to_s
-        result += "-#{id.year}" if id.year
-        result += " (#{id.amendment})" if id.amendment
-        result += id.suffix if id.suffix
-        result += " (RA#{id.reaffirmed})" if id.reaffirmed
-        result
-      end
-
-      # Addendum: "ASHRAE Addendum a to Standard 15-2001"
-      def render_addendum(id)
-        return id.base.to_s unless id.base
-
-        base_type = id.base.type || "Standard"
-
-        if id.copublisher
-          "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base}"
-        else
-          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base.number}"
-          result += "-#{id.base.year}" if id.base.year
-          result
-        end.tap { |r| r << " (#{id.addendum_date})" if id.addendum_date }
-      end
-
-      # AddendaPackage: "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
-      def render_addenda_package(id)
-        return id.base.to_s unless id.base
-
-        result = "ASHRAE #{id.base.type || 'Standard'} #{id.base.number}"
-        result += "-#{id.base.year}" if id.base.year
-        result += ": Addenda #{id.package_description}" if id.package_description
-        result
-      end
-
-      # CombinedAddenda: "ASHRAE Addenda c and d to Standard 15-1994"
-      def render_combined_addenda(id)
-        return id.base.to_s unless id.base
-
-        base_type = id.base.type || "Standard"
-        if id.addendum_codes
-          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base.number}"
-        else
-          result = "ASHRAE Addenda to #{base_type} #{id.base.number}"
-        end
-        result += "-#{id.base.year}" if id.base.year
-        result
-      end
-
-      # Errata: "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
-      def render_errata(id)
-        return id.base.to_s unless id.base
-
-        result = id.base.to_s
-        result += " Errata"
-        result += " (#{id.errata_date})" if id.errata_date
-        result
-      end
-
-      # Interpretation: "Interpretations for Standard 15.2-2022"
-      def render_interpretation(id)
-        return id.base.to_s unless id.base
-
-        base_type = id.base.type || "Standard"
-        result = "Interpretations for #{base_type} #{id.base.number}"
-        result += "-#{id.base.year}" if id.base.year
-        result
-      end
-    end
-  end
-end

data/lib/pubid/ashrae/urn_parser.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ashrae
-    # Parses ASHRAE URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:ashrae:{number}:{year}:{type}[:{suffix}][:amd.{N}][:reaff.{Y}]
-    #
-    # The type token follows the year; the human-readable form prefixes the
-    # type ("ASHRAE Standard 90.1-2019"). The year separator is `-`.
-    #
-    # Examples:
-    # - urn:ashrae:90.1:2019:standard → ASHRAE Standard 90.1-2019
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        number, year = parts
-        text = "ASHRAE Standard #{number}"
-        text += "-#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/asme/renderer.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Asme
-    # Human-readable renderer for ASME identifiers.
-    #
-    # Produces strings like:
-    #   "ASME B16.5-2020"
-    #   "CSA B44.10/ASME A17.10"
-    #   "ASME BPVC III.1.NB-2023"
-    #   "ASME PTC 4-2013"
-    #
-    # The renderer is registered as the `:human` format in the ASME format
-    # registry and invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        id = @id
-        parts = []
-
-        if id.first_publisher && id.first_code
-          # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
-          parts << id.first_publisher
-          parts << id.first_code
-          parts << "/#{id.second_publisher}" if id.second_publisher
-          parts << id.number.to_s if id.number && id.number.to_s != ""
-        elsif id.joint_publisher
-          # ISO/ASME or ASME/ANS format
-          parts << id.joint_publisher
-          parts << id.number.to_s if id.number && id.number.to_s != ""
-        else
-          # Standard ASME format
-          parts << id.publisher if id.publisher
-          parts << id.number.to_s if id.number
-        end
-
-        result = parts.join(" ")
-
-        if id.ptc_suffix
-          result += " #{id.ptc_suffix}"
-        end
-
-        if id.csa_number
-          result += "/CSA #{id.csa_number}"
-        end
-
-        if id.handbook
-          result += " Handbook"
-        end
-
-        if id.draft_year
-          result += "-#{id.draft_year}"
-        elsif id.year
-          result += "-#{id.year}"
-        end
-
-        result += " #{id.parenthetical_revision}" if id.parenthetical_revision
-        result += " (#{id.language})" if id.language
-        result += " (#{id.reaffirmation})" if id.reaffirmation
-        result += " #{id.revision_note}" if id.revision_note
-
-        # Normalize all em-dashes and en-dashes to regular dash
-        result.gsub(/[–—]/, "-")
-      end
-    end
-  end
-end

data/lib/pubid/asme/urn_parser.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Asme
-    # Parses ASME URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:asme:{publisher}:{code}:{year}
-    #
-    # publisher is the lowercase publisher string. code is the alphanumeric
-    # designation (e.g., "B16.5", "PTC1", "BPVC-2023"). The year separator
-    # in human-readable form is `-`, not `:`.
-    #
-    # Examples:
-    # - urn:asme:asme:B16.5:2020   → ASME B16.5-2020
-    # - urn:asme:asme:PTC1:2020    → ASME PTC1-2020
-    # - urn:asme:asme:BPVC-2023    → ASME BPVC-2023
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        _publisher, code, year = parts
-
-        text = "ASME #{code}"
-        text += "-#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/astm/identifiers/code_number.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Astm
-    module Identifiers
-      # Installs the flat, index-friendly code columns on every CONCRETE ASTM
-      # identifier class.
-      #
-      # Why every concrete class and not Pubid::Astm::SingleIdentifier, which
-      # they all inherit from: `number` redefines the parent
-      # ::Pubid::Identifier's `attribute :number, Components::Code` as a plain
-      # :string (Astm::Components::Code is not a subclass of it). Declaring that
-      # on a class the concrete types INHERIT from resolves against the parent
-      # definition nondeterministically under multi-flavor load — it passes an
-      # ASTM-only run and can flip `root.number` to "" under the full suite (the
-      # IEEE lesson; see lib/pubid/ieee/identifiers/code_number.rb and
-      # CLAUDE.md).
-      #
-      # NOTE the module is included by `Standard` AND by `IsoDualPublished`,
-      # which inherits from Standard. That is deliberate, not redundant: a class
-      # that is itself inherited from must still declare the columns so its
-      # subclass holds its own snapshot rather than relying on the parent's.
-      # Every instantiable ASTM class declares them for itself.
-      #
-      # This matters because relaton-index sorts and bsearches every row on
-      # `id.root.number.to_s`, and ASTM kept identity in an
-      # Astm::Components::Code under a `code` attribute, so all 248 parseable
-      # fixture ids keyed "".
-      module CodeNumber
-        def self.included(base)
-          # Bare document number ("2938"), the relaton index key. `letter` is a
-          # sibling column, so E2938 and D2938 narrow to the same bucket and
-          # are then separated by the full hash — the IEEE prefix/number split.
-          base.attribute :number, :string
-          base.attribute :letter, :string
-          base.attribute :suffix, :string
-          base.attribute :subseries, :string
-          # Named for the RARE case with a false default, so the canonical
-          # to_hash drops it from every ordinary row.
-          base.attribute :dual_m, :boolean, default: -> { false }
-        end
-
-        # The composed document code, rebuilt on demand from the split columns.
-        # ASTM's renderer reads the individual fields (`code.letter`,
-        # `code.number`, `code.dual_m`) in several places, so the component has
-        # to keep its structure rather than collapsing to a string as ASME's
-        # does.
-        #
-        # Deliberately NOT an attribute and NOT memoised: the columns are
-        # writable (the base #exclude rebuilds through them), so a cached Code
-        # would go stale. nil when there is no number and no letter, preserving
-        # the nil-`code` branches the renderer and URN generator both test.
-        def code
-          return nil if number.nil? && letter.nil?
-
-          Components::Code.new(
-            letter: letter,
-            number: number,
-            suffix: suffix,
-            subseries: subseries,
-            dual_m: dual_m,
-          )
-        end
-
-        # Every field of the code is identity-bearing — Code#to_s renders all
-        # of them and they are all in the serialized hash — so all of them must
-        # reach the slug, or two distinct documents share a filename.
-        # CLAUDE.md's rule: a marker that only reaches `==` is not enough.
-        def mr_number_with_part
-          segments = [letter, number, suffix].compact
-          segments << "s#{subseries}" if subseries
-          segments << "m" if dual_m
-          return nil if segments.empty?
-
-          segments.join("-").downcase.gsub(/[^a-z0-9-]+/, "-")
-            .gsub(/\A-+|-+\z/, "")
-        end
-      end
-    end
-  end
-end

data/lib/pubid/astm/identifiers.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Astm
-    module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
-      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
-      autoload :Standard, "#{__dir__}/identifiers/standard"
-      autoload :IsoDualPublished, "#{__dir__}/identifiers/iso_dual_published"
-      autoload :Manual, "#{__dir__}/identifiers/manual"
-      autoload :ResearchReport, "#{__dir__}/identifiers/research_report"
-      autoload :DataSeries, "#{__dir__}/identifiers/data_series"
-      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
-      autoload :Monograph, "#{__dir__}/identifiers/monograph"
-      autoload :Adjunct, "#{__dir__}/identifiers/adjunct"
-      autoload :WorkInProgress, "#{__dir__}/identifiers/work_in_progress"
-    end
-  end
-end