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

data/lib/pubid/bsi/identifier.rb

@@ -1,6 +1,27 @@
 # frozen_string_literal: true
 
-# Pubid::Bsi::Identifier is the BSI base class (a real Pubid::Identifier
-# subclass); its body, `.parse` (including the IEC-delegation logic), and the
-# SingleIdentifier back-compat alias live in single_identifier.rb. This file
-# just ensures it is loaded when a consumer references Pubid::Bsi::Identifier.
+module Pubid
+  module Bsi
+    module Identifier
+      def self.parse(string)
+        # Delegate to IEC for bare IEC identifiers
+        # This handles IEC-specific features like VAP suffixes (CSV, RLV, etc.)
+        # and consolidated supplements (+AMD1:2001)
+        if string.match?(/\bIEC\b/) &&
+            (string.match?(/\s+(CSV|CMV|RLV|SER|EXV|PAC|PRV)\b/) ||
+             string.match?(/\+AMD\d+:/) ||
+             string.match?(/\+COR\d+:/))
+          return Pubid::Iec.parse(string)
+        end
+
+        parser = Parser.new
+        scheme = Scheme.new
+
+        parsed = parser.parse(string)
+        Builder.build(parsed, scheme)
+      rescue Parslet::ParseFailed => e
+        raise StandardError, "Failed to parse '#{string}': #{e.message}"
+      end
+    end
+  end
+end

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

@@ -10,8 +10,8 @@ module Pubid
       # "BS 1902-2.3:Addendum No. 1:1976"
       # "BS 2000-0:Addendum 1:1983"
       # "BS 6034:1981:Addendum No. 1:1986"
-      class AddendumDocument < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      class AddendumDocument < Base
+        attribute :base_identifier, Base, polymorphic: true
         attribute :addendum_number, :string
         attribute :addendum_year, :integer
         attribute :addendum_type, :string, default: -> {
@@ -21,8 +21,42 @@ module Pubid
           ":"
         } # Separator before Addendum (":" or " ")
 
+        def to_s(lang: :en, lang_single: false)
+          result = base_identifier.to_s(lang: lang, lang_single: lang_single)
+
+          # Determine separator - if separator is explicitly ":", use it
+          # Otherwise if base has year and doesn't already have double colon, use space
+          base_has_year = base_identifier.to_s =~ /:(\d{4})$/
+
+          sep = if separator == ":"
+                  ":"
+                elsif base_has_year && base_identifier.to_s !~ /:\d{4}:/
+                  " "
+                else
+                  separator
+                end
+
+          # Format: "BASE:Addendum No. N:YEAR" or "BASE Addendum No. N:YEAR" or "BASE:Addendum N:YEAR"
+          result += sep
+          result += "Addendum"
+
+          # Add space after "Addendum" if there's a type prefix (like "No.")
+          if addendum_type.empty?
+            # No type prefix, but still need space before number
+          else
+            result += " #{addendum_type}"
+          end
+          result += " "
+          result += " "
+
+          result += addendum_number.to_s
+          result += ":#{addendum_year}" if addendum_year
+
+          result
+        end
+
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Pubid
       # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
       # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
       class AdoptedEuropeanNorm < BritishStandard
-        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # CEN object
+        attribute :adopted_identifier, Base, polymorphic: true # CEN object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,25 +16,53 @@ module Pubid
         attribute :expert_commentary, :boolean
         attribute :expert_commentary_topic, :string
 
-        # 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.
-        # AdoptedEuropeanNorm is constructed explicitly by the builder, not
-        # selected by type-code lookup.
-        def self.type
-          nil
-        end
+        def to_s(lang: :en, lang_single: false)
+          # 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 - preserve the "version" or "Translation" suffix if present
+          if translation_lang
+            result += if translation_suffix_type == "version"
+                        " (#{translation_lang} version)"
+                      elsif translation_suffix_type == "Translation"
+                        " (#{translation_lang} Translation)"
+                      else
+                        " (#{translation_lang})"
+                      end
+          elsif translation_upper
+            result += if translation_suffix_type == "Translation"
+                        " (#{translation_upper} Translation)"
+                      else
+                        " (#{translation_upper})"
+                      end
+          end
+
+          # ExpertCommentary suffix
+          if expert_commentary
+            result += if expert_commentary_topic
+                        " ExComm (#{expert_commentary_topic})"
+                      else
+                        " ExComm"
+                      end
+          end
 
-        # Walk to the adopted document for the relaton-index key.
-        #
-        # The `#number` delegation below is not enough on its own: a
-        # "DD ENV ISO 11079:1999" adopts a CenCenelec EuropeanPrestandard,
-        # which is ITSELF a wrapper around the ISO standard, so the delegation
-        # returned that wrapper's own (nil) number and the chain died one level
-        # short. `#root` recurses, so it reaches the ISO standard however many
-        # adoption layers sit in between.
-        def root
-          adopted_identifier ? adopted_identifier.root : self
+          result
         end
 
         # Delegate common methods to adopted identifier

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, ::Pubid::Identifier, polymorphic: true # ISO/IEC object
+        attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,13 +16,44 @@ module Pubid
         attribute :expert_commentary, :boolean
         attribute :expert_commentary_topic, :string
 
-        # 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
+        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
+
+          result
         end
 
         # Delegate common methods to adopted identifier

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

@@ -54,11 +54,64 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :aerospace,
-            web: :aerospace_standard, title: "Aerospace/Specialized Standard",
+          { key: :aerospace, 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
+        end
       end
     end
   end

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

@@ -5,42 +5,34 @@ module Pubid
     module Identifiers
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
-      class Amendment < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      class Amendment < Base
+        attribute :base_identifier, Base, polymorphic: true
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
         attribute :separator, :string, default: -> { "+" }
-        # true for the trailing " AMD5" / " AMD AA" suffix form, false for the
-        # compact "+A5" / "/A5" join form. Distinguishes the two when no year is
-        # present (previously the presence of a year was a reliable proxy).
-        attribute :amd_suffix_form, :boolean, default: -> { false }
 
-        def publisher
-          base&.publisher
-        end
-
-        # Base document = the standard this amendment 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
+          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
         end
 
-        # Uniform supplement interface (shared with Corrigendum) so callers need
-        # not special-case the class.
-        def supplement_type
-          :amendment
-        end
-
-        def supplement_number
-          amendment_number
-        end
-
-        def supplement_year
-          amendment_year
+        def publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Base BSI identifier (module organization)
+      class Base < Pubid::Identifier
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -11,29 +11,103 @@ 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 < SingleIdentifier
-        attribute :identifiers, ::Pubid::Identifier, collection: true, 
-                                                     polymorphic: true
+      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
-
-        # A bundle carries no number of its own — each member holds one — so
-        # `root.number`, the key relaton-index sorts and bsearches on, was "".
-        # Walk to the first member, the shape ConsolidatedIdentifier already
-        # uses. Members of one bundle are consecutive numbers of a single
-        # series, so the bundle files under the first, and `<=>` above orders
-        # bundles by that same member.
-        def root
-          identifiers&.first ? identifiers.first.root : self
-        end
       end
     end
   end

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

@@ -11,16 +11,7 @@ module Pubid
       #   21/30445138 DC
       #   24/30300822 DC
       class CommitteeDocument < SingleIdentifier
-        # The 8-digit document number lives in the `number` inherited from
-        # SingleIdentifier (a Bsi::Components::Code). It used to be a separate
-        # `document_number` :string, which left `number` nil — so `root.number`,
-        # the key relaton-index sorts and bsearches on, was "".
-        #
-        # The duplicate is DELETED rather than mirrored into `number`: keeping
-        # both would emit the same digits twice in `to_hash`, and a derived
-        # `#number` method is not available here because `number` is a lutaml
-        # attribute, whose generated accessor such a method would collide with.
-        # Nothing is retyped — the inherited attribute is already a Code.
+        attribute :document_number, :string # The 8-digit document number
 
         # TYPED_STAGES for committee documents (draft by default)
         TYPED_STAGES = [
@@ -38,6 +29,22 @@ module Pubid
           { 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