pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

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

@@ -76,24 +76,12 @@ module Pubid
           if args[:draft_obj]
             self.draft_obj = args[:draft_obj]
             self.draft = args[:draft_obj].to_s
+          elsif args[:draft].is_a?(String)
+            self.draft_obj = Components::Draft.parse(args[:draft])
+            self.draft = draft_obj.to_s
           elsif args[:draft]
-            # If draft is passed as string, try to create Draft object
-            if args[:draft].is_a?(String)
-              # Try to parse the string to extract version/revision
-              if args[:draft] =~ /^D(\d+)(?:\.(\d+))?/
-                version = $1
-                revision = $2
-                self.draft_obj = Components::Draft.new(version: version,
-                                                       revision: revision)
-              else
-                # Simple case - treat as version
-                self.draft_obj = Components::Draft.new(version: args[:draft])
-              end
-              self.draft = draft_obj.to_s
-            else
-              self.draft_obj = args[:draft]
-              self.draft = args[:draft].to_s
-            end
+            self.draft_obj = args[:draft]
+            self.draft = args[:draft].to_s
           end
 
           # Set other attributes
@@ -122,328 +110,109 @@ module Pubid
           draft_obj.numeric_month
         end
 
-        # Parse IEEE identifier string
+        # Parse IEEE identifier string.
+        #
+        # PreParser owns all regex/dispatch logic; this method is a thin
+        # orchestrator that consumes a PreParser::Result and routes to the
+        # correct builder.
         def self.parse(input)
-          # Preprocessing: Convert comma-separated dual standards to "and" format
-          # This must happen BEFORE the "and" check below
-          # Pattern: "IEEE Std 960-1989, Std 1177-1989" -> "IEEE Std 960-1989 and IEEE Std 1177-1989"
-          input = input.gsub(/(\d{4}),\s+Std\s/, '\1 and IEEE Std ')
-
-          # Check for AIEE identifiers (but NOT those with parentheses which have relationships/adoptions)
-          # AIEE has its own parser/builder for simple identifiers
-          # AIEE inputs with parentheses are handled by IEEE parser for relationship/adoption parsing
-          if input.start_with?("AIEE ") && !input.include?("(")
-            return Aiee::Identifier.parse(input)
-          end
-
-          # Check for IEC/IEEE copublished patterns first (before other checks)
-          if input.start_with?("IEC/IEEE ")
-            return parse_single(input)
-          end
-
-          # Check for semicolon-separated dual identifiers (IEC-first patterns)
-          # Pattern: "IEC 61523-3 First edition 2004-09; IEEE 1497"
-          if input.include?("; ")
-            parts = input.split("; ")
-            if parts.length == 2
-              # Try to parse both parts
-              begin
-                first = parse_single(parts[0].strip)
-                second = parse_single(parts[1].strip)
-
-                return Identifiers::DualPublished.new(
-                  first_identifier: first,
-                  second_identifier: second,
-                )
-              rescue Parslet::ParseFailed
-                # If parsing fails, continue with normal flow
-              end
-            end
-          end
-
-          # PREPROCESS: Handle (R####) (Revision of...) pattern
-          # Convert to single parenthetical: (Reaffirmed ####, Revision of...)
-          # This allows parser to capture both in one parenthetical
-          if input =~ /\(R(\d{4})\)\s*\(Revision of ([^)]+)\)/
-            year = $1
-            $2
-            # Replace the two parentheticals with reaffirmed info extracted
-            # Parse normally but capture year first
-            input_modified = input.sub(
-              /\(R(\d{4})\)\s*\(Revision of ([^)]+)\)/, "(Revision of \\2)"
-            )
-
-            # Parse the modified input
-            result = parse_single(input_modified)
-            # Add reaffirmed attribute
-            if result.class.attributes.key?(:reaffirmed)
-              result.reaffirmed = year
-            end
-            return result
-          end
-
-          # PREPROCESS: Handle (Reaffirmed ####) (Revision of...) pattern (full word format)
-          # Pattern: "ANSI/IEEE Std 101-1987 (Reaffirmed 2010) (Revision of IEEE Std 101-1972)"
-          if input =~ /\(Reaffirmed\s+(\d{4})\)\s*\(Revision of ([^)]+)\)/
-            year = $1
-            $2
-            # Replace the two parentheticals
-            input_modified = input.sub(
-              /\(Reaffirmed\s+(\d{4})\)\s*\(Revision of ([^)]+)\)/, "(Revision of \\2)"
-            )
-
-            # Parse the modified input
-            result = parse_single(input_modified)
-            # Add reaffirmed attribute
-            if result.class.attributes.key?(:reaffirmed)
-              result.reaffirmed = year
-            end
-            return result
-          end
-
-          # NEW Session 174: Check for IRE dual published pattern
-          # Pattern after preprocessing: "IEEE Std 218-1956 (R1980) (56 IRE 28.S2)"
-          # First parenthetical: (Rxxx) reaffirmed
-          # Second parenthetical: IRE identifier
-          if /\(R\d{4}\)\s*\((\d+\s+IRE[^)]+)\)/.match?(input)
-            main_part = input.split(" (R").first.strip # Get "IEEE Std 218-1956"
-            reaffirmed_year = input.match(/\(R(\d{4})\)/)[1]
-            ire_part = input.match(/\((\d+\s+IRE[^)]+)\)/)[1]
-
-            begin
-              # Parse main identifier
-              ieee_id = parse_single(main_part)
-              # Add reaffirmed year
-              ieee_id.reaffirmed = reaffirmed_year if ieee_id.class.attributes.key?(:reaffirmed)
-
-              # Parse IRE identifier
-              ire_id = parse_single(ire_part)
-
-              return Identifiers::DualPublished.new(
-                first_identifier: ieee_id,
-                second_identifier: ire_id,
-              )
-            rescue Parslet::ParseFailed
-              # If parsing fails, fall through to regular processing
-            end
-          end
-
-          # Check for space-separated dual identifiers (e.g., "IEC 62014-5 IEEE Std 1734-2011")
-          # This must be checked before " and " pattern
-          # Look for pattern where a second publisher appears after the first complete identifier
-          # Publishers: IEEE, AIEE, ANSI, ASA, IEC, ISO, ASTM, NACE, NSF, ASHRAE, NCTA, AESC
-          publishers = %w[IEEE AIEE ANSI ASA IEC ISO ASTM NACE NSF ASHRAE NCTA
-                          AESC]
-
-          # Find all positions where publishers appear (but NOT inside parentheses)
-          # Publishers inside parentheses are part of relationship clauses, not dual published patterns
-          publisher_positions = []
-          publishers.each do |pub|
-            # Look for publisher at word boundaries (preceded by space or start of string)
-            regex = /(?:^|\s)(#{Regexp.escape(pub)})(?:\s|\/)/
-            input.scan(regex) do
-              match_pos = Regexp.last_match.begin(1)
-
-              # Check if this publisher is inside parentheses (relationship clause)
-              # Count parens before this position
-              before_match = input[0...match_pos]
-              paren_count = before_match.count("(") - before_match.count(")")
-
-              # Skip publishers inside parentheses - they're part of relationship clauses
-              next if paren_count.positive?
-
-              publisher_positions << { pos: match_pos, publisher: pub }
-            end
-          end
-
-          # If we have 2 or more publishers at distinct positions (not co-publishers with /)
-          if publisher_positions.length >= 2
-            # Sort by position
-            publisher_positions.sort_by! { |p| p[:pos] }
-
-            # Check if they're not part of a co-published pattern (Publisher1/Publisher2)
-            # by ensuring there's no slash between them
-            first_pub = publisher_positions[0]
-            second_pub = publisher_positions[1]
-
-            # Get the substring between the two publishers
-            between = input[first_pub[:pos]..(second_pub[:pos] - 1)]
-
-            # If there's no slash and no " and ", this might be space-separated dual
-            if !between.include?("/") && !between.include?(" and ")
-              # Try to split at the second publisher position
-              # Back up to find the space before the second publisher
-              split_pos = second_pub[:pos]
-              while split_pos.positive? && input[split_pos - 1] == " "
-                split_pos -= 1
-              end
-
-              first_part = input[0...split_pos].strip
-              second_part = input[split_pos..].strip
-
-              # Try to parse both parts
-              begin
-                first = parse_single(first_part)
-                second = parse_single(second_part)
-
-                # Only treat as dual if both parse successfully
-                return Identifiers::DualPublished.new(
-                  first_identifier: first,
-                  second_identifier: second,
-                )
-              rescue Parslet::ParseFailed
-                # If parsing fails, continue with normal flow
-              end
-            end
-          end
-
-          # Check for dual published patterns with " and "
-          if input.include?(" and ")
-            # DON'T split if " and " is inside parentheses (likely a relationship clause)
-            # Check if parentheses are balanced and " and " is inside them
-            paren_count = 0
-            and_outside_parens = false
-            and_position = nil
-
-            input.each_char.with_index do |char, i|
-              paren_count += 1 if char == "("
-              paren_count -= 1 if char == ")"
-
-              # Check if " and " starts at this position and we're outside parens
-              if paren_count.zero? && input[i..(i + 4)] == " and "
-                and_outside_parens = true
-                and_position = i
-                break
-              end
-            end
-
-            # Only split if " and " is outside parentheses
-            if and_outside_parens && and_position
-              # Split at the found position only (not at all " and " occurrences)
-              first_part = input[0...and_position].strip
-              second_part = input[(and_position + 5)..].strip
-
-              # Parse each part separately
-              first = parse_single(first_part)
-              second = parse_single(second_part)
-
-              return Identifiers::DualPublished.new(
-                first_identifier: first,
-                second_identifier: second,
-              )
-            end
-          end
-
-          # NEW Session 171: Check for dual published patterns with " & " (ampersand)
-          if input.include?(" & ")
-            # DON'T split if " & " is inside parentheses
-            paren_count = 0
-            ampersand_outside_parens = false
-
-            input.each_char.with_index do |char, i|
-              paren_count += 1 if char == "("
-              paren_count -= 1 if char == ")"
-
-              # Check if " & " starts at this position and we're outside parens
-              if paren_count.zero? && input[i..(i + 2)] == " & "
-                ampersand_outside_parens = true
-                break
-              end
-            end
-
-            # Only split if " & " is outside parentheses
-            if ampersand_outside_parens
-              parts = input.split(" & ")
-              if parts.length == 2
-                # Parse each part separately
-                first = parse_single(parts[0].strip)
-                second = parse_single(parts[1].strip)
-
-                return Identifiers::DualPublished.new(
-                  first_identifier: first,
-                  second_identifier: second,
-                )
-              end
-            end
-          end
-
-          # Special case: AIEE identifiers with ASA parenthetical references
-          # Pattern: "AIEE No 18-1934 (ASA C55 1934)"
-          if input.match?(/^AIEE\s+/) && input.include?("(") && input.include?("ASA")
-            main_part = input.split("(").first.strip
-            adoption_match = input.match(/\((ASA[^)]+)\)/)
-
-            if adoption_match
-              adoption_part = adoption_match.captures.first
-              # Parse the main AIEE identifier
-              begin
-                aiee_id = parse_single(main_part)
-                # Parse the ASA identifier
-                asa_id = parse_single(adoption_part)
-
-                return Identifiers::AdoptedStandard.new(
-                  ieee_identifier: aiee_id,
-                  adopted_identifier: asa_id,
-                )
-              rescue Parslet::ParseFailed
-                # If parsing fails, fall through to regular processing
-              end
-            end
+          result = PreParser.preprocess(input)
+
+          case result.dispatch
+          when :aiee_simple
+            return Aiee::Identifier.parse(result.input)
+          when :iec_ieee_copublished
+            return parse_single(result.input)
+          when :dual_semicolon
+            return build_dual(result.parts)
+          when :dual_reaffirmed
+            return build_reaffirmed(result)
+          when :dual_ire
+            return build_dual_with_reaffirmed(result)
+          when :dual_space_separated
+            return build_dual(result.parts)
+          when :dual_and
+            return build_dual(result.parts)
+          when :dual_ampersand
+            return build_dual(result.parts)
+          when :aiee_asa_adoption
+            return build_aiee_asa_adoption(result.parts)
+          when :adopted
+            return build_adopted(result.parts)
+          else
+            parse_single(result.input)
           end
+        rescue Parslet::ParseFailed
+          parse_single(input)
+        end
 
-          # Check for adopted standards (parenthetical adoptions)
-          # Only consider it an adoption if the parenthetical content looks like an identifier
-          if input.include?("(") && input.include?(")") && !input.start_with?("IEC/IEEE ")
-            # Extract the part before parentheses and the adoption part
-            main_part = input.split("(").first.strip
-            adoption_match = input.match(/\(([^)]+)\)/)
-            adoption_part = adoption_match&.captures&.first
-
-            # Check if adoption_part looks like an identifier (contains publisher or type keywords)
-            # BUT exclude revision/amendment/supersedes notes
-            # AND exclude Pattern 4 relationship types
-            if main_part && adoption_part &&
-                !adoption_part.match?(/^\s*(Revision|Revison|Amendment|Corrigendum|Corrigenda|incorporates|Incorporating|Incorporates|Adoption|Supplement|Draft Amendment|DRAFT Amendment|Draft Revision|Reaffirmation|Redesignation|redesignated as|Supersedes|Supercedes|Includes|Previously designated as|Notebooks|Standard Newspaper)/i) &&
-                (adoption_part.match?(/\b(ANSI|ISO|IEC|IEEE|AIEE|IRE|ASA|ASTM|CSA|ASME|NACE|NSF|ASHRAE|NCTA|AESC)\s/) ||
-                 adoption_part.match?(/^\s*(ANSI|ISO|IEC|IEEE|AIEE|IRE|ASA|ASTM|CSA|ASME|NACE|NSF|ASHRAE|NCTA|AESC)\b/) ||
-                 adoption_part.match?(/\bStd\s+\d+/))
-              # Parse the main IEEE identifier
-              ieee_id = parse_single(main_part)
+        # ---- dispatch constructors (used by parse) ----
 
-              # Parse comma-separated adopted identifiers
-              adopted_parts = adoption_part.split(",").map(&:strip)
-              adopted_ids = adopted_parts.map do |part|
-                if part.strip.start_with?("IEC")
-                  # Use IEC parser for IEC adoptions
-                  # Preprocess to convert "Edition X.Y" to IEC format
-                  # Pattern: "IEC 60255-24 Edition 2.0 2013-04" → "IEC 60255-24:2013-04 ED2.0"
-                  iec_part = part.dup
-                  # Replace " Edition X.Y YYYY-MM" (or similar) with ":YYYY-MM EDX.Y"
-                  iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s+([0-9-]+)/,
-                                 ':\2 ED\1')
-                  # Replace " Edition X.Y" at end (no date)
-                  iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s*$/, ' ED\1')
-                  Pubid::Iec.parse(iec_part)
-                elsif part.strip.start_with?("ANSI")
-                  # Use ANSI parser for ANSI adoptions
-                  Pubid::Ansi.parse(part)
-                else
-                  # Use IEEE parser for other adoptions
-                  parse_single(part)
-                end
-              end
+        def self.build_dual(parts)
+          first = parse_single(parts[0])
+          second = parse_single(parts[1])
+          Identifiers::DualPublished.new(
+            first_identifier: first,
+            second_identifier: second,
+          )
+        end
+        private_class_method :build_dual
 
-              return Identifiers::AdoptedStandard.new(
-                ieee_identifier: ieee_id,
-                adopted_identifiers: adopted_ids,
-              )
+        def self.build_reaffirmed(result)
+          parsed = parse_single(result.input)
+          parsed.reaffirmed = result.metadata[:reaffirmed] if parsed.class.attributes.key?(:reaffirmed)
+          parsed
+        end
+        private_class_method :build_reaffirmed
+
+        def self.build_dual_with_reaffirmed(result)
+          ieee_id = parse_single(result.parts[0])
+          ieee_id.reaffirmed = result.metadata[:reaffirmed] if ieee_id.class.attributes.key?(:reaffirmed)
+          ire_id = parse_single(result.parts[1])
+          Identifiers::DualPublished.new(
+            first_identifier: ieee_id,
+            second_identifier: ire_id,
+          )
+        end
+        private_class_method :build_dual_with_reaffirmed
+
+        def self.build_aiee_asa_adoption(parts)
+          aiee_id = parse_single(parts[0])
+          asa_id = parse_single(parts[1])
+          Identifiers::AdoptedStandard.new(
+            ieee_identifier: aiee_id,
+            adopted_identifier: asa_id,
+          )
+        end
+        private_class_method :build_aiee_asa_adoption
+
+        def self.build_adopted(parts)
+          ieee_id = parse_single(parts[0])
+          adopted_parts = parts[1].split(",").map(&:strip)
+          adopted_ids = adopted_parts.map do |part|
+            if part.start_with?("IEC")
+              Pubid::Iec.parse(normalize_iec_adoption(part))
+            elsif part.start_with?("ANSI")
+              Pubid::Ansi.parse(part)
+            else
+              parse_single(part)
             end
-            # If it doesn't look like an identifier, let the parser handle it as additional_parameters
           end
-
-          # Fall back to single identifier parsing
-          parse_single(input)
+          Identifiers::AdoptedStandard.new(
+            ieee_identifier: ieee_id,
+            adopted_identifiers: adopted_ids,
+          )
+        end
+        private_class_method :build_adopted
+
+        # "IEC 60255-24 Edition 2.0 2013-04" → "IEC 60255-24:2013-04 ED2.0"
+        def self.normalize_iec_adoption(part)
+          iec_part = part.dup
+          iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s+([0-9-]+)/, ':\2 ED\1')
+          iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s*$/, ' ED\1')
+          iec_part
         end
+        private_class_method :normalize_iec_adoption
 
         # Parse a single IEEE identifier
         def self.parse_single(input)
@@ -457,133 +226,7 @@ module Pubid
         end
 
         def to_s
-          parts = []
-
-          # Publisher(s) - handle copublisher array properly
-          if copublisher && !copublisher.empty?
-            # Copublisher is an array, join all publishers with single slash
-            parts << [publisher, *copublisher].join("/")
-          else
-            parts << publisher
-          end
-
-          # Draft status
-          parts << draft_status if draft_status
-
-          # Type - only render for IEEE/AIEE publishers, and only for non-projects
-          # Must come BEFORE code
-          should_render_type = publisher&.match?(/^(IEEE|AIEE)/)
-
-          if should_render_type && !typed_stage&.project_status && type && !type.to_s.strip.empty? && type != "P"
-            # Non-project with explicit type (Std, No, etc.)
-            type_str = type.dup
-            # Remove P prefix if somehow present
-            type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
-            parts << type_str unless type_str.strip.empty?
-          end
-
-          # Code - with P prefix for projects (concatenated, not separated)
-          if code_obj
-            result = code_obj.to_s
-
-            # Prepend P if this is a project AND code doesn't already have P
-            if typed_stage&.project_status && should_render_type && !result.start_with?("P")
-              result = "P#{result}"
-            end
-
-            # Only attach year to code if there's no edition, no month, and no draft
-            result += "-#{year}" if year && !draft_obj && !edition && !month
-
-            # Append draft to code - with or without space based on original format
-            if draft_obj
-              result += space_before_draft ? " #{draft_obj}" : draft_obj.to_s
-            end
-
-            # Append interpretation notation (/INT)
-            result += "/INT" if interpretation
-
-            # Append conformance notation (/ConformanceNN-YYYY)
-            if conf_number
-              result += "/Conformance#{conf_number}"
-              result += "-#{conf_year}" if conf_year
-            end
-
-            # Append ASHRAE joint publication (/ASHRAE Guideline NN-YYYY)
-            if ashrae_number
-              result += "/ASHRAE Guideline #{ashrae_number}"
-              result += "-#{ashrae_year}" if ashrae_year
-            end
-
-            # Append IEEE cross-reference (/C62.22.1-1996)
-            result += crossref if crossref
-
-            parts << result
-          elsif should_render_type && typed_stage&.project_status
-            # No code but is a project - add standalone P
-            parts << "P"
-          end
-
-          # Edition - with year if present (IEC style)
-          if edition
-            edition_str = "Edition #{edition}"
-            if year
-              edition_str += " #{year}"
-              edition_str += "-#{edition_month}" if edition_month
-            end
-            parts << edition_str
-          end
-
-          # Build the main identifier (without month yet)
-          result = parts.join(" ")
-
-          # Month/Day - append directly to avoid extra space before comma
-          if month
-            # Format: ", Month Day, Year" or ", Month, Year"
-            result += ", #{month}"
-            result += " #{day}" if day
-            if year && !edition
-              # Add comma after month if year follows
-              result += ", #{year}"
-            end
-          end
-
-          # Add parenthetical content if present
-          # Handle multiple parenthetical clauses (reaffirmed + relationships/revision)
-          parentheticals = []
-
-          reaff = reaffirmed
-          if reaff && !reaff.to_s.strip.empty?
-            parentheticals << "(R#{reaff})"
-          end
-
-          # Then add relationships/revision/amendment as second parenthetical
-          if parenthetical_content
-            parentheticals << "(#{parenthetical_content})"
-          elsif relationships && !relationships.empty?
-            # Render relationships (multiple separated by /)
-            relationship_str = relationships.join(" / ")
-            parentheticals << "(#{relationship_str})"
-          elsif revision_of
-            parentheticals << "(Revision of IEEE Std #{revision_of})"
-          elsif amendment_to
-            parentheticals << "(Amendment to IEEE Std #{amendment_to})"
-          elsif adoption
-            parentheticals << "(Adoption of #{adoption})"
-          elsif note && !note.to_s.strip.empty?
-            # Only add note if it doesn't duplicate other content
-            parentheticals << "(#{note})"
-          end
-
-          # Append all parentheticals with space separation
-          result += " #{parentheticals.join(' ')}" unless parentheticals.empty?
-
-          # Book nickname - outside parentheses in square brackets
-          result += " [#{nickname}]" if nickname && !nickname.to_s.strip.empty?
-
-          # Redline suffix
-          result += " - Redline" if redline
-
-          result
+          render(format: :human)
         end
       end
     end

data/lib/pubid/ieee/identifiers/conformance_identifier.rb

@@ -21,13 +21,7 @@ module Pubid
         ].freeze
 
         def to_s
-          return base_identifier.to_s unless base_identifier
-
-          # Format: BASE/ConformanceNN-YEAR
-          result = base_identifier.to_s
-          result += "/Conformance#{conf_number}" if conf_number
-          result += "-#{conf_year}" if conf_year
-          result
+          render(format: :human)
         end
       end
     end

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

@@ -21,15 +21,7 @@ module Pubid
         ].freeze
 
         def to_s
-          return super unless base_identifier
-
-          # Format: BASE/Cor NUMBER-YEAR or BASE/Cor. NUMBER-YEAR
-          result = base_identifier.to_s
-          result += "/Cor"
-          result += ". " if cor_number # Add period and space for formal format
-          result += cor_number if cor_number
-          result += "-#{cor_year}" if cor_year
-          result
+          render(format: :human)
         end
       end
     end

data/lib/pubid/ieee/identifiers/csa_dual_published.rb

@@ -33,13 +33,7 @@ module Pubid
         end
 
         def to_s
-          # Format: IEEE_IDENTIFIER/CSA CSA_IDENTIFIER
-          # The CSA identifier should render with "CSA" prefix
-          csa_str = csa_identifier.to_s
-          # Ensure CSA prefix is present
-          csa_str = "CSA #{csa_str}" unless csa_str.start_with?("CSA", "CAN/")
-
-          "#{ieee_identifier}/#{csa_str}"
+          render(format: :human)
         end
 
         def self.parse(string)

data/lib/pubid/ieee/identifiers/dual_identifier.rb

@@ -10,7 +10,7 @@ module Pubid
         attribute :second_identifier, Base, polymorphic: true
 
         def to_s
-          "#{first_identifier} and #{second_identifier}"
+          render(format: :human)
         end
       end
     end

data/lib/pubid/ieee/identifiers/dual_published.rb

@@ -15,7 +15,7 @@ module Pubid
         attribute :second_identifier, Base, polymorphic: true
 
         def to_s
-          "#{first_identifier} and #{second_identifier}"
+          render(format: :human)
         end
 
         def publisher

data/lib/pubid/ieee/identifiers/iec_ieee_copublished.rb

@@ -14,12 +14,7 @@ module Pubid
         attribute :date_info, :string           # Date information like "(10/07)"
 
         def to_s
-          result = "IEC/IEEE"
-          result += " #{copublished_number}" if copublished_number
-          result += draft_info if draft_info
-          result += " IEC:#{iec_year}" if iec_year
-          result += " #{date_info}" if date_info
-          result
+          render(format: :human)
         end
       end
     end