pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # ExplanatorySupplement represents BSI explanatory supplement documents
+      # Format: BS {number}-{part}:Explanatory Supplement:{year}
+      #
+      # Examples:
+      #   BS 5655-1:Explanatory Supplement:1981
+      class ExplanatorySupplement < SingleIdentifier
+        # TYPED_STAGES for explanatory supplement (published by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubexplanatorysupplement,
+            stage_code: :published,
+            type_code: :explanatory_supplement,
+            abbr: ["BS"],
+            name: "Explanatory Supplement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          {
+            key: :explanatory_supplement,
+            title: "Explanatory Supplement",
+            short: "BS",
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Explanatory Supplement format:
+          # BS {number}-{part}:Explanatory Supplement:{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 += ":Explanatory Supplement:#{year_val}"
+            # Month if present
+            result += "-#{format('%02d', month)}" if month
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Flex document identifier
+      class Flex < SingleIdentifier
+        TYPED_STAGES = [
+          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],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :flex, title: "BSI Flex", short: "BSI Flex" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          parts = []
+
+          # Publisher is always "BSI Flex"
+          parts << "BSI Flex"
+
+          # Number with part/subpart
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+            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(" ")
+
+          # Edition comes before date for Flex
+          result += " v#{edition}" if edition
+
+          # 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/handbook.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Handbook
+      # Examples: "Handbook 17:1963", "HB 10146:1998"
+      class Handbook < Base
+        attribute :number, Bsi::Components::Code
+        attribute :part, Bsi::Components::Code
+        attribute :date, Bsi::Components::Date
+        attribute :original_abbr, :string # Preserve "Handbook" or "HB"
+
+        def self.type
+          {
+            short: "HB",
+            full: "Handbook",
+            names: ["Handbook", "HB"],
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Use preserved original abbreviation, default to "Handbook"
+          abbr = original_abbr || "Handbook"
+
+          number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+          if part
+            part_val = part.is_a?(Components::Code) ? part.value : part
+            number_str += "-#{part_val.to_s.strip}"
+          end
+
+          result = "#{abbr} #{number_str}"
+          result += ":#{date.year}" if date
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Index
+      # Examples: "BS 5000:Index:1981", "BS 185 Index:1964", "BS 5000 Index Issue 4:1980"
+      class Index < SingleIdentifier
+        attribute :issue_number, :string  # For "Index Issue N" format
+        attribute :index_format, :string  # Preserve ":Index" or " Index" separator
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :index,
+            stage_code: :published,
+            type_code: :index,
+            abbr: ["Index"],
+            name: "Index",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :index, title: "Index", short: "Index" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - Index has special format
+          parts = []
+
+          # Publisher (BS)
+          parts << publisher.to_s if publisher
+
+          # Number
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Index suffix with colon or space format
+          result += if issue_number
+                      " Index Issue #{issue_number}"
+                    elsif index_format == "colon"
+                      ":Index"
+                    else
+                      " Index"
+                    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/method.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Method
+      # Examples:
+      # - Basic: "BS 2782-1:Method 131B:1983"
+      # - Range: "BS 2782-4:Methods 451F to 451J:1978"
+      # - And: "BS 2782-8:Methods 823A and 823B:1978"
+      class Method < SingleIdentifier
+        attribute :method_code, :string     # Main method code (e.g., "131B")
+        attribute :method_to, :string       # Second method code for "to" format (e.g., "451J")
+        attribute :method_and, :string      # Second method code for "and" format (e.g., "823B")
+        attribute :is_plural, :boolean      # Track singular vs plural ("Method" vs "Methods")
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubmethod,
+            stage_code: :published,
+            type_code: :method,
+            abbr: ["Method", "Methods"],
+            name: "Method",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :method, title: "Method", short: "Method" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - Method has three formats
+          parts = []
+
+          # Publisher (BS)
+          parts << publisher.to_s if publisher
+
+          # Number with part (e.g., "2782-1")
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+            # Add part if present (e.g., "2782" + "-" + "1")
+            if part
+              part_val = part.is_a?(Components::Code) ? part.value : part
+              number_str += "-#{part_val}"
+            end
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Method suffix with appropriate format
+          if method_to
+            # Range format: ":Methods X to Y"
+            result += ":Methods #{method_code} to #{method_to}"
+          elsif method_and
+            # And format: ":Methods X and Y"
+            result += ":Methods #{method_code} and #{method_and}"
+          else
+            # Basic format: singular or plural
+            method_word = is_plural ? "Methods" : "Method"
+            result += ":#{method_word} #{method_code}"
+          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/national_annex.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # National Annex (NA) identifier
+      # Can have own supplements: "NA+A1:2012 to BASE"
+      class NationalAnnex < SingleIdentifier
+        attribute :na_supplements, Base, polymorphic: true, collection: true # Supplements on the NA itself
+        attribute :base_doc, Base, polymorphic: true # The identifier after "to"
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubna,
+            stage_code: :published,
+            type_code: :na,
+            abbr: ["NA"],
+            name: "National Annex",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :na, title: "National Annex", short: "NA" }
+        end
+
+        # Delegation methods to access wrapped base_doc attributes
+        def number
+          base_doc&.number || super
+        end
+
+        def date
+          base_doc&.date || super
+        end
+
+        def part
+          base_doc&.part || super
+        end
+
+        def subpart
+          base_doc&.subpart || super
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          result = "NA"
+
+          # Add NA supplements if present
+          if na_supplements&.any?
+            na_supplements.each do |supp|
+              if supp.is_a?(Amendment)
+                result += "+A#{supp.amendment_number}:#{supp.amendment_year}"
+              elsif supp.is_a?(Corrigendum)
+                result += "+C#{supp.corrigendum_number}:#{supp.corrigendum_year}"
+              end
+            end
+          end
+
+          result += " to "
+
+          # Render the base identifier (what this NA is for)
+          result += if base_doc
+                      base_doc.to_s
+                    else
+                      # Fallback to parent rendering
+                      super
+                    end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Practice Guide (PP - Published Practice)
+      # Examples: "PP 888:1982", "PP 7307:1986", "PP 7722:2006"
+      class PracticeGuide < Base
+        attribute :number, Bsi::Components::Code
+        attribute :date, Bsi::Components::Date
+
+        def self.type
+          {
+            short: "PP",
+            full: "Published Practice",
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          result = "PP #{number}"
+          result += ":#{date.year}" if date
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Publicly Available Specification (PAS) identifier
+      class PubliclyAvailableSpecification < SingleIdentifier
+        TYPED_STAGES = [
+          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],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :pas, title: "Publicly Available Specification", short: "PAS" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - PAS uses type abbreviation as prefix
+          parts = []
+
+          # Use type abbreviation (PAS) instead of publisher (BS)
+          type_abbr = type&.abbr || "PAS"
+          parts << type_abbr
+
+          # Number with part and subpart
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+
+            # Collection (second number with slash, e.g., PAS 2035/2030)
+            if second_number
+              second_val = second_number.is_a?(Components::Code) ? second_number.value : second_number
+              number_str += "/#{second_val}"
+            end
+
+            # Part and subpart
+            if part
+              part_val = part.is_a?(Components::Code) ? part.value : part
+              number_str += "-#{part_val.to_s.strip}"
+            end
+            if subpart
+              subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
+              number_str += "-#{subpart_val.to_s.strip}"
+            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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Published Document (PD) identifier
+      class PublishedDocument < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubpd,
+            stage_code: :published,
+            type_code: :pd,
+            abbr: ["PD"],
+            name: "Published Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :pd, title: "Published Document", short: "PD" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - PD uses type abbreviation as prefix
+          parts = []
+
+          # Use type abbreviation (PD) instead of publisher (BS)
+          type_abbr = type&.abbr || "PD"
+          parts << type_abbr
+
+          # Number with part and subpart
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+
+            # Collection (second number with slash, e.g., PD 6430/1)
+            if second_number
+              second_val = second_number.is_a?(Components::Code) ? second_number.value : second_number
+              number_str += "/#{second_val}"
+            end
+
+            # Part and subpart
+            if part
+              part_val = part.is_a?(Components::Code) ? part.value : part
+              number_str += "-#{part_val.to_s.strip}"
+            end
+            if subpart
+              subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
+              number_str += "-#{subpart_val.to_s.strip}"
+            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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BSI Section
+      # Examples:
+      # - Colon format (DD): "DD 51:Section 0:1977"
+      # - Space format (BS): "BS 3224 Section B2:1970"
+      class Section < SingleIdentifier
+        attribute :section_id, :string # Section identifier (0-7 or B2, C1, D1, etc.)
+        attribute :section_format, :string # Preserve ":Section" or " Section" separator
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubsection,
+            stage_code: :published,
+            type_code: :section,
+            abbr: ["Section"],
+            name: "Section",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :section, title: "Section", short: "Section" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - Section has two formats
+          parts = []
+
+          # Publisher (DD, BS, etc.)
+          parts << publisher.to_s if publisher
+
+          # Number
+          if number
+            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Section suffix with colon or space format
+          result += if section_format == "colon"
+                      ":Section #{section_id}"
+                    else
+                      " Section #{section_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/set.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Set represents multiple standards published as a set
+      # Format: {identifier} + {identifier} [+ {identifier} ...]
+      # Each identifier is separated by " + " (space, plus, space)
+      #
+      # Examples:
+      #   BS ISO 20400 + BS ISO 44001+BS ISO 44002
+      #   BS ISO 9001+BS ISO 14001
+      class Set < Base
+        attribute :identifiers, Base, collection: true, polymorphic: true
+        attribute :separators, :string, collection: true # Should all be " + "
+
+        def to_s(lang: :en, lang_single: false)
+          return "" if identifiers.nil? || identifiers.empty?
+
+          parts = []
+
+          identifiers.each_with_index do |id, i|
+            # Render each identifier
+            parts << id.to_s
+
+            # Add separator (always " + " between identifiers)
+            if i < identifiers.length - 1
+              parts << " + "
+            end
+          end
+
+          parts.join
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(Set)
+
+          # Compare first identifier
+          identifiers.first <=> other.identifiers.first
+        end
+      end
+    end
+  end
+end