pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -5,9 +5,93 @@ module Pubid
     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 < SingleIdentifier
-        attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
-                                                     collection: true
+      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
@@ -62,22 +146,6 @@ module Pubid
           base = identifiers&.first
           base.type if base&.class&.attributes&.key?(:type)
         end
-
-        # Base document = the wrapped standard (first entry), fully peeled.
-        def base_document
-          identifiers&.first&.base_document || self
-        end
-
-        # The origin document. Members live in `identifiers` (not `base`), so
-        # walk the first member to its root.
-        def root
-          identifiers&.first&.root || self
-        end
-
-        # Dropping the supplement layer yields the base standard alone.
-        def drop_supplements
-          identifiers&.first || self
-        end
       end
     end
   end

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

@@ -5,38 +5,22 @@ module Pubid
     module Identifiers
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
-      class Corrigendum < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      class Corrigendum < Base
+        attribute :base_identifier, Base, polymorphic: true
         attribute :corrigendum_number, :string
         attribute :corrigendum_year, :integer
         attribute :separator, :string, default: -> { "+" }
 
-        def publisher
-          base&.publisher
-        end
-
-        # Base document = the standard this corrigendum applies to, fully peeled.
-        def base_document
-          base&.base_document || self
-        end
-
-        # Dropping the supplement layer yields the base standard.
-        def drop_supplements
-          base || self
+        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
 
-        # Uniform supplement interface (shared with Amendment) so callers need
-        # not special-case the class.
-        def supplement_type
-          :corrigendum
-        end
-
-        def supplement_number
-          corrigendum_number
-        end
-
-        def supplement_year
-          corrigendum_year
+        def publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -27,6 +27,42 @@ module Pubid
           }
         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

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

@@ -21,6 +21,35 @@ module Pubid
           { 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

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

@@ -17,10 +17,54 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :dd,
-            web: :draft_document, title: "Draft Document", short: "DD" }
+          { 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

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

@@ -6,10 +6,46 @@ module Pubid
       # Electronic Publication (EP) identifier
       class ElectronicBook < SingleIdentifier
         def self.type
-          { key: :ep,
-            web: :electronic_book, title: "Electronic Publication", short: "EP" }
+          { 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

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

@@ -9,26 +9,37 @@ module Pubid
       # 1. "Expert Commentary" (full form)
       # 2. "ExComm" (abbreviated form)
       # 3. "ExComm (Fire)" (with optional topic suffix)
-      class ExpertCommentary < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      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&.publisher
+          base_identifier&.publisher
         end
 
         def number
-          base&.number
+          base_identifier&.number
         end
 
         def year
-          base&.year
-        end
-
-        # Base document = the commented standard, fully peeled.
-        def base_document
-          base&.base_document || self
+          base_identifier&.year
         end
       end
     end

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

@@ -29,6 +29,53 @@ module Pubid
           }
         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

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

@@ -20,9 +20,40 @@ module Pubid
           { key: :flex, title: "BSI Flex", short: "BSI Flex" }
         end
 
-        # Base document = the Flex standard without its version (edition).
-        def base_document
-          exclude(:edition)
+        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

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

@@ -5,7 +5,9 @@ module Pubid
     module Identifiers
       # BSI Handbook
       # Examples: "Handbook 17:1963", "HB 10146:1998"
-      class Handbook < SingleIdentifier
+      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"
 
@@ -17,6 +19,20 @@ module Pubid
           }
         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

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

@@ -24,6 +24,38 @@ module Pubid
           { 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

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

@@ -29,6 +29,47 @@ module Pubid
           { 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

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

@@ -6,8 +6,8 @@ module Pubid
       # National Annex (NA) identifier
       # Can have own supplements: "NA+A1:2012 to BASE"
       class NationalAnnex < SingleIdentifier
-        attribute :na_supplements, ::Pubid::Identifier, polymorphic: true, collection: true # Supplements on the NA itself
-        attribute :base_doc, ::Pubid::Identifier, polymorphic: true # The identifier after "to"
+        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(
@@ -21,8 +21,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :na,
-            web: :national_annex, title: "National Annex", short: "NA" }
+          { key: :na, title: "National Annex", short: "NA" }
         end
 
         # Delegation methods to access wrapped base_doc attributes
@@ -42,6 +41,32 @@ module Pubid
           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