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

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

@@ -5,7 +5,8 @@ module Pubid
     module Identifiers
       # BSI Practice Guide (PP - Published Practice)
       # Examples: "PP 888:1982", "PP 7307:1986", "PP 7722:2006"
-      class PracticeGuide < SingleIdentifier
+      class PracticeGuide < 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 = "PP #{number}"
+          result += ":#{date.year}" if date
+          result
+        end
       end
     end
   end

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

@@ -17,10 +17,62 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :pas,
-            web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
+          { 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

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

@@ -17,10 +17,62 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :pd,
-            web: :published_document, title: "Published Document", short: "PD" }
+          { 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

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

@@ -26,6 +26,36 @@ module Pubid
           { 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

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

@@ -12,28 +12,34 @@ module Pubid
       # Examples:
       #   BS ISO 20400 + BS ISO 44001+BS ISO 44002
       #   BS ISO 9001+BS ISO 14001
-      class Set < SingleIdentifier
-        attribute :identifiers, ::Pubid::Identifier, collection: true, 
-                                                     polymorphic: true
+      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
-
-        # As for BundledIdentifier: a set holds no number of its own, so walk
-        # to the first member for the relaton-index key.
-        #
-        # NOTE the members are frequently a FOREIGN flavor (BS ISO ... holds
-        # Pubid::Iso identifiers), which `to_hash` still rejects — see the
-        # hand-off bsi-set-cross-flavor-type. `#root` is unaffected by that:
-        # it only reads the object, never serializes it.
-        def root
-          identifiers&.first ? identifiers.first.root : self
-        end
       end
     end
   end

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

@@ -6,16 +6,7 @@ module Pubid
       # Standalone Amendment identifier (no base reference)
       # Examples: "AMD 11015", "(AMD 10971)", "AMD Corrigendum 14716"
       class StandaloneAmendment < SingleIdentifier
-        # The amendment number lives in the `number` inherited from
-        # SingleIdentifier — already a Bsi::Components::Code, exactly what the
-        # deleted `amendment_number` was, so nothing is retyped. It used to sit
-        # under the private name, leaving `number` nil and `root.number` "".
-        #
-        # A standalone amendment is its OWN document (there is no base standard
-        # to walk to — that is what "standalone" means), so it needs a real
-        # number rather than a #root override. `Identifiers::Amendment`, the
-        # attached kind, keeps its own `amendment_number` and is untouched:
-        # there the ordinal is a supplement ordinal, not the document number.
+        attribute :amendment_number, Components::Code
         attribute :corrigendum, :boolean, default: false
         attribute :parenthesized, :boolean, default: false
 
@@ -34,6 +25,15 @@ module Pubid
           { key: :standalone_amendment, title: "Amendment", short: "AMD" }
         end
 
+        def to_s(lang: :en, lang_single: false)
+          base = if corrigendum
+                   "AMD Corrigendum #{amendment_number}"
+                 else
+                   "AMD #{amendment_number}"
+                 end
+
+          parenthesized ? "(#{base})" : base
+        end
       end
     end
   end

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

@@ -8,8 +8,8 @@ module Pubid
       # Supports both forward and reverse formats:
       # Forward: "BS 1000:Supplement No. 1:1972", "BS 1722-1 Supplement No. 1:1974"
       # Reverse: "Supplement No. 1 (1970) to BS 1831:1969"
-      class SupplementDocument < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      class SupplementDocument < Base
+        attribute :base_identifier, Base, polymorphic: true
         attribute :supplement_number, :string
         attribute :supplement_year, :integer
         attribute :supplement_type, :string, default: -> {
@@ -20,8 +20,30 @@ module Pubid
           ":"
         } # Separator before Supplement (":" or " ")
 
+        def to_s
+          base_str = base_identifier.to_s
+
+          if reverse_format
+            # Reverse format: "Supplement No. 1 (1970) to BS 1831:1969"
+            supplement_str = if supplement_type == "No."
+                               "Supplement No. #{supplement_number} (#{supplement_year})"
+                             else
+                               "Supplement #{supplement_number} (#{supplement_year})"
+                             end
+            "#{supplement_str} to #{base_str}"
+          else
+            # Forward format: "BS 1000:Supplement No. 1:1972" or "BS 1722-1 Supplement No. 1:1974"
+            supplement_str = if supplement_type == "No."
+                               "#{separator}Supplement No. #{supplement_number}:#{supplement_year}"
+                             else
+                               "#{separator}Supplement #{supplement_number}:#{supplement_year}"
+                             end
+            "#{base_str}#{supplement_str}"
+          end
+        end
+
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -29,6 +29,52 @@ module Pubid
           }
         end
 
+        def to_s(lang: :en, lang_single: false)
+          # Supplementary Index format: BS {number} Supplementary Index:{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 += " Supplementary Index:#{year_val}"
+            # Month if present
+            result += "-#{format('%02d', month)}" if month
+          end
+
+          result
+        end
       end
     end
   end

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

@@ -24,10 +24,55 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts,
-            web: :technical_specification, title: "Technical Specification", short: "TS" }
+          { key: :ts, title: "Technical Specification", short: "TS" }
         end
 
+        def to_s(lang: :en, lang_single: false)
+          # Technical specifications use a simple format: TS {number}:{year}
+          parts = []
+          parts << "TS"
+
+          # 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 += ":#{year_val}"
+            # Month if present
+            result += "-#{format('%02d', month)}" if month
+          end
+
+          result
+        end
       end
     end
   end

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

@@ -29,6 +29,38 @@ module Pubid
           { key: :test_method, title: "Test Method", short: "BS" }
         end
 
+        def to_s(lang: :en, lang_single: false)
+          # Test Method format: BS {number}:{test_series}:{test_id}:{year}
+          parts = []
+
+          # Publisher (BS)
+          parts << "BS"
+
+          # Number
+          if number
+            number_str = if number.is_a?(Components::Code)
+                           number.value.to_s
+                         else
+                           number.to_s
+                         end
+            parts << number_str
+          end
+
+          result = parts.join(" ")
+
+          # Test series and test ID suffixes
+          if test_series && test_id
+            result += ":#{test_series}:#{test_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

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

@@ -11,25 +11,40 @@ module Pubid
       #   PD 5500:2018+A3:2020 PDF
       #   PAS 96:2017 - TC
       #   PP 7722:2006 BOOK
-      class ValueAddedPublication < SingleIdentifier
-        attribute :base, ::Pubid::Identifier, polymorphic: true
+      class ValueAddedPublication < Base
+        attribute :base_identifier, Base, polymorphic: true
         attribute :format, :string, values: ["PDF", "TC", "BOOK"]
 
-        # Delegate common attributes to base
+        def to_s(lang: :en, lang_single: false)
+          base_str = base_identifier.to_s(lang: lang, lang_single: lang_single)
+
+          case format
+          when "TC"
+            "#{base_str} - TC"
+          when "PDF"
+            "#{base_str} PDF"
+          when "BOOK"
+            "#{base_str} BOOK"
+          else
+            base_str
+          end
+        end
+
+        # Delegate common attributes to base_identifier
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
 
         def number
-          base&.number
+          base_identifier&.number
         end
 
         def year
-          base&.year
+          base_identifier&.year
         end
 
         def date
-          base&.date
+          base_identifier&.date
         end
       end
     end

data/lib/pubid/bsi/identifiers.rb

@@ -10,6 +10,7 @@ module Pubid
                "#{__dir__}/identifiers/adopted_international_standard"
       autoload :AerospaceStandard, "#{__dir__}/identifiers/aerospace_standard"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :BritishIndustrialPractice,
                "#{__dir__}/identifiers/british_industrial_practice"
       autoload :BritishStandard, "#{__dir__}/identifiers/british_standard"

data/lib/pubid/bsi/parser.rb

@@ -4,20 +4,7 @@ require "parslet"
 
 module Pubid
   module Bsi
-    class Parser < ::Pubid::Parser::Grammar
-      # Case-insensitive string match (Parslet 2.0 has no built-in `stri`).
-      # Each character becomes a two-case character class; other characters
-      # (spaces, punctuation) match verbatim.
-      def stri(string)
-        string.each_char.map do |char|
-          if char =~ /[a-z]/i
-            match["#{char.upcase}#{char.downcase}"]
-          else
-            str(char)
-          end
-        end.reduce(:>>)
-      end
-
+    class Parser < Parslet::Parser
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:space) { str(" ") }
@@ -309,15 +296,14 @@ module Pubid
       # Single letter (a-z or A-Z) that comes immediately after number or part
       rule(:letter_edition) { match["a-zA-Z"].as(:letter_edition) }
 
-      # Amendment (+A1:2008 or /A2:2019 or /Amd 1:2020 or +A1:15 for short year,
-      # or +A2 / /A2 without a year — mirrors the optional-year corrigendum rule)
+      # Amendment (+A1:2008 or /A2:2019 or /Amd 1:2020 or +A1:15 for short year)
       rule(:amendment) do
         ((plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
           str("A") >> digits.as(:amd_number) >>
-          (colon >> digit.repeat(2, 4).as(:amd_year)).maybe) |
+          colon >> digit.repeat(2, 4).as(:amd_year)) |
           ((plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
             str("Amd") >> space >> digits.as(:amd_number) >>
-            (colon >> digit.repeat(4, 4).as(:amd_year)).maybe)
+            colon >> digit.repeat(4, 4).as(:amd_year))
       end
 
       # Corrigendum (+AC:2009 or +AC1:2008 or /AC1:2005 or +C1:2018 or +C1 without year)
@@ -532,8 +518,8 @@ module Pubid
       # 3. "ExComm (Fire)" (with optional topic suffix)
       rule(:expert_commentary) do
         space >> (
-          stri("Expert Commentary").as(:expert_commentary_full) |
-          (stri("ExComm") >> (space >> str("(") >> match["A-Za-z"].repeat(1).as(:expert_commentary_topic) >> str(")")).maybe).as(:expert_commentary)
+          str("Expert Commentary").as(:expert_commentary_full) |
+          (str("ExComm") >> (space >> str("(") >> match["A-Za-z"].repeat(1).as(:expert_commentary_topic) >> str(")")).maybe).as(:expert_commentary)
         )
       end