honeybadger 4.5.3 → 4.5.4

data/vendor/bundle/ruby/2.6.0/gems/airbrussh-1.3.1/lib/airbrussh/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Airbrussh
-  VERSION = "1.3.1".freeze
-end

data/vendor/bundle/ruby/2.6.0/gems/airbrussh-1.3.1/lib/sshkit/formatter/airbrussh.rb

@@ -1,12 +0,0 @@
-require "airbrussh/formatter"
-
-# Capistrano's formatter configuration requires that the formatter class
-# be in the SSHKit::Formatter namespace. So we declare
-# SSHKit::Formatter::Airbrussh that simply functions as an alias for
-# Airbrussh::Formatter.
-module SSHKit
-  module Formatter
-    class Airbrussh < Airbrussh::Formatter
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/my_class.rb

@@ -1,6 +0,0 @@
-class MyClass
-  def my_method
-    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
-    @string = "quux"
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_my_class_group_by.rb

@@ -1,11 +0,0 @@
-class MyClass
-  def my_method
-    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
-    @string = "quux"
-  end
-end
-
-require File.join(__dir__, "..", "lib", "allocation_stats")
-
-stats = AllocationStats.trace { MyClass.new.my_method }
-puts stats.allocations.group_by(:sourcefile, :sourceline, :class).to_text

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_my_class_raw.rb

@@ -1,11 +0,0 @@
-class MyClass
-  def my_method
-    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
-    @string = "quux"
-  end
-end
-
-require File.join(__dir__, "..", "lib", "allocation_stats")
-
-stats = AllocationStats.trace { MyClass.new.my_method }
-puts stats.allocations.to_text(columns: [:sourcefile, :sourceline, :class_path, :method_id, :class])

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_object_allocations.rb

@@ -1,7 +0,0 @@
-require 'objspace'
-
-ObjectSpace.trace_object_allocations do
-  a = [2,3,5,7,11,13,17,19,23,29,31]
-  puts ObjectSpace.allocation_sourcefile(a)
-  puts ObjectSpace.allocation_sourceline(a)
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_psych_group_by.rb

@@ -1,8 +0,0 @@
-require "yaml"
-require File.join(__dir__, "..", "lib", "allocation_stats")
-
-stats = AllocationStats.trace do
-  y = YAML.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
-end
-
-puts stats.allocations(alias_paths: true).group_by(:sourcefile, :class).to_text

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_psych_keys.rb

@@ -1,8 +0,0 @@
-require "yaml"
-require File.join(__dir__, "..", "lib", "allocation_stats")
-
-stats = AllocationStats.trace do
-  y = YAML.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
-end
-
-stats.allocations.group_by(:sourcefile, :class).all.keys.each { |key| puts key.inspect }

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_specs/strings.rb

@@ -1,15 +0,0 @@
-def an_array_of_strings
-  ["foo", "bar", "baz", "qux", "quux"]
-end
-
-def foo
-  "foo"
-end
-
-def teamwork
-  "Teamwork"
-end
-
-def tea
-  "Tea"
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/examples/trace_specs/strings_spec.rb

@@ -1,15 +0,0 @@
-require "pry"
-
-require_relative File.join("..", "..", "lib", "allocation_stats")
-require_relative "strings"
-AllocationStats.trace_rspec
-
-describe "Array of Strings" do
-  it "allocates Strings and Arrays" do
-    expect(an_array_of_strings).to include(foo)
-  end
-
-  it "allocates more Strings" do
-    expect(teamwork).to include(tea)
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/lib/allocation_stats.rb

@@ -1,153 +0,0 @@
-# Copyright 2014 Google Inc. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
-
-require "objspace"
-require_relative "allocation_stats/core_ext/basic_object"
-require_relative "allocation_stats/allocation"
-require_relative "allocation_stats/allocations_proxy"
-require_relative "allocation_stats/trace_rspec"
-
-require "rubygems"
-
-# Container for an aggregation of object allocation data. Pass a block to
-# {#trace AllocationStats.new.trace}. Then use the AllocationStats object's public
-# interface to dig into the data and discover useful information.
-class AllocationStats
-  # a convenience constant
-  RUBYLIBDIR = RbConfig::CONFIG["rubylibdir"]
-
-  # a convenience constant
-  GEMDIR = Gem.dir
-
-  # @!attribute [rw] burn
-  # @return [Fixnum]
-  # burn count for block tracing. Defaults to 0. When called with a block,
-  # #trace will yield the block @burn-times before actually tracing the object
-  # allocations. This offers the benefit of pre-memoizing objects, and loading
-  # any required Ruby files before tracing.
-  attr_accessor :burn
-
-  attr_accessor :gc_profiler_report
-
-  # @!attribute [r] new_allocations
-  # @return [Array]
-  # allocation data for all new objects that were allocated
-  # during the {#initialize} block. It is better to use {#allocations}, which
-  # returns an {AllocationsProxy}, which has a much more convenient,
-  # domain-specific API for filtering, sorting, and grouping {Allocation}
-  # objects, than this plain Array object.
-  attr_reader :new_allocations
-
-  def initialize(burn: 0)
-    @burn = burn
-    # Copying ridiculous workaround from:
-    # https://github.com/ruby/ruby/commit/7170baa878ac0223f26fcf8c8bf25492415e6eaa
-    Class.name
-  end
-
-  def self.trace(&block)
-    allocation_stats = AllocationStats.new
-    allocation_stats.trace(&block)
-  end
-
-  def trace(&block)
-    if block_given?
-      trace_block(&block)
-    else
-      start
-    end
-  end
-
-  def trace_block
-    @burn.times { yield }
-
-    GC.start
-    GC.disable
-
-    @existing_object_ids = {}
-
-    ObjectSpace.each_object.to_a.each do |object|
-      @existing_object_ids[object.__id__ / 1000] ||= []
-      @existing_object_ids[object.__id__ / 1000] << object.__id__
-    end
-
-    ObjectSpace.trace_object_allocations {
-      yield
-    }
-
-    collect_new_allocations
-    ObjectSpace.trace_object_allocations_clear
-    profile_and_start_gc
-
-    return self
-  end
-
-  # Begin tracing object allocations. Tracing must be stopped with
-  # AllocationStats#stop. Garbage collection is disabled while tracing is
-  # enabled.
-  def start
-    GC.start
-    GC.disable
-
-    @existing_object_ids = {}
-
-    ObjectSpace.each_object.to_a.each do |object|
-      @existing_object_ids[object.__id__ / 1000] ||= []
-      @existing_object_ids[object.__id__ / 1000] << object.__id__
-    end
-
-    ObjectSpace.trace_object_allocations_start
-
-    return self
-  end
-
-  def collect_new_allocations
-    @new_allocations = []
-    ObjectSpace.each_object.to_a.each do |object|
-      next if ObjectSpace.allocation_sourcefile(object).nil?
-      next if ObjectSpace.allocation_sourcefile(object) == __FILE__
-      next if @existing_object_ids[object.__id__ / 1000] &&
-              @existing_object_ids[object.__id__ / 1000].include?(object.__id__)
-
-      @new_allocations << Allocation.new(object)
-    end
-  end
-
-  # Stop tracing object allocations that was started with AllocationStats#start.
-  def stop
-    collect_new_allocations
-    ObjectSpace.trace_object_allocations_stop
-    ObjectSpace.trace_object_allocations_clear
-    profile_and_start_gc
-  end
-
-  # Inspect @new_allocations, the canonical array of {Allocation} objects.
-  def inspect
-    @new_allocations.inspect
-  end
-
-  # Proxy for the @new_allocations array that allows for individual filtering,
-  # sorting, and grouping of the Allocation objects.
-  def allocations(alias_paths: false)
-    AllocationsProxy.new(@new_allocations, alias_paths: alias_paths)
-  end
-
-  def profile_and_start_gc
-    GC::Profiler.enable
-    GC.enable
-    GC.start
-    @gc_profiler_report = GC::Profiler.result
-    GC::Profiler.disable
-  end
-  private :profile_and_start_gc
-end
-
-if ENV["TRACE_PROCESS_ALLOCATIONS"]
-  $allocation_stats = AllocationStats.new.trace
-
-  at_exit do
-    $allocation_stats.stop
-    puts "Object Allocation Report"
-    puts "------------------------"
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/lib/allocation_stats/allocation.rb

@@ -1,159 +0,0 @@
-# Copyright 2014 Google Inc. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
-
-require "json"
-
-class AllocationStats
-  # Information about an individual allocation is captured in this class.
-  class Allocation
-    # a convenience constants
-    PWD = Dir.pwd
-
-    # a list of helper methods that Allocation provides on top of the object
-    # that was allocated.
-    HELPERS = [:class_plus, :gem]
-
-    # a list of attributes that Allocation has on itself; inquiries in this
-    # list should just use Allocation's attributes, rather than the internal
-    # object's.
-    ATTRIBUTES = [:sourcefile, :sourceline, :class_path, :method_id, :memsize]
-
-    # @!attribute [rw] memsize
-    # the memsize of the object which was allocated
-    attr_accessor :memsize
-
-    # @!attribute [r] class_path
-    # the classpath of where the object was allocated
-    attr_reader :class_path
-
-    # @!attribute [r] method_id
-    # the method ID of where the object was allocated
-    attr_reader :method_id
-
-    # @!attribute [r] object
-    # the actual object that was allocated
-    attr_reader :object
-
-    # @!attribute [r] sourceline
-    # the line in the sourcefile where the object was allocated
-    attr_reader :sourceline
-
-    def initialize(object)
-      @object = object
-      @memsize    = ObjectSpace.memsize_of(object)
-      @sourcefile = ObjectSpace.allocation_sourcefile(object)
-      @sourceline = ObjectSpace.allocation_sourceline(object)
-      @class_path = ObjectSpace.allocation_class_path(object)
-      @method_id  = ObjectSpace.allocation_method_id(object)
-    end
-
-    # the sourcefile where the object was allocated
-    def file; @sourcefile; end
-
-    alias :line :sourceline
-
-    # If the source file has recognized paths in it, those portions of the full
-    # path will be aliased like so:
-    #
-    # * the present work directory is aliased to "<PWD>"
-    # * the Ruby lib directory (where the standard library lies) is aliased to
-    #   "<RUBYLIBDIR>"
-    # * the Gem directory (where all gems lie) is aliased to "<GEMDIR>"
-    #
-    # @return the source file, aliased.
-    def sourcefile_alias
-      case
-      when @sourcefile[AllocationStats::RUBYLIBDIR]
-        @sourcefile.sub(AllocationStats::RUBYLIBDIR, "<RUBYLIBDIR>")
-      when @sourcefile[AllocationStats::GEMDIR]
-        @sourcefile.sub(/#{AllocationStats::GEMDIR}\/gems\/([^\/]+)\//, '<GEM:\1>/')
-      when @sourcefile[PWD]
-        @sourcefile.sub(PWD, "<PWD>")
-      else
-        @sourcefile
-      end
-    end
-
-    # Either the full source file (via `@sourcefile`), or the aliased source
-    # file, via {#sourcefile_alias}
-    #
-    # @param [TrueClass] alias_path whether or not to alias the path
-    def sourcefile(alias_path = false)
-      alias_path ? sourcefile_alias : @sourcefile
-    end
-
-    # Returns class name, plus, for Arrays, extended information. When all of
-    # the elements of the Array are instances of a total of three or fewer
-    # classes, then those classes are listed in brackets. For example:
-    #
-    # @example Array with only Fixnum and Bignum elements
-    #   allocation.class_plus  #=> "Array<Fixnum,Bignum>"
-    # @example Array with elements of class A, B, C, and D
-    #   allocation.class_plus  #=> "Array"
-    # @example String (not an Array)
-    #   allocation.class_plus  #=> "String"
-    def class_plus
-      case @object
-      when Array
-        object_classes = element_classes(@object.map {|e| e.class }.uniq)
-        if object_classes
-          "Array<#{object_classes}>"
-        else
-          "Array"
-        end
-      else
-        @object.class.name
-      end
-    end
-
-    # Override Rubygems' Kernel#gem
-    #
-    # @return [String] the name of the Rubygem where this allocation occurred.
-    # @return [nil] if this allocation did not occur in a Rubygem.
-    def gem
-      gem_regex = /#{AllocationStats::GEMDIR}#{File::SEPARATOR}
-        gems#{File::SEPARATOR}
-        (?<gem_name>[^#{File::SEPARATOR}]+)#{File::SEPARATOR}
-      /x
-      match = gem_regex.match(sourcefile)
-      match && match[:gem_name]
-    end
-
-    # Convert into a JSON string, which can be used in rack-allocation_stats's
-    # interactive mode.
-    def as_json
-      {
-        "memsize"      => @memsize,
-        "class_path"   => @class_path,
-        "method_id"    => @method_id,
-        "file"         => sourcefile_alias,
-        "file (raw)"   => @sourcefile,
-        "line"         => @sourceline,
-        "class"        => @object.class.name,
-        "class_plus"   => class_plus
-      }
-    end
-
-    # Convert into a JSON string, which can be used in rack-allocation_stats's
-    # interactive mode.
-    def to_json(*a)
-      as_json.to_json(*a)
-    end
-
-    # @return either _the one_ class passed in, the two-to-four classes passed
-    #   in separated by commas, or `nil` if more than four classes were passed
-    #   in.
-    #
-    # @api private
-    def element_classes(classes)
-      if classes.size == 1
-        classes.first
-      elsif classes.size > 1 && classes.size < 4
-        classes.join(",")
-      else
-        nil
-      end
-    end
-    private :element_classes
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/allocation_stats-0.1.5/lib/allocation_stats/allocations_proxy.rb

@@ -1,330 +0,0 @@
-# Copyright 2014 Google Inc. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
-
-class AllocationStats
-  # AllocationsProxy acts as a proxy for an array of Allocation objects. The
-  # idea behind this class is merely to provide some domain-specific methods
-  # for transforming (filtering, sorting, and grouping) allocation information.
-  # This class uses the Command pattern heavily, in order to build and maintain
-  # the list of transforms it will ultimately perform, before retrieving the
-  # transformed collection of Allocations.
-  #
-  # Chaining
-  # ========
-  #
-  # Use of the Command pattern and Procs allows for transform-chaining in any
-  # order. Apply methods such as {#from} and {#group_by} to build the internal
-  # list of transforms. The transforms will not be applied to the collection of
-  # Allocations until a call to {#to_a} ({#all}) resolves them.
-  #
-  # Filtering Transforms
-  # --------------------
-  #
-  # Methods that filter the collection of Allocations will add a transform to
-  # an Array, `@wheres`. When the result set is finally retrieved, each where
-  # is applied serially, so that `@wheres` represents a logical conjunction
-  # (_"and"_) of of filtering transforms. Presently there is no way to _"or"_
-  # filtering transforms together with a logical disjunction.
-  #
-  # Mapping Transforms
-  # ------------------
-  #
-  # Grouping Transform
-  # ------------------
-  #
-  # Only one method will allow a grouping transform: {#group_by}. Only one
-  # grouping transform is allowed; subsequent calls to {#group_by} will only
-  # replace the previous grouping transform.
-  class AllocationsProxy
-
-    # Instantiate an {AllocationsProxy} with an array of Allocations.
-    # {AllocationProxy's} view of `pwd` is set at instantiation.
-    #
-    # @param [Array<Allocation>] allocations array of Allocation objects
-    def initialize(allocations, alias_paths: false)
-      @allocations = allocations
-      @pwd = Dir.pwd
-      @wheres = []
-      @group_by = nil
-      @mappers  = []
-      @alias_paths = alias_paths
-    end
-
-    # Apply all transformations to the contained list of Allocations. This is
-    # aliased as `:all`.
-    def to_a
-      results = @allocations
-
-      @wheres.each do |where|
-        results = where.call(results)
-      end
-
-      # First apply group_by
-      results = @group_by.call(results) if @group_by
-
-      # Apply each mapper
-      @mappers.each do |mapper|
-        results = mapper.call(results)
-      end
-
-      results
-    end
-    alias :all :to_a
-
-    # If a value is passed in, @alias_paths will be set to this value, and the
-    # AllocationStats object will be returned. If no value is passed in, this
-    # will return the @alias_paths.
-    def alias_paths(value = nil)
-      # reader
-      return @alias_paths if value.nil?
-
-      # writer
-      @alias_paths = value
-
-      return self
-    end
-
-    # Sort allocation groups by the number of allocations in each group.
-    def sort_by_size
-      @mappers << Proc.new do |allocations|
-        allocations.sort_by { |key, value| -value.size }
-                   .inject({}) { |hash, pair| hash[pair[0]] = pair[1]; hash }
-      end
-
-      self
-    end
-    alias :sort_by_count :sort_by_size
-
-    # Select allocation groups which have at least `count` allocations.
-    #
-    # @param [Fixnum] count the minimum number of Allocations for each group to
-    # be selected.
-    def at_least(count)
-      @mappers << Proc.new do |allocations|
-        allocations.delete_if { |key,value| value.size < count }
-      end
-
-      self
-    end
-
-    # Select allocations for which the {Allocation#sourcefile sourcefile}
-    # includes `pattern`.
-    #
-    # `#from` can be called multiple times, adding to `@wheres`. See
-    # documentation for {AllocationsProxy} for more information about chaining.
-    #
-    # @param [String] pattern the partial file path to match against, in the
-    #   {Allocation#sourcefile Allocation's sourcefile}.
-    def from(pattern)
-      @wheres << Proc.new do |allocations|
-        allocations.select { |allocation| allocation.sourcefile[pattern] }
-      end
-
-      self
-    end
-
-    # Select allocations for which the {Allocation#sourcefile sourcefile} does
-    # not include `pattern`.
-    #
-    # `#not_from` can be called multiple times, adding to `@wheres`. See
-    # documentation for {AllocationsProxy} for more information about chaining.
-    #
-    # @param [String] pattern the partial file path to match against, in the
-    #   {Allocation#sourcefile Allocation's sourcefile}.
-    def not_from(pattern)
-      @wheres << Proc.new do |allocations|
-        allocations.reject { |allocation| allocation.sourcefile[pattern] }
-      end
-
-      self
-    end
-
-    # Select allocations for which the {Allocation#sourcefile sourcefile}
-    # includes the present working directory.
-    #
-    # `#from_pwd` can be called multiple times, adding to `@wheres`. See
-    # documentation for {AllocationsProxy} for more information about chaining.
-    def from_pwd
-      @wheres << Proc.new do |allocations|
-        allocations.select { |allocation| allocation.sourcefile[@pwd] }
-      end
-
-      self
-    end
-
-    # Group allocations by one or more attributes, that is, a list of symbols.
-    # Commonly, you might want to group allocations by:
-    #
-    # * :sourcefile, :sourceline, :class
-    # * :sourcefile, :method_id, :class
-    # * :classpath, :method_id, :class
-    #
-    # In this case, `:class` is the class of the allocated object (as opposed
-    # to `:classpath`, the classpath where the allocation occured).
-    def group_by(*args)
-      @group_keys = args
-
-      @group_by = Proc.new do |allocations|
-        getters = attribute_getters(@group_keys)
-
-        allocations.group_by do |allocation|
-          getters.map { |getter| getter.call(allocation) }
-        end
-      end
-
-      self
-    end
-
-    # Select allocations that match `conditions`.
-    #
-    # @param [Hash] conditions pairs of attribute names and values to be matched amongst allocations.
-    #
-    # @example select allocations of String objects:
-    #   allocations.where(class: String)
-    def where(conditions)
-      @wheres << Proc.new do |allocations|
-        conditions = conditions.inject({}) do |memo, pair|
-          faux, value = *pair
-          getter = attribute_getters([faux]).first
-          memo.merge(getter => value)
-        end
-
-        allocations.select do |allocation|
-          conditions.all? { |getter, value| getter.call(allocation) == value }
-        end
-      end
-
-      self
-    end
-
-    def attribute_getters(faux_attributes)
-      faux_attributes.map do |faux|
-        if faux == :sourcefile
-          lambda { |allocation| allocation.sourcefile(@alias_paths) }
-        elsif Allocation::HELPERS.include?(faux) ||
-              Allocation::ATTRIBUTES.include?(faux)
-          lambda { |allocation| allocation.__send__(faux) }
-        else
-          lambda { |allocation| allocation.object.__send__(faux) }
-        end
-      end
-    end
-    private :attribute_getters
-
-    # Map to bytes via {Allocation#memsize #memsize}. This is done in one of
-    # two ways:
-    #
-    # * If the current result set is an Array, then this transform just maps
-    #   each Allocation to its `#memsize`.
-    # * If the current result set is a Hash (meaning it has been grouped), then
-    #   this transform maps each value in the Hash (which is an Array of
-    #   Allocations) to the sum of the Allocation `#memsizes` within.
-    def bytes
-      @mappers << Proc.new do |allocations|
-        if allocations.is_a? Array
-          allocations.map(&:memsize)
-        elsif allocations.is_a? Hash
-          bytes_h = {}
-          allocations.each do |key, allocations|
-            bytes_h[key] = allocations.inject(0) { |sum, allocation| sum + allocation.memsize }
-          end
-          bytes_h
-        end
-      end
-
-      self
-    end
-
-    # default columns for the tabular output
-    DEFAULT_COLUMNS = [:sourcefile, :sourceline, :class_path, :method_id, :memsize, :class]
-
-    # columns that should be right-aligned for the tabular output
-    NUMERIC_COLUMNS = [:sourceline, :memsize]
-
-    # Resolve the AllocationsProxy (by calling {#to_a}) and return tabular
-    # information about the Allocations as a String.
-    #
-    # @param [Array<Symbol>] columns a list of columns to print out
-    #
-    # @return [String] information about the Allocations, in a tabular format
-    def to_text(columns: DEFAULT_COLUMNS)
-      resolved = to_a
-
-      # if resolved is an Array of Allocations
-      if resolved.is_a?(Array) && resolved.first.is_a?(Allocation)
-        to_text_from_plain(resolved, columns: columns)
-
-      # if resolved is a Hash (was grouped)
-      elsif resolved.is_a?(Hash)
-        to_text_from_groups(resolved)
-      end
-    end
-
-    # Resolve all transformations, and convert the resultant Array to JSON.
-    def to_json
-      to_a.to_json
-    end
-
-    # Return tabular information about the un-grouped list of Allocations.
-    #
-    # @private
-    def to_text_from_plain(resolved, columns: DEFAULT_COLUMNS)
-      getters = attribute_getters(columns)
-
-      widths = getters.each_with_index.map do |attr, idx|
-        (resolved.map { |a| attr.call(a).to_s.size } << columns[idx].to_s.size).max
-      end
-
-      text = []
-
-      text << columns.each_with_index.map { |attr, idx|
-        attr.to_s.center(widths[idx])
-      }.join("  ").rstrip
-
-      text << widths.map { |width| "-" * width }.join("  ")
-
-      text += resolved.map { |allocation|
-        getters.each_with_index.map { |getter, idx|
-          value = getter.call(allocation).to_s
-          NUMERIC_COLUMNS.include?(columns[idx]) ? value.rjust(widths[idx]) : value.ljust(widths[idx])
-        }.join("  ").rstrip
-      }
-
-      text.join("\n")
-    end
-    private :to_text_from_plain
-
-    # Return tabular information about the grouped Allocations.
-    #
-    # @private
-    def to_text_from_groups(resolved)
-      columns = @group_keys + ["count"]
-
-      keys = resolved.is_a?(Hash) ? resolved.keys : resolved.map(&:first)
-      widths = columns.each_with_index.map do |column, idx|
-        (keys.map { |group| group[idx].to_s.size } << columns[idx].to_s.size).max
-      end
-
-      text = []
-
-      text << columns.each_with_index.map { |attr, idx|
-        attr.to_s.center(widths[idx])
-      }.join("  ").rstrip
-
-      text << widths.map { |width| "-" * width }.join("  ")
-
-      text += resolved.map { |group, allocations|
-        line = group.each_with_index.map { |attr, idx|
-          NUMERIC_COLUMNS.include?(columns[idx]) ?
-            attr.to_s.rjust(widths[idx]) :
-            attr.to_s.ljust(widths[idx])
-        }.join("  ")
-
-        line << "  " + allocations.size.to_s.rjust(5)
-      }
-
-      text.join("\n")
-    end
-    private :to_text_from_groups
-  end
-end