pubid 2.0.1 → 2.0.3

data/lib/pubid/nist/caster.rb

@@ -128,7 +128,16 @@ module Pubid
                                                  id: value[:owmwp_year])
           { first_number: Components::Code.new(value: number_part), edition: edition_part }
 
-        when :first_number, :second_number
+        # The polymorphic number wrappers split per branch in the grammar
+        # (asme's designator/designator_code pattern): first_number /
+        # second_number (string) arrive over the bare branches,
+        # first_number_composite / second_number_composite (raw) over the
+        # branches carrying inner captures. The composite keys map onto
+        # the same dispatch.
+        when :first_number, :first_number_composite, :second_number,
+             :second_number_composite
+          type = :first_number if type == :first_number_composite
+          type = :second_number if type == :second_number_composite
           return nil if value.nil? || value.to_s.strip.empty?
 
           # NEW: Handle OWMWP date-based number (nested hash structure)
@@ -1039,8 +1048,9 @@ module Pubid
 
         when :edition_month, :edition_year, :edition_day, :edition_has_rev
           # These work together: edition_month + edition_year -> single edition ID
-          # Skip processing if this is edition_month alone (will be processed with edition_year)
-          return nil if type == :edition_month
+          # Skip processing if this is edition_month or edition_day alone
+          # (both are consumed by the edition_year branch via parsed_hash)
+          return nil if type == :edition_month || type == :edition_day
 
           # Process edition_year, combining with edition_month if present
           return nil if value.nil? || value.to_s.strip.empty?

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

@@ -346,7 +346,7 @@ module Pubid
       # @param format [:full, :long, :abbreviated, :short, :mr] output format
       def to_s(format = nil)
         # Handle both keyword argument (hash) and positional argument (symbol/string)
-        annotated = format.is_a?(Hash) ? format[:annotated] : nil
+        flags = plain_render_flags(format)
         format = format[:format] if format.is_a?(Hash)
 
         # Default to parsed_format if available (preserves input format on round-trip)
@@ -358,7 +358,42 @@ module Pubid
         # NIST's `to_s` takes a POSITIONAL format and its `render` override
         # builds no rendering context, so neither the flag nor the context
         # reaches the shared hook. Apply the annotation fallback here.
-        annotate_plain_render(rendered, annotated: annotated)
+        annotate_plain_render(rendered, **flags)
+      end
+
+      # The keyword flags a positional-format `to_s` hands to
+      # `annotate_plain_render`. Ruby fills the positional `format` with a
+      # Hash when a caller passes keywords, so they arrive here.
+      #
+      # `with_publisher: false` cuts the leading `NIST`/`NBS` from the
+      # finished string ({#publisher_prefixes}), which covers every place a
+      # NIST style prints a publisher — the compound `NBS …` series, the
+      # `default_publisher` subclasses and a supplement's base — in one
+      # step.
+      def plain_render_flags(format)
+        return {} unless format.is_a?(Hash)
+
+        format.slice(:annotated, :with_publisher)
+      end
+      private :plain_render_flags
+
+      # The MR style (`NIST.SP.800-53`) is a fixed machine form and ignores
+      # `with_publisher:`. The test reads the OUTPUT, not the requested
+      # format: several subclasses pick their style themselves (an id parsed
+      # from an MR string still renders the short style), so the format a
+      # caller asked for does not say which style came back.
+      def apply_with_publisher(result, format, with_publisher)
+        mr_style = result.is_a?(String) && result.match?(/\A(?:NIST|NBS)\./)
+        return result if mr_style
+
+        super
+      end
+      private :apply_with_publisher
+
+      # Every leading publisher token a NIST short style can print: the
+      # parsed publisher, and the two `default_publisher` values.
+      def publisher_prefixes
+        [publisher.to_s, "NIST", "NBS"]
       end
 
       # NIST has its own defined MR format (to_mr_style) used by relaton-nist

data/lib/pubid/nist/identifiers/circular.rb

@@ -57,7 +57,7 @@ module Pubid
           # string: with the flag set, `super` returns a string ending in
           # "</span>" and the anchor no longer matches. Render plain, rewrite,
           # then annotate.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] if format.is_a?(Hash)
 
           result = super(format)
@@ -72,7 +72,7 @@ module Pubid
                                  "e#{edition.id || '?'}.#{edition.additional_text}")
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

data/lib/pubid/nist/identifiers/circular_supplement.rb

@@ -41,7 +41,7 @@ module Pubid
           # Hash. Normalise it away before `super`, so the annotation is applied
           # once, here, and covers the date-range branch too — that branch
           # returns a hand-composed string and never reached `super` at all.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] || :short if format.is_a?(Hash)
 
           # Handle date range supplements (no base identifier)
@@ -52,7 +52,7 @@ module Pubid
                      super(format)
                    end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

data/lib/pubid/nist/identifiers/commercial_standards_monthly.rb

@@ -45,7 +45,7 @@ module Pubid
           # a Hash — Ruby converts keywords for a method that accepts none.
           # The same idiom `Identifiers::Base#to_s` uses. This renderer
           # ignores `format`, so only the flag is read.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           result = "#{publisher} #{series}"
 
@@ -61,7 +61,7 @@ module Pubid
             result += " #{vol_str}n#{issue_number.number}"
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

data/lib/pubid/nist/identifiers/crpl_report.rb

@@ -91,7 +91,7 @@ module Pubid
           # a Hash — Ruby converts keywords for a method that accepts none.
           # The same idiom `Identifiers::Base#to_s` uses. This renderer
           # ignores `format`, so only the flag is read.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           # Use actual series attribute if it contains subseries (e.g., "CRPL-F-B")
           # Otherwise use default series_code ("CRPL")
@@ -129,7 +129,7 @@ module Pubid
           result += append_short_components
 
           result += range_notation if range_notation
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -38,7 +38,7 @@ module Pubid
           # string: with the flag set, `super` returns a string ending in
           # "</span>" and the anchor no longer matches. Render plain, rewrite,
           # then annotate.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] if format.is_a?(Hash)
 
           # Use the base to_s method first
@@ -50,7 +50,7 @@ module Pubid
                                  "#{edition.type}#{edition.id}-#{edition.additional_text}")
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

data/lib/pubid/nist/identifiers/internal_report.rb

@@ -40,7 +40,7 @@ module Pubid
           # `super` is handed a SYMBOL below, so the base's annotation hook
           # never sees the flag. Capture it here and wrap what comes back —
           # exactly once, because the base returned plain text.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           # Handle both keyword argument (hash) and positional argument (symbol/string)
           effective_format = if format.is_a?(Hash)
@@ -56,7 +56,7 @@ module Pubid
                        super(effective_format)
                      end
 
-          annotate_plain_render(rendered, annotated: annotated)
+          annotate_plain_render(rendered, **flags)
         end
       end
     end

data/lib/pubid/nist/identifiers/miscellaneous_publication.rb

@@ -40,7 +40,7 @@ module Pubid
         # Hash — Ruby converts keywords for a method that accepts none. The same
         # idiom `Identifiers::Base#to_s` uses.
         def to_s(format = :short)
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] || :short if format.is_a?(Hash)
 
           rendered = case format
@@ -50,7 +50,7 @@ module Pubid
                        to_short_style
                      end
 
-          annotate_plain_render(rendered, annotated: annotated)
+          annotate_plain_render(rendered, **flags)
         end
 
         public

data/lib/pubid/nist/identifiers/monograph.rb

@@ -38,7 +38,7 @@ module Pubid
           # `super` is handed a SYMBOL below, so the base's annotation hook
           # never sees the flag. Capture it here and wrap what comes back —
           # exactly once, because the base returned plain text.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           # Handle both keyword argument (hash) and positional argument (symbol/string)
           effective_format = if format.is_a?(Hash)
@@ -56,7 +56,7 @@ module Pubid
                        super(effective_format)
                      end
 
-          annotate_plain_render(rendered, annotated: annotated)
+          annotate_plain_render(rendered, **flags)
         end
 
         private

data/lib/pubid/nist/identifiers/report.rb

@@ -43,7 +43,7 @@ module Pubid
         # Hash — Ruby converts keywords for a method that accepts none. The same
         # idiom `Identifiers::Base#to_s` uses.
         def to_s(format = :short)
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] || :short if format.is_a?(Hash)
 
           rendered = case format
@@ -53,7 +53,7 @@ module Pubid
                        to_short_style
                      end
 
-          annotate_plain_render(rendered, annotated: annotated)
+          annotate_plain_render(rendered, **flags)
         end
 
         private