pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/bsi/components/code.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Code component for BSI flavor
+      class Code < Pubid::Components::Code
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/date.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Date component for BSI flavor
+      class Date < Pubid::Components::Date
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/publisher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Publisher component for BSI flavor
+      class Publisher < Pubid::Components::Publisher
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Type component for BSI flavor
+      class Type < Pubid::Components::Type
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifier.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifier
+      def self.parse(string)
+        # 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
+        scheme = Scheme.new
+
+        parsed = parser.parse(string)
+        Builder.build(parsed, scheme)
+      rescue Parslet::ParseFailed => e
+        raise StandardError, "Failed to parse '#{string}': #{e.message}"
+      end
+
+      # Factory mirroring pubid 1.x's `Pubid::Bsi::Identifier.create` API.
+      # Dispatches via {Pubid::Bsi::Scheme}'s IDENTIFIER_CLASS_MAP and
+      # TYPED_STAGES_REGISTRY; default subclass is BritishStandard.
+      #
+      # BSI's renderer requires BSI-namespaced Component subclasses
+      # (`Bsi::Components::*`), so coercion is inlined rather than reusing
+      # {Pubid::Components::Factory}.
+      def self.create(type: nil, stage: nil, **opts)
+        klass = resolve_create_class(type: type, stage: stage)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type:, stage:)
+        scheme = Scheme.new
+        klass = nil
+        if type
+          klass = scheme.locate_identifier_klass_by_type_code(type)
+        elsif stage
+          ts = scheme.locate_typed_stage_by_abbr(stage.to_s)
+          klass = scheme.locate_identifier_klass_by_type_code(ts.type_code) if ts
+        end
+        klass || Identifiers::BritishStandard
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        if stage
+          Scheme.new.locate_typed_stage_by_abbr(stage.to_s)
+        elsif klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code.to_sym == :published
+          end
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        if (v = opts[:publisher])
+          attrs[:publisher] = Components::Publisher.new(body: v.to_s)
+        end
+        %i[number part subpart].each do |k|
+          v = opts[k]
+          attrs[k] = Components::Code.new(value: v.to_s) unless v.nil?
+        end
+        if (v = opts[:year])
+          attrs[:date] = Components::Date.new(year: v.to_s)
+        end
+        # BSI :edition is a plain string attribute (not a Component).
+        attrs[:edition] = opts[:edition].to_s if opts[:edition]
+        # TODO(create-shim): BSI also has prefix, flex_prefix, iteration,
+        # second_number, month, translation_lang/upper attributes that
+        # aren't yet wired through. Add as call sites require them.
+        attrs
+      end
+      private_class_method :resolve_create_class,
+                           :resolve_create_typed_stage,
+                           :coerce_create_attrs
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Addendum Document Identifier
+      # Contains a base identifier plus addendum parameters
+      # Supports various formats:
+      # "BS 1501-2 Addendum No. 1:1973"
+      # "BS 1902-2.3:Addendum No. 1:1976"
+      # "BS 2000-0:Addendum 1:1983"
+      # "BS 6034:1981:Addendum No. 1:1986"
+      class AddendumDocument < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :addendum_number, :string
+        attribute :addendum_year, :integer
+        attribute :addendum_type, :string, default: -> {
+          "No."
+        } # "No." or empty for "Addendum N"
+        attribute :separator, :string, default: -> {
+          ":"
+        } # Separator before Addendum (":" or " ")
+
+        def to_s(lang: :en, lang_single: false)
+          result = base_identifier.to_s(lang: lang, lang_single: lang_single)
+
+          # Determine separator - if separator is explicitly ":", use it
+          # Otherwise if base has year and doesn't already have double colon, use space
+          base_has_year = base_identifier.to_s =~ /:(\d{4})$/
+
+          sep = if separator == ":"
+                  ":"
+                elsif base_has_year && base_identifier.to_s !~ /:\d{4}:/
+                  " "
+                else
+                  separator
+                end
+
+          # Format: "BASE:Addendum No. N:YEAR" or "BASE Addendum No. N:YEAR" or "BASE:Addendum N:YEAR"
+          result += sep
+          result += "Addendum"
+
+          # Add space after "Addendum" if there's a type prefix (like "No.")
+          if addendum_type.empty?
+            # No type prefix, but still need space before number
+          else
+            result += " #{addendum_type}"
+          end
+          result += " "
+          result += " "
+
+          result += addendum_number.to_s
+          result += ":#{addendum_year}" if addendum_year
+
+          result
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/adopted_european_norm.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AdoptedEuropeanNorm wraps CEN identifiers
+      # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
+      # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
+      class AdoptedEuropeanNorm < BritishStandard
+        attribute :adopted_identifier, Base, polymorphic: true # CEN object
+        attribute :edition, :string
+        attribute :translation_lang, :string
+        attribute :translation_upper, :string
+        attribute :translation_suffix_type, :string # "version" or "Translation"
+        attribute :reaffirmation_year, :string # For "(R2004)" notation
+        attribute :expert_commentary, :boolean
+        attribute :expert_commentary_topic, :string
+
+        def to_s(lang: :en, lang_single: false)
+          # Get the BSI prefix (BS, PD, DD)
+          prefix = case publisher
+                   when Components::Publisher
+                     publisher.body
+                   when Array
+                     publisher.join("/")
+                   when String
+                     publisher
+                   else
+                     "BS"
+                   end
+
+          result = prefix
+          result += " #{adopted_identifier}" if adopted_identifier
+          result += " ED#{edition}" if edition
+
+          # Reaffirmation notation like (R2004)
+          result += " (R#{reaffirmation_year})" if reaffirmation_year
+
+          # Translation - preserve the "version" or "Translation" suffix if present
+          if translation_lang
+            result += if translation_suffix_type == "version"
+                        " (#{translation_lang} version)"
+                      elsif translation_suffix_type == "Translation"
+                        " (#{translation_lang} Translation)"
+                      else
+                        " (#{translation_lang})"
+                      end
+          elsif translation_upper
+            result += if translation_suffix_type == "Translation"
+                        " (#{translation_upper} Translation)"
+                      else
+                        " (#{translation_upper})"
+                      end
+          end
+
+          # ExpertCommentary suffix
+          if expert_commentary
+            result += if expert_commentary_topic
+                        " ExComm (#{expert_commentary_topic})"
+                      else
+                        " ExComm"
+                      end
+          end
+
+          result
+        end
+
+        # Delegate common methods to adopted identifier
+        def number
+          adopted_identifier&.number
+        end
+
+        def year
+          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        end
+
+        def date
+          adopted_identifier&.date if adopted_identifier&.methods&.include?(:date)
+        end
+
+        def parts
+          adopted_identifier&.parts if adopted_identifier&.methods&.include?(:parts)
+        end
+
+        def part
+          adopted_identifier&.part if adopted_identifier&.methods&.include?(:part)
+        end
+
+        def subpart
+          adopted_identifier&.subpart if adopted_identifier&.methods&.include?(:subpart)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/adopted_international_standard.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AdoptedInternationalStandard wraps ISO/IEC identifiers directly
+      # Example: "BS ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
+      # Example: "BS IEC 62600:2020" where IEC 62600:2020 is an IEC identifier object
+      class AdoptedInternationalStandard < BritishStandard
+        attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC object
+        attribute :edition, :string
+        attribute :translation_lang, :string
+        attribute :translation_upper, :string
+        attribute :translation_suffix_type, :string # "version" or "Translation"
+        attribute :reaffirmation_year, :string # For "(R2004)" notation
+        attribute :expert_commentary, :boolean
+        attribute :expert_commentary_topic, :string
+
+        def to_s
+          # Get the BSI prefix (BS, PD, DD)
+          prefix = case publisher
+                   when Components::Publisher
+                     publisher.body
+                   when Array
+                     publisher.join("/")
+                   when String
+                     publisher
+                   else
+                     "BS"
+                   end
+
+          result = prefix
+          result += " #{adopted_identifier}" if adopted_identifier
+          result += " ED#{edition}" if edition
+
+          # Reaffirmation notation like (R2004)
+          result += " (R#{reaffirmation_year})" if reaffirmation_year
+
+          # Translation - normalize to just "(Language)" format
+          # "(French version)", "(French Translation)", "(French)" all become "(French)"
+          if translation_lang
+            result += " (#{translation_lang})"
+          elsif translation_upper
+            result += " (#{translation_upper})"
+          end
+
+          # ExpertCommentary suffix
+          if expert_commentary
+            result += if expert_commentary_topic
+                        " ExComm (#{expert_commentary_topic})"
+                      else
+                        " ExComm"
+                      end
+          end
+
+          result
+        end
+
+        # Delegate common methods to adopted identifier
+        def number
+          adopted_identifier&.number
+        end
+
+        def year
+          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        end
+
+        def date
+          adopted_identifier&.date if adopted_identifier&.methods&.include?(:date)
+        end
+
+        def parts
+          adopted_identifier&.parts if adopted_identifier&.methods&.include?(:parts)
+        end
+
+        def part
+          adopted_identifier&.part if adopted_identifier&.methods&.include?(:part)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/aerospace_standard.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AerospaceStandard handles BSI aerospace and specialized standards
+      # with letter prefixes indicating domain categorization.
+      #
+      # Categorization includes:
+      # - Aircraft (A, B, C, F, G, HC, L, S, SP, X)
+      # - Methods related to aircraft (M)
+      # - Marine (MA)
+      # - Polyester (PL)
+      # - Aerospace materials (TA for Titanium-Aluminium alloys)
+      # - Automotive (AU)
+      # - Multi-letter prefixes (2A, 2B, 2C, 2F, 2G, 2HC, 2HR, 2L, 2M, 2S, 2SP, 2TA, 2X, etc.)
+      #
+      # Examples:
+      #   BS A 109:2024       # Aircraft (A prefix)
+      #   BS AU 145e:2018     # Automotive (AU prefix) with letter suffix
+      #   BS M 38:1971        # Methods (M prefix)
+      #   BS 2A 293:2005      # Multi-letter prefix (2A)
+      #   BS SP 113:1954      # Specification (SP prefix)
+      #   BS TA 40:1971       # Titanium-Aluminium (TA prefix)
+      class AerospaceStandard < SingleIdentifier
+        attribute :prefix, :string
+
+        # Single-letter aerospace/specialized prefixes
+        SINGLE_LETTER_PREFIXES = %w[
+          A B C F G L M S X
+          AU HC MA PL QC SP TA
+        ].freeze
+
+        # Multi-letter prefixes (number + letter combination)
+        MULTI_LETTER_PREFIXES = %w[
+          2A 2B 2C 2F 2G 2HC 2HR 2L 2M 2S 2SP 2TA 2X
+          3A 3B 3F 3G 3HR 3J 3L 3S 3TA
+          4F 4L 4S
+          5S 7S
+        ].freeze
+
+        ALL_PREFIXES = (SINGLE_LETTER_PREFIXES + MULTI_LETTER_PREFIXES).freeze
+
+        # TYPED_STAGES for aerospace standards (published by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubas,
+            stage_code: :published,
+            type_code: :aerospace,
+            abbr: ["BS"],
+            name: "Aerospace/Specialized Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :aerospace, title: "Aerospace/Specialized Standard",
+            short: "BS" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          parts = []
+          parts << "BS" # Always BS for aerospace
+          parts << prefix if prefix
+
+          # Number with part/subpart and letter suffix edition
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+
+            # Part and subpart
+            if part
+              part_val = part.is_a?(Components::Code) ? part.value : part
+              number_str += "-#{part_val}"
+            end
+            if subpart
+              subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
+              number_str += "-#{subpart_val}"
+            end
+
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Letter suffix edition (for aerospace/specialized standards)
+          # Append directly to number/part without space or v prefix
+          # e.g., BS AU 145e:2018, BS AU 200-1a:1984
+          if edition&.match?(/^[a-zA-Z]$/)
+            result += edition
+          end
+
+          # 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
+
+          # Regular edition (non-letter suffix, like v1.0)
+          # Only add if edition is not a single letter (already handled above)
+          if edition && !edition.match?(/^[a-zA-Z]$/)
+            result += " v#{edition}"
+          end
+
+          # Translation
+          if translation_lang
+            result += " (#{translation_lang})"
+          elsif translation_upper
+            result += " (#{translation_upper})"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Amendment Identifier
+      # Contains a base identifier plus amendment parameters
+      class Amendment < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :amendment_number, :string
+        attribute :amendment_year, :integer
+        attribute :separator, :string, default: -> { "+" }
+
+        def to_s
+          if base_identifier
+            if amendment_year
+              "#{base_identifier}#{separator}A#{amendment_number}:#{amendment_year}"
+            elsif amendment_number&.match?(/^[A-Z]+$/)
+              # Letter suffixes (AA, AB, etc.) have a space, numeric suffixes don't
+              "#{base_identifier} AMD #{amendment_number}"
+            else
+              "#{base_identifier} AMD#{amendment_number}"
+            end
+          elsif amendment_year
+            "#{separator}A#{amendment_number}:#{amendment_year}"
+          elsif amendment_number&.match?(/^[A-Z]+$/)
+            # Letter suffixes (AA, AB, etc.) have a space, numeric suffixes don't
+            "AMD #{amendment_number}"
+          else
+            "AMD#{amendment_number}"
+          end
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Base BSI identifier (module organization)
+      class Base < Pubid::Identifier
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/british_industrial_practice.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # British Industrial Practice (BIP)
+      # Examples: "BIP 2225:2022", "BIP 0142:2014", "BIP 0009:2020"
+      class BritishIndustrialPractice < Base
+        attribute :number, Bsi::Components::Code
+        attribute :date, Bsi::Components::Date
+
+        def self.type
+          {
+            short: "BIP",
+            full: "British Industrial Practice",
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          result = "BIP #{number}"
+          result += ":#{date.year}" if date
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/british_standard.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # British Standard (BS) identifier
+      class BritishStandard < SingleIdentifier
+        TYPED_STAGES = [
+          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],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :bs, title: "British Standard", short: "BS" }
+        end
+      end
+    end
+  end
+end