allocation_stats 0.1.1

data/lib/allocation_stats/allocation.rb

@@ -0,0 +1,137 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+require "json"
+
+class AllocationStats
+  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
+
+    def file; @sourcefile; end
+    #def line; @sourceline; 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[PWD]
+        @sourcefile.sub(PWD, "<PWD>")
+      when @sourcefile[AllocationStats::RUBYLIBDIR]
+        @sourcefile.sub(AllocationStats::RUBYLIBDIR, "<RUBYLIBDIR>")
+      when @sourcefile[AllocationStats::GEMDIR]
+        @sourcefile.sub(/#{AllocationStats::GEMDIR}\/gems\/([^\/]+)\//, '<GEM:\1>/')
+      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
+
+    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
+
+    # @return [String] the name of the Rubygem where this allocation occurred.
+    # @return [nil] if this allocation did not occur in a Rubygem.
+    #
+    # Override Rubygems' Kernel#gem
+    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
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    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/lib/allocation_stats/allocations_proxy.rb

@@ -0,0 +1,289 @@
+# Copyright 2013 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
+
+    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
+
+    def alias_paths(value = nil)
+      # reader
+      return @alias_paths if value.nil?
+
+      # writer
+      @alias_paths = value
+
+      return self
+    end
+
+    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 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
+
+    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
+
+    def where(hash)
+      @wheres << Proc.new do |allocations|
+        conditions = hash.inject({}) do |h, pair|
+          faux, value = *pair
+          getter = attribute_getters([faux]).first
+          h.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
+
+    def to_json
+      to_a.to_json
+    end
+
+    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
+
+    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

data/spec/allocation_stats/allocations_proxy_spec.rb

@@ -0,0 +1,366 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+require_relative File.join("..", "spec_helper")
+SPEC_HELPER_PATH = File.expand_path(File.join(__dir__, "..", "spec_helper.rb"))
+MAX_PATH_LENGTH = [SPEC_HELPER_PATH.size, __FILE__.size].max
+
+describe AllocationStats::AllocationsProxy do
+  it "should track new objects by path" do
+    existing_array = [1,2,3,4,5]
+
+    stats = AllocationStats.trace do
+      new_string     = "stringy string"
+      another_string = "another string"
+    end
+
+    results = stats.allocations.group_by(:sourcefile).all
+    results.class.should eq Hash
+    results.keys.size.should == 1
+    results.keys.first.should eq [__FILE__]
+    results[[__FILE__]].class.should eq Array
+    results[[__FILE__]].size.should == 2
+  end
+
+  it "should track new objects by path" do
+    existing_array = [1,2,3,4,5]
+
+    stats = AllocationStats.trace do
+      new_string     = "stringy string"
+      another_string = "another string"
+      a_foreign_string = allocate_a_string_from_spec_helper
+    end
+
+    results = stats.allocations.group_by(:sourcefile).all
+    results.keys.size.should == 2
+    results.keys.should include([__FILE__])
+    results.keys.any? { |file| file[0]["spec_helper"] }.should be_true
+  end
+
+  it "should track new objects by path and class" do
+    existing_array = [1,2,3,4,5]
+
+    stats = AllocationStats.trace do
+      new_string     = "stringy string"
+      another_string = "another string"
+      an_array       = [1,1,2,3,5,8,13,21,34,55]
+      a_foreign_string = allocate_a_string_from_spec_helper
+    end
+
+    results = stats.allocations.group_by(:sourcefile, :class).all
+    results.keys.size.should == 3
+    results.keys.should include([__FILE__, String])
+    results.keys.should include([__FILE__, Array])
+  end
+
+  it "should track new objects by path and class_name (Array with 1x type)" do
+    stats = AllocationStats.trace do
+      square_groups = []
+      10.times do |i|
+        square_groups << [(4*i+0)**2, (4*i+1)**2, (4*i+2)**2, (4*i+3)**2]
+      end
+    end
+
+    results = stats.allocations.group_by(:sourcefile, :class_plus).all
+    results.keys.size.should == 2
+    results.keys.should include([__FILE__, "Array<Array>"])
+    results.keys.should include([__FILE__, "Array<Fixnum>"])
+  end
+
+  it "should track new objects by path and class_name (Array with 2-3x type)" do
+    stats = AllocationStats.trace do
+      two_classes = [1,2,3,"a","b","c"]
+      three_classes = [1,1.0,"1"]
+    end
+
+    results = stats.allocations.group_by(:sourcefile, :class_plus).all
+    results.keys.size.should == 3
+    results.keys.should include([__FILE__, "Array<Fixnum,String>"])
+    results.keys.should include([__FILE__, "Array<Fixnum,Float,String>"])
+  end
+
+  it "should track new objects by path and class_name (Arrays with same size)" do
+    stats = AllocationStats.trace do
+      ary = []
+      10.times do
+        ary << [1,2,3,4,5]
+      end
+    end
+
+    results = stats.allocations.group_by(:sourcefile, :class_plus).all
+    pending "Not written yet"
+  end
+
+  it "should track new objects by class_path, method_id and class" do
+    existing_array = [1,2,3,4,5]
+
+    stats = AllocationStats.trace do
+      new_string       = "stringy string"
+      another_string   = "another string"
+      an_array         = [1,1,2,3,5,8,13,21,34,55]
+      a_foreign_string = allocate_a_string_from_spec_helper
+    end
+
+    results = stats.allocations.group_by(:class_path, :method_id, :class).all
+    results.keys.size.should == 3
+
+    # Things allocated inside rspec describe and it blocks have nil as the
+    # method_id.
+    results.keys.should include([nil, nil, String])
+    results.keys.should include([nil, nil, Array])
+    results.keys.should include(["Object", :allocate_a_string_from_spec_helper, String])
+  end
+
+  it "should track new bytes" do
+    stats = AllocationStats.trace do
+      an_array       = [1,1,2,3,5,8,13,21,34,55]
+    end
+
+    byte_sums = stats.allocations.bytes.all
+    byte_sums.size.should == 1
+    byte_sums[0].should be 80
+  end
+
+  it "should track new bytes by path and class" do
+    stats = AllocationStats.trace do
+      new_string     = "stringy string"                      # 1: String from here
+      an_array       = [1,1,2,3,5,8,13,21,34,55]             # 2: Array from here
+      a_foreign_string = allocate_a_string_from_spec_helper  # 3: String from spec_helper
+
+      class A; end                                           # 4: Class from here
+      an_a = A.new                                           # 5: A from here
+    end
+
+    byte_sums = stats.allocations.group_by(:sourcefile, :class).bytes.all
+    byte_sums.keys.size.should == 5
+    byte_sums.keys.should include([__FILE__, Array])
+    byte_sums[[__FILE__, Array]].should eq 80  # 10 Fixnums * 8 bytes/Fixnum
+  end
+
+  it "should track new allocations in pwd" do
+    existing_array = [1,2,3,4,5]
+
+    stats = AllocationStats.trace do
+      new_string     = "stringy string"           # 1: String from here
+      another_string = "another string"
+      an_array       = [1,1,2,3,5,8,13,21,34,55]  # 2: Array from here
+      a_range        = "aaa".."zzz"
+      y = YAML.dump(["one string", "two string"]) # lots of objects not from here
+    end
+
+    results = stats.allocations.from_pwd.group_by(:class).all
+    results.keys.size.should == 3
+    results[[String]].size.should == 6
+    results[[Array]].size.should == 3  # one for empty *args in YAML.dump
+    results[[Range]].size.should == 1
+  end
+
+  it "should pass itself to Yajl::Encoder.encode correctly" do
+    pending "I don't know why this isn't passing, but it's not worth worrying about now"
+    stats = AllocationStats.trace do
+      new_hash = {0 => "foo", 1 => "bar"}
+    end
+
+    Yajl::Encoder.encode(stats.allocations.to_a).should eq \
+      "[{\"memsize\":192,\"file\":\"#{__FILE__}\",\"line\":170,\"class_plus\":\"Hash\"}," +
+        "{\"memsize\":0,\"file\":\"#{__FILE__}\",\"line\":170,\"class_plus\":\"String\"}," +
+        "{\"memsize\":0,\"file\":\"#{__FILE__}\",\"line\":170,\"class_plus\":\"String\"}]"
+  end
+
+  it "should shorten paths of stuff in RUBYLIBDIR" do
+    stats = AllocationStats.trace do
+      y = YAML.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations(alias_paths: true).group_by(:sourcefile, :class).all.keys.map(&:first)
+    files.should include("<RUBYLIBDIR>/psych/nodes/node.rb")
+  end
+
+  it "should shorten paths of stuff in gems" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations(alias_paths: true).group_by(:sourcefile, :class).all.keys.map(&:first)
+    files.should include("<GEM:yajl-ruby-1.1.0>/lib/yajl.rb")
+  end
+
+  it "should track new objects by gem" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    gems = stats.allocations.group_by(:gem, :class).all.keys.map(&:first)
+    gems.should include("yajl-ruby-1.1.0")
+    gems.should include(nil)
+  end
+
+  it "should be able to filter to just anything from pwd" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations.group_by(:sourcefile, :class).from_pwd.all.keys.map(&:first)
+    files.should_not include("<GEMDIR>/gems/yajl-ruby-1.1.0/lib/yajl.rb")
+  end
+
+  it "should be able to filter to just anything from pwd, even if from is specified before group_by" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations.from_pwd.group_by(:sourcefile, :class).all.keys.map(&:first)
+    files.should_not include("<GEMDIR>/gems/yajl-ruby-1.1.0/lib/yajl.rb")
+  end
+
+  it "should be able to filter to just one path" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations(alias_paths: true).group_by(:sourcefile, :class).from("yajl.rb").all.keys.map(&:first)
+    files.should include("<GEM:yajl-ruby-1.1.0>/lib/yajl.rb")
+  end
+
+  it "should be able to filter to just one path" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    files = stats.allocations.not_from("yajl.rb").group_by(:sourcefile, :class).all.keys.map(&:first)
+    files.should_not include("<GEMDIR>/gems/yajl-ruby-1.1.0/lib/yajl.rb")
+  end
+
+  it "should be able to filter to just one path" do
+    stats = AllocationStats.trace do
+      j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+    end
+
+    classes = stats.allocations.where(class: String).group_by(:sourcefile, :class).all.keys.map(&:last)
+    classes.should_not include(Array)
+    classes.should_not include(Hash)
+    classes.should include(String)
+  end
+
+  context "to_text" do
+    before do
+      @stats = AllocationStats.trace { MyClass.new.my_method }
+      @line = __LINE__ - 1
+    end
+
+    it "should output to fixed-width text correctly" do
+      text = @stats.allocations.to_text
+      spec_helper_plus_line = "#{SPEC_HELPER_PATH.ljust(MAX_PATH_LENGTH)}          #{MyClass::MY_METHOD_BODY_LINE}"
+
+      expect(text).to include("                                             sourcefile                                                sourceline  class_path  method_id  memsize   class")
+      expect(text).to include("-----------------------------------------------------------------------------------------------------  ----------  ----------  ---------  -------  -------")
+      expect(text).to include("#{spec_helper_plus_line}  MyClass     my_method      192  Hash")
+      expect(text).to include("#{spec_helper_plus_line}  MyClass     my_method        0  String")
+      expect(text).to include("#{__FILE__.ljust(MAX_PATH_LENGTH)}         #{@line}  Class       new              0  MyClass")
+    end
+
+    it "should output to fixed-width text with custom columns correctly" do
+      text = @stats.allocations.to_text(columns: [:sourcefile, :sourceline, :class])
+      spec_helper_plus_line = "#{SPEC_HELPER_PATH.ljust(MAX_PATH_LENGTH)}          #{MyClass::MY_METHOD_BODY_LINE}"
+
+      expect(text).to include("                                             sourcefile                                                sourceline   class")
+      expect(text).to include("#{"-" * MAX_PATH_LENGTH}  ----------  -------")
+      expect(text).to include("#{spec_helper_plus_line}  Hash")
+      expect(text).to include("#{spec_helper_plus_line}  String")
+      expect(text).to include("#{__FILE__.ljust(MAX_PATH_LENGTH)}         #{@line}  MyClass")
+    end
+
+    it "should output to fixed-width text with custom columns and aliased paths correctly" do
+      text = @stats.allocations(alias_paths: true).to_text(columns: [:sourcefile, :sourceline, :class])
+      spec_helper_plus_line = "<PWD>/spec/spec_helper.rb                                      #{MyClass::MY_METHOD_BODY_LINE}"
+
+      expect(text).to include("                     sourcefile                        sourceline   class")
+      expect(text).to include("-----------------------------------------------------  ----------  -------")
+      expect(text).to include("#{spec_helper_plus_line}  Hash")
+      expect(text).to include("#{spec_helper_plus_line}  String")
+      expect(text).to include("<PWD>/spec/allocation_stats/allocations_proxy_spec.rb         #{@line}  MyClass")
+    end
+
+    it "should output to fixed-width text after group_by correctly" do
+      text = @stats.allocations(alias_paths: true).group_by(:sourcefile, :sourceline, :class).to_text
+      spec_helper_plus_line = "<PWD>/spec/spec_helper.rb                                      #{MyClass::MY_METHOD_BODY_LINE}"
+
+      expect(text).to include("                     sourcefile                        sourceline   class   count\n")
+      expect(text).to include("-----------------------------------------------------  ----------  -------  -----\n")
+      expect(text).to include("#{spec_helper_plus_line}  Hash         1")
+      expect(text).to include("#{spec_helper_plus_line}  String       2")
+      expect(text).to include("<PWD>/spec/allocation_stats/allocations_proxy_spec.rb         #{@line}  MyClass      1")
+    end
+  end
+
+  context "to_json" do
+    before do
+      @stats = AllocationStats.trace { MyClass.new.my_method }
+      @line = __LINE__ - 1
+    end
+
+    it "should output to json correctly" do
+      json = @stats.allocations.to_json
+      expect { Yajl::Parser.parse(json) }.to_not raise_error
+    end
+
+    it "should output to json correctly" do
+      allocations = @stats.allocations.all
+      json = allocations.to_json
+      parsed = Yajl::Parser.parse(json)
+
+      first = {
+        "file" => "<PWD>/spec/spec_helper.rb",
+        "file (raw)" =>  "/usr/local/google/home/srawlins/code/allocation_stats/spec/spec_helper.rb",
+        "line" => 20,
+        "class_path" => "MyClass",
+        "method_id" => :my_method.to_s,
+        "memsize" => 192,
+        "class" => "Hash",
+        "class_plus" => "Hash"
+      }
+
+      expect(parsed.size).to be(4)
+      expect(parsed.any? { |allocation| allocation == first } ).to be_true
+    end
+  end
+
+  context "sorting" do
+    before do
+      @stats = AllocationStats.trace do
+        ary = []
+        4.times do
+          ary << [1,2,3,4,5]
+        end
+        str_1 = "string"; str_2 = "strang"
+      end
+      @lines = [__LINE__ - 6, __LINE__ - 4, __LINE__ - 2]
+    end
+
+    it "should sort Allocations that have not been grouped" do
+      results = @stats.allocations.group_by(:sourcefile, :sourceline, :class).sort_by_count.all
+
+      expect(results.keys[0]).to include(@lines[1])
+      expect(results.keys[1]).to include(@lines[2])
+      expect(results.keys[2]).to include(@lines[0])
+
+      expect(results.values[0].size).to eq(4)
+      expect(results.values[1].size).to eq(2)
+      expect(results.values[2].size).to eq(1)
+    end
+
+    it "should output to fixed-width text after group_by..sort_by_count correctly" do
+      text = @stats.allocations(alias_paths: true)
+                   .group_by(:sourcefile, :sourceline, :class)
+                   .sort_by_count
+                   .to_text.split("\n")
+      spec_file = "<PWD>/spec/allocation_stats/allocations_proxy_spec.rb       "
+
+      expect(text[0]).to eq("                     sourcefile                        sourceline  class   count")
+      expect(text[1]).to eq("-----------------------------------------------------  ----------  ------  -----")
+      expect(text[2]).to eq("#{spec_file}  #{@lines[1]}  Array       4")
+      expect(text[3]).to eq("#{spec_file}  #{@lines[2]}  String      2")
+      expect(text[4]).to eq("#{spec_file}  #{@lines[0]}  Array       1")
+    end
+  end
+end