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

data/lib/pubid/iec/identifiers.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iec
-    module Identifiers
-      autoload :Amendment, "#{__dir__}/identifiers/amendment"
-      autoload :Base, "#{__dir__}/identifiers/base"
-      autoload :ComponentSpecification, "#{__dir__}/identifiers/component_specification"
-      autoload :ConformityAssessment, "#{__dir__}/identifiers/conformity_assessment"
-      autoload :ConsolidatedIdentifier, "#{__dir__}/identifiers/consolidated_identifier"
-      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
-      autoload :FragmentIdentifier, "#{__dir__}/identifiers/fragment_identifier"
-      autoload :Guide, "#{__dir__}/identifiers/guide"
-      autoload :InternationalStandard, "#{__dir__}/identifiers/international_standard"
-      autoload :InterpretationSheet, "#{__dir__}/identifiers/interpretation_sheet"
-      autoload :OperationalDocument, "#{__dir__}/identifiers/operational_document"
-      autoload :PubliclyAvailableSpecification, "#{__dir__}/identifiers/publicly_available_specification"
-      autoload :SheetIdentifier, "#{__dir__}/identifiers/sheet_identifier"
-      autoload :SocietalTechnologyTrendReport, "#{__dir__}/identifiers/societal_technology_trend_report"
-      autoload :SystemsReferenceDocument, "#{__dir__}/identifiers/systems_reference_document"
-      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
-      autoload :TechnicalSpecification, "#{__dir__}/identifiers/technical_specification"
-      autoload :TechnicalGroup, "#{__dir__}/identifiers/technical_group"
-      autoload :TechnologyReport, "#{__dir__}/identifiers/technology_report"
-      autoload :TestReportForm, "#{__dir__}/identifiers/test_report_form"
-      autoload :VapIdentifier, "#{__dir__}/identifiers/vap_identifier"
-      autoload :WhitePaper, "#{__dir__}/identifiers/white_paper"
-      autoload :WorkingDocument, "#{__dir__}/identifiers/working_document"
-    end
-  end
-end

data/lib/pubid/iec/renderer.rb

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iec
-    # Human-readable renderer for IEC identifiers.
-    #
-    # Components are accessed only through `component.render(context:)`.
-    #
-    # Produces strings like:
-    #   "IEC 60038:2009"
-    #   "IEC/CD 60038"
-    #   "IEC 60038:2009/AMD1:2011"
-    #   "IEC/FDAM 60038-1"
-    #   "IEC 60529:1989+AMD1:1999 CSV"
-    #
-    # The renderer is registered as the `:human` format in the IEC format
-    # registry and invoked via `render(format: :human)`.
-    #
-    # For simple (non-wrapper) identifiers, the renderer delegates to the
-    # identifier's own `publisher_portion` / `number_portion` helpers so that
-    # per-type overrides (e.g. TR, TS, Guide) continue to work without
-    # duplication.  Wrapper types (Consolidated, VAP, Sheet, Fragment,
-    # Supplement, WorkingDocument, TestReportForm) have rendering logic
-    # here because their structure differs fundamentally.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        id = @id
-
-        case id
-        when Identifiers::ConsolidatedIdentifier
-          render_consolidated(id, opts, context)
-        when Identifiers::VapIdentifier
-          render_vap(id, opts, context)
-        when Identifiers::SheetIdentifier
-          render_sheet(id, opts, context)
-        when Identifiers::FragmentIdentifier
-          render_fragment(id, opts, context)
-        when Identifiers::WorkingDocument
-          render_working_document(id, context)
-        when Identifiers::TechnicalGroup
-          render_technical_group(id, context)
-        when Identifiers::TestReportForm
-          render_test_report_form(id, context)
-        when SupplementIdentifier
-          render_supplement(id, opts, context)
-        else
-          render_single(id, opts, context)
-        end
-      end
-
-      private
-
-      def render_single(id, opts, context)
-        parts = []
-        parts << id.publisher_portion
-        parts << id.number_portion
-
-        if id.is_a?(Identifiers::Base)
-          parts << " #{id.edition.render(context:)}" if id.edition&.number
-        elsif opts[:with_edition] && id.edition&.number
-          parts << " #{id.edition.render(context:)}"
-        end
-
-        # VAP codes live on VapIdentifier (rendered in render_vap), not Base.
-
-        if id.is_a?(Identifiers::Base) && id.database
-          parts << " DB"
-        end
-
-        parts << " (all parts)" if id.all_parts
-
-        result = parts.compact.join
-
-        result << id.language_portion(lang_single: opts[:lang_single]) if id.languages&.any?
-
-        result
-      end
-
-      def render_supplement(id, opts, context)
-        id.ensure_base
-
-        if id.synthetic_base?
-          render_supplement_standalone(id, context)
-        elsif id.base
-          render_supplement_attached(id, opts, context)
-        else
-          render_single(id, opts, context)
-        end
-      end
-
-      def render_supplement_standalone(id, context)
-        # This is a second, independent publisher/stage join that
-        # SingleIdentifier#publisher_portion never reaches. It follows the same
-        # house style: the slash separates copublishers, and a SPACE separates
-        # the publisher from the stage abbreviation. See issue #360 item 2.
-        parts = []
-
-        if id.publisher
-          publishers = [id.publisher.render(context:)]
-          if id.copublishers&.any?
-            publishers += id.copublishers.map { |c| c.render(context:) }
-          end
-          parts << publishers.join("/")
-        end
-
-        abbr = id.typed_stage.abbr.first
-        number_str = id.base.number.to_s
-        number_str += "-#{id.number}" if id.number
-        number_str += "-#{id.subpart}" if id.subpart
-        parts << "#{abbr} #{number_str}"
-
-        result = parts.join(" ")
-        result += ":#{id.date.render(context:)}" if id.date
-        result += " #{id.edition.render(context:)}" if id.edition&.number
-        result
-      end
-
-      def render_supplement_attached(id, opts, context)
-        parts = []
-        parts << id.base.to_s(**opts)
-
-        abbr = id.typed_stage.abbr.first.upcase
-        supp_part = "/#{abbr}#{id.number}"
-        supp_part += ":#{id.date.render(context:)}" if id.date
-        parts << supp_part
-
-        parts << " #{id.edition.render(context:)}" if id.edition&.number
-
-        parts.join
-      end
-
-      def render_consolidated(id, opts, _context)
-        id.identifiers.map.with_index do |sub_id, idx|
-          if idx.zero?
-            sub_id.to_s(**opts)
-          elsif sub_id.is_a?(Identifiers::Amendment)
-            render_consolidated_amendment(sub_id)
-          elsif sub_id.is_a?(Identifiers::Corrigendum)
-            render_consolidated_corrigendum(sub_id)
-          else
-            "+#{sub_id.to_s(**opts)}"
-          end
-        end.join
-      end
-
-      def render_consolidated_amendment(id)
-        if id.date&.present?
-          "+AMD#{id.number}:#{id.date.render}"
-        else
-          "+AMD#{id.number}"
-        end
-      end
-
-      def render_consolidated_corrigendum(id)
-        if id.date&.present?
-          "+COR#{id.number}:#{id.date.render}"
-        else
-          "+COR#{id.number}"
-        end
-      end
-
-      def render_vap(id, opts, context)
-        parts = []
-
-        parts << id.base.to_s(**opts.merge(with_edition: false))
-        parts << " #{id.vap.join('-')}" if id.vap&.any?
-        parts << " #{id.edition.render(context:)}" if id.edition&.number
-
-        parts.compact.join
-      end
-
-      def render_sheet(id, opts, context)
-        parts = []
-        parts << id.base.to_s(**opts)
-        parts << "/#{id.sheet_number}"
-        parts << ":#{id.year}" if id.year
-        parts.join
-      end
-
-      def render_fragment(id, opts, context)
-        parts = []
-        parts << id.base.to_s(**opts)
-
-        parts << if id.base.is_a?(Identifiers::Corrigendum)
-                   "/FRAGC#{id.fragment_number}"
-                 else
-                   "/FRAG#{id.fragment_number}"
-                 end
-
-        parts << " #{id.edition.render(context:)}" if id.edition&.number
-
-        parts.join
-      end
-
-      def render_technical_group(id, _context)
-        parts = []
-        parts << id.publisher_portion
-        parts << " #{id.technical_committee}"
-        parts << id.subcommittee if id.subcommittee
-        parts.join
-      end
-
-      def render_working_document(id, context)
-        if id.wp_stage
-          # A work-programme registration renders bare, as it is written:
-          # "PNW 65-915 ED1", not "IEC/PNW 65-915 ED1". Its number is
-          # TC-scoped, not an IEC document number, and prefixing "IEC " would
-          # break idempotence — "IEC PNW 65-915 ED1" re-parses as an
-          # International Standard, so rendering would not be a fixed point.
-          parts = []
-          parts << id.wp_stage
-          if id.wp_type && !id.wp_type.strip.empty?
-            parts << " #{id.wp_type.strip}"
-          end
-
-          if id.number
-            num_str = id.number.to_s
-            num_str += "-#{id.part}" if id.part && id.part.to_s != ""
-            num_str += "-#{id.subpart}" if id.subpart && id.subpart.to_s != ""
-            parts << " #{num_str}"
-          end
-
-          parts << " #{id.edition.render(context:)}" if id.edition&.number
-          return parts.join
-        end
-
-        parts = []
-        parts << id.technical_committee if id.technical_committee
-
-        if id.wd_number
-          num_part = id.wd_number.to_s
-          num_part += "(#{id.wd_language})" if id.wd_language
-          parts << num_part
-        end
-
-        parts << id.wd_stage if id.wd_stage
-
-        parts.join("/")
-      end
-
-      def render_test_report_form(id, context)
-        parts = []
-        parts << id.publisher_portion
-
-        if id.cispr_identifier
-          cispr_parts = []
-          cispr_parts << id.cispr_identifier.publisher.render(context:)
-
-          num_str = id.cispr_identifier.number.to_s
-          num_str += "-#{id.cispr_identifier.part}" if id.cispr_identifier.part && id.cispr_identifier.part.to_s != ""
-          cispr_parts << num_str
-
-          cispr_str = cispr_parts.join(" ")
-          cispr_str += ":#{id.date.render(context:)}" if id.date
-
-          parts << " #{cispr_str}"
-        else
-          parts << id.number_portion
-        end
-
-        parts << id.trf_info.to_s if id.trf_info && !id.trf_info.empty?
-
-        parts.compact.join
-      end
-    end
-  end
-end

data/lib/pubid/ieee/compaction.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    # Serialization compaction for IEEE hashes — a recursive transform hooked
-    # into Ieee::Identifier#to_hash (collapse) and .from_hash (expand). Two
-    # compactions, both provably lossless and nested-safe (they descend into a
-    # Corrigendum `base` too):
-    #
-    # 1. **typed_stage -> `stage` scalar.** The multi-field `typed_stage` object
-    #    becomes a single `stage` key holding its canonical abbreviation,
-    #    rebuilt from the TYPED_STAGES registry. The abbreviation keys the
-    #    registry uniquely, and the collapse fires only when the registry's
-    #    reconstruction is byte-identical to the serialized sub-hash — an
-    #    unrecognised / non-matching stage is left as the full object (fails
-    #    closed).
-    #
-    # 2. **`draft` slash strip.** `Components::Draft#to_s` renders `"/D3"`; the
-    #    leading `/` is boilerplate, so the serialized form is `"D3"`. No expand
-    #    step is needed — `Draft.parse` already accepts the slashless form and
-    #    reproduces `"/D3"` (verified across the whole corpus), so from_hash and
-    #    rendering are unchanged.
-    #
-    # A recursive hash transform (rather than lutaml attributes) is deliberate:
-    # `stage` collides with the inherited `Components::Stage` attribute name (a
-    # redefinition would reintroduce the multi-flavor nondeterminism we hit with
-    # `number`), and only a whole-hash walk reaches a nested Corrigendum `base`,
-    # which a per-object `to_hash` override cannot (the nested-serialization
-    # wall). The runtime `typed_stage`/`draft_obj` objects are untouched.
-    module Compaction
-      module_function
-
-      # abbr => canonical serialized typed_stage sub-hash, mirroring what the
-      # parent serializer + canonicalizer emit (nils dropped, and a default
-      # `project_status: false` dropped). Memoized.
-      def sub_hash_for(abbr)
-        (@sub_hash_for ||= build_sub_hash_map)[abbr]
-      end
-
-      def build_sub_hash_map
-        TypedStages::TYPED_STAGES.to_h { |ts| [ts.abbr.first, entry_sub_hash(ts)] }
-      end
-
-      # NB: this must list every Components::TypedStage attribute. If a field is
-      # added there but not here, the collapse guard fails closed — affected
-      # stages stay full objects (still lossless) but stop compacting; extend
-      # this list to keep them compact.
-      def entry_sub_hash(typed_stage)
-        {
-          "abbr" => typed_stage.abbr,
-          "stage_code" => typed_stage.stage_code,
-          "type_code" => typed_stage.type_code,
-          "iso_stage_equivalent" => typed_stage.iso_stage_equivalent,
-          "ieee_draft_equivalent" => typed_stage.ieee_draft_equivalent,
-          "approval_status" => typed_stage.approval_status,
-          "project_status" => typed_stage.project_status || nil,
-        }.compact
-      end
-
-      # Recursively compact every hash in the tree: collapse a reproducible
-      # `typed_stage` to a `stage` scalar and strip the leading `/` off `draft`.
-      def collapse(node)
-        collapse_hash(node) if node.is_a?(::Hash)
-        node.each { |v| collapse(v) } if node.is_a?(::Array)
-        node
-      end
-
-      def collapse_hash(node)
-        collapse_stage(node)
-        draft = node["draft"]
-        node["draft"] = draft.delete_prefix("/") if draft.is_a?(::String)
-        node.each_value { |v| collapse(v) }
-      end
-
-      # Collapse only when the registry rebuilds the exact same sub-hash, so no
-      # information is ever lost.
-      def collapse_stage(node)
-        ts = node["typed_stage"]
-        abbr = ts["abbr"]&.first if ts.is_a?(::Hash)
-        return unless abbr && sub_hash_for(abbr) == ts
-
-        node.delete("typed_stage")
-        node["stage"] = abbr
-      end
-
-      # Inverse of {collapse} for `stage`: replace a recognised `stage` scalar
-      # with its registry typed_stage sub-hash so lutaml rebuilds the component
-      # (nested bases included). `draft` needs no expansion — Draft.parse
-      # accepts the slashless form. An unrecognised value is left alone.
-      def expand(node)
-        expand_hash(node) if node.is_a?(::Hash)
-        node.each { |v| expand(v) } if node.is_a?(::Array)
-        node
-      end
-
-      def expand_hash(node)
-        key = stage_key(node)
-        sub = sub_hash_for(node[key].to_s) if key
-        if sub
-          node.delete(key)
-          node["typed_stage"] = deep_dup(sub)
-        end
-        node.each_value { |v| expand(v) }
-      end
-
-      def stage_key(node)
-        return :stage if node.key?(:stage)
-
-        "stage" if node.key?("stage")
-      end
-
-      def deep_dup(node)
-        case node
-        when ::Hash then node.transform_values { |v| deep_dup(v) }
-        when ::Array then node.map { |v| deep_dup(v) }
-        else node
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ieee/identifiers/amendment.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    module Identifiers
-      # Amendment identifier for IEEE standards
-      # Represents additions/changes to a published standard
-      # Example: IEEE Std 802.3-2018/Amd 4-2020
-      class Amendment < SupplementIdentifier
-        # The amendment's own ordinal (`number`) and `year` — uniform names,
-        # not `amd_number`/`amd_year`. `number` is a plain string redefining the
-        # inherited Components::Code (leaf-safe, like the standards); `year` is
-        # the inherited base :string. `root.number` still returns the *base*
-        # document number, so the index key is unaffected. Mirrors Corrigendum.
-        attribute :number, :string
-        # `year` inherited from the base.
-
-        # TYPED_STAGES for amendment
-        # Amendment uses "Amd" abbreviation
-        TYPED_STAGES = [
-          Components::TypedStage.new(
-            abbr: ["Amd"],
-            type_code: "amendment",
-            stage_code: "published",
-          ),
-        ].freeze
-
-        # MR supplement suffix: `amd.{number}.{year}` (e.g. "/amd.4.2020").
-        # The MrString renderer recurses into `base` and appends this so the
-        # full IEEE amendment round-trips losslessly (mirrors Corrigendum).
-        def mr_supplement_suffix
-          segments = ["amd"]
-          segments << number.to_s if number
-          segments << year.to_s if year
-          segments.join(".")
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    module Identifiers
-      # Mixin for concrete IEEE leaf identifiers that are their own `#root` and
-      # carry a document code. It splits the code into separate, index-friendly
-      # scalar attributes and, crucially, **replaces** the serialized `code`
-      # string with them:
-      #
-      #   number    :string             bare-digit narrowing key ("802", "37")
-      #   prefix    :string             letter series designator ("C"), if any
-      #   parts     :string collection  dotted/dashed parts (["16", "1"])
-      #   separator :string             "." or "-", to render the parts back
-      #
-      # relaton's index-v2 keys its binary search on `id.root.number.to_s` and
-      # narrows a part-less reference (`IEEE 802`) to the whole bucket of parts
-      # (`802.11`, `802.16`, `802.16.1`), then matches `parts` — so `number`
-      # (part-less) and `parts` MUST be separate columns. The full `code` string
-      # is not serialized at all; `code_obj` (the runtime Components::Code the
-      # renderer/urn_generator read) is rebuilt losslessly from the four fields.
-      #
-      # Why a leaf mixin and not the base: IEEE keeps identity in `code`, so the
-      # base class's inherited generic `number` (a `Components::Code`) is nil.
-      # Redefining `attribute :number, :string` on the shared,
-      # **directly-instantiated** `Ieee::Identifier` base resolves against the
-      # parent's `Components::Code` **nondeterministically under multi-flavor
-      # load** (it passes IEEE-only but flips once every flavor is required,
-      # e.g. the full suite). Applying the split only on leaf classes that are
-      # never a superclass avoids that merge ambiguity — the same pattern
-      # CIE/IHO/IETF use. Never define a `#number` *method*: it collides with
-      # lutaml's generated accessor and corrupts attribute resolution.
-      module CodeNumber
-        def self.included(base)
-          base.attribute :number, :string
-          base.attribute :prefix, :string
-          base.attribute :parts, :string, collection: true, default: -> { [] }
-          base.attribute :separator, :string
-        end
-
-        # Accept keyword args or a single positional hash (the latter is what the
-        # base #exclude/matching rebuild passes) — see Identifier#initialize.
-        def initialize(args = {}, **kwargs)
-          super
-          sync_split_from_code_obj
-        end
-
-        # On the parse path `code_obj` is already built (base #initialize parses
-        # it from the `code:` arg); hoist its fields onto the split attributes
-        # so they serialize.
-        def sync_split_from_code_obj
-          co = code_obj
-          return unless co
-
-          self.number    = co.number
-          self.prefix    = co.prefix
-          self.parts     = co.parts
-          self.separator = co.original_separator
-        end
-
-        # After from_hash there is no `code` string and no cached object, so
-        # rebuild code_obj from the split fields. On the parse path base
-        # #initialize already set @code_obj, so the `||=` returns it unchanged.
-        def code_obj
-          @code_obj ||= rebuild_code_obj_from_split
-        end
-
-        def rebuild_code_obj_from_split
-          return nil if number.nil? || number.to_s.empty?
-
-          nonempty_parts = parts.nil? || parts.empty? ? nil : parts
-          Components::Code.new(
-            prefix: prefix,
-            number: number,
-            parts: nonempty_parts,
-            original_separator: separator,
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ieee/identifiers/nesc/edition.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    module Identifiers
-      module Nesc
-        # A plain year-first NESC edition — the National Electrical Safety Code
-        # itself, referenced by publication year rather than by its C2 code.
-        #
-        # @example
-        #   nesc = Pubid::Ieee.parse(
-        #     "2017 National Electrical Safety Code(R) (NESC(R))",
-        #   )
-        #   nesc.to_s
-        #   # => "IEEE Std 2017 National Electrical Safety Code(R) (NESC(R))"
-        #
-        # Rendering is Nesc::Base's; this class exists so that the builder never
-        # instantiates the abstract Base. Only concrete leaves may carry the
-        # CodeNumber mixin's `:string` `number` (see the mixin's notes on the
-        # multi-flavor attribute-resolution landmine), and every identifier that
-        # can be a `#root` needs a non-empty `number` for the relaton index.
-        class Edition < Base
-          include Pubid::Ieee::Identifiers::CodeNumber
-
-          def self.polymorphic_name
-            "pubid:ieee:nesc-edition"
-          end
-        end
-      end
-    end
-  end
-end