pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/bsi/single_identifier.rb

@@ -2,10 +2,34 @@
 
 module Pubid
   module Bsi
-    class SingleIdentifier < Pubid::Identifier
-      # Generate URN for this identifier
-      #
-      # @return [String] URN representation
+    # 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)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, 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)
+      rescue Parslet::ParseFailed => e
+        raise StandardError, "Failed to parse '#{string}': #{e.message}"
+      end
 
       attribute :publisher, Bsi::Components::Publisher, default: -> {
         Bsi::Components::Publisher.new(body: "BS")
@@ -29,81 +53,8 @@ module Pubid
       attribute :explicit_publisher, :boolean, default: -> { false }
       attribute :space_separated_part, :boolean, default: -> { false }
 
-      def to_s(lang: :en, lang_single: false)
-        # Build string representation
-        parts = []
-
-        # For supplement/addendum base identifiers, flex_prefix replaces publisher+prefix
-        parts << publisher.to_s if publisher
-        if flex_prefix
-          # Flex prefix is the full prefix including BS (e.g., "BS CECC" becomes "BS" + space + "CECC")
-          parts << flex_prefix
-        elsif prefix
-          # Standard publisher
-
-          # Prefix if present (specialized prefix like A, AU, C, etc.)
-          parts << prefix.to_s
-        end
-
-        # Number with iteration, part, and subpart
-        if number
-          number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
-
-          # Collection (second number with slash)
-          if second_number
-            second_val = second_number.is_a?(Components::Code) ? second_number.value : second_number
-            number_str += "/#{second_val}"
-          end
-
-          # Part and subpart - check if space-separated
-          space_separated = space_separated_part
-          if part
-            part_val = part.is_a?(Components::Code) ? part.value : part
-            # Trim part value to remove leading/trailing spaces from parser
-            part_str = part_val.to_s.strip
-            # Use space for space-separated parts, dash otherwise
-            separator = space_separated ? " " : "-"
-            number_str += "#{separator}#{part_str}"
-          end
-          if subpart
-            subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
-            subpart_str = subpart_val.to_s.strip
-            number_str += "-#{subpart_str}"
-          end
-
-          # Iteration (bracket notation like 1000[9])
-          if iteration && !iteration.empty?
-            number_str += "[#{iteration}]"
-          end
-
-          parts << number_str
-        end
-
-        result = parts.join(" ")
-
-        # Date
-        if date
-          year_val = date.is_a?(Components::Date) ? date.year : date.to_i
-          result += ":#{year_val}"
-          # Month if present
-          result += "-#{format('%02d', month)}" if month
-        end
-
-        # Edition
-        result += " v#{edition}" if edition
-
-        # Translation
-        if translation_lang
-          result += " (#{translation_lang})"
-        elsif translation_upper
-          result += " (#{translation_upper})"
-        end
-
-        result
-      end
-
       def <=>(other)
-        return nil unless other.is_a?(SingleIdentifier)
+        return nil unless other.is_a?(Pubid::Bsi::Identifier)
 
         # Compare by number first
         num_cmp = number.to_s <=> other.number.to_s
@@ -125,5 +76,9 @@ module Pubid
         end
       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

@@ -44,9 +44,8 @@ module Pubid
           parts << "/#{second}"
         end
 
-        if identifier.date
-          year = identifier.date.year
-          parts << year.to_s
+        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

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

@@ -12,21 +12,251 @@ module Pubid
     autoload :Builder, "#{__dir__}/bsi/builder"
     autoload :Identifier, "#{__dir__}/bsi/identifier"
     autoload :Identifiers, "#{__dir__}/bsi/identifiers"
-    autoload :Model, "#{__dir__}/bsi/model"
+    # 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 :Scheme, "#{__dir__}/bsi/scheme"
+    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)
+      if string.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, 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)

data/lib/pubid/builder/base.rb

@@ -5,31 +5,43 @@ module Pubid
     # Base class for all flavor-specific builders.
     #
     # Provides the shared build loop that converts parsed data into identifier
-    # objects. Flavors subclass and override only `cast` and optionally
-    # `default_identifier_class`.
+    # objects. Flavors subclass and override:
+    # - +select_class(data)+ to dispatch by data shape (default returns
+    #   +default_identifier_class+).
+    # - +cast(key, value)+ to transform raw parsed values into components.
+    # - +handle_key(identifier, key, value)+ for non-attribute side effects.
     #
     # The build loop:
     # 1. Flattens array-of-hashes input (from Parslet transforms)
-    # 2. Iterates each key-value pair
-    # 3. Calls `cast(key, value)` to convert raw values to component objects
-    # 4. Assigns the result to the identifier via `send`
-    # 5. Silently skips unknown attributes (rescue NoMethodError)
+    # 2. Asks +select_class(data)+ for the identifier class
+    # 3. Iterates each key-value pair
+    # 4. Calls +cast(key, value)+ to convert raw values to component objects
+    # 5. Assigns the result to the identifier via setter
+    # 6. Silently skips unknown attributes
     class Base
       attr_reader :identifier
 
-      def initialize(identifier_class = default_identifier_class)
+      def initialize(identifier_class = nil)
         @identifier_class = identifier_class
       end
 
       def build(data)
         data = flatten_array(data) if data.is_a?(Array)
-        identifier = @identifier_class.new
+        identifier_class = @identifier_class || select_class(data)
+        identifier = identifier_class.new
         assign_attributes(identifier, data)
         identifier
       end
 
       private
 
+      # Override in subclasses to dispatch to a specific identifier class
+      # based on the shape of the parsed data (type code, supplement marker,
+      # etc.). Defaults to +default_identifier_class+.
+      def select_class(_data)
+        default_identifier_class
+      end
+
       # Override in subclasses to convert raw parsed values to component objects.
       # Return a Hash to assign multiple attributes, or a single value.
       # Return nil to skip the assignment.
@@ -87,8 +99,9 @@ module Pubid
       }.freeze
 
       def locate_typed_stage(typed_stage_string)
-        typed_stage_string = "" if typed_stage_string.nil?
-        @scheme.locate_typed_stage_by_abbr(typed_stage_string)
+        raise NotImplementedError,
+              "#{self.class} must implement locate_typed_stage " \
+              "(rely on the flavor module's locate_stage method)"
       end
 
       def convert_roman_to_integer(roman_numeral)
@@ -122,6 +135,40 @@ module Pubid
         end
       end
 
+      # Splits a compound document number ("1234", "1234-1", "1234-1-2")
+      # into number/part/subpart Code components. Flavor-specific dash/slash
+      # normalization lives in +normalize_number_with_part+; legacy year
+      # extraction (e.g. ISO "4037-1979") lives in +extract_legacy_year+.
+      def parse_number_with_part(value, code_class:)
+        normalized = normalize_number_with_part(value)
+        parts = normalized.split("-").reject(&:empty?)
+        number = parts.shift
+        part = parts.shift&.strip
+        subpart = parts.any? ? parts.join("-") : nil
+
+        legacy = extract_legacy_year(number, part, code_class)
+        return legacy if legacy
+
+        part = convert_roman_to_integer(part) if part
+
+        code_hash = { number: code_class.new(value: number) }
+        code_hash[:part] = code_class.new(value: part) if part
+        code_hash[:subpart] = code_class.new(value: subpart) if subpart
+        code_hash
+      end
+
+      # Hook: normalize the raw number_with_part string before splitting.
+      # Override in subclasses for flavor-specific dash/slash/space handling.
+      def normalize_number_with_part(value)
+        value.to_s
+      end
+
+      # Hook: detect a year masquerading as a part (e.g. "4037-1979") and
+      # return a number+date hash, or nil to continue normal splitting.
+      def extract_legacy_year(_number, _part, _code_class)
+        nil
+      end
+
       def parse_languages(value)
         original_value = value.to_s
         normalized_value = original_value.gsub("/", ",")

data/lib/pubid/bundled_identifier.rb

@@ -1,4 +1,3 @@
-require_relative "identifier"
 # frozen_string_literal: true
 
 module Pubid

data/lib/pubid/ccsds/builder.rb

@@ -34,20 +34,21 @@ module Pubid
         # Extract corrigenda numbers
         corr_array = data[:corrigenda]
         corr_array = [corr_array] unless corr_array.is_a?(Array)
-        corr_numbers = corr_array.map { |c| c[:cor_number].to_i }
+        corr_numbers = corr_array.map { |c| c[:cor_number].to_s }
 
         # Build base identifier (without corrigenda)
         base_data = data.dup
         base_data.delete(:corrigenda)
         base = build_base(base_data)
 
-        # Build Corrigendum object for each corrigendum number
+        # Build Corrigendum object for each corrigendum number. The corrigendum
+        # sequence is stored in the inherited `number` attribute (mirroring ISO).
         # Note: CCSDS uses "Cor. 1" format (single corrigendum per identifier)
         # If multiple corrigenda exist, we build the last one wrapping the base
         corr_numbers.reduce(base) do |current_base, cor_num|
           Identifiers::Corrigendum.new(
             base_identifier: current_base,
-            cor_number: cor_num,
+            number: cor_num,
           )
         end
       end