memory_profiler 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 841f12f37a8d6ee73594fc0e9ab8718a1d79fb01
-  data.tar.gz: ecb6925b365225274bfca91f11161d9dd83cd5d9
+  metadata.gz: f7e1c880efe5b674c1d8281a7f8659ca224abafe
+  data.tar.gz: 37e0a418e082d1fd1af188a0966efdc9e97c92d8
 SHA512:
-  metadata.gz: 87d5d6cb856bf78f196edef91c06d04ab8ad239d2c124cb1233ceeb90e8363a0deaccfd1a00d10ad68290e84b008ae83e9312fbb6b6a89d1fe433edb7aeb72b5
-  data.tar.gz: 68125449269c55e6f9e18299ba43bd4d743eb3f5a3e49558b7d7ef2b339a8942355678480ee52f40d72d74512cb347c5bad17ff9fd1f81d357f19ee4d10cb9f9
+  metadata.gz: e900a6abc28f73ceffc12dae74ba7cb416c53930b5eb9703d00b25a075afda2f9137f6a4f52f6958b91b9afa057c9fc4845227517c147226a1ab99de7dc384c3
+  data.tar.gz: 915bd319992cbfa7ba1f38a64ae8a5e83358a1bb390f67ac283dfe70cab03463e1698e869a73641f563c4a9aaa29d5b0732049e29341d46c4de1d61f042b2089

data/README.md

@@ -35,7 +35,14 @@ report.pretty_print
 
 ## Options
 
-You can use `allow_files` option for displaying only lines which contain string or array with strings:
+The report method can take a few options:
+
+* `top`: maximum number of entries to display in a report (default is 50)
+* `allow_files`: include only certain files from tracing - can be given as a String, Regexp, or array of Strings
+* `ignore_files`: exclude certain files from tracing - can be given as a String or Regexp
+* `trace`: an array of classes for which you explicitly want to trace object allocations
+
+Check out `Reporter#new` for more details.
 
 ```
 pry> require 'memory_profiler'
@@ -77,14 +84,6 @@ rubygems x 305879
 . . .
 ```
 
-Other options include:
-
-* `top`: maximum number of entries to display in a report
-* `trace`: an array of classes for which you explicitly want to trace object allocations
-* `ignore_files`: a regular expression used to exclude certain files from tracing (opposite of `allow_files`)
-
-Check out `Reporter#new` for more details.
-
 ## Example Session
 
 You can easily use memory_profiler to profile require impact of a gem, for example:
@@ -366,6 +365,9 @@ Memory profiler also performs some String analysis to help you find strings that
 
 ## Changelog
 
+### 0.9.5
+- Improved stability and performance @dgynn
+
 ### 0.9.4
 - FIX: remove incorrect RVALUE offset on 2.2  @dgynn
 - FEATURE: add total memory usage @dgynn
@@ -380,7 +382,6 @@ Memory profiler also performs some String analysis to help you find strings that
 - This is quite stable, upping version to reflect
 - Fixed bug where it would crash when location was nil for some reason
 
-
 ### 0.0.4
 - Added compatibility with released version of Ruby 2.1.0
 - Cleanup to use latest APIs available in 2.1.0

data/lib/memory_profiler/helpers.rb

@@ -1,37 +1,32 @@
 module MemoryProfiler
-  module Helpers
-    def self.guess_gem(path)
-      if /(\/gems\/.*)*\/gems\/(?<gem>[^\/]+)/ =~ path
-        gem
-      elsif /\/rubygems\// =~ path
-        "rubygems"
-      elsif /(?<app>[^\/]+\/(bin|app|lib))/ =~ path
-        app
-      else
-        "other"
-      end
+  class Helpers
+
+    def initialize
+      @gem_guess_cache = Hash.new
+      @location_cache = Hash.new { |h,k| h[k] = Hash.new.compare_by_identity }
+      @class_name_cache = Hash.new.compare_by_identity
     end
 
-    # helper to work around GC.start not freeing everything
-    def self.full_gc
-      # TODO: discuss with @tmm1 and @ko1 if the while loop is needed
-      GC.start(full_mark: true) while new_count = decreased_count(new_count)
+    def guess_gem(path)
+      @gem_guess_cache[path] ||=
+        if /(\/gems\/.*)*\/gems\/(?<gemname>[^\/]+)/ =~ path
+          gemname
+        elsif /\/rubygems[\.\/]/ =~ path
+          "rubygems".freeze
+        elsif /(?<app>[^\/]+\/(bin|app|lib))/ =~ path
+          app
+        else
+          "other".freeze
+        end
     end
 
-    def self.decreased_count(old)
-      count = count_objects
-      if !old || count < old
-        count
-      else
-        nil
-      end
+    def lookup_location(file, line)
+      @location_cache[file][line] ||= "#{file}:#{line}"
     end
 
-    def self.count_objects
-      i = 0
-      ObjectSpace.each_object do |obj|
-        i += 1
-      end
+    def lookup_class_name(klass)
+      @class_name_cache[klass] ||= klass.name || '<<Unknown>>'
     end
+
   end
 end

data/lib/memory_profiler/reporter.rb

@@ -1,9 +1,8 @@
 require 'objspace'
 module MemoryProfiler
-  # Reporter is the top level api used for generating memory reports
+  # Reporter is the top level API used for generating memory reports.
   #
   # @example Measure object allocation in a block
-  #
   #   report = Reporter.report(top: 50) do
   #     5.times { "foo" }
   #   end
@@ -12,84 +11,71 @@ module MemoryProfiler
 
     def initialize(opts = {})
       @top          = opts[:top] || 50
-      @trace        = opts[:trace]
-      @ignore_files = opts[:ignore_files]
-      @allow_files = Array(opts[:allow_files])
+      @trace        = opts[:trace] && Array(opts[:trace])
+      @ignore_files = opts[:ignore_files] && Regexp.new(opts[:ignore_files])
+      @allow_files  = opts[:allow_files] && /#{Array(opts[:allow_files]).join('|')}/
     end
 
-    # Helper for generating new reporter and running against block
+    # Helper for generating new reporter and running against block.
+    # @param [Hash] opts the options to create a report with
+    # @option opts :top max number of entries to output
+    # @option opts :trace a class or an array of classes you explicitly want to trace
+    # @option opts :ignore_files a regular expression used to exclude certain files from tracing
+    # @option opts :allow_files a string or array of strings to selectively include in tracing
+    # @return [MemoryProfiler::Results]
     def self.report(opts={}, &block)
       self.new(opts).run(&block)
     end
 
     # Collects object allocation and memory of ruby code inside of passed block.
-    #
-    # @param [Hash] opts the options to create a message with.
-    # @option opts [Fixnum] :top max number of entries to output in report
-    # @option opts [Array <Class>] :trace an array of classes you explicitly want to trace
-    # @return [MemoryProfiler::Results]
     def run(&block)
 
-      allocated, rvalue_size = nil
-
-      rvalue_size = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
-      Helpers.full_gc
+      GC.start
       GC.disable
 
+      generation = GC.count
       ObjectSpace.trace_object_allocations do
-        generation = GC.count
         block.call
-        allocated = object_list(generation, rvalue_size)
       end
-
-      results = Results.new
-      results.strings_allocated = results.string_report(allocated, top)
+      allocated = object_list(generation)
+      retained = StatHash.new.compare_by_identity
 
       GC.enable
+      GC.start
 
-      Helpers.full_gc
+      # Caution: Do not allocate any new Objects between the call to GC.start and the completion of the retained
+      #          lookups. It is likely that a new Object would reuse an object_id from a GC'd object.
 
-      retained = StatHash.new
       ObjectSpace.each_object do |obj|
+        next unless ObjectSpace.allocation_generation(obj) == generation
         begin
           found = allocated[obj.__id__]
           retained[obj.__id__] = found if found
         rescue
           # __id__ is not defined on BasicObject, skip it
-          # we can probably trasplant the object_id at this point,
+          # we can probably transplant the object_id at this point,
           # but it is quite rare
         end
       end
+      ObjectSpace.trace_object_allocations_clear
 
+      results = Results.new
       results.register_results(allocated, retained, top)
       results
     end
 
-    def trace_all?
-      !trace
-    end
-
-    def ignore_file?(file)
-      return true if file == __FILE__
-      @ignore_files && @ignore_files =~ file
-    end
-
-    def allow_file?(file)
-      return true if @allow_files.empty?
-      !/#{@allow_files.join('|')}/.match(file).to_s.empty?
-    end
+    private
 
     # Iterates through objects in memory of a given generation.
     # Stores results along with meta data of objects collected.
-    def object_list(generation, rvalue_size)
+    def object_list(generation)
 
-      results = StatHash.new
       objs = []
 
       ObjectSpace.each_object do |obj|
-        next unless generation == ObjectSpace.allocation_generation(obj)
+        next unless ObjectSpace.allocation_generation(obj) == generation
         begin
-          if trace_all? || trace.include?(obj.class)
+          if !trace || trace.include?(obj.class)
             objs << obj
           end
         rescue
@@ -97,29 +83,40 @@ module MemoryProfiler
         end
       end
 
+      rvalue_size = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
+      rvalue_size_adjustment = RUBY_VERSION < '2.2' ? rvalue_size : 0
+      helper = Helpers.new
+
+      result = StatHash.new.compare_by_identity
+
       objs.each do |obj|
-        file = ObjectSpace.allocation_sourcefile(obj)
-        next if !allow_file?(file) || ignore_file?(file)
+        file = ObjectSpace.allocation_sourcefile(obj) || "(no name)".freeze
+        next if @ignore_files && @ignore_files =~ file
+        next if @allow_files && !(@allow_files =~ file)
 
         line       = ObjectSpace.allocation_sourceline(obj)
-        class_path = ObjectSpace.allocation_class_path(obj)
-        method_id  = ObjectSpace.allocation_method_id(obj)
+        location   = helper.lookup_location(file, line)
+        klass      = obj.class
+        class_name = helper.lookup_class_name(klass)
+        gem        = helper.guess_gem(file)
+        string     = '' << obj  if klass == String
 
-        class_name = obj.class.name rescue "BasicObject"
         begin
           object_id = obj.__id__
 
-          memsize = ObjectSpace.memsize_of(obj)
-          memsize += rvalue_size if RUBY_VERSION < '2.2'.freeze
+          memsize = ObjectSpace.memsize_of(obj) + rvalue_size_adjustment
           # compensate for API bug
           memsize = rvalue_size if memsize > 100_000_000_000
-          results[object_id] = Stat.new(class_name, file, line, class_path, method_id, memsize)
+          result[object_id] = MemoryProfiler::Stat.new(class_name, gem, file, location, memsize, string)
         rescue
           # __id__ is not defined, give up
         end
       end
 
-      results
+      # Although `objs` will go out of scope, clear the array so objects can definitely be GCd
+      objs.clear
+
+      result
     end
   end
 end

data/lib/memory_profiler/results.rb

@@ -1,89 +1,69 @@
 module MemoryProfiler
   class Results
 
-    def self.register_type(name, lookup)
-      ["allocated", "retained"].product(["objects", "memory"]).each do |type, metric|
-        full_name = "#{type}_#{metric}_by_#{name}"
-        attr_accessor full_name
-
-        @@lookups ||= []
-        mapped = lookup
-
-        if metric == "memory"
-          mapped = lambda { |stat|
-            [lookup.call(stat), stat.memsize]
-          }
-        end
-
-        @@lookups << [full_name, mapped]
+    def self.register_type(name, stat_attribute)
+      @@lookups ||= []
+      @@lookups << [name, stat_attribute]
 
+      ["allocated", "retained"].product(["objects", "memory"]).each do |type, metric|
+        attr_accessor "#{type}_#{metric}_by_#{name}"
       end
     end
 
-    register_type :gem, lambda { |stat|
-                        Helpers.guess_gem("#{stat.file}")
-                      }
-
-    register_type :file, lambda { |stat|
-                         stat.file || "(no name)"
-                       }
-
-    register_type :location, lambda { |stat|
-                             "#{stat.file}:#{stat.line}"
-                           }
-
-    register_type :class, lambda { |stat|
-                             "#{stat.class_name}"
-                           }
+    register_type 'gem', :gem
+    register_type 'file', :file
+    register_type 'location', :location
+    register_type 'class', :class_name
 
     attr_accessor :strings_retained, :strings_allocated
     attr_accessor :total_retained, :total_allocated
     attr_accessor :total_retained_memsize, :total_allocated_memsize
 
-    def self.from_raw(allocated, retained, top)
-      self.new.register_results(allocated, retained, top)
-    end
-
     def register_results(allocated, retained, top)
-      @@lookups.each do |name, lookup|
-        mapped = lambda { |tuple|
-          lookup.call(tuple[1])
-        }
-
-        result =
-            if name =~ /^allocated/
-              allocated.top_n(top, &mapped)
-            else
-              retained.top_n(top, &mapped)
-            end
-
-        self.send "#{name}=", result
+
+      @@lookups.each do |name, stat_attribute|
+
+        memsize_results, count_results = allocated.top_n(top, stat_attribute)
+
+        self.send("allocated_memory_by_#{name}=", memsize_results)
+        self.send("allocated_objects_by_#{name}=", count_results)
+
+        memsize_results, count_results = retained.top_n(top, stat_attribute)
+
+        self.send("retained_memory_by_#{name}=", memsize_results)
+        self.send("retained_objects_by_#{name}=", count_results)
       end
 
+
+      self.strings_allocated = string_report(allocated, top)
       self.strings_retained = string_report(retained, top)
 
-      self.total_allocated = allocated.count
-      self.total_allocated_memsize = allocated.values.map(&:memsize).inject(:+) || 0
-      self.total_retained = retained.count
-      self.total_retained_memsize = retained.values.map(&:memsize).inject(:+) || 0
+      self.total_allocated = allocated.size
+      self.total_allocated_memsize = allocated.values.map!(&:memsize).inject(0, :+)
+      self.total_retained = retained.size
+      self.total_retained_memsize = retained.values.map!(&:memsize).inject(0, :+)
 
       self
     end
 
-    StringStat = Struct.new(:string, :count, :location)
-
     def string_report(data, top)
-      data
-          .reject { |id, stat| stat.class_name != "String" }
-          .map { |id, stat| [begin; ObjectSpace._id2ref(id); rescue; "__UNKNOWN__"; end, "#{stat.file}:#{stat.line}"] }
-          .group_by { |string, location| string }
-          .sort_by { |string, list| -list.count }
+      data.values
+          .keep_if { |stat| stat.string_value }
+          .map! { |stat| [stat.string_value, stat.location] }
+          .group_by { |string, _location| string }
+          .sort_by {|string, list| [-list.size, string] }
           .first(top)
-          .map { |string, list| [string, list.group_by { |str, location| location }
-          .map { |location, locations| [location, locations.count] }] }
+          .map { |string, list| [string, list.group_by { |_string, location| location }
+                                             .map { |location, locations| [location, locations.size] }
+                                ]
+          }
     end
 
-    def pretty_print(io = STDOUT, **options)
+    # Output the results of the report
+    # @param [Hash] options the options for output
+    # @option opts [String] :to_file a path to your log file
+    # @option opts [Boolean] :color_output a flag for whether to colorize output
+    def pretty_print(io = STDOUT, options = {})
       io = File.open(options[:to_file], "w") if options[:to_file]
 
       color_output = options.fetch(:color_output) { io.respond_to?(:isatty) && io.isatty }
@@ -116,7 +96,7 @@ module MemoryProfiler
       io.puts @colorize.line("-----------------------------------")
       strings.each do |string, stats|
         io.puts "#{stats.reduce(0) { |a, b| a + b[1] }.to_s.rjust(10)}  #{@colorize.string((string[0..200].inspect))}"
-        stats.sort_by { |x, y| -y }.each do |location, count|
+        stats.sort_by { |x, y| [-y, x] }.each do |location, count|
           io.puts "#{@colorize.path(count.to_s.rjust(10))}  #{location}"
         end
         io.puts
@@ -127,7 +107,7 @@ module MemoryProfiler
     def dump(description, data, io)
       io.puts description
       io.puts @colorize.line("-----------------------------------")
-      if data
+      if data && !data.empty?
         data.each do |item|
           io.puts "#{item[:count].to_s.rjust(10)}  #{item[:data]}"
         end

data/lib/memory_profiler/stat.rb

@@ -1,3 +1,18 @@
 module MemoryProfiler
-  Stat = Struct.new(:class_name, :file, :line, :class_path, :method_id, :memsize)
+  class Stat
+
+    attr_reader :class_name, :gem, :file, :location, :memsize, :string_value
+
+    def initialize(class_name, gem, file, location, memsize, string_value)
+      @class_name = class_name
+      @gem = gem
+
+      @file = file
+      @location = location
+
+      @memsize = memsize
+      @string_value = string_value
+    end
+
+  end
 end

data/lib/memory_profiler/top_n.rb

@@ -1,54 +1,21 @@
 module MemoryProfiler
   module TopN
-    # Efficient mechanism for finding top_n entries in a list
-    # optional block can specify custom element and weight
-    def top_n(max = 10)
+    # Fast approach for determining the top_n entries in a Hash of Stat objects.
+    # Returns results for both memory (memsize summed) and objects allocated (count) as a tuple.
+    def top_n(max, metric)
 
-      sorted =
-        if block_given?
-          self.map { |row|
-            yield(row)
-          }
-        else
-          self.dup
-        end
+      stats_by_metric = self.values.map! { |stat| [stat.send(metric), stat.memsize] }
 
-      sorted.compact!
-      sorted.sort!
+      stat_totals = stats_by_metric.group_by { |metric_value, _memsize| metric_value }.
+          map { |key, values| [key, values.reduce(0) { |sum, item| _key, memsize = item ; sum + memsize }, values.size] }
 
-      found = []
+      stats_by_memsize = stat_totals.sort_by! { |metric, memsize, _count| [-memsize, metric] }.first(max).
+          map! { |metric, memsize, _count| { data: metric, count: memsize } }
+      stats_by_count = stat_totals.sort_by! { |metric, _memsize, count| [-count, metric] }.first(max).
+          map! { |metric, _memsize, count| { data: metric, count: count } }
 
-      last = sorted[0]
-      count = 0
-      lowest_count = 0
+      [stats_by_memsize, stats_by_count]
 
-      sorted << nil
-
-      sorted.each do |row|
-
-        current_item, current_count = row
-
-        unless current_item == last
-          if count > lowest_count
-            found << {data: last, count: count}
-          end
-
-          if found.length > max
-            found.sort!{|x,y| x[:count] <=> y[:count] }
-            found.delete_at(0)
-            lowest_count = found[0][:count]
-          end
-
-          count = 0
-          last = current_item
-        end
-
-        count += (current_count || 1) unless row.nil?
-      end
-
-      found
-        .sort!{|x,y| x[:count] <=> y[:count] }
-        .reverse
     end
   end
 end

data/lib/memory_profiler/version.rb

@@ -1,3 +1,3 @@
 module MemoryProfiler
-  VERSION = "0.9.4"
+  VERSION = "0.9.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memory_profiler
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-05 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,20 +80,15 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Memory profiling routines for Ruby Head
+description: Memory profiling routines for Ruby 2.1+
 email:
 - sam.saffron@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- Gemfile
-- Guardfile
 - LICENSE.txt
 - README.md
-- Rakefile
 - lib/memory_profiler.rb
 - lib/memory_profiler/helpers.rb
 - lib/memory_profiler/monochrome.rb
@@ -104,14 +99,7 @@ files:
 - lib/memory_profiler/stat_hash.rb
 - lib/memory_profiler/top_n.rb
 - lib/memory_profiler/version.rb
-- memory_profiler.gemspec
-- test/test_helper.rb
-- test/test_helpers.rb
-- test/test_reporter.rb
-- test/test_results.rb
-- test/test_stat_hash.rb
-- test/test_top_n.rb
-homepage: ''
+homepage: https://github.com/SamSaffron/memory_profiler
 licenses:
 - MIT
 metadata: {}
@@ -123,7 +111,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -131,14 +119,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: Memory profiling routines for Ruby Head
-test_files:
-- test/test_helper.rb
-- test/test_helpers.rb
-- test/test_reporter.rb
-- test/test_results.rb
-- test/test_stat_hash.rb
-- test/test_top_n.rb
+summary: Memory profiling routines for Ruby 2.1+
+test_files: []

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.0
-script: 'bundle exec rake test'

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in memory_profiler.gemspec
-gemspec

data/Guardfile

@@ -1,7 +0,0 @@
-guard :minitest do
-  # with Minitest::Unit
-  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
-  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/test_#{m[2]}.rb" }
-  watch(%r{^test/test_helper\.rb$})      { 'test' }
-
-end

data/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new do |t|
-  t.pattern = "test/test_*.rb"
-end
-
-task default: "test"

data/memory_profiler.gemspec

@@ -1,26 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'memory_profiler/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "memory_profiler"
-  spec.version       = MemoryProfiler::VERSION
-  spec.authors       = ["Sam Saffron"]
-  spec.email         = ["sam.saffron@gmail.com"]
-  spec.description   = %q{Memory profiling routines for Ruby Head}
-  spec.summary       = %q{Memory profiling routines for Ruby Head}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-minitest"
-end

data/test/test_helper.rb

@@ -1,3 +0,0 @@
-require 'memory_profiler'
-require 'minitest/pride'
-require 'minitest/autorun'

data/test/test_helpers.rb

@@ -1,32 +0,0 @@
-require_relative 'test_helper'
-
-module MemoryProfiler
-
-  class TestHelpers < Minitest::Test
-    def assert_gem_parse(expected, path)
-      assert_equal(expected, Helpers.guess_gem(path))
-    end
-
-    def test_rubygems_parse
-      assert_gem_parse( "rubygems",
-                        "/home/sam/.rbenv/versions/ruby-head/lib/ruby/2.1.0/rubygems/version.rb")
-    end
-
-    def test_standard_parse
-      assert_gem_parse( "rails_multisite",
-                        "/home/sam/Source/discourse/vendor/gems/rails_multisite/lib")
-    end
-
-    def test_another_standard_parse
-      assert_gem_parse( "activesupport-3.2.12",
-                        "/home/sam/.rbenv/versions/ruby-head/lib/ruby/gems/2.1.0/gems/activesupport-3.2.12/lib/active_support/dependencies.rb")
-    end
-
-    def test_app_path_parse
-      assert_gem_parse( "discourse/app",
-                        "/home/sam/Source/discourse/app/assets")
-    end
-
-  end
-
-end

data/test/test_reporter.rb

@@ -1,101 +0,0 @@
-require_relative 'test_helper'
-
-class TestReporter < Minitest::Test
-
-  class Foo; end
-
-  def allocate_strings(n)
-    n.times do
-      ""
-    end
-  end
-
-  def test_counts
-    a = nil
-    result = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-      a = "hello"
-    end
-    assert_equal(11, result.total_allocated)
-    assert_equal(1, result.total_retained)
-    assert_equal(1, result.retained_objects_by_location.length)
-  end
-
-  def test_class_tracing
-    result = MemoryProfiler::Reporter.report(:trace => [Foo]) do
-      "hello"
-      "hello"
-      Foo.new
-    end
-    assert_equal(1, result.total_allocated)
-    assert_equal(0, result.total_retained)
-  end
-
-  def test_ignore_file
-    result = MemoryProfiler::Reporter.report(:ignore_files => /test_reporter\.rb/) do
-      "hello"
-      "hello"
-      Foo.new
-    end
-
-    assert_equal(0, result.total_allocated)
-    assert_equal(0, result.total_retained)
-  end
-
-  def test_no_color_output
-    report = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-    end
-    io = StringIO.new
-    report.pretty_print io, color_output: false
-    assert(!io.string.include?("\033"), 'excludes color information')
-  end
-
-  def test_color_output
-    report = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-    end
-    io = StringIO.new
-    report.pretty_print io, color_output: true
-    assert(io.string.include?("\033"), 'includes color information')
-  end
-
-  class StdoutMock < StringIO
-    def isatty
-      true
-    end
-  end
-
-  def test_color_output_defaults_to_true_when_run_from_tty
-    report = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-    end
-    io = StdoutMock.new
-    report.pretty_print io
-    assert(io.string.include?("\033"), 'includes color information')
-  end
-
-  def test_mono_output_defaults_to_true_when_not_run_from_tty
-    report = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-    end
-    io = StringIO.new
-    report.pretty_print io
-    assert(!io.string.include?("\033"), 'excludes color information')
-  end
-
-  def test_reports_can_be_reused_with_different_color_options
-    report = MemoryProfiler::Reporter.report do
-      allocate_strings(10)
-    end
-
-    io = StringIO.new
-    report.pretty_print io, color_output: true
-    assert(io.string.include?("\033"), 'includes color information')
-
-    io = StringIO.new
-    report.pretty_print io, color_output: false
-    assert(!io.string.include?("\033"), 'excludes color information')
-  end
-
-end

data/test/test_results.rb

@@ -1,9 +0,0 @@
-require_relative 'test_helper'
-
-class TestResults < Minitest::Test
-  def test_pretty_print_works
-    io = StringIO.new
-    MemoryProfiler::Results.new.pretty_print io
-  end
-
-end

data/test/test_stat_hash.rb

@@ -1,6 +0,0 @@
-require_relative 'test_helper'
-
-class TestStatHash < Minitest::Test
-
-
-end

data/test/test_top_n.rb

@@ -1,39 +0,0 @@
-require_relative 'test_helper'
-
-class ArrayWithTopN < Array
-  include MemoryProfiler::TopN
-end
-
-class TestTopN < Minitest::Test
-
-  def tn(*vals)
-    ArrayWithTopN.new.concat(vals)
-  end
-
-  def test_top_n
-    data = tn( 7,1,2,2,3,3,99,3 )
-    results = data.top_n(2)
-
-    assert_equal([{data: 3, count: 3}, {data: 2, count: 2}], results)
-  end
-
-  def test_top_n_with_block
-    data = tn( 0,3,6,1,4,2 )
-
-    results = data.top_n(2) do |r|
-      r%3
-    end
-
-    assert_equal([{data: 0, count: 3}, {data: 1, count: 2}], results)
-  end
-  def test_top_n_with_block_and_size
-    data = tn( [1,100], [1,10], [2,1], [2,1], [2,1],[3,100] )
-
-    results = data.top_n(2) do |r|
-      r
-    end
-
-    assert_equal([{data: 1, count: 110}, {data: 3, count: 100}], results)
-  end
-
-end