hecks 3.4.2 → 3.6.0

data/lib/hecks/bluebook/pattern_subset.rb

@@ -1,106 +1,92 @@
+require_relative "pattern_subset/scan"
+require_relative "pattern_subset/refusals"
+
 module Hecks
   module Bluebook
     # Which regexes a bluebook `pattern:` may say: only what every engine reads the same way.
     # Backtracking-only and ASCII/Unicode-dependent constructs are refused.
     module PatternSubset
-      Rejection = Struct.new(:construct, :reason)
-
-      REASONS = {
-        backreference:
-                             "backreferences cannot be matched in linear time and portable " \
-                             "engines refuse them ; a declared pattern may not depend on one",
-        named_backreference:
-                             "a named backreference is still a backreference — it cannot be " \
-                             "matched in linear time ; a declared pattern may not depend on one",
-        perl_class:
-                             "engines read it in OPPOSITE directions : ASCII in some and " \
-                             "Unicode in others, so an Arabic-Indic digit satisfies one and not " \
-                             "the other. Spell the range you mean — [0-9], [A-Za-z0-9_], [ \t] " \
-                             "— which every engine reads the same way",
-        posix_class:
-                             "[:digit:] and friends flip between ASCII and Unicode across " \
-                             "engines — the mirror of the perl classes, and wrong in the same " \
-                             "way. Spell the range you mean",
-        lookahead:
-                             "lookahead cannot be matched in linear time and portable engines " \
-                             "refuse it ; a declared pattern may not depend on it",
-        lookbehind:
-                             "lookbehind cannot be matched in linear time and portable engines " \
-                             "refuse it ; a declared pattern may not depend on it",
-        atomic_group:
-                             "an atomic group is a backtracking-engine control knob — " \
-                             "linear-time engines reject `(?>` as a syntax error",
-        possessive:
-                             "a possessive quantifier is a backtracking-engine control knob — " \
-                             "linear-time engines reject it as a syntax error"
-      }.freeze
-
       module_function
 
       # Returns nil when the pattern is admitted, a Rejection when it is not.
       #
       # One ordered character walk defines the subset; an escaped construct is a literal,
       # which is why each backslash pair is stepped over rather than matched as a whole.
-      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       #
       # @param pattern [String, Symbol, #to_s] the declared `pattern:` regex source
       # @return [Rejection, nil] the reason the pattern is refused, or `nil` if admitted
       def validate(pattern)
-        chars = pattern.to_s.chars
-        index = 0
-        # Inside `[...]` quantifier characters are literals, and `]` closes the class unless
-        # it is the first character after `[` or `[^`.
-        in_class = false
-        class_start = nil
-
-        while index < chars.length
-          if chars[index] == "\\"
-            nxt = chars[index + 1]
-            return refuse(:backreference)        if nxt&.match?(/[1-9]/)
-            return refuse(:named_backreference)  if %w[k g].include?(nxt)
-            return refuse(:perl_class)           if %w[d D w W s S].include?(nxt)
-
-            index += nxt ? 2 : 1
-            next
-          end
-
-          if in_class
-            if chars[index] == "]" && index != class_start
-              in_class = false
-              index += 1
-              next
-            end
-
-            return refuse(:posix_class) if posix_class_at?(chars, index)
-
-            index += 1
-            next
-          end
-
-          if chars[index] == "["
-            return refuse(:posix_class) if posix_class_at?(chars, index)
-
-            in_class = true
-            class_start = index + 1
-            class_start += 1 if chars[class_start] == "^"
-            index += 1
-            next
-          end
-
-          if chars[index] == "(" && chars[index + 1] == "?"
-            return refuse(:lookahead)    if %w[= !].include?(chars[index + 2])
-            return refuse(:lookbehind)   if chars[index + 2] == "<" && %w[= !].include?(chars[index + 3])
-            return refuse(:atomic_group) if chars[index + 2] == ">"
-          end
-
-          return refuse(:possessive) if possessive_at?(chars, index)
-
-          index += 1
+        scan = Scan.new(pattern.to_s.chars)
+        until scan.done?
+          key = read_step(scan)
+          return refuse(key) if key
         end
+        nil
+      end
+
+      # Reads one construct, advancing `scan` past it.
+      #
+      # @return [Symbol, nil] the refusal key when the construct is outside the subset
+      def read_step(scan)
+        return escape_step(scan) if scan.char == "\\"
+        return class_step(scan) if scan.in_class?
+        return open_class_step(scan) if scan.char == "["
+
+        plain_step(scan)
+      end
+
+      def escape_step(scan)
+        nxt = scan.peek
+        key = escape_refusal(nxt)
+        scan.take(nxt ? 2 : 1) unless key
+        key
+      end
+
+      def escape_refusal(nxt)
+        return :backreference if nxt&.match?(/[1-9]/)
+        return :named_backreference if %w[k g].include?(nxt)
+
+        :perl_class if %w[d D w W s S].include?(nxt)
+      end
+
+      def class_step(scan)
+        if scan.closing_bracket?
+          scan.leave_class
+          scan.take
+          return nil
+        end
+
+        key = :posix_class if posix_class_at?(scan.chars, scan.index)
+        scan.take
+        key
+      end
 
+      def open_class_step(scan)
+        return :posix_class if posix_class_at?(scan.chars, scan.index)
+
+        scan.enter_class
+        scan.take
         nil
       end
 
+      def plain_step(scan)
+        key = group_refusal(scan.chars, scan.index) || (:possessive if possessive_at?(scan.chars, scan.index))
+        scan.take
+        key
+      end
+
+      # @return [Symbol, nil] the refusal key for a `(?=`, `(?!`, `(?<=`, `(?<!` or `(?>` group
+      def group_refusal(chars, index)
+        return unless chars[index] == "(" && chars[index + 1] == "?"
+        return :lookahead if %w[= !].include?(chars[index + 2])
+        return :lookbehind if chars[index + 2] == "<" && %w[= !].include?(chars[index + 3])
+
+        :atomic_group if chars[index + 2] == ">"
+      end
+
+      # How a line anchor is rewritten to a whole-string anchor.
+      ANCHORS = { "^" => "\\A", "$" => "\\z" }.freeze
+
       # Rewrites the line anchors of a declared pattern into whole-string anchors.
       #
       # Ruby reads `^` and `$` as line anchors, so `"ok\n../evil"` satisfies `^[a-z]+$`; Rust's
@@ -110,48 +96,26 @@ module Hecks
       # @param pattern [String, Symbol, #to_s] the declared `pattern:` regex source
       # @return [String] the source with `^` as `\A` and `$` as `\z` outside classes
       def whole_string(pattern)
-        chars = pattern.to_s.chars
-        in_class = false
-        class_start = nil
+        scan = Scan.new(pattern.to_s.chars)
         out = +""
-        index = 0
-        while index < chars.length
-          char = chars[index]
-          if char == "\\"
-            out << char << chars[index + 1].to_s
-            index += 2
-            next
-          end
-          if in_class
-            in_class = false if char == "]" && index != class_start
-          elsif char == "["
-            in_class = true
-            class_start = index + 1
-            class_start += 1 if chars[class_start] == "^"
-          elsif char == "^"
-            char = "\\A"
-          elsif char == "$"
-            char = "\\z"
-          end
-          out << char
-          index += 1
-        end
+        out << anchored(scan) until scan.done?
         out
       end
 
-      # Spelled out, not derived from the key: callers read these strings in refusals.
-      CONSTRUCTS = {
-        backreference:       "backreference",
-        named_backreference: "named backreference",
-        perl_class:          "perl character class",
-        posix_class:         "posix bracket class",
-        lookahead:           "lookahead",
-        lookbehind:          "lookbehind",
-        atomic_group:        "atomic group",
-        possessive:          "possessive quantifier"
-      }.freeze
-
-      def refuse(key) = Rejection.new(CONSTRUCTS.fetch(key), REASONS.fetch(key))
+      # Reads one character (or an escaped pair) and answers what it becomes.
+      def anchored(scan)
+        return scan.take(2) if scan.char == "\\"
+
+        if scan.in_class?
+          scan.leave_class if scan.closing_bracket?
+          scan.take
+        elsif scan.char == "["
+          scan.enter_class
+          scan.take
+        else
+          ANCHORS.fetch(scan.char) { scan.char }.tap { scan.take }
+        end
+      end
 
       def posix_class_at?(chars, index)
         return false unless chars[index] == "[" && chars[index + 1] == ":"
@@ -172,24 +136,19 @@ module Hecks
 
       # Length of a `{n}` / `{n,}` / `{n,m}` bound at `index`, or nil if there is none.
       def bounded_quantifier_length(chars, index)
-        cursor = index + 1
-        digit_seen = false
-
-        while chars[cursor]&.match?(/[0-9]/)
-          digit_seen = true
-          cursor += 1
-        end
-        return nil unless digit_seen
-
-        if chars[cursor] == ","
-          cursor += 1
-          cursor += 1 while chars[cursor]&.match?(/[0-9]/)
-        end
+        cursor = skip_digits(chars, index + 1)
+        return nil if cursor == index + 1
 
+        cursor = skip_digits(chars, cursor + 1) if chars[cursor] == ","
         return nil unless chars[cursor] == "}"
 
         cursor - index + 1
       end
+
+      def skip_digits(chars, cursor)
+        cursor += 1 while chars[cursor]&.match?(/[0-9]/)
+        cursor
+      end
     end
   end
 end

data/lib/hecks/bluebook/process_manager.rb

@@ -1,5 +1,6 @@
 require_relative "behaviour/process_manager"
 require_relative "../ir"
+require_relative "keyword_fields"
 
 module Hecks
   module Bluebook
@@ -33,7 +34,7 @@ module Hecks
     Saga = Struct.new(:trigger, :from_state, :to_state, :compensations, keyword_init: true) do
       def undoes = compensations.map(&:command_name)
 
-      def to_s = "#{trigger} → #{to_state} (#{undoes.join(', ')})"
+      def to_s = "#{trigger} → #{to_state} (#{undoes.join(", ")})"
     end
 
     # The built form of a `process_manager "Name" do ... end` block, made by
@@ -59,18 +60,18 @@ module Hecks
 
       attr_reader :name, :correlates_by, :starts_on, :ends_on, :states, :handlers
 
+      # Every optional keyword and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        correlates_by: nil, starts_on: nil, ends_on: nil, states: [], handlers: []
+      }.freeze
+
       # @param correlates_by [Symbol, nil] the payload field that correlates a triggering
       #   event to an instance
       # @param starts_on [String, nil] the event that starts a new instance
       # @param ends_on [String, nil] the event that ends an instance
-      def initialize(name:, correlates_by: nil, starts_on: nil, ends_on: nil,
-                     states: [], handlers: [])
-        @name          = name.to_s
-        @correlates_by = correlates_by
-        @starts_on     = starts_on
-        @ends_on       = ends_on
-        @states        = states
-        @handlers      = handlers
+      def initialize(name:, **given)
+        KeywordFields.assign(self, KeywordFields.fill(given, FIELD_DEFAULTS))
+        @name = name.to_s
       end
     end
   end

data/lib/hecks/bluebook/project_discovery.rb

@@ -20,16 +20,19 @@ module Hecks
       def bluebook_directories
         found = []
         Find.find(root) do |path|
-          if File.directory?(path)
-            if SKIPPED_DIRECTORIES.include?(File.basename(path))
-              Find.prune
-            elsif File.basename(path) == "bluebook" && Dir.glob(File.join(path, "*.bluebook")).any?
-              found << path
-            end
-          end
+          next unless File.directory?(path)
+
+          Find.prune if SKIPPED_DIRECTORIES.include?(File.basename(path))
+          found << path if bluebook_directory?(path)
         end
         found.sort
       end
+
+      private
+
+      def bluebook_directory?(path)
+        File.basename(path) == "bluebook" && Dir.glob(File.join(path, "*.bluebook")).any?
+      end
     end
   end
 end

data/lib/hecks/bluebook/project_register.rb

@@ -41,58 +41,59 @@ module Hecks
       # @raise [Runtime::WiringError] if a second tenant registers the same directory while
       #   an aggregate binds to an adapter that is not `tenant_capable?`
       def register(bluebooks, registry, dispatcher, directory)
-        bluebooks.each do |bluebook|
-          refuse_unless_safe_for_second_tenant!(bluebook, registry, directory)
-          world = registry.world(bluebook.name)
-          realm = world&.realm
-          raise MissingRealm, "#{bluebook.name} in #{directory} has no world realm" if realm.to_s.empty?
-          if world.latest && bluebook.version && world.latest != bluebook.version
-            raise LatestMismatch,
-                  "#{bluebook.name} in #{directory} declares latest #{world.latest.inspect}, not #{bluebook.version.inspect}"
-          end
-
-          bluebook.aggregates.each { |aggregate| register_aggregate!(aggregate, bluebook, world, realm, directory, dispatcher) }
-          bluebook.read_models.each { |model| register_read_model!(model, bluebook, world, realm, directory, dispatcher) }
-        end
+        bluebooks.each { |bluebook| register_bluebook(bluebook, registry, dispatcher, directory) }
         self
       end
 
       private
 
-      def register_aggregate!(aggregate, bluebook, world, realm, directory, dispatcher)
+      # The bluebook being registered and where it is registered from.
+      Context = Struct.new(:bluebook, :world, :realm, :directory, :dispatcher)
+
+      def register_bluebook(bluebook, registry, dispatcher, directory)
+        refuse_unless_safe_for_second_tenant!(bluebook, registry, directory)
+        world = registry.world(bluebook.name)
+        realm = world&.realm
+        raise MissingRealm, "#{bluebook.name} in #{directory} has no world realm" if realm.to_s.empty?
+
+        refuse_latest_mismatch!(bluebook, world, directory)
+        register_declarations(Context.new(bluebook, world, realm, directory, dispatcher))
+      end
+
+      def register_declarations(context)
+        context.bluebook.aggregates.each { |aggregate| register_aggregate!(aggregate, context) }
+        context.bluebook.read_models.each do |model|
+          register_pair!(context, :query, model.query_name, model.query_name)
+        end
+      end
+
+      def refuse_latest_mismatch!(bluebook, world, directory)
+        return unless world.latest && bluebook.version && world.latest != bluebook.version
+
+        raise LatestMismatch,
+              "#{bluebook.name} in #{directory} declares latest #{world.latest.inspect}, not #{bluebook.version.inspect}"
+      end
+
+      def register_aggregate!(aggregate, context)
         aggregate.commands.each do |command|
-          if bluebook.version
-            add(Fqn.command(realm: realm, domain: bluebook.name, version: bluebook.version,
-                            aggregate: aggregate.hecks_name, command: command.hecks_name),
-                directory, dispatcher, command.hecks_name, bluebook.version)
-          end
-          if current?(bluebook, world)
-            add(Fqn.command(realm: realm, domain: bluebook.name, aggregate: aggregate.hecks_name,
-                            command: command.hecks_name), directory, dispatcher, command.hecks_name, bluebook.version)
-          end
+          register_pair!(context, :command, command.hecks_name, command.hecks_name, aggregate: aggregate.hecks_name)
         end
         aggregate.queries.each do |query|
-          name = Naming.snake(query.name)
-          if bluebook.version
-            add(Fqn.query(realm: realm, domain: bluebook.name, version: bluebook.version,
-                          aggregate: aggregate.hecks_name, query: name), directory, dispatcher, query.name, bluebook.version)
-          end
-          if current?(bluebook, world)
-            add(Fqn.query(realm: realm, domain: bluebook.name, aggregate: aggregate.hecks_name,
-                          query: name), directory, dispatcher, query.name, bluebook.version)
-          end
+          register_pair!(context, :query, Naming.snake(query.name), query.name, aggregate: aggregate.hecks_name)
         end
       end
 
-      def register_read_model!(model, bluebook, world, realm, directory, dispatcher)
-        if bluebook.version
-          add(Fqn.query(realm: realm, domain: bluebook.name, version: bluebook.version,
-                        query: model.query_name), directory, dispatcher, model.query_name, bluebook.version)
-        end
-        if current?(bluebook, world)
-          add(Fqn.query(realm: realm, domain: bluebook.name, query: model.query_name),
-              directory, dispatcher, model.query_name, bluebook.version)
-        end
+      # Registers the versioned FQN of one command or query, then its unversioned one when the
+      # bluebook is the current version.
+      def register_pair!(context, kind, name, declared_verb, **scope)
+        bluebook = context.bluebook
+        register_fqn!(context, kind, name, declared_verb, **scope, version: bluebook.version) if bluebook.version
+        register_fqn!(context, kind, name, declared_verb, **scope) if current?(bluebook, context.world)
+      end
+
+      def register_fqn!(context, kind, name, declared_verb, **scope)
+        fqn = Fqn.public_send(kind, realm: context.realm, domain: context.bluebook.name, **scope, kind => name)
+        add(fqn, context.directory, context.dispatcher, declared_verb, context.bluebook.version)
       end
 
       # A directory's first registration is never refused; only a second one (another tenant

data/lib/hecks/bluebook/query.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/query"
+require_relative "keyword_fields"
 
 module Hecks
   # Reopened to add `render_value`, the wire-literal rendering `emits_ir` procs use.
@@ -27,22 +28,28 @@ module Hecks
 
       attr_reader :name, :description, :attributes, :returns, :needs
 
+      # Every optional keyword and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        description: nil, attributes: [], wheres: [], order_by: nil, limit: nil, offset: nil,
+        cursor: nil, authorization: nil, null_semantics: nil, inspection: nil, returns: nil, needs: []
+      }.freeze
+
+      # The keywords the `Options` base takes; the rest belong to the query itself.
+      OPTION_KEYS = [:wheres, :order_by, :limit, :offset, :cursor, :authorization, :null_semantics,
+                     :inspection].freeze
+
       # @param null_semantics [QuerySpecification::Common::NullSemantics, nil] defaults to
       #   `NullSemantics.default`
-      def initialize(name:, description: nil, attributes: [], wheres: [],
-                     order_by: nil, limit: nil, offset: nil, cursor: nil,
-                     authorization: nil, null_semantics: nil,
-                     inspection: nil, returns: nil, needs: [])
-        null_semantics ||= QuerySpecification::Common::NullSemantics.default
-        super(wheres: wheres, order_by: order_by, limit: limit, offset: offset, cursor: cursor,
-              authorization: authorization,
-              null_semantics: null_semantics, inspection: inspection)
+      def initialize(name:, **given)
+        fields = KeywordFields.fill(given, FIELD_DEFAULTS)
+        fields[:null_semantics] ||= QuerySpecification::Common::NullSemantics.default
+        super(**fields.slice(*OPTION_KEYS))
         @name        = name.to_s
         @hecks_name  = @name
-        @description = description
-        @attributes  = attributes
-        @returns     = returns&.to_s
-        @needs       = needs
+        @description = fields[:description]
+        @attributes  = fields[:attributes]
+        @returns     = fields[:returns]&.to_s
+        @needs       = fields[:needs]
       end
 
       # The value object a `returns` names, without the `list_of(...)` wrapper.

data/lib/hecks/bluebook/read_model.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/read_model"
+require_relative "keyword_fields"
 
 module Hecks
   module Bluebook
@@ -25,6 +26,18 @@ module Hecks
                   :count, :median_field, :sum_field, :avg_field, :min_field, :max_field,
                   :percentile_field, :percentile_at, :any_field, :all_field
 
+      # Every optional keyword of its own and what it holds when the declaration omits it;
+      # any other keyword goes to the specification base.
+      FIELD_DEFAULTS = {
+        description: nil, reference_name: nil, reference_target: nil, aggregate_heads: [], group_by: [],
+        count: nil, median_field: nil, sum_field: nil, avg_field: nil, min_field: nil,
+        max_field: nil, percentile_field: nil, percentile_at: nil, any_field: nil, all_field: nil
+      }.freeze
+
+      # The reduction keywords, among `FIELD_DEFAULTS`, that `assign_reductions` reads.
+      REDUCTION_KEYS = [:count, :median_field, :sum_field, :avg_field, :min_field, :max_field,
+                        :percentile_field, :percentile_at, :any_field, :all_field].freeze
+
       # Nil `reference_name`/`reference_target` mean a rootless read model, so `&.` keeps
       # them nil. `count` through `all_field` are `Behaviour::ReadModel::REDUCTION_FIELDS`,
       # one keyword per wire field: `Assembly::Build`/`Reconstruction` construct this
@@ -36,23 +49,16 @@ module Hecks
       # @param reference_target [String, Symbol, nil] the rooted aggregate's name
       # @param aggregate_heads [Array<Hash{Symbol => Object}>] rows of `:aggregate`, `:as`, `:many`
       # @param group_by [Array<Hash{field: Symbol}>] the declared group-by fields, one row each
-      # rubocop:disable-next Metrics/ParameterLists
-      def initialize(name:, description: nil, reference_name: nil, reference_target: nil, aggregate_heads: [],
-                     group_by: [], count: nil, median_field: nil, sum_field: nil, avg_field: nil,
-                     min_field: nil, max_field: nil, percentile_field: nil, percentile_at: nil,
-                     any_field: nil, all_field: nil, **)
-        super(joins: aggregate_heads, **)
+      def initialize(name:, **given)
+        fields = KeywordFields.fill(given.slice(*FIELD_DEFAULTS.keys), FIELD_DEFAULTS)
+        super(joins: fields[:aggregate_heads], **given.except(*FIELD_DEFAULTS.keys))
         @name             = name.to_s
         @hecks_name       = @name
-        @description      = description
-        @reference_name   = reference_name&.to_sym
-        @reference_target = reference_target&.to_s
-        @aggregate_heads  = aggregate_heads
-        # Rows are `{field: :agg}` hashes, the same shape as `aggregate_heads`.
-        @group_by         = group_by
-        assign_reductions(count: count, median_field: median_field, sum_field: sum_field, avg_field: avg_field,
-                          min_field: min_field, max_field: max_field, percentile_field: percentile_field,
-                          percentile_at: percentile_at, any_field: any_field, all_field: all_field)
+        # `group_by` rows are `{field: :agg}` hashes, the same shape as `aggregate_heads`.
+        KeywordFields.assign(self, fields.slice(:description, :aggregate_heads, :group_by))
+        @reference_name   = fields[:reference_name]&.to_sym
+        @reference_target = fields[:reference_target]&.to_s
+        assign_reductions(**fields.slice(*REDUCTION_KEYS))
       end
 
       # Every reduction is omitted from the export, not nil, when undeclared, so
@@ -72,33 +78,29 @@ module Hecks
       private
 
       # Stays nil (never false) when undeclared: the Judge skips setters whose source is nil.
-      def assign_reductions(count:, median_field:, sum_field:, avg_field:, min_field:, max_field:,
-                            percentile_field:, percentile_at:, any_field:, all_field:)
-        @count            = count ? true : nil
-        @median_field     = median_field&.to_sym
-        @sum_field        = sum_field&.to_sym
-        @avg_field        = avg_field&.to_sym
-        @min_field        = min_field&.to_sym
-        @max_field        = max_field&.to_sym
-        @percentile_field = percentile_field&.to_sym
-        @percentile_at    = percentile_at&.to_f
-        @any_field        = any_field&.to_sym
-        @all_field        = all_field&.to_sym
+      def assign_reductions(count:, percentile_at:, **fields)
+        @count         = count ? true : nil
+        @percentile_at = percentile_at&.to_f
+        fields.each { |key, value| instance_variable_set(:"@#{key}", value&.to_sym) }
       end
 
       def reduction_pairs
-        pairs = {}
-        pairs[:count] = true if @count
-        pairs[:median_field] = @median_field.to_s if @median_field
-        pairs[:sum_field] = @sum_field.to_s if @sum_field
-        pairs[:avg_field] = @avg_field.to_s if @avg_field
-        pairs[:min_field] = @min_field.to_s if @min_field
-        pairs[:max_field] = @max_field.to_s if @max_field
-        pairs[:percentile_field] = @percentile_field.to_s if @percentile_field
-        pairs[:percentile_at] = @percentile_at if @percentile_field
-        pairs[:any_field] = @any_field.to_s if @any_field
-        pairs[:all_field] = @all_field.to_s if @all_field
-        pairs
+        REDUCTION_KEYS.each_with_object({}) do |key, pairs|
+          pairs[key] = emitted_reduction(key) if declared_reduction?(key)
+        end
+      end
+
+      # `percentile_at` is emitted whenever its field is, even if the point itself is nil.
+      def declared_reduction?(key)
+        gate = key == :percentile_at ? :percentile_field : key
+        instance_variable_get(:"@#{gate}") ? true : false
+      end
+
+      def emitted_reduction(key)
+        value = instance_variable_get(:"@#{key}")
+        return value if key == :percentile_at
+
+        key == :count ? true : value.to_s
       end
     end
   end