pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/bsi/single_identifier.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    # BSI base class. Canonical name Pubid::Bsi::Identifier; SingleIdentifier is a
+    # back-compat alias (BSI's common ancestor — there is no Identifiers::Base).
+    # Every concrete BSI identifier descends from it, so they are all
+    # `is_a?(Pubid::Bsi::Identifier)` natively and get the shared polymorphic
+    # `from_hash` (no facade needed).
+    class Identifier < ::Pubid::Identifier
+      def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        # Delegate to IEC for bare IEC identifiers. This handles IEC-specific
+        # features like VAP suffixes (CSV, RLV, etc.) and consolidated
+        # supplements (+AMD1:2001).
+        if string.match?(/\bIEC\b/) &&
+            (string.match?(/\s+(CSV|CMV|RLV|SER|EXV|PAC|PRV)\b/) ||
+             string.match?(/\+AMD\d+:/) ||
+             string.match?(/\+COR\d+:/))
+          return Pubid::Iec.parse(string)
+        end
+
+        parser = Parser.new
+
+        parsed = parser.parse(string)
+        Builder.build(parsed)
+      end
+
+      attribute :publisher, Bsi::Components::Publisher, default: -> {
+        Bsi::Components::Publisher.new(body: "BS")
+      }
+      attribute :prefix, :string # Specialized prefix (A, AU, C, M, 2A, etc.)
+      attribute :flex_prefix, :string # Flex type prefix (CECC, E9111, M, etc.)
+      # `number`/`part`/`subpart` are plain strings, not Bsi::Components::Code:
+      # BSI never populates a field of that component beyond `value`. This class
+      # body is the sole home of Pubid::Bsi::Identifier (bsi/identifier.rb is a
+      # comment-only load stub), so declaring here is safe - every subclass body
+      # opens after it has run. `second_number` keeps the component type: it is
+      # not one of the three attributes the shared base declares.
+      attribute :number, :string
+      attribute :iteration, :string # For bracket notation like 1000[9]
+      attribute :part, :string
+      attribute :subpart, :string
+      attribute :second_number, Bsi::Components::Code # For collections like PAS 2035/2030
+      attribute :date, Bsi::Components::Date
+      attribute :stage, Pubid::Components::Stage
+      attribute :type, Bsi::Components::Type
+      attribute :typed_stage, Pubid::Components::TypedStage
+      attribute :edition, :string
+      attribute :month, :integer
+      attribute :translation_lang, :string
+      attribute :translation_upper, :string
+      attribute :explicit_prefix, :boolean, default: -> { false }
+      attribute :explicit_publisher, :boolean, default: -> { false }
+      attribute :space_separated_part, :boolean, default: -> { false }
+
+      def <=>(other)
+        return nil unless other.is_a?(Pubid::Bsi::Identifier)
+
+        # Compare by number first
+        num_cmp = number.to_s <=> other.number.to_s
+        return num_cmp unless num_cmp.zero?
+
+        # Then by part
+        part_cmp = (part || "0").to_s <=> (other.part || "0").to_s
+        return part_cmp unless part_cmp.zero?
+
+        # Then by date
+        if date && other.date
+          date.to_s <=> other.date.to_s
+        elsif date
+          1
+        elsif other.date
+          -1
+        else
+          0
+        end
+      end
+
+      # Annex F series groupings per "Rules for the structure and drafting
+      # of UK standards" (BSI, 2017), F.1.3-F.1.5. Each maps a `prefix`
+      # token to the broader series category.
+      SERIES_CATEGORIES = {
+        # F.1.3 Automobile
+        "AU" => :automotive,
+        # F.1.4 Aerospace
+        "A" => :aerospace, "B" => :aerospace, "C" => :aerospace,
+        "F" => :aerospace, "G" => :aerospace, "HC" => :aerospace,
+        "L" => :aerospace, "S" => :aerospace, "SP" => :aerospace,
+        "X" => :aerospace, "M" => :aerospace, "TA" => :aerospace,
+        "2A" => :aerospace, "2B" => :aerospace, "2C" => :aerospace,
+        "2F" => :aerospace, "2G" => :aerospace, "2HC" => :aerospace,
+        "2HR" => :aerospace, "2L" => :aerospace, "2M" => :aerospace,
+        "2S" => :aerospace, "2SP" => :aerospace, "2TA" => :aerospace,
+        "2X" => :aerospace, "3A" => :aerospace, "3B" => :aerospace,
+        "3F" => :aerospace, "3G" => :aerospace, "3HR" => :aerospace,
+        "3J" => :aerospace, "3L" => :aerospace, "3S" => :aerospace,
+        "3TA" => :aerospace, "4F" => :aerospace, "4L" => :aerospace,
+        "4S" => :aerospace, "5S" => :aerospace, "7S" => :aerospace,
+        # F.1.5 Marine
+        "MA" => :marine, "PL" => :marine, "QC" => :marine,
+      }.freeze
+
+      # Series accessor — semantically named alias for `prefix` per
+      # issue #252. Returns the prefix token (e.g., "AU", "MA", "2A").
+      def series
+        prefix
+      end
+
+      # Series category — one of :automotive, :aerospace, :marine, or nil
+      # when the identifier doesn't carry a recognized Annex F prefix.
+      def series_category
+        SERIES_CATEGORIES[prefix.to_s] if prefix
+      end
+
+      def automotive?
+        series_category == :automotive
+      end
+
+      def aerospace?
+        series_category == :aerospace
+      end
+
+      def marine?
+        series_category == :marine
+      end
+    end
+
+    # Backward-compatible alias: BSI's base class is Pubid::Bsi::Identifier.
+    # Concrete types declared as `< SingleIdentifier` continue to work.
+    SingleIdentifier = Identifier
+  end
+end

data/lib/pubid/bsi/urn_generator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "bsi"]
+
+        if identifier.publisher
+          pub = identifier.publisher.to_s
+          parts << pub.to_s.downcase
+        else
+          parts << "bs"
+        end
+
+        if identifier.prefix
+          parts << identifier.prefix.to_s.downcase
+        end
+
+        if identifier.flex_prefix
+          parts << identifier.flex_prefix.to_s.downcase
+        end
+
+        # Fall back to the wrapped document's number. A wrapper — an adopted
+        # European norm, a bundle, a set — carries no number of its own, and
+        # `AdoptedEuropeanNorm#number` only delegates ONE level, so a
+        # "DD ENV ISO 11079:1999" (which adopts a CEN prestandard that is
+        # itself a wrapper around the ISO standard) emitted the identity-free
+        # `urn:bsi:dd` — the same URN as every other DD adoption. `#root`
+        # recurses to the origin document, and for a non-wrapper it is `self`,
+        # so this changes nothing for an ordinary identifier.
+        urn_number = identifier.number || identifier.root.number
+        if urn_number
+          number = urn_number.to_s
+          if identifier.iteration && !identifier.iteration.empty?
+            number += "[#{identifier.iteration}]"
+          end
+          parts << number
+        end
+
+        if identifier.part
+          part = identifier.part.to_s
+          parts << "-#{part}"
+        end
+
+        if identifier.subpart
+          subpart = identifier.subpart.to_s
+          parts << "-#{subpart}"
+        end
+
+        if identifier.second_number
+          second = identifier.second_number.to_s
+          parts << "/#{second}"
+        end
+
+        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+          parts << identifier.date.render(context: URN_CONTEXT)
+        elsif identifier.year
+          parts << identifier.year.to_s
+        end
+
+        if identifier.month
+          parts << format("%02d", identifier.month)
+        end
+
+        if identifier.edition
+          parts << "v#{identifier.edition}"
+        end
+
+        if identifier.translation_lang
+          parts << identifier.translation_lang.to_s.downcase
+        elsif identifier.translation_upper
+          parts << identifier.translation_upper.to_s.downcase
+        end
+
+        if identifier.type
+          type = identifier.type&.abbr || identifier.type.to_s
+          parts << type.to_s.downcase if type && type.to_s != "BS"
+        end
+
+        if identifier.typed_stage
+          stage_code = identifier.typed_stage.stage_code
+          if stage_code && stage_code != :published
+            parts << "stage.#{stage_code}"
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/bsi/urn_parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    # Parses BSI URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:bsi:{publisher}:{number}:{year}[:{supp_type}:{supp_number}:{supp_year}]
+    #
+    # publisher is the lowercase publisher (e.g., "bs", "pd"). supplement
+    # triples (`amd`/`cor`/`add`) follow the base identifier.
+    #
+    # Examples:
+    # - urn:bsi:bs:9001:2015                → BS 9001:2015
+    # - urn:bsi:bs:9001:2015:amd:1:2020     → BS 9001:2015/A1:2020
+    class UrnParser < Pubid::UrnParser::Base
+      SUPPLEMENT_ABBR = {
+        "amd" => "Amd",
+        "cor" => "Cor",
+        "add" => "Add",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        publisher_token, number, year, *supplement_parts = parts
+        publisher = publisher_token.upcase
+        text = "#{publisher} #{number}"
+        text += ":#{year}" if year
+        text += build_supplements(supplement_parts)
+        flavor_parse(text)
+      end
+
+      private
+
+      def build_supplements(parts)
+        return "" if parts.empty?
+
+        chunks = parts.each_slice(3).to_a
+        chunks.map { |type, num, supp_year| render_supplement(type, num, supp_year) }.join
+      end
+
+      def render_supplement(type, num, supp_year)
+        label = SUPPLEMENT_ABBR.fetch(type.downcase) { type.capitalize }
+        suffix = num ? " #{num}" : ""
+        suffix += ":#{supp_year}" if supp_year
+        "/#{label}#{suffix}"
+      end
+    end
+  end
+end

data/lib/pubid/bsi.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed BSI reference can start with, curated from the
+    # parser grammar (lib/pubid/bsi/parser.rb): the publisher (`bs` => BS/BSI),
+    # the native series/type rules that begin references (dd, pd, pas, na, ts,
+    # handbook => HB, pp, bip, ep_type), and the "BS <adopted-org>" combos the
+    # grammar builds from `bs` + `adopted_org_prefix`. Deliberately EXCLUDES the
+    # aerospace single/multi-letter prefixes (see
+    # identifiers/aerospace_standard.rb SINGLE_LETTER_PREFIXES / the parser's
+    # `single_letter_prefix` rule — A/B/C/S/X ...) because they are dangerously
+    # ambiguous and never lead a routable reference on their own; and the bare
+    # adopted forms (ISO/IEC/EN alone), which route to their own SDOs.
+    PREFIXES = (%w[BS BSI DD PD PAS NA TS HB PP BIP EP] +
+      ["BS EN", "BS ISO", "BS IEC", "BS EN ISO", "BS EN IEC"]).freeze
+
+    module Components
+      autoload :Code, "#{__dir__}/bsi/components/code"
+      autoload :Date, "#{__dir__}/bsi/components/date"
+      autoload :Publisher, "#{__dir__}/bsi/components/publisher"
+      autoload :Type, "#{__dir__}/bsi/components/type"
+    end
+
+    autoload :Builder, "#{__dir__}/bsi/builder"
+    autoload :Identifier, "#{__dir__}/bsi/identifier"
+    autoload :Identifiers, "#{__dir__}/bsi/identifiers"
+    # NOTE: bsi/model.rb is legacy/unused (nothing references Pubid::Bsi::Model)
+    # and defines a conflicting `class Identifier < Lutaml::Model::Serializable`.
+    # It is intentionally NOT autoloaded so it can never clash with the real
+    # Pubid::Bsi::Identifier (single_identifier.rb).
+    autoload :Parser, "#{__dir__}/bsi/parser"
+    autoload :Renderer, "#{__dir__}/bsi/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/bsi/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/bsi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/bsi/urn_parser"
+
+    # TYPED_STAGES_REGISTRY for native BSI types. Used by Pubid::Bsi.locate_stage
+    # to map abbreviations (e.g. "BS", "PD", "Handbook") to typed stages.
+    TYPED_STAGES_REGISTRY = [
+      # British Standard (BS)
+      Pubid::Components::TypedStage.new(
+        code: :pubbs,
+        stage_code: :published,
+        type_code: :bs,
+        abbr: ["BS"],
+        name: "British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :drbs,
+        stage_code: :draft,
+        type_code: :bs,
+        abbr: ["Draft BS", "DBS"],
+        name: "Draft British Standard",
+        harmonized_stages: %w[30.00 30.20 30.60 40.00 40.20 40.60],
+      ),
+
+      # Published Document (PD)
+      Pubid::Components::TypedStage.new(
+        code: :pubpd,
+        stage_code: :published,
+        type_code: :pd,
+        abbr: ["PD"],
+        name: "Published Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Publicly Available Specification (PAS)
+      Pubid::Components::TypedStage.new(
+        code: :pubpas,
+        stage_code: :published,
+        type_code: :pas,
+        abbr: ["PAS"],
+        name: "Publicly Available Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # National Annex (NA)
+      Pubid::Components::TypedStage.new(
+        code: :pubna,
+        stage_code: :published,
+        type_code: :na,
+        abbr: ["NA"],
+        name: "National Annex",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Draft Document (DD)
+      Pubid::Components::TypedStage.new(
+        code: :pubdd,
+        stage_code: :published,
+        type_code: :dd,
+        abbr: ["DD"],
+        name: "Draft Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Flex Document
+      Pubid::Components::TypedStage.new(
+        code: :pubflex,
+        stage_code: :published,
+        type_code: :flex,
+        abbr: ["Flex", "BSI Flex"],
+        name: "BSI Flex",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Handbook
+      Pubid::Components::TypedStage.new(
+        code: :pubhandbook,
+        stage_code: :published,
+        type_code: :handbook,
+        abbr: ["Handbook", "HB"],
+        name: "BSI Handbook",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Practice Guide (PP)
+      Pubid::Components::TypedStage.new(
+        code: :pubpp,
+        stage_code: :published,
+        type_code: :pp,
+        abbr: ["PP"],
+        name: "Published Practice",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # British Industrial Practice (BIP)
+      Pubid::Components::TypedStage.new(
+        code: :pubbip,
+        stage_code: :published,
+        type_code: :bip,
+        abbr: ["BIP"],
+        name: "British Industrial Practice",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Aerospace/Specialized British Standard (with letter prefix)
+      Pubid::Components::TypedStage.new(
+        code: :pubaerospace,
+        stage_code: :published,
+        type_code: :aerospace,
+        abbr: ["BS A", "BS AU", "BS C", "BS M", "BS S", "BS L", "BS TA",
+               "BS MA", "BS PL", "BS QC", "BS G", "BS HC", "BS F", "BS X", "BS B"],
+        name: "Aerospace/Specialized British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Index
+      Pubid::Components::TypedStage.new(
+        code: :pubindex,
+        stage_code: :published,
+        type_code: :index,
+        abbr: ["Index"],
+        name: "BSI Index",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Method
+      Pubid::Components::TypedStage.new(
+        code: :pubmethod,
+        stage_code: :published,
+        type_code: :method,
+        abbr: ["Method", "Methods"],
+        name: "BSI Method",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Section
+      Pubid::Components::TypedStage.new(
+        code: :pubsection,
+        stage_code: :published,
+        type_code: :section,
+        abbr: ["Section"],
+        name: "BSI Section",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # DISC (Delivering Information Solutions to Customers)
+      Pubid::Components::TypedStage.new(
+        code: :pubdisc,
+        stage_code: :published,
+        type_code: :disc,
+        abbr: ["DISC"],
+        name: "DISC",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Detailed Specification (with N or C notation)
+      Pubid::Components::TypedStage.new(
+        code: :pubdetailed_spec,
+        stage_code: :published,
+        type_code: :detailed_specification,
+        abbr: ["DETAILED SPEC"],
+        name: "Detailed Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Standalone Amendment
+      Pubid::Components::TypedStage.new(
+        code: :standalone_amendment,
+        stage_code: :published,
+        type_code: :amendment,
+        abbr: ["AMD"],
+        name: "Amendment",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Technical Specification
+      Pubid::Components::TypedStage.new(
+        code: :pubts,
+        stage_code: :published,
+        type_code: :ts,
+        abbr: ["TS"],
+        name: "Technical Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+    ].freeze
+
+    def self.parse(string)
+      unless string.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if string.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(string)
+    end
+
+    def self.transform(data)
+      Builder.build(data)
+    end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # Includes classes with explicit type declarations (Hash or nil).
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .select { |c| c.singleton_methods(false).include?(:type) }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    end
+
+    # Build typed stage index from the module's TYPED_STAGES_REGISTRY
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= TYPED_STAGES_REGISTRY
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type&.dig(:key)&.to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register Ubsi flavor with the registry
+Pubid::Registry.register(:bsi, Pubid::Bsi)
+
+# Per-flavor format registry: inherits global formats, overrides :human.
+# SingleIdentifier is the abstract base for every concrete BSI identifier
+# (including Amendment and Corrigendum), so wiring the registry here covers
+# the whole flavor in one shot.
+Pubid::Bsi::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Bsi::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Bsi::Renderer)