pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Standalone Amendment identifier (no base reference)
+      # Examples: "AMD 11015", "(AMD 10971)", "AMD Corrigendum 14716"
+      class StandaloneAmendment < SingleIdentifier
+        attribute :amendment_number, Components::Code
+        attribute :corrigendum, :boolean, default: false
+        attribute :parenthesized, :boolean, default: false
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :standalone_amendment,
+            stage_code: :published,
+            type_code: :amendment,
+            abbr: ["AMD"],
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :standalone_amendment, title: "Amendment", short: "AMD" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          base = if corrigendum
+                   "AMD Corrigendum #{amendment_number}"
+                 else
+                   "AMD #{amendment_number}"
+                 end
+
+          parenthesized ? "(#{base})" : base
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Supplement Document Identifier
+      # Contains a base identifier plus supplement parameters
+      # Supports both forward and reverse formats:
+      # Forward: "BS 1000:Supplement No. 1:1972", "BS 1722-1 Supplement No. 1:1974"
+      # Reverse: "Supplement No. 1 (1970) to BS 1831:1969"
+      class SupplementDocument < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :supplement_number, :string
+        attribute :supplement_year, :integer
+        attribute :supplement_type, :string, default: -> {
+          "No."
+        } # "No." or empty for "Supplement N"
+        attribute :reverse_format, :boolean, default: false # true for "Supplement No. N (YEAR) to BS..."
+        attribute :separator, :string, default: -> {
+          ":"
+        } # Separator before Supplement (":" or " ")
+
+        def to_s
+          base_str = base_identifier.to_s
+
+          if reverse_format
+            # Reverse format: "Supplement No. 1 (1970) to BS 1831:1969"
+            supplement_str = if supplement_type == "No."
+                               "Supplement No. #{supplement_number} (#{supplement_year})"
+                             else
+                               "Supplement #{supplement_number} (#{supplement_year})"
+                             end
+            "#{supplement_str} to #{base_str}"
+          else
+            # Forward format: "BS 1000:Supplement No. 1:1972" or "BS 1722-1 Supplement No. 1:1974"
+            supplement_str = if supplement_type == "No."
+                               "#{separator}Supplement No. #{supplement_number}:#{supplement_year}"
+                             else
+                               "#{separator}Supplement #{supplement_number}:#{supplement_year}"
+                             end
+            "#{base_str}#{supplement_str}"
+          end
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # SupplementaryIndex represents BSI supplementary index documents
+      # Format: BS {number} Supplementary Index:{year}
+      #
+      # Examples:
+      #   BS 185 Supplementary Index:1965
+      class SupplementaryIndex < SingleIdentifier
+        # TYPED_STAGES for supplementary index (published by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubsupplementaryindex,
+            stage_code: :published,
+            type_code: :supplementary_index,
+            abbr: ["BS"],
+            name: "Supplementary Index",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          {
+            key: :supplementary_index,
+            title: "Supplementary Index",
+            short: "BS",
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Supplementary Index format: BS {number} Supplementary Index:{year}
+          parts = []
+          parts << "BS"
+
+          # Number with part/subpart
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+
+            # Part and subpart
+            if part
+              part_val = if part.is_a?(Components::Code)
+                           part.value
+                         else
+                           part
+                         end
+              number_str += "-#{part_val}"
+            end
+            if subpart
+              subpart_val = if supart.is_a?(Components::Code)
+                              subpart.value
+                            else
+                              subpart
+                            end
+              number_str += "-#{subpart_val}"
+            end
+
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Date
+          if date
+            year_val = date.is_a?(Components::Date) ? date.year : date.to_i
+            result += " Supplementary Index:#{year_val}"
+            # Month if present
+            result += "-#{format('%02d', month)}" if month
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # TechnicalSpecification represents BSI technical specifications
+      # Format: TS {number}:{year}
+      #
+      # Examples:
+      #   TS 3:1993
+      #   TS 1:1998
+      #   TS 1:1995
+      class TechnicalSpecification < SingleIdentifier
+        # TYPED_STAGES for technical specifications (published by default)
+        TYPED_STAGES = [
+          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.type
+          { key: :ts, title: "Technical Specification", short: "TS" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Technical specifications use a simple format: TS {number}:{year}
+          parts = []
+          parts << "TS"
+
+          # Number with part/subpart
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+
+            # Part and subpart
+            if part
+              part_val = if part.is_a?(Components::Code)
+                           part.value
+                         else
+                           part
+                         end
+              number_str += "-#{part_val}"
+            end
+            if subpart
+              subpart_val = if supart.is_a?(Components::Code)
+                              subpart.value
+                            else
+                              subpart
+                            end
+              number_str += "-#{subpart_val}"
+            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
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # TestMethod represents BSI test method identifiers
+      # Format: BS {number}:{test_series}:{test_id}:{year}
+      #
+      # Examples:
+      #   BS 1006:B01C:LFS1:1982
+      #   BS 1006:B01C:LFS2:1985
+      #   BS 1006:B01C:LFS4:1990
+      class TestMethod < SingleIdentifier
+        attribute :test_series, :string     # Test series code (e.g., "B01C")
+        attribute :test_id, :string         # Test ID (e.g., "LFS1")
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubtestmethod,
+            stage_code: :published,
+            type_code: :test_method,
+            abbr: ["BS"],
+            name: "Test Method",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :test_method, title: "Test Method", short: "BS" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Test Method format: BS {number}:{test_series}:{test_id}:{year}
+          parts = []
+
+          # Publisher (BS)
+          parts << "BS"
+
+          # Number
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Test series and test ID suffixes
+          if test_series && test_id
+            result += ":#{test_series}:#{test_id}"
+          end
+
+          # Date
+          if date
+            year_val = date.is_a?(Components::Date) ? date.year : date.to_i
+            result += ":#{year_val}"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Value-Added Publication Identifier
+      # Wraps base identifier with format suffix (PDF, TC, BOOK)
+      # Similar to IEC VapIdentifier and BSI ExpertCommentary
+      #
+      # Examples:
+      #   PD 5500:2018+A3:2020 PDF
+      #   PAS 96:2017 - TC
+      #   PP 7722:2006 BOOK
+      class ValueAddedPublication < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :format, :string, values: ["PDF", "TC", "BOOK"]
+
+        def to_s(lang: :en, lang_single: false)
+          base_str = base_identifier.to_s(lang: lang, lang_single: lang_single)
+
+          case format
+          when "TC"
+            "#{base_str} - TC"
+          when "PDF"
+            "#{base_str} PDF"
+          when "BOOK"
+            "#{base_str} BOOK"
+          else
+            base_str
+          end
+        end
+
+        # Delegate common attributes to base_identifier
+        def publisher
+          base_identifier&.publisher
+        end
+
+        def number
+          base_identifier&.number
+        end
+
+        def year
+          base_identifier&.year
+        end
+
+        def date
+          base_identifier&.date
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      autoload :AddendumDocument, "#{__dir__}/identifiers/addendum_document"
+      autoload :AdoptedEuropeanNorm,
+               "#{__dir__}/identifiers/adopted_european_norm"
+      autoload :AdoptedInternationalStandard,
+               "#{__dir__}/identifiers/adopted_international_standard"
+      autoload :AerospaceStandard, "#{__dir__}/identifiers/aerospace_standard"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :BritishIndustrialPractice,
+               "#{__dir__}/identifiers/british_industrial_practice"
+      autoload :BritishStandard, "#{__dir__}/identifiers/british_standard"
+      autoload :BundledIdentifier, "#{__dir__}/identifiers/bundled_identifier"
+      autoload :CommitteeDocument, "#{__dir__}/identifiers/committee_document"
+      autoload :ConsolidatedIdentifier,
+               "#{__dir__}/identifiers/consolidated_identifier"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :DetailedSpecification,
+               "#{__dir__}/identifiers/detailed_specification"
+      autoload :Disc, "#{__dir__}/identifiers/disc"
+      autoload :DraftDocument, "#{__dir__}/identifiers/draft_document"
+      autoload :ElectronicBook, "#{__dir__}/identifiers/electronic_book"
+      autoload :ExplanatorySupplement,
+               "#{__dir__}/identifiers/explanatory_supplement"
+      autoload :ExpertCommentary, "#{__dir__}/identifiers/expert_commentary"
+      autoload :Flex, "#{__dir__}/identifiers/flex"
+      autoload :Handbook, "#{__dir__}/identifiers/handbook"
+      autoload :Index, "#{__dir__}/identifiers/index"
+      autoload :Method, "#{__dir__}/identifiers/method"
+      autoload :NationalAnnex, "#{__dir__}/identifiers/national_annex"
+      autoload :PracticeGuide, "#{__dir__}/identifiers/practice_guide"
+      autoload :PublishedDocument, "#{__dir__}/identifiers/published_document"
+      autoload :PubliclyAvailableSpecification,
+               "#{__dir__}/identifiers/publicly_available_specification"
+      autoload :Section, "#{__dir__}/identifiers/section"
+      autoload :Set, "#{__dir__}/identifiers/set"
+      autoload :StandaloneAmendment,
+               "#{__dir__}/identifiers/standalone_amendment"
+      autoload :SupplementDocument, "#{__dir__}/identifiers/supplement_document"
+      autoload :SupplementaryIndex, "#{__dir__}/identifiers/supplementary_index"
+      autoload :TechnicalSpecification,
+               "#{__dir__}/identifiers/technical_specification"
+      autoload :TestMethod, "#{__dir__}/identifiers/test_method"
+      autoload :ValueAddedPublication,
+               "#{__dir__}/identifiers/value_added_publication"
+    end
+  end
+end

data/lib/pubid/bsi/model.rb

@@ -0,0 +1,196 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    # Supplement model for amendments and corrigenda
+    class Supplement < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :number, :string
+      attribute :year, :string, default: -> {}
+
+      def to_s
+        prefix = type == "amendment" ? "A" : "C"
+        result = "+#{prefix}#{number}"
+        result += ":#{year}" if year
+        result
+      end
+    end
+
+    # National Annex model
+    class NationalAnnex < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :supplement, Supplement, default: -> {}
+      attribute :base, Identifier, default: -> {}
+
+      def to_s
+        result = type
+        result += supplement.to_s if supplement
+        result += " to #{base}" if base
+        result
+      end
+    end
+
+    # Collection model for combined documents (e.g., PAS 2035/2030)
+    class Collection < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :numbers, :string, collection: true
+      attribute :year, :string, default: -> {}
+      attribute :supplements, Supplement, collection: true, default: -> { [] }
+
+      def to_s
+        result = "#{type} #{numbers.join('/')}"
+        result += ":#{year}" if year
+        supplements.each { |s| result += s.to_s }
+        result
+      end
+    end
+
+    # Expert Commentary model
+    class ExpertCommentary < Lutaml::Model::Serializable
+      attribute :base, Identifier
+
+      def to_s
+        "#{base} ExComm"
+      end
+    end
+
+    # Main BSI Identifier model
+    class Identifier < Lutaml::Model::Serializable
+      attribute :type, :string, default: -> { "BS" }
+      attribute :number, :string, default: -> {}
+      attribute :part, :string, default: -> {}
+      attribute :second_number, :string, default: -> {}
+      attribute :year, :string, default: -> {}
+      attribute :month, :string, default: -> {}
+      attribute :edition, :string, default: -> {}
+      attribute :supplements, Supplement, collection: true, default: -> { [] }
+      attribute :adopted, :string, default: -> {
+      } # Will store adopted identifier object
+      attribute :expert_commentary, :boolean, default: -> { false }
+      attribute :tracked_changes, :boolean, default: -> { false }
+      attribute :translation, :string, default: -> {}
+      attribute :pdf, :boolean, default: -> { false }
+      attribute :national_annex, NationalAnnex, default: -> {}
+
+      def to_s
+        # Handle national annex
+        if national_annex
+          return render_national_annex
+        end
+
+        # Handle expert commentary
+        if expert_commentary
+          base_id = self.class.new(
+            type: type,
+            number: number,
+            part: part,
+            year: year,
+            month: month,
+            supplements: supplements,
+            adopted: adopted,
+          )
+          return "#{base_id} ExComm"
+        end
+
+        # Handle collection (combined documents)
+        if second_number
+          return render_collection
+        end
+
+        # Regular identifier
+        render_identifier
+      end
+
+      private
+
+      def render_national_annex
+        result = "NA"
+
+        # Add NA supplements
+        if national_annex.supplement
+          result += national_annex.supplement.to_s
+        end
+
+        result += " to "
+
+        # Render base identifier
+        base_id = self.class.new(
+          type: type,
+          number: number,
+          part: part,
+          year: year,
+          month: month,
+          supplements: supplements,
+          adopted: adopted,
+        )
+        result += base_id.to_s
+
+        result
+      end
+
+      def render_collection
+        first_num = number
+        second_num = second_number
+
+        result = "#{type} #{first_num}/#{second_num}"
+        result += ":#{year}" if year
+        supplements.each { |s| result += s.to_s }
+
+        result
+      end
+
+      def render_identifier
+        ""
+
+        # Type prefix
+        result = if type == "BSI Flex"
+                   "BSI Flex"
+                 else
+                   type
+                 end
+
+        result += " "
+
+        # Adopted document or number
+        if adopted
+          # For adopted documents, render the adopted identifier
+          # but suppress its year if we have our own year
+          adopted_str = adopted.to_s
+          if year && adopted.class.attributes.key?(:year)
+            # Remove year from adopted if we have our own
+            adopted_str = adopted_str.sub(/:#{adopted.year}/, "")
+          end
+          result += adopted_str
+        else
+          # Regular number
+          result += number.to_s if number
+          result += "-#{part}" if part
+        end
+
+        # Edition (for Flex) - must come before year-month
+        result += " v#{edition}" if edition
+
+        # Year and month
+        if year
+          result += ":#{year}"
+          result += "-#{month}" if month
+        end
+
+        # Supplements
+        supplements.each { |s| result += s.to_s }
+
+        # Tracked changes
+        result += " - TC" if tracked_changes
+
+        # Translation
+        result += " (#{translation})" if translation
+
+        # PDF marker
+        result += " PDF" if pdf
+
+        result
+      end
+    end
+  end
+end