pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BundledIdentifier represents multiple standards published together
+      # Examples:
+      #   BS SP 10 & 11:1949
+      #   BS 2SP 68 to BS 2SP 71:1973
+      #   BS SP 13; 14; 15 and 16:1949
+      #   BS 4048:Parts 1 and 2:1966
+      class BundledIdentifier < Base
+        attribute :identifiers, Base, collection: true, polymorphic: true
+        attribute :separators, :string, collection: true # Separators between identifiers
+        attribute :common_year, Bsi::Components::Date # Year applied to all if present
+        attribute :bundle_type, :string # "Parts", "Sections", or nil for regular bundles
+
+        def to_s(lang: :en, lang_single: false)
+          return "" if identifiers.nil? || identifiers.empty?
+
+          # Special case: Parts/Sections bundles like "BS 4048:Parts 1 and 2:1966"
+          if bundle_type
+            base_id = identifiers.first
+            parts_list = identifiers[1..].map do |id|
+              # Extract just the part number
+              part_val = id.class.attributes.key?(:part) ? id.part : nil
+              if part_val
+                pv = part_val.is_a?(Components::Code) ? part_val.value : part_val
+                pv.to_s
+              else
+                id.to_s
+              end
+            end.join(" and ")
+
+            result = "#{base_id.to_s.sub(/:.*$/,
+                                         '')}:#{bundle_type} #{parts_list}"
+            result += ":#{common_year.year}" if common_year
+            return result
+          end
+
+          # Regular bundle: render based on explicit markers
+          parts = []
+
+          identifiers.each_with_index do |id, i|
+            # Check metadata flags for how item was parsed
+            explicit_prefix = id.explicit_prefix
+            explicit_publisher = id.explicit_publisher
+
+            if i.zero?
+              # First item always uses full form
+              parts << id.to_s
+            elsif explicit_publisher
+              # Full form: has explicit publisher (e.g., "BS SP 50")
+              parts << id.to_s
+            elsif explicit_prefix
+              # Prefix-only form: has explicit prefix but no publisher (e.g., "SP 138")
+              abbrev_str = ""
+              prefix = id.class.attributes.key?(:prefix) ? id.prefix : nil
+              if prefix && !prefix.to_s.empty?
+                abbrev_str = prefix.to_s
+              end
+              if id.number
+                number_val = id.number.is_a?(Components::Code) ? id.number.value : id.number
+                abbrev_str += " " if !abbrev_str.empty?
+                abbrev_str += number_val.to_s
+              end
+              if id.part
+                part_val = id.part.is_a?(Components::Code) ? id.part.value : id.part
+                abbrev_str += "-#{part_val}"
+              end
+              parts << abbrev_str
+            else
+              # Minimal form: no explicit markers (e.g., "125")
+              abbrev_str = ""
+              if id.number
+                number_val = id.number.is_a?(Components::Code) ? id.number.value : id.number
+                abbrev_str = number_val.to_s
+              end
+              if id.part
+                part_val = id.part.is_a?(Components::Code) ? id.part.value : id.part
+                abbrev_str += "-#{part_val}"
+              end
+              parts << abbrev_str
+            end
+
+            # Add separator - preserve original spacing
+            if i < identifiers.length - 1
+              sep = separators[i] || " and "
+              parts << sep
+            end
+          end
+
+          result = parts.join
+
+          # Add common year if present and not already in last identifier
+          if common_year && !result.match?(/:#{common_year.year}$/)
+            result += ":#{common_year.year}"
+          end
+
+          result
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(BundledIdentifier)
+
+          # Compare first identifier
+          identifiers.first <=> other.identifiers.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # CommitteeDocument represents BSI committee draft documents
+      # Format: YY/NNNNNNNN DC (2-digit year, 8-digit number, DC suffix)
+      #
+      # Examples:
+      #   14/30300822 DC
+      #   21/30445138 DC
+      #   24/30300822 DC
+      class CommitteeDocument < SingleIdentifier
+        attribute :document_number, :string # The 8-digit document number
+
+        # TYPED_STAGES for committee documents (draft by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :draft_committee,
+            stage_code: :draft,
+            type_code: :committee_document,
+            abbr: ["DC"],
+            name: "Draft Committee Document",
+            harmonized_stages: %w[30.00 30.20 30.60 40.00 40.20 40.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :committee_document, title: "Committee Document", short: "DC" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Committee documents use a unique format: YY/NNNNNNNN DC
+          # The year is 2-digit (extracted from date or use current date format)
+          # Note: Assumes 2000s for years 00-99 (Y2K assumption)
+          year_str = if date
+                       if date.is_a?(Components::Date)
+                         date.year.to_s[-2, 2]
+                       else
+                         date.to_s[-2, 2]
+                       end
+                     else
+                       "00" # Default if no date
+                     end
+
+          "#{year_str}/#{document_number} DC"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Consolidated Identifier - contains base document plus supplements
+      # Example: "BS 4592-0:2006+A1:2012" = [BS 4592-0:2006, Amendment 1:2012]
+      class ConsolidatedIdentifier < Base
+        attribute :identifiers, Base, polymorphic: true, collection: true
+
+        def to_s(lang: :en, lang_single: false)
+          base_id = identifiers.first
+
+          # Render base without suffixes (will add them after supplements)
+          result = if base_id.is_a?(Base) && base_id.class.method_defined?(:to_s_without_suffixes)
+                     base_id.to_s_without_suffixes
+                   else
+                     # Temporarily remove suffixes for rendering
+                     base_str = base_id.to_s
+                     # Remove known suffixes (more flexible patterns to handle topics)
+                     base_str = base_str.sub(/ ExComm \(.*?\)$/, "") # ExComm (Fire)
+                       .sub(/ ExComm$/, "") # ExComm without topic
+                       .sub(/ - TC$/, "")
+                       .sub(/ PDF$/, "")
+                       .sub(/ \([A-Z][a-z]+\)$/, "")
+                     base_str
+                   end
+
+          # Add supplements
+          identifiers[1..].each do |id|
+            if id.is_a?(Amendment)
+              if id.amendment_year
+                sep = id.is_a?(Base) && id.separator ? id.separator : "+"
+                result += "#{sep}A#{id.amendment_number}:#{id.amendment_year}"
+              else
+                # Letter suffixes (AA, AB, etc.) have a space, numeric suffixes don't
+                result += if id.amendment_number&.match?(/^[A-Z]+$/)
+                            " AMD #{id.amendment_number}"
+                          else
+                            " AMD#{id.amendment_number}"
+                          end
+              end
+            elsif id.is_a?(Corrigendum)
+              sep = id.is_a?(Base) && id.separator ? id.separator : "+"
+              result += "#{sep}C"
+              result += id.corrigendum_number.to_s if id.corrigendum_number
+              result += ":#{id.corrigendum_year}" if id.corrigendum_year
+            else
+              result += id.to_s
+            end
+          end
+
+          # Add suffixes from base identifier AFTER supplements
+          if base_id.is_a?(Pubid::Identifier)
+            base_attrs = base_id.class.attributes
+            ec = base_attrs.key?(:expert_commentary) ? base_id.expert_commentary : nil
+            if ec
+              ect = base_attrs.key?(:expert_commentary_topic) ? base_id.expert_commentary_topic : nil
+              result += ect ? " ExComm (#{ect})" : " ExComm"
+            end
+
+            tc = base_attrs.key?(:tracked_changes) ? base_id.tracked_changes : nil
+            result += " - TC" if tc
+
+            # Translation - preserve the "version" or "Translation" suffix if present
+            tl = base_attrs.key?(:translation_lang) ? base_id.translation_lang : nil
+            if tl
+              ts_type = base_attrs.key?(:translation_suffix_type) ? base_id.translation_suffix_type : nil
+              result += if ts_type == "version"
+                          " (#{tl} version)"
+                        elsif ts_type == "Translation"
+                          " (#{tl} Translation)"
+                        else
+                          " (#{tl})"
+                        end
+            else
+              tu = base_attrs.key?(:translation_upper) ? base_id.translation_upper : nil
+              if tu
+                ts_type = base_attrs.key?(:translation_suffix_type) ? base_id.translation_suffix_type : nil
+                result += if ts_type == "Translation"
+                            " (#{tu} Translation)"
+                          else
+                            " (#{tu})"
+                          end
+              end
+            end
+
+            # Reaffirmation notation like (R2004)
+            ry = base_attrs.key?(:reaffirmation_year) ? base_id.reaffirmation_year : nil
+            result += " (R#{ry})" if ry
+          end
+
+          result
+        end
+
+        def to_urn
+          base = identifiers&.first
+          return nil unless base
+
+          urn = base.to_urn if base.class.method_defined?(:to_urn)
+          return urn unless urn
+
+          # Append supplement info to URN
+          identifiers[1..].each do |id|
+            if id.is_a?(Amendment)
+              urn += ":amd:#{id.amendment_number}"
+              urn += ":#{id.amendment_year}" if id.amendment_year
+            elsif id.is_a?(Corrigendum)
+              urn += ":cor:#{id.corrigendum_number}"
+              urn += ":#{id.corrigendum_year}" if id.corrigendum_year
+            end
+          end
+          urn
+        end
+
+        # Delegate to first identifier (base document)
+        def publisher
+          identifiers&.first&.publisher
+        end
+
+        def number
+          identifiers&.first&.number
+        end
+
+        def year
+          base = identifiers&.first
+          base.year if base&.class&.attributes&.key?(:year)
+        end
+
+        def date
+          base = identifiers&.first
+          base.date if base&.class&.attributes&.key?(:date)
+        end
+
+        def parts
+          base = identifiers&.first
+          base.parts if base&.class&.attributes&.key?(:parts)
+        end
+
+        def part
+          base = identifiers&.first
+          base.part if base&.class&.attributes&.key?(:part)
+        end
+
+        def type
+          base = identifiers&.first
+          base.type if base&.class&.attributes&.key?(:type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Corrigendum Identifier
+      # Contains a base identifier plus corrigendum parameters
+      class Corrigendum < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :corrigendum_number, :string
+        attribute :corrigendum_year, :integer
+        attribute :separator, :string, default: -> { "+" }
+
+        def to_s
+          result = base_identifier ? base_identifier.to_s : ""
+          result += "#{separator}C"
+          result += corrigendum_number.to_s if corrigendum_number
+          result += ":#{corrigendum_year}" if corrigendum_year
+          result
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Detailed Specification identifier with N or C notation
+      # Examples: "BS 9074 N002:1974", "BS 9300 C155-168:1971"
+      class DetailedSpecification < SingleIdentifier
+        attribute :spec_code, Components::Code
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :detailed_spec,
+            stage_code: :published,
+            type_code: :detailed_specification,
+            abbr: ["DETAILED SPEC"],
+            name: "Detailed Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          {
+            key: :detailed_specification,
+            title: "Detailed Specification",
+            short: "DETAILED SPEC",
+          }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          parts = []
+
+          # Publisher prefix
+          parts << "BS"
+
+          # Base number
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+            parts << number_str
+          end
+
+          # Spec notation (N002 or C155-168)
+          if spec_code
+            code_val = if spec_code.is_a?(Components::Code)
+                         spec_code.value
+                       else
+                         spec_code
+                       end
+            result = "#{parts.join(' ')} #{code_val}"
+          else
+            result = parts.join(" ")
+          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/disc.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # DISC (Delivering Information Solutions to Customers) identifier
+      # Examples: "DISC PD 2000-2:1997", "DISC PD 3004:1998"
+      class Disc < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :disc,
+            stage_code: :published,
+            type_code: :disc,
+            abbr: ["DISC"],
+            name: "DISC",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :disc, title: "DISC", short: "DISC" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          parts = []
+
+          # DISC prefix
+          parts << "DISC"
+
+          # Type (PD) + number
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+            if part
+              part_val = part.is_a?(Components::Code) ? part.value : part
+              number_str += "-#{part_val.to_s.strip}"
+            end
+            parts << "PD #{number_str}"
+          end
+
+          result = parts.join(" ")
+
+          # Date with colon separator
+          if date
+            result += ":#{date}"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Draft Document (DD) identifier
+      class DraftDocument < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubdd,
+            stage_code: :published,
+            type_code: :dd,
+            abbr: ["DD"],
+            name: "Draft Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :dd, title: "Draft Document", short: "DD" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - DD uses type abbreviation as prefix
+          parts = []
+
+          # Use type abbreviation (DD) instead of publisher (BS)
+          type_abbr = type&.abbr || "DD"
+          parts << type_abbr
+
+          # Number with part and subpart
+          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.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}"
+          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/electronic_book.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Electronic Publication (EP) identifier
+      class ElectronicBook < SingleIdentifier
+        def self.type
+          { key: :ep, title: "Electronic Publication", short: "EP" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          # Build string representation - EP uses type abbreviation as prefix
+          parts = []
+
+          # Use type abbreviation (EP)
+          parts << "EP"
+
+          # Number with part and subpart
+          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.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}"
+          end
+
+          # Edition/Version
+          result += " Version #{edition}" if edition
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Expert Commentary Identifier
+      # Wraps a base identifier with Expert Commentary suffix
+      # Three formats:
+      # 1. "Expert Commentary" (full form)
+      # 2. "ExComm" (abbreviated form)
+      # 3. "ExComm (Fire)" (with optional topic suffix)
+      class ExpertCommentary < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :format, :string # "full", "abbr", "abbr_with_topic"
+        attribute :topic, :string # e.g., "Fire"
+
+        def to_s
+          base_str = base_identifier.to_s
+          # Ensure suffix appears only once at the end
+          base_str = base_str.sub(/ (Expert Commentary|ExComm(\s*\(.*\))?)$/,
+                                  "")
+
+          case format
+          when "full"
+            "#{base_str} Expert Commentary"
+          when "abbr_with_topic"
+            "#{base_str} ExComm (#{topic})"
+          else # "abbr" (default)
+            "#{base_str} ExComm"
+          end
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+
+        def number
+          base_identifier&.number
+        end
+
+        def year
+          base_identifier&.year
+        end
+      end
+    end
+  end
+end