pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    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.)
+      attribute :number, Bsi::Components::Code
+      attribute :iteration, :string # For bracket notation like 1000[9]
+      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
+      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 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)
+
+        # 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 || 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
+        if date && other.date
+          date.to_s <=> other.date.to_s
+        elsif date
+          1
+        elsif other.date
+          -1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/urn_generator.rb

@@ -0,0 +1,84 @@
+# 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
+
+        if identifier.number
+          number = identifier.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
+          year = identifier.date.year
+          parts << year.to_s
+        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.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    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"
+    autoload :Model, "#{__dir__}/bsi/model"
+    autoload :Parser, "#{__dir__}/bsi/parser"
+    autoload :Scheme, "#{__dir__}/bsi/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/bsi/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/bsi/urn_generator"
+
+    def self.parse(string)
+      Identifier.parse(string)
+    end
+
+    def self.transform(data)
+      Builder.build(data)
+    end
+  end
+end
+
+# Register Ubsi flavor with the registry
+Pubid::Registry.register(:bsi, Pubid::Bsi)

data/lib/pubid/builder/base.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Builder
+    # 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`.
+    #
+    # 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)
+    class Base
+      attr_reader :identifier
+
+      def initialize(identifier_class = default_identifier_class)
+        @identifier_class = identifier_class
+      end
+
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        identifier = @identifier_class.new
+        assign_attributes(identifier, data)
+        identifier
+      end
+
+      private
+
+      # 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.
+      def cast(_key, value)
+        value
+      end
+
+      def default_identifier_class
+        raise NotImplementedError,
+              "#{self.class} must implement default_identifier_class"
+      end
+
+      def flatten_array(data)
+        data.each_with_object({}) do |h, acc|
+          acc.merge!(h)
+        end
+      end
+
+      def assign_attributes(identifier, data)
+        attrs = identifier.class.attributes
+        data.each_pair do |key, value|
+          realized = cast(key.to_sym, value)
+          next if realized.nil?
+
+          next if handle_key(identifier, key, realized)
+
+          if realized.is_a?(Hash)
+            realized.each_pair do |k, v|
+              setter = "#{k}="
+              identifier.public_send(setter, v) if attrs.key?(k.to_sym)
+            end
+          else
+            setter = "#{key}="
+            identifier.public_send(setter, realized) if attrs.key?(key.to_sym)
+          end
+        end
+      end
+
+      def handle_key(_identifier, _key, _value)
+        false
+      end
+
+      LANG_CHAR_MAP = {
+        "R" => "ru",
+        "F" => "fr",
+        "E" => "en",
+        "A" => "ar",
+        "S" => "es",
+        "D" => "de",
+      }.freeze
+
+      ROMAN_MAP = {
+        "I" => 1, "V" => 5, "X" => 10,
+        "L" => 50, "C" => 100, "D" => 500, "M" => 1000
+      }.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)
+      end
+
+      def convert_roman_to_integer(roman_numeral)
+        return roman_numeral unless roman_numeral.to_s.match?(/^[IVXLCDM]+$/i)
+
+        result = 0
+        prev_value = 0
+
+        roman_numeral.to_s.upcase.chars.reverse.each do |char|
+          value = ROMAN_MAP[char]
+          if value < prev_value
+            result -= value
+          else
+            result += value
+          end
+          prev_value = value
+        end
+
+        result.to_s
+      end
+
+      def parse_date(value)
+        value = value.to_s
+        if value.match?(/^\d{4}(-\d{2})?$/)
+          year, month = value.split("-")
+          Pubid::Components::Date.new(year: year, month: month || nil)
+        elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
+          Pubid::Components::Date.new(year: value)
+        else
+          raise ArgumentError, "Invalid date format: #{value.inspect}"
+        end
+      end
+
+      def parse_languages(value)
+        original_value = value.to_s
+        normalized_value = original_value.gsub("/", ",")
+        normalized_value.split(",").map do |lang|
+          lang = lang.strip
+          original_lang = lang
+          lang = LANG_CHAR_MAP[lang] if lang.length == 1
+          Pubid::Components::Language.new(code: lang,
+                                          original_code: original_lang)
+        end
+      end
+    end
+  end
+end