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

data/lib/pubid/bsi/scheme.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    class Scheme < Pubid::Scheme
+      # TYPED_STAGES_REGISTRY for native BSI types
+      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
+
+      # Map type codes to identifier classes
+      IDENTIFIER_CLASS_MAP = {
+        bs: "Identifiers::BritishStandard",
+        pd: "Identifiers::PublishedDocument",
+        pas: "Identifiers::PubliclyAvailableSpecification",
+        na: "Identifiers::NationalAnnex",
+        dd: "Identifiers::DraftDocument",
+        flex: "Identifiers::Flex",
+        handbook: "Identifiers::Handbook",
+        pp: "Identifiers::PracticeGuide",
+        bip: "Identifiers::BritishIndustrialPractice",
+        aerospace: "Identifiers::AerospaceStandard",
+        index: "Identifiers::Index",
+        method: "Identifiers::Method",
+        section: "Identifiers::Section",
+        disc: "Identifiers::Disc",
+        bundled: "Identifiers::BundledIdentifier",
+        detailed_specification: "Identifiers::DetailedSpecification",
+        standalone_amendment: "Identifiers::StandaloneAmendment",
+        ts: "Identifiers::TechnicalSpecification",
+        committee_document: "Identifiers::CommitteeDocument",
+        explanatory_supplement: "Identifiers::ExplanatorySupplement",
+        supplementary_index: "Identifiers::SupplementaryIndex",
+        test_method: "Identifiers::TestMethod",
+        set: "Identifiers::Set",
+      }.freeze
+
+      # Default typed stage for when no match is found
+      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+        code: :pubbs,
+        stage_code: :published,
+        type_code: :bs,
+        abbr: ["BS"],
+        name: "British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ).freeze
+
+      def locate_typed_stage_by_abbr(abbr)
+        abbr_str = abbr.to_s.strip
+        TYPED_STAGES_REGISTRY.find do |ts|
+          ts.abbr.include?(abbr_str)
+        end || DEFAULT_TYPED_STAGE
+      end
+
+      def locate_identifier_klass_by_type_code(type_code)
+        class_name = IDENTIFIER_CLASS_MAP[type_code.to_sym]
+        return Identifiers::BritishStandard unless class_name
+
+        # Convert string to actual class
+        class_name.split("::").reduce(Pubid::Bsi) do |mod, name|
+          mod.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/single_identifier.rb

@@ -2,53 +2,20 @@
 
 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
+    class SingleIdentifier < Pubid::Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
 
       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 :number, Bsi::Components::Code
       attribute :iteration, :string # For bracket notation like 1000[9]
-      attribute :part, :string
-      attribute :subpart, :string
+      attribute :part, Bsi::Components::Code
+      attribute :subpart, Bsi::Components::Code
       attribute :second_number, Bsi::Components::Code # For collections like PAS 2035/2030
       attribute :date, Bsi::Components::Date
       attribute :stage, Pubid::Components::Stage
@@ -62,15 +29,88 @@ 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?(Pubid::Bsi::Identifier)
+        return nil unless other.is_a?(SingleIdentifier)
 
         # 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
+        part_cmp = (part || Components::Code.new(value: "0")).to_s <=> (other.part || Components::Code.new(value: "0")).to_s
         return part_cmp unless part_cmp.zero?
 
         # Then by date
@@ -84,58 +124,6 @@ module Pubid
           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

@@ -21,17 +21,8 @@ module Pubid
           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.number
+          number = identifier.number.to_s
           if identifier.iteration && !identifier.iteration.empty?
             number += "[#{identifier.iteration}]"
           end
@@ -53,8 +44,9 @@ module Pubid
           parts << "/#{second}"
         end
 
-        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-          parts << identifier.date.render(context: URN_CONTEXT)
+        if identifier.date
+          year = identifier.date.year
+          parts << year.to_s
         elsif identifier.year
           parts << identifier.year.to_s
         end