pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

@@ -7,7 +7,7 @@ module Pubid
       # 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 :adopted_identifier, ::Pubid::Identifier, polymorphic: true # ISO/IEC object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,44 +16,17 @@ module Pubid
         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
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedInternationalStandard is constructed explicitly by the builder,
+        # not selected by type-code lookup.
+        def self.type
+          nil
+        end
 
-          result
+        def to_s
+          render(format: :human)
         end
 
         # Delegate common methods to adopted identifier

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

@@ -54,63 +54,13 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :aerospace, title: "Aerospace/Specialized Standard",
+          { key: :aerospace,
+            web: :aerospace_standard, 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -5,30 +5,14 @@ module Pubid
     module Identifiers
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
-      class Amendment < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class Amendment < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, 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
+          render(format: :human)
         end
 
         def publisher

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # British Industrial Practice (BIP)
       # Examples: "BIP 2225:2022", "BIP 0142:2014", "BIP 0009:2020"
-      class BritishIndustrialPractice < Base
+      class BritishIndustrialPractice < SingleIdentifier
         attribute :number, Bsi::Components::Code
         attribute :date, Bsi::Components::Date
 
@@ -17,9 +17,7 @@ module Pubid
         end
 
         def to_s(lang: :en, lang_single: false)
-          result = "BIP #{number}"
-          result += ":#{date.year}" if date
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -25,7 +25,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :bs, title: "British Standard", short: "BS" }
+          { key: :bs,
+            web: :british_standard, title: "British Standard", short: "BS" }
         end
       end
     end

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

@@ -11,95 +11,14 @@ module Pubid
       #   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
+      class BundledIdentifier < SingleIdentifier
+        attribute :identifiers, ::Pubid::Identifier, 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         def <=>(other)

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

@@ -30,20 +30,7 @@ module Pubid
         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"
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -5,92 +5,11 @@ 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 < Base
-        attribute :identifiers, Base, polymorphic: true, collection: true
+      class ConsolidatedIdentifier < SingleIdentifier
+        attribute :identifiers, ::Pubid::Identifier, 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         def to_urn

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

@@ -5,18 +5,14 @@ module Pubid
     module Identifiers
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
-      class Corrigendum < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class Corrigendum < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, 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
+          render(format: :human)
         end
 
         def publisher

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

@@ -28,40 +28,7 @@ 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -22,33 +22,7 @@ module Pubid
         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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -17,53 +17,12 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :dd, title: "Draft Document", short: "DD" }
+          { key: :dd,
+            web: :draft_document, 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -6,45 +6,12 @@ module Pubid
       # Electronic Publication (EP) identifier
       class ElectronicBook < SingleIdentifier
         def self.type
-          { key: :ep, title: "Electronic Publication", short: "EP" }
+          { key: :ep,
+            web: :electronic_book, 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
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

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

@@ -9,25 +9,13 @@ module Pubid
       # 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
+      class ExpertCommentary < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, 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
+          render(format: :human)
         end
 
         def publisher