zombie_scout 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc91be8df398812d74758f0f52b4fb5314debcbe
-  data.tar.gz: 908249e99886cd2546e40a59d6a68cbe379ed2df
+  metadata.gz: c1d48e23ce3d846d2a1bb64d2c5a698386a7ccbb
+  data.tar.gz: dec98dc4fcf229576c71c080c00e4a24e1afa7d1
 SHA512:
-  metadata.gz: a2854512c5126c80f7c33dd118ec0577adfab4adeba60c823eaa47602933eee4fc81c3c91a6b9483f927a262de8cae58524e5a7d4138475c5f718e0552310b97
-  data.tar.gz: ad6e1a064157c087b9b081c0aa889af10f85f337d47eb9beab4c52a141f9143265f0a406338cae3c6c50a0cbf9c5055750625f991e00a9fd256465eae54d51d1
+  metadata.gz: 989aedb17a61b6aa6dc899a3b9426117dc771fece220a5fb1505d5b21b36e40dde5a06af2e17a424e438fffb212b765e4500aa227f3bec11c9350081ab6e1d91
+  data.tar.gz: 973b0f339bbfef34d128924df0d66902be6c929ac96c617516f230c28c7b2ebce8761026376a11cb6b5efcf104a22a914574bbf62e24fb5c4c4c03d9ebf810e5

data/Gemfile

@@ -1,6 +1,7 @@
 source 'http://rubygems.org'
 
 gem 'parser', '~> 2.1'
+gem 'flog', '~> 4.2'
 gem 'thor', '~> 0.18'
 
 group :test do

data/Gemfile.lock

@@ -4,6 +4,9 @@ GEM
     ast (1.1.0)
     diff-lcs (1.1.3)
     fakefs (0.5.0)
+    flog (4.2.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.4)
     parser (2.1.4)
       ast (~> 1.1)
       slop (~> 3.4, >= 3.4.5)
@@ -16,6 +19,9 @@ GEM
     rspec-expectations (2.11.3)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.11.3)
+    ruby_parser (3.4.1)
+      sexp_processor (~> 4.1)
+    sexp_processor (4.4.1)
     slop (3.4.7)
     thor (0.18.1)
 
@@ -24,6 +30,7 @@ PLATFORMS
 
 DEPENDENCIES
   fakefs
+  flog (~> 4.2)
   parser (~> 2.1)
   rake
   rspec

data/README.md

@@ -14,7 +14,26 @@ parses your code to find method declarations, and then greps through your
 project's source, looking for each method.  If Zombie Scout can't find any
 calls to a method, it presumes the method is dead, and reports back to you.
 
-### Fair Warning
+### How Does It Work?
+
+#### Phase 1: Parse
+
+Zombie Scout parses your ruby files, and remembers all the methods it sees
+defined.
+
+#### Phase 2: Grep
+
+Then it greps your whole project - currently *.rb and *.erb files - for
+whole-word occurrances of any of the methods it found. The whole-word grep
+(`grep -w`) means that searching for `dead_method` won't count `dead_methods`
+as a match, and accidentally think it's live.
+
+So, if you have 1,000 methods, you have to run 1,000 greps? That's slow, right?
+Good news: back in Phase 1, when Zombie Scout parsed your code, it also
+remembered all the method CALLS it saw, and it automatically counts those
+methods as not-zombies, so it saves a bunch of time by not grepping for them.
+
+#### Fair Warning
 
 Zombie Scout isn't exhaustive or thorough - it's a scout, not a spy. (That
 could be another project, though - a Zombie Spy.)
@@ -57,23 +76,69 @@ Or, add this to your Gemfile:
 
 ## Usage
 
+### From the Command Line
+
 You can run it on a whole folder:
 
     dan@aleph:~/projects/zombie_scout$ zombie_scout scout
-    Scouting out /home/dan/projects/zombie_scout!
-    lib/zombie_scout/method_finder.rb:23    on_def
-    lib/zombie_scout/method_finder.rb:29    on_defs
-    lib/zombie_scout/method_finder.rb:35    on_send
-    lib/zombie_scout/method_finder.rb:77    on_sym
-    Scouted 23 methods in 8 files. Found 4 potential zombies.
+    Scouted 43 methods in 9 files, in 1.096459054 seconds.
+    Found 11 potential zombies, with a combined flog score of 51.5.
+
+    lib/zombie_scout/parser.rb:29   on_send 8.3
+    lib/zombie_scout/parser.rb:23   on_defs 5.9
+    lib/zombie_scout/parser.rb:65   handle_def_delegators   5.8
+    lib/zombie_scout/parser.rb:56   handle_attr_accessor    5.6
+    lib/zombie_scout/parser.rb:17   on_def  4.9
+    lib/zombie_scout/parser.rb:48   handle_attr_writer      4.3
+    lib/zombie_scout/parser.rb:40   handle_attr_reader      4.3
+    lib/zombie_scout/parser.rb:73   handle_def_delegator    3.8
+    lib/zombie_scout/parser.rb:79   handle_scope    3.8
+    lib/zombie_scout/parser.rb:100  on_sym  2.4
+    lib/zombie_scout/mission.rb:34  zombie_count    2.4
 
 (See what I meant about callbacks and false-positives?)
 
 Or you can run it on a given file or glob:
 
-    dan@aleph:~/projects/zombie_scout$ zombie_scout scout lib/zombie_scout.rb
-    Scouting out /home/dan/projects/zombie_scout!
-    Scouted 0 methods in 1 files. Found 0 potential zombies.
+    dan@aleph:~/projects/zombie_scout$ zombie_scout scout lib/app.rb
+    Scouted 1 methods in 1 files, in 0.041942649 seconds.
+    Found 0 potential zombies, with a combined flog score of 0.0.
+
+ZombieScout will also report in CSV, if you like:
+
+    dan@aleph:~/projects/zombie_scout$ zombie_scout scout --format csv
+    location,name,flog_score
+    lib/zombie_scout/parser.rb:29,on_send,8.3
+    lib/zombie_scout/parser.rb:23,on_defs,5.9
+    lib/zombie_scout/parser.rb:65,handle_def_delegators,5.8
+    lib/zombie_scout/parser.rb:56,handle_attr_accessor,5.6
+    lib/zombie_scout/parser.rb:17,on_def,4.9
+    lib/zombie_scout/parser.rb:48,handle_attr_writer,4.3
+    lib/zombie_scout/parser.rb:40,handle_attr_reader,4.3
+    lib/zombie_scout/parser.rb:73,handle_def_delegator,3.8
+    lib/zombie_scout/parser.rb:79,handle_scope,3.8
+    lib/zombie_scout/parser.rb:100,on_sym,2.4
+    lib/zombie_scout/mission.rb:34,zombie_count,2.4
+
+### In Ruby
+
+You can also embed ZombieScout in your own code, if you need that kind of
+thing:
+
+    irb> require 'zombie_scout'
+     => true
+    irb> require 'pp'
+     => true
+    irb> > pp ZombieScout::Mission.new('.').scout
+    [{:location=>"./lib/zombie_scout/parser.rb:17",
+      :name=>:on_def,
+      :flog_score=>4.9},
+     {:location=>"./lib/zombie_scout/parser.rb:23",
+      :name=>:on_defs,
+      :flog_score=>5.9},
+     {:location=>"./lib/zombie_scout/parser.rb:29",
+      :name=>:on_send,
+      :flog_score=>8.3}, ...]
 
 ## Code Status
 
@@ -84,10 +149,11 @@ Or you can run it on a given file or glob:
 * [x] parse for attr_reader/writer/accessors, & forwardables, & rails scopes
 * [ ] parse for rails delegators
 * [ ] let users configure: files to search for methods, files to search for calls...probably in `.zombie_scout`.
+* [x] option for CSV output
 
 ToThinkAbouts:
-* [ ] extract a hash-y report structure that can be used by whatever, from the default report
-* [ ] pass a method name, or a ruby class
+* [x] extract a hash-y report structure that can be used by whatever, from the default report
+* [x] pass a ruby file, or a glob
 * [ ] rspec/mini-test drop-in tests that can be added easily, to fail your
   build if the scout or spy finds dead code. (This is probably a bad idea.)
 

data/Rakefile

@@ -4,3 +4,7 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new
 
 task :default => :spec
+
+task :console do
+  sh('irb -I lib -r zombie_scout')
+end

data/bin/zombie_scout

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby 
+#!/usr/bin/env ruby
 require 'rubygems'
 require 'zombie_scout'
 

data/lib/zombie_scout/app.rb

@@ -4,8 +4,30 @@ require 'zombie_scout/mission'
 module ZombieScout
   class App < Thor
     desc "scout", "scout for zombie code in current directory"
+    option :format, default: 'report'
     def scout(*globs)
-      Mission.new(globs).scout
+      mission = Mission.new(globs)
+      report = mission.scout.sort_by { |z| -z[:flog_score] }
+
+      if options[:format] == 'report'
+        total_flog_score = report.map { |z| z[:flog_score] }.reduce(0, :+)
+
+        puts "Scouted #{mission.defined_method_count} methods in #{mission.source_count} files, in #{mission.duration} seconds."
+        puts "Found #{report.size} potential zombies, with a combined flog score of #{total_flog_score.round(1)}."
+        puts
+
+        report.each do |zombie|
+          puts [zombie[:location], zombie[:name], zombie[:flog_score]] * "\t"
+        end
+      elsif options[:format] == 'csv'
+        require 'csv'
+        CSV do |csv|
+          csv << %w(location name flog_score)
+          report.each do |zombie|
+            csv << [zombie[:location], zombie[:name], zombie[:flog_score]]
+          end
+        end
+      end
     end
   end
 end

data/lib/zombie_scout/flog_scorer.rb

@@ -0,0 +1,27 @@
+require 'flog'
+
+module ZombieScout
+  class FlogScorer
+    def initialize(zombie_location)
+      @zombie_location = zombie_location
+    end
+
+    def score
+      raw_score.round(1)
+    end
+
+    private
+
+    def raw_score
+      flog = Flog.new(methods: true, quiet: true, score:false)
+      all_scores = flog.flog(zombie_path)
+      method_locations = flog.instance_variable_get(:@method_locations)
+      scores = all_scores.fetch(method_locations.invert.fetch(@zombie_location, {}), {})  # default to {} in case there is no score. (it's a 0)
+      flog.score_method(scores)
+    end
+
+    def zombie_path
+      @zombie_location.sub(/\:\d+$/, '')
+    end
+  end
+end

data/lib/zombie_scout/mission.rb

@@ -1,38 +1,74 @@
 require 'zombie_scout/ruby_project'
-require 'zombie_scout/method_finder'
+require 'zombie_scout/parser'
 require 'zombie_scout/method_call_finder'
+require 'zombie_scout/flog_scorer'
 
 module ZombieScout
   class Mission
+    attr_reader :defined_method_count
+
     def initialize(globs)
-      puts "Scouting out #{Dir.pwd}!"
       @ruby_project = RubyProject.new(*globs)
     end
 
     def scout
-      zombies.each do |zombie|
-        puts [zombie.location, zombie.name] * "\t"
-      end
+      @start_time = Time.now
+      zombies.map { |zombie|
+        { location: zombie.location,
+          name: zombie.name,
+          flog_score: flog_score(zombie.location)
+        }
+      }.tap {
+        @end_time = Time.now
+      }
+    end
+
+    def duration
+      @end_time - @start_time
+    end
 
-      puts "Scouted #{methods.size} methods in #{sources.size} files. Found #{zombies.size} potential zombies."
+    def source_count
+      sources.size
+    end
+
+    def zombie_count
+      zombies.size
     end
 
     private
 
+    def sources
+      @sources ||= @ruby_project.ruby_sources
+    end
+
+    def flog_score(zombie_location)
+      ZombieScout::FlogScorer.new(zombie_location).score
+    end
+
     def zombies
-      @zombies ||= methods.select { |method|
+      return @zombies unless @zombies.nil?
+
+      scout!
+      @zombies ||= @defined_methods.select { |method|
         might_be_dead?(method)
       }
     end
 
-    def methods
-      @methods ||= sources.map { |ruby_source|
-        MethodFinder.new(ruby_source).find_methods
-      }.flatten
-    end
+    def scout!
+      @defined_methods, @called_methods = [], []
 
-    def sources
-      @sources ||= @ruby_project.ruby_sources
+      sources.each do |ruby_source|
+        parser = ZombieScout::Parser.new(ruby_source)
+        @defined_methods.concat(parser.defined_methods)
+        @called_methods.concat(parser.called_methods)
+      end
+
+      @defined_method_count = @defined_methods.size
+
+      @called_methods.uniq!
+      @defined_methods.reject! do |method|
+        @called_methods.include?(method.name)
+      end
     end
 
     def might_be_dead?(method)

data/lib/zombie_scout/{method_finder.rb → parser.rb}

@@ -3,21 +3,15 @@ require 'parser/current'
 module ZombieScout
   Method = Class.new(Struct.new(:name, :location))
 
-  class MethodFinder < Parser::AST::Processor
+  class Parser < Parser::AST::Processor
+    attr_reader :defined_methods, :called_methods
+
     def initialize(ruby_source)
       @ruby_source = ruby_source
-    end
-
-    def find_methods
-      @methods = []
-      @private_method_calls = []
-
-      node = Parser::CurrentRuby.parse(@ruby_source.source)
+      @defined_methods = []
+      @called_methods = []
+      node = ::Parser::CurrentRuby.parse(@ruby_source.source)
       process(node)
-
-      @methods.reject { |method|
-        @private_method_calls.include?(method.name)
-      }
     end
 
     def on_def(node)
@@ -36,10 +30,9 @@ module ZombieScout
       receiver, method_name, *args = *node
       if respond_to?(:"handle_#{method_name}", true)
         send(:"handle_#{method_name}", args, node)
-      elsif receiver.nil?  # Then it's a private method call
-        @private_method_calls << method_name
-        process_all(args)
       end
+      @called_methods << method_name
+      process_all(args)
     end
 
     private
@@ -99,11 +92,11 @@ module ZombieScout
     def stash_method(method_name, node)
       line_number = node.location.line
       location = [@ruby_source.path, line_number].join(":")
-      @methods << Method.new(method_name, location)
+      @defined_methods << Method.new(method_name, location)
     end
   end
 
-  class SymbolExtracter < Parser::AST::Processor
+  class SymbolExtracter < ::Parser::AST::Processor
     def on_sym(node)
       node.to_a[0]
     end

data/lib/zombie_scout/version.rb

@@ -1,3 +1,3 @@
 module ZombieScout
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/zombie_scout/parser_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'zombie_scout/parser'
+
+describe ZombieScout::Parser do
+  let(:ruby_source) {
+    double(:ruby_source, path: 'lib/fizzbuzz.rb', source: ruby_code)
+  }
+
+  describe '#called_methods' do
+    let(:called_methods) {
+      ZombieScout::Parser.new(ruby_source).called_methods
+    }
+    context 'when a ruby file has code that calls methods' do
+      let(:ruby_code) {
+        "class RockBand
+           def rock_out
+             turn_up_amps
+             play_tunes
+           end
+         end"
+      }
+      it 'can find the called methods' do
+        expect(called_methods).to match_array %i(play_tunes turn_up_amps)
+      end
+    end
+  end
+
+  describe '#defined_methods' do
+    let(:defined_methods) {
+      ZombieScout::Parser.new(ruby_source).defined_methods.sort_by(&:name)
+    }
+    context 'when a ruby file has instance or class methods' do
+      let(:ruby_code) {
+        "class FizzBuzz
+         def fizz
+           'plop plop'
+         end
+
+         def self.buzz
+           'bzz bzz bzz'
+         end
+       end"
+      }
+
+      it 'can find the methods' do
+        expect(defined_methods[0].name).to eq :buzz
+        expect(defined_methods[0].location).to eq 'lib/fizzbuzz.rb:6'
+
+        expect(defined_methods[1].name).to eq :fizz
+        expect(defined_methods[1].location).to eq 'lib/fizzbuzz.rb:2'
+      end
+    end
+
+    context 'when a ruby file has attr_readers' do
+      context "when they're declared with symbols, the normal way" do
+        let(:ruby_code) {
+          "class Book
+           attr_reader :title, :author
+         end"
+        }
+        it 'can find attr_readers' do
+          expect(defined_methods.map(&:name)).to match_array(%i[author title])
+        end
+      end
+      context "when they're declare with a splat from an array of symbols" do
+        let(:ruby_code) {
+          "class Book
+           attributes = %i(title author)
+           attr_reader *attributes
+         end"
+        }
+        it 'will ignore them' do
+          expect(defined_methods).to be_empty
+        end
+      end
+    end
+
+    context 'when a ruby file has attr_writers' do
+      context "when they're declared with symbols, the normal way" do
+        let(:ruby_code) {
+          "class Book
+           attr_writer :title, :author
+         end"
+        }
+        it 'can find attr_writers' do
+          expect(defined_methods.map(&:name)).to match_array(%i[author= title=])
+        end
+      end
+      context "when they're declare with a splat from an array of symbols" do
+        let(:ruby_code) {
+          "class Book
+           attributes = %i(title author)
+           attr_reader *attributes
+         end"
+        }
+        it 'will ignore them' do
+          expect(defined_methods).to be_empty
+        end
+      end
+    end
+
+    context 'when a ruby file has attr_accessors' do
+      context "when they're declared with symbols, the normal way" do
+        let(:ruby_code) {
+          "class Book
+           attr_accessor :title, :author
+         end"
+        }
+        it 'can find attr_accessors' do
+          expect(defined_methods.map(&:name)).to match_array(%i[author author= title title=])
+        end
+      end
+      context "when they're declare with a splat from an array of symbols" do
+        let(:ruby_code) {
+          "class Book
+           attributes = %i(title author)
+           attr_accessor *attributes
+         end"
+        }
+        it 'will ignore them' do
+          expect(defined_methods).to be_empty
+        end
+      end
+    end
+
+    context 'when a ruby file uses Forwardable::def_delegator' do
+      let(:ruby_code) {
+        "class RecordCollection
+         extend Forwardable
+         def_delegator :@records, :[], :record_number
+       end"
+      }
+      it 'can find methods created by def_delegator' do
+        expect(defined_methods.map(&:name)).to match_array([:record_number])
+      end
+    end
+
+    context 'when a ruby file uses Forwardable::def_delegators' do
+      let(:ruby_code) {
+        "class RecordCollection
+         extend Forwardable
+         def_delegators :@records, :size, :<<, :map
+       end"
+      }
+      it 'can find methods created by def_delegators' do
+        expect(defined_methods.map(&:name)).to match_array(%i[<< map size])
+      end
+    end
+
+    context 'when a rails model has scopes' do
+      let(:ruby_code) {
+        "class Post
+         scope :published, -> { where(published: true) }
+         scope :draft, -> { where(published: true) }
+       end"
+      }
+      it 'can find scopes' do
+        expect(defined_methods.map(&:name)).to match_array(%i[draft published])
+      end
+    end
+
+    context 'when a ruby file has private methods' do
+      let(:ruby_code) {
+        "class FizzBuzz
+         def fizz
+           magick_helper
+         end
+
+         private
+         def magick_helper
+           'magick sauce'
+         end
+
+         def other_helper
+           'boo'
+         end
+      end"
+      }
+      it 'excludes private method calls, since we KNOW they are called' do
+        expect(defined_methods.map(&:name)).to match_array([:fizz, :magick_helper, :other_helper])
+      end
+    end
+  end
+end

data/zombie_scout.gemspec

@@ -10,12 +10,12 @@ Gem::Specification.new do |s|
 
   s.summary     = "Find dead methods in your Ruby app"
   s.description = "
-      zombie_scout finds methods in classes in your ruby project, 
-      and then searches for calls to them, and tells you which ones 
+      zombie_scout finds methods in classes in your ruby project,
+      and then searches for calls to them, and tells you which ones
       are never called.".strip.gsub(/^\s*/, '')
   s.homepage    = 'https://github.com/danbernier/zombie_scout'
   s.license     = 'ASL2'
-      
+
   s.authors     = ["Dan Bernier"]
   s.email       = ['danbernier@gmail.com']
 
@@ -26,5 +26,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency('parser', '~> 2.1')
   s.add_dependency('thor', '~> 0.18')
+  s.add_dependency('flog', '~> 4.2')
   s.add_development_dependency "bundler", "~> 1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zombie_scout
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Dan Bernier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-28 00:00:00.000000000 Z
+date: 2014-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,8 +66,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
-description: "zombie_scout finds methods in classes in your ruby project, \nand then
-  searches for calls to them, and tells you which ones \nare never called."
+description: |-
+  zombie_scout finds methods in classes in your ruby project,
+  and then searches for calls to them, and tells you which ones
+  are never called.
 email:
 - danbernier@gmail.com
 executables:
@@ -74,14 +90,15 @@ files:
 - bin/zombie_scout
 - lib/zombie_scout.rb
 - lib/zombie_scout/app.rb
+- lib/zombie_scout/flog_scorer.rb
 - lib/zombie_scout/method_call_finder.rb
-- lib/zombie_scout/method_finder.rb
 - lib/zombie_scout/mission.rb
+- lib/zombie_scout/parser.rb
 - lib/zombie_scout/ruby_project.rb
 - lib/zombie_scout/ruby_source.rb
 - lib/zombie_scout/version.rb
 - spec/spec_helper.rb
-- spec/zombie_scout/method_finder_spec.rb
+- spec/zombie_scout/parser_spec.rb
 - spec/zombie_scout/ruby_project_spec.rb
 - spec/zombie_scout/ruby_source_spec.rb
 - zombie_scout.gemspec
@@ -111,6 +128,6 @@ specification_version: 4
 summary: Find dead methods in your Ruby app
 test_files:
 - spec/spec_helper.rb
-- spec/zombie_scout/method_finder_spec.rb
+- spec/zombie_scout/parser_spec.rb
 - spec/zombie_scout/ruby_project_spec.rb
 - spec/zombie_scout/ruby_source_spec.rb

data/spec/zombie_scout/method_finder_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-require 'zombie_scout/method_finder'
-
-describe ZombieScout::MethodFinder, '#find_methods' do
-  let(:ruby_source) {
-    double(:ruby_source, path: 'lib/fizzbuzz.rb', source: ruby_code)
-  }
-  let(:zombies) {
-    ZombieScout::MethodFinder.new(ruby_source).find_methods.sort_by(&:name)
-  }
-
-  context 'when a ruby file has instance or class methods' do
-    let(:ruby_code) {
-      "class FizzBuzz
-         def fizz
-           'plop plop'
-         end
-
-         def self.buzz
-           'bzz bzz bzz'
-         end
-       end"
-    }
-
-    it 'can find the methods' do
-      expect(zombies[0].name).to eq :buzz
-      expect(zombies[0].location).to eq 'lib/fizzbuzz.rb:6'
-
-      expect(zombies[1].name).to eq :fizz
-      expect(zombies[1].location).to eq 'lib/fizzbuzz.rb:2'
-    end
-  end
-
-  context 'when a ruby file has attr_readers' do
-    context "when they're declared with symbols, the normal way" do
-      let(:ruby_code) {
-        "class Book
-           attr_reader :title, :author
-         end"
-      }
-      it 'can find attr_readers' do
-        expect(zombies.map(&:name)).to eq(%i[author title])
-      end
-    end
-    context "when they're declare with a splat from an array of symbols" do
-      let(:ruby_code) {
-        "class Book
-           attributes = %i(title author)
-           attr_reader *attributes
-         end"
-      }
-      it 'will ignore them' do
-        expect(zombies).to be_empty
-      end
-    end
-  end
-
-  context 'when a ruby file has attr_writers' do
-    context "when they're declared with symbols, the normal way" do
-      let(:ruby_code) {
-        "class Book
-           attr_writer :title, :author
-         end"
-      }
-      it 'can find attr_writers' do
-        expect(zombies.map(&:name)).to eq(%i[author= title=])
-      end
-    end
-    context "when they're declare with a splat from an array of symbols" do
-      let(:ruby_code) {
-        "class Book
-           attributes = %i(title author)
-           attr_reader *attributes
-         end"
-      }
-      it 'will ignore them' do
-        expect(zombies).to be_empty
-      end
-    end
-  end
-
-  context 'when a ruby file has attr_accessors' do
-    context "when they're declared with symbols, the normal way" do
-      let(:ruby_code) {
-        "class Book
-           attr_accessor :title, :author
-         end"
-      }
-      it 'can find attr_accessors' do
-        expect(zombies.map(&:name)).to eq(%i[author author= title title=])
-      end
-    end
-    context "when they're declare with a splat from an array of symbols" do
-      let(:ruby_code) {
-        "class Book
-           attributes = %i(title author)
-           attr_accessor *attributes
-         end"
-      }
-      it 'will ignore them' do
-        expect(zombies).to be_empty
-      end
-    end
-  end
-
-  context 'when a ruby file uses Forwardable::def_delegator' do
-    let(:ruby_code) {
-      "class RecordCollection
-         extend Forwardable
-         def_delegator :@records, :[], :record_number
-       end"
-    }
-    it 'can find methods created by def_delegator' do
-      expect(zombies.map(&:name)).to match_array([:record_number])
-    end
-  end
-
-  context 'when a ruby file uses Forwardable::def_delegators' do
-    let(:ruby_code) {
-      "class RecordCollection
-         extend Forwardable
-         def_delegators :@records, :size, :<<, :map
-       end"
-    }
-    it 'can find methods created by def_delegators' do
-      expect(zombies.map(&:name)).to eq(%i[<< map size])
-    end
-  end
-
-  context 'when a rails model has scopes' do
-    let(:ruby_code) {
-      "class Post
-         scope :published, -> { where(published: true) }
-         scope :draft, -> { where(published: true) }
-       end"
-    }
-    it 'can find scopes' do
-      expect(zombies.map(&:name)).to eq(%i[draft published])
-    end
-  end
-
-  context 'when a ruby file has private methods' do
-    let(:ruby_code) {
-      "class FizzBuzz
-         def fizz
-           magick_helper
-         end
-
-         private
-         def magick_helper
-           'magick sauce'
-         end
-      end"
-    }
-    it 'excludes private method calls, since we KNOW they are called' do
-      expect(zombies.map(&:name)).to match_array([:fizz])
-      expect(zombies.map(&:name)).not_to include :magick_helper
-    end
-  end
-end