coverfield 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c06502048cd2cfbb46d8383572891c9a6a4ebff8
-  data.tar.gz: 1156c6922c0181fd7267ed4bd3fe9a370127aad5
+  metadata.gz: 555473b54c96dd9e9ae8104e1489048f1779c6f7
+  data.tar.gz: 76961b00f2fee8690d255cafc26f3cab2218ef85
 SHA512:
-  metadata.gz: 1be8dfd4b92c3e2b0d6188c3fee72e8f28868994d284e600bad14eaba2a317932e0f186337f44c8290fe8934e3406308a2004d3d489f0a98a897af582dba5fcb
-  data.tar.gz: b33d06bb0e8d0bd9155294110fc245ec8f5ed3c351e438000c2add9d6ac6f4d1c4a84360c5e682cbfa51c38083695032de21206c59ac38508116221079506b30
+  metadata.gz: a0bb29b2a0704b40627ace26e352ce8ca4107c2ec18a090686baa5f23beed1bb98b20cedcf2bfff5e43db6e16e95fe81547c531a9011c9b999b5d2a200449dfc
+  data.tar.gz: 9b5806d01aea4cb702640e7378eae01a51ef9001f4441b2e6ff63f2c5b3bc38fb1f2b8ecbad0e9588fce329f7c3b5b4e81a28ec1fbc626621755c066b41cfccd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    coverfield (0.1.0)
+    coverfield (0.3.0)
       colorize (~> 0.7)
       rubocop (~> 0.40)
 
@@ -10,10 +10,24 @@ GEM
   specs:
     ast (2.3.0)
     colorize (0.7.7)
+    diff-lcs (1.2.5)
     parser (2.3.1.2)
       ast (~> 2.2)
     powerpack (0.1.1)
     rainbow (2.1.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
     rubocop (0.40.0)
       parser (>= 2.3.1.0, < 3.0)
       powerpack (~> 0.1)
@@ -29,6 +43,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.12)
   coverfield!
+  rspec (~> 3.4)
 
 BUNDLED WITH
    1.12.5

data/README.md

@@ -2,24 +2,24 @@
 
 [![Gem Version](http://img.shields.io/gem/v/coverfield.svg)](http://badge.fury.io/rb/coverfield)
 
-**Warning:** Alpha Release, do not rely on or use in production yet!
+**Warning:** This is a Beta Release!
 
 One day I found a class in my ruby app with > 95% coverage in
 [SimpleCov](https://github.com/colszowka/simplecov) but without any dedicated
 spec. SimpleCov is an awesome tool if you want to get an idea of your test
-coverage, but it has a flaw: It doesn't look whether theres a spec for a
+coverage, but it has a flaw: It doesn't look whether there's a spec for a
 class/module/method or not, it just reports if a line of code was executed while
-the spec suite run thru. In my case a class which was used relative often so
+the spec suite run through. In my case a class which was used relative often so
 gathered nearly 100% coverage, but I've never wrote any line of testing code
 specific vor that class.
 
 To get an overview which classes, modules and methods my test suite covers (and
 more important: which not), I've wrote a small script, which scans all
 production code, finds the classes and methods and checks if there are dedicated
-tests for that methods whitin the specs. It compiles a report which clearly
+tests for that methods within the specs. It compiles a report which clearly
 tells me, what specs are missing.
 
-This script is not a substitution for SimpleCov! SimpleCov is a wonderful peave
+This script is not a substitution for SimpleCov! SimpleCov is a wonderful piece
 of software and it's coverage report is very important. Think of Coverfield as a
 additional tool for examining the quality of your test suite under another
 aspect and from a different view.
@@ -30,12 +30,13 @@ covered by specs and which not. SimpleCov then tells you how well the body of
 those methods is tested and if there are edge cases which are not touched by the
 test suite.
 
+[Click here for a screenshot of the coverfield generated report](https://twitter.com/phortx/status/745256593625911296).
+
 
 
 ## Future
 
-This project has still prototype character (this is an alpha release) and
-there's plenty to do (specs for example).
+This gem is still in beta phase and there's plenty to do (specs for example).
 
 And I wrote [Christoph Olszowka](https://github.com/colszowka) to ask
 him if there is a chance that this will be included to SimpleCov in some
@@ -47,7 +48,7 @@ way. I would really appreciate that!
 Big thanks and Kudos to the folks of
 [RuboCop](https://github.com/bbatsov/rubocop)! Coverfield is based on the AST
 Ruby Parser, which is part of the RuboCop gem. Without that awesome peace of
-software, covervield would have been much more code and much more complicated.
+software, coverfield would have been much more code and much more complicated.
 Thank you very much, nice work!
 
 Also thanks to [Christoph Olszowka](https://github.com/colszowka) for his
@@ -59,26 +60,27 @@ will be some kind of integration in the future.
 
 Install via `gem install coverfield`.
 
-Then just call `coverfield lib/ app/` in your apps root dir.
+Then just call `coverfield -u lib/ app/` in your apps root dir.
+
+For more info take a look at the usage information of `coverfield -h`.
 
 
 ### Considerations
 
 Coverfield requires you to have a specific architecture of your RSpec Suite.
 
-1. All specs are located in `spec/`.
-2. Within `spec` all specs are placed in the same path as the file which is
-   tested by the spec. For example the spec for the file
+1. Within the spec directory all specs are placed in the same path as the file
+   which is tested by the spec. For example the spec for the file
    `/lib/some/nice_class.rb` have to be placed in
    `/spec/lib/some/nice_class_spec.rb` or `/spec/some/nice_class_spec.rb`.
    And the spec for the file `/app/models/post.rb` goes to
    `/spec/app/models/post.rb` or `/spec/models/post.rb`
    [Why?](http://stackoverflow.com/questions/14180003/rspec-naming-conventions-for-files-and-directory-structure)
-3. The first `describe` call have to be built like that:
+2. The first `describe` call have to be built like that:
    `describe Some::NiceClass do` assuming, that `/lib/some/nice_code.rb` defines
    the class `Some::NiceClass`.
    [Why?](http://rspec.info/documentation/3.4/rspec-core/#Basic_Structure)
-4. All inner `describe` calls for the methods have to be built like that:
+3. All inner `describe` calls for the methods have to be built like that:
    `describe '#method_name' do`. The `#` is optional and may also be a `.`.
    [Why?](http://betterspecs.org/#describe)
-5. All dependencies of your app have to be installed (`bundle install`).
+4. All dependencies of your app have to be installed (`bundle install`).

data/bin/coverfield

@@ -1,65 +1,22 @@
 #!/usr/bin/env ruby
 
-# Run that script in your apps root. Important: rubocop and colorize gems have to be installed!
+# Run that script in your apps root.
 
-require 'bundler'
-require 'rubocop'
 require 'colorize'
-
-APP_ROOT = Bundler.root.to_s
-
 require 'coverfield'
-require 'coverfield/source/class'
-require 'coverfield/source/file'
-require 'coverfield/source/test_file'
-
-
-# Ensure there are paths to search for
-paths = ARGV
-paths = [APP_ROOT + '/lib'] if paths.empty?
-
-
-# Find files
-target_finder = RuboCop::TargetFinder.new(RuboCop::ConfigStore.new)
-target_files = target_finder.find(paths)
-
-
-# Map all found files to SourceFiles
-source_files = target_files.map { |file| Coverfield::Source::File.new(file) }
-
-
-# Initialize counter variables
-total_covered = 0
-total_methods = 0
-total_relevant_methods = 0
+require 'coverfield/cli'
+require 'coverfield/report'
 
-# Iterate over all found files and their classes for fancy output
-source_files.each do |file|
-  file.classes.each do |cls|
-    class_name = cls.full_qualified_name.to_s.light_blue
-    coverage = "#{file.coverage}/#{cls.relevant_method_count}/#{cls.method_count}"
-    covered = file.coverage == cls.relevant_method_count
-    puts "#{covered ? '[X]'.green : '[ ]'.red} Found class: #{class_name} with #{covered ? coverage.green : coverage.red} covered methods in #{file.relative_file_name.light_blue}".bold
 
-    file.hints.each do |hint|
-      puts "    - #{hint}"
-    end
+# Load the Command Line Interface to parse the options and arguments.
+# That also initializes the config, which will be available via cli.config
+cli = Coverfield::CLI.new
 
-    total_methods += cls.method_count
-    total_relevant_methods += cls.relevant_method_count
-    total_covered += file.coverage
 
-    puts
-  end
-end
+# Find all source files based on the include_paths in the config
+source_files = Coverfield.find_source_files(cli.config)
 
-relevant_percent = (total_relevant_methods * 100 / total_methods).round.to_s + '%'
-covered_percent = (total_covered * 100 / total_methods).round.to_s + '%'
-uncovered_percent = ((total_relevant_methods - total_covered) * 100 / total_methods).round.to_s + '%'
 
-puts
-puts "There are #{total_methods.to_s.yellow} methods in total."
-puts "#{total_relevant_methods.to_s.yellow} (#{relevant_percent.yellow}) of them are relevant for coverage."
-puts "And #{total_covered.to_s.yellow} (#{covered_percent.yellow}) methods are covered by tests."
-puts "Thus there are #{(total_relevant_methods - total_covered).to_s.yellow} (#{uncovered_percent.yellow}) uncovered methods."
-puts
+# Create and print the report
+report = Coverfield::Report.new(cli.config, source_files)
+puts report.full_report

data/coverfield.gemspec

@@ -12,16 +12,18 @@ Gem::Specification.new do |gem|
   gem.description = 'Smarter Ruby/RSpec coverage reports: Tells you which classes, modules and methods don\'t have any specs'
   gem.summary     = 'Smarter Ruby/RSpec coverage reports'
   gem.license     = 'GPL-3.0'
-
   gem.required_ruby_version = '>= 2.3.0'
 
-  gem.add_dependency 'rubocop', '~> 0.40'
+
+  gem.add_dependency 'rubocop',  '~> 0.40'
   gem.add_dependency 'colorize', '~> 0.7'
 
   gem.add_development_dependency 'bundler', '~> 1.12'
+  gem.add_development_dependency 'rspec', '~> 3.4'
+
 
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.require_paths = ['lib']
-end
+end

data/lib/coverfield.rb

@@ -1,4 +1,41 @@
 module Coverfield
   module Source
   end
+
+  class << self
+    # Finds all ruby source files in the given paths
+    # Returns an array of Coverfield::Source::File instances
+    public def find_source_files(config)
+      require 'rubocop'
+      require 'coverfield/source/file'
+
+      # Find files
+      target_finder = RuboCop::TargetFinder.new(RuboCop::ConfigStore.new)
+      target_files = target_finder.find(config.include_paths)
+
+
+      # Map all found files to SourceFiles
+      target_files = target_files.map { |file| Coverfield::Source::File.new(config, file) }
+
+      # Debug output
+      dump_file_list(target_files) if config.debug
+
+      # Return the file list
+      target_files
+    end
+
+
+    # Dumps the list of found files
+    private def dump_file_list(file_list)
+      puts "Found #{file_list.size} source files:".blue
+
+      file_list.each do |file|
+        test_file_word = (file.test_file.file_exists? ? 'a'.green : 'no'.red)
+        puts "    - #{file.relative_file_name} with #{test_file_word} test file"
+      end
+
+      puts
+      puts
+    end
+  end
 end

data/lib/coverfield/cli.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+require 'coverfield/config'
+
+# Command Line Interface: Parses the options and constructs a
+# Coverfield::Config, which is available via the `config` method
+class Coverfield::CLI
+  attr_reader :config
+
+  # Constructor
+  public def initialize
+    # Create the config store
+    @config = Coverfield::Config.new
+
+    # Parse the CLI options and write them to the config store
+    parse_cli_options
+
+    # Determine all source pathes
+    @config.include_paths = include_paths
+
+    # Debug output
+    @config.dump_config if @config.debug
+  end
+
+
+  # Parses the CLI options and writes them to the config store
+  private def parse_cli_options
+    opt_parser = OptionParser.new do |opt|
+      opt.banner = 'Usage: coverfield [OPTION]... [FILE]...'
+      opt.separator  ''
+      opt.separator  'Options:'
+
+      # --uncovered-only
+      opt.on('-u', '--uncovered-only', "Don't print classes with 100% coverage") do
+        @config.uncovered_only = true
+      end
+
+      # --skip-summary
+      opt.on('-s', '--skip-summary', "Don't print the coverage summary") do
+        @config.skip_summary = true
+      end
+
+      # --spec-dir
+      opt.on('-d', '--spec-dir=DIR', "Sets the directory which contains the specs. Default is 'spec/'") do |dir|
+        @config.spec_dir = dir
+      end
+
+
+      # --debug
+      opt.on('-D', '--debug', 'Enables debug output') do
+        @config.debug = true
+      end
+
+      # --help
+      opt.on('-h', '--help', 'Prints usage informations') do
+        puts opt
+        exit
+      end
+    end
+
+    opt_parser.parse!
+  end
+
+
+  # Determines all pathes where ruby source files should be searched in
+  private def include_paths
+    # Ensure there are paths to search for
+    paths = ARGV
+    paths = [config.app_root + '/lib'] if paths.empty?
+
+    # Filter everything, that doesn't exist
+    paths.select { |path| File.exists?(path) }
+  end
+end

data/lib/coverfield/config.rb

@@ -0,0 +1,42 @@
+# A simple config store
+class Coverfield::Config
+  attr_accessor :uncovered_only,
+                :skip_summary,
+                :include_paths,
+                :app_root,
+                :spec_dir,
+                :debug
+
+  # Constructor
+  public def initialize
+    @uncovered_only = false
+    @skip_summary = false
+    @debug = false
+    @include_paths = []
+    @spec_dir = 'spec/'
+
+    # Bundler already contains a good logic to determine the apps root
+    require 'bundler'
+    @app_root = Bundler.root.to_s
+  end
+
+
+  # Returns the full absolute path to the spec dir
+  public def spec_path
+    @app_root + '/' + @spec_dir
+  end
+
+
+  # Prints all options
+  public def dump_config
+    puts 'Options:'.blue
+    puts "    Uncovered only:  #{@uncovered_only}"
+    puts "    Skip summary:    #{@skip_summary}"
+    puts "    Debug mode:      #{@debug}"
+    puts "    Include paths:   #{@include_paths}"
+    puts "    App root:        #{@app_root}"
+    puts "    Spec directory:  #{@spec_dir} (= #{spec_path})"
+    puts
+    puts
+  end
+end

data/lib/coverfield/report.rb

@@ -0,0 +1,80 @@
+class Coverfield::Report
+  public def initialize(config, source_files)
+    @config = config
+    @source_files = source_files
+  end
+
+
+  public def full_report
+    # Some counter variables
+    @total_covered = 0
+    @total_methods = 0
+    @total_relevant_methods = 0
+
+    # Will contain the report
+    report = ''
+
+    # Iterate over all found files and generate a report for each file
+    report << @source_files.map(&method(:for_file)).reject(&:empty?).join("\n")
+
+    # Report summary
+    unless @config.skip_summary
+      # Some calculations
+      total_uncovered = @total_relevant_methods - @total_covered
+      relevant_percent = (@total_relevant_methods * 100 / @total_methods).round.to_s + '%'
+      covered_percent = (@total_covered * 100 / @total_methods).round.to_s + '%'
+      uncovered_percent = (total_uncovered * 100 / @total_methods).round.to_s + '%'
+
+      # Generate summary
+      report << "\nThere are #{@total_methods.to_s.yellow} methods in total.\n"
+      report << "#{@total_relevant_methods.to_s.yellow} (#{relevant_percent.yellow}) of them are relevant for coverage.\n"
+      report << "And #{@total_covered.to_s.yellow} (#{covered_percent.yellow}) methods are covered by tests.\n"
+      report << "Thus there are #{total_uncovered.to_s.yellow} (#{uncovered_percent.yellow}) uncovered methods.\n"
+    end
+
+    report + "\n"
+  end
+
+
+  # Tells if a line should be displayed according to the amount of
+  # relevant_methods, if the class is covered and the config
+  private def should_display_line?(relevant_methods, covered)
+    relevant_methods > 0 && !(@config.uncovered_only && covered)
+  end
+
+
+  private def for_file(file)
+    report = ''
+
+    # Generate a report for each class in that file
+    file.classes.each do |cls|
+      covered = cls.coverage == cls.relevant_method_count
+
+      if should_display_line?(cls.relevant_method_count, covered)
+        class_name = cls.full_qualified_name.to_s.light_blue
+        coverage = "#{cls.coverage}/#{cls.relevant_method_count}/#{cls.method_count}"
+        report << "#{covered ? '[X]'.green : '[ ]'.red} Found class: #{class_name} with #{covered ? coverage.green : coverage.red} covered methods.\n".bold
+        report << "    => Source file: #{file.relative_file_name.light_blue}\n"
+
+        if file.test_file.file_exists?
+          report << "    => Test file: #{file.test_file.relative_file_name.light_blue}\n"
+        else
+          report << "    => Test file: #{'Not found'.light_red} (expected one of #{file.allowed_test_files.join(', ')})\n"
+        end
+
+        # Write the hints to the report
+        if cls.hints.any?
+          report << cls.hints.map{ |hint| "    - #{hint}" }.reject(&:empty?).join("\n")
+          report << "\n"
+        end
+      end
+
+      # Increase the counter variables
+      @total_methods += cls.method_count
+      @total_relevant_methods += cls.relevant_method_count
+      @total_covered += cls.coverage
+    end
+
+    report
+  end
+end

data/lib/coverfield/source/class.rb

@@ -1,7 +1,8 @@
 require 'coverfield/source/method'
 
+# Represents a class within a source file
 class Coverfield::Source::Class
-  attr_reader :name, :module_name, :node, :methods, :source_file
+  attr_reader :name, :module_name, :node, :methods, :source_file, :coverage, :hints
 
   # Constructor
   public def initialize(class_name, module_name, node, source_file)
@@ -10,25 +11,59 @@ class Coverfield::Source::Class
     @node = node
     @methods = []
     @source_file = source_file
+    @coverage = 0
+    @hints = []
     find_methods
   end
 
+
+  # Returns the full qualified name like Coverfield::Source::Class
   public def full_qualified_name
     name = @name
     name = "#{@module_name}::#{name}" unless @module_name.empty?
     name
   end
 
+
+  # Returns the amount of methods, which should be covered by tests
   public def relevant_method_count
     relevant_methods = @methods.select { |m| !m.nocov?}
     relevant_methods.size
   end
 
+
+  # Returns the total amount of methods within the class
   public def method_count
     @methods.size
   end
 
-  # Finds all methods
+
+  # Calculates the coverage of that class based on the relevant methods
+  # and sets the @coverage and the @hints fields
+  public def calculate_coverage
+    @coverage = 0
+    @hints = []
+    test_file = source_file.test_file
+
+    methods.each do |method|
+      # Is the method covered?
+      if test_file.cover?(full_qualified_name, method.name)
+        @coverage += 1
+      else
+        # Should it be covered?
+        if method.nocov?
+          @coverage += 1
+        else
+          # If it should be covered, but isn't, create a hint
+          method_name = "#{name}.#{method.name}".red
+          @hints << "Missing test for #{method_name}"
+        end
+      end
+    end
+  end
+
+
+  # Finds all methods within the class
   private def find_methods
     node.each_node(:def) do |node|
       @methods << Coverfield::Source::Method.new(*node, self)

data/lib/coverfield/source/file.rb

@@ -3,19 +3,21 @@ require 'coverfield/source/test_file'
 require 'coverfield/source/class'
 require 'coverfield/source/nocov_range'
 
+# Represents a ruby source file which consists of classes
 class Coverfield::Source::File
   include Coverfield::Source::FileMethods
 
-  attr_reader :classes, :test_file, :coverage, :hints
+  attr_reader :classes, :test_file
+
 
   # Constructor
-  public def initialize(file_name)
+  public def initialize(config, file_name)
+    @config = config
     @file_name = file_name
     @classes = []
-    @coverage = 0
-    @hints = []
     @nocov_ranges = []
 
+    # Ignore empty files
     unless File.zero?(file_name)
       parse_code
       find_nocov_ranges
@@ -28,28 +30,13 @@ class Coverfield::Source::File
   end
 
 
-  # Calculates the number of covered methods of this file and sets @coverage and @hints
+  # Iterates over all classes and calculates their test coverage
   private def calculate_coverage
-    @coverage = 0
-
-    classes.each do |cls|
-      cls.methods.each do |method|
-        if test_file.cover?(cls.full_qualified_name, method.name)
-          @coverage += 1
-        else
-          method_name = "#{cls.name}.#{method.name}".red
-
-          if method.nocov?
-            @coverage += 1
-          else
-            @hints << "Missing test for #{method_name} in #{test_file.relative_file_name.yellow}"
-          end
-        end
-      end
-    end
+    classes.each { |cls| cls.calculate_coverage }
   end
 
 
+  # Tells if a method node is located within two :nocov: tags
   public def nocov?(method_body_node)
     @nocov_ranges.each do |nocov_range|
       return true if nocov_range.includes?(method_body_node)
@@ -59,18 +46,20 @@ class Coverfield::Source::File
   end
 
 
-  # Find class definitions
+  # Finds all class definitions within that file
   private def find_classes
     @processed_source.ast.each_node(:class) do |node|
       name, superclass, body = *node
       _scope, const_name, value = *name
       module_name = node.parent_module_name
 
+      # If the module_name is 'Object', the notation is not Coverfield::Source::TestFile but nested modules/class
       if module_name == 'Object'
         nothing, scope_name, nothing = *_scope
         module_name = scope_name.to_s
       end
 
+      # Create a new class object and push that to the @classes array
       @classes << Coverfield::Source::Class.new(const_name, module_name, node, self)
     end
   end
@@ -78,24 +67,30 @@ class Coverfield::Source::File
 
   # Find the spec file for that class
   private def find_test_file
-    spec_path = APP_ROOT + '/spec'
-    relative_file_name = @file_name.to_s.gsub(APP_ROOT, '')
-    @test_file = Coverfield::Source::TestFile.new(spec_path + relative_file_name.gsub('.rb', '_spec.rb'))
-
-    # When no file was found also try without '/lib' or '/app'
-    unless @test_file.file_exists?
-      relative_file_name.gsub!(/^\/(lib|app)/, '')
-      @test_file = Coverfield::Source::TestFile.new(spec_path + relative_file_name)
+    allowed_test_files.each do |file|
+      @test_file = Coverfield::Source::TestFile.new(@config, file)
+
+      # break
+      return false if test_file.file_exists?
     end
   end
 
 
+  public def allowed_test_files
+    template = (@config.spec_dir + relative_file_name).gsub('.rb', '_spec.rb')
+    allowed_files = *template
+    allowed_files << template.gsub(/^\/(lib|app)/, '')
+    allowed_files
+  end
+
+
+  # Collects all :nocov: tag ranges in the file
   private def find_nocov_ranges
     first = true
     line = 0
 
     @processed_source.comments.each do |comment|
-      if comment.type == :inline && comment.text.strip =~ /^#\s*\:nocov\:/
+      if comment.type == :inline && comment.text.strip =~ /^#\s*:nocov:/
         if first
           line = comment.loc.expression.first_line
         else

data/lib/coverfield/source/file_methods.rb

@@ -1,3 +1,4 @@
+# Mixin for shared methods between TestFile and File
 module Coverfield::Source::FileMethods
   attr_reader :file_name
 
@@ -9,6 +10,6 @@ module Coverfield::Source::FileMethods
 
   # Returns the file name relative to the app root
   public def relative_file_name
-    @file_name.gsub(APP_ROOT + '/', '')
+    @file_name.gsub(@config.app_root + '/', '')
   end
 end

data/lib/coverfield/source/method.rb

@@ -1,6 +1,8 @@
+# Represents a method within a class
 class Coverfield::Source::Method
   attr_reader :name, :args, :body, :source_class
 
+  # Constructor
   public def initialize(method_name, args, body, source_class)
     @name = method_name
     @args = args
@@ -8,6 +10,8 @@ class Coverfield::Source::Method
     @source_class = source_class
   end
 
+
+  # Tells whether the method should be covered by a test or not
   public def nocov?
     @source_class.source_file.nocov? @body
   end

data/lib/coverfield/source/nocov_range.rb

@@ -1,9 +1,12 @@
+# Represents a range of lines in a source file which is wrapped in :nocov: tags
 class Coverfield::Source::NocovRange
+  # Consructor
   public def initialize(first_line, last_line)
     @first_line = first_line
     @last_line = last_line
   end
 
+  # Tells if a node is within that nocov rage
   public def includes?(node)
     source_range = node.source_range
     source_range.first_line > @first_line && source_range.last_line < @last_line

data/lib/coverfield/source/test_file.rb

@@ -1,14 +1,18 @@
 require 'coverfield/source/file_methods'
 
+# Represents a spec file
 class Coverfield::Source::TestFile
   include Coverfield::Source::FileMethods
 
+
   # Constructor
-  public def initialize(file_name)
-    @file_name = file_name
-    @file_exists = File.exists?(@file_name) && !File.zero?(file_name)
+  public def initialize(config, file_name)
+    @config = config
+    @file_name = config.app_root + '/' + file_name
+    @file_exists = File.exists?(file_name) && !File.zero?(file_name)
     @describes = {}
 
+    # If the file doesn't exist, do nothing
     if file_exists?
       parse_code
       find_describes
@@ -24,7 +28,7 @@ class Coverfield::Source::TestFile
   end
 
 
-  # Tells if that file covers a class_name method_name pair
+  # Tells if that file covers a method of a class pair
   public def cover?(class_name, method_name)
     return false unless file_exists?
 
@@ -37,9 +41,14 @@ class Coverfield::Source::TestFile
   end
 
 
-  # Small helper method which builts the full qualified class name out of a describe arguments node
+  # Helper method which builts the full qualified class name out of
+  # a describe arguments node
   private def get_spec_class_name(describe_args_node)
+    # If the argument is already a string, there's nothing to do
     return describe_args_node if describe_args_node.is_a?(String)
+
+    # Otherwise it's a constant chain like Coverfield::Source::TestFile
+    # which will be concatenated
     subject_ary = []
 
     describe_args_node.each_node(:const) do |const_part|
@@ -78,8 +87,8 @@ class Coverfield::Source::TestFile
             value = value.to_s
           end
 
+          # Remove the . or # from the string
           @describes[current_subject] << value.strip.gsub(/^(?:\.|#)(.+)$/i, '\1')
-
         end
 
         first_describe = false

data/lib/coverfield/version.rb

@@ -1,5 +1,5 @@
 module Coverfield
-  version = '0.1.0'
+  version = '0.3.0'
 
   def version.to_a
     split('.').map(&:to_i)

data/spec/lib/coverfield/report_spec.rb

@@ -0,0 +1,64 @@
+require 'coverfield/config'
+require 'coverfield/report'
+
+describe Coverfield::Report do
+  subject { Coverfield::Report }
+
+  let(:config) { Coverfield::Config.new }
+
+  describe '#should_display_line?' do
+    context "while it shouldn't skip covered classes" do
+      subject { Coverfield::Report.new(config, []) }
+
+      context 'and there are no relevant methods' do
+        it 'returns false' do
+          expect(subject.instance_eval { should_display_line?(0, true) }).to eq(false)
+          expect(subject.instance_eval { should_display_line?(0, false) }).to eq(false)
+        end
+      end
+
+      context 'and there are relevant methods' do
+        context 'coverage is 100%' do
+          it 'returns true' do
+            expect(subject.instance_eval { should_display_line?(1, true) }).to eq(true)
+          end
+        end
+
+        context 'and coverage is below 100%' do
+          it 'returns true' do
+            expect(subject.instance_eval { should_display_line?(1, false) }).to eq(true)
+          end
+        end
+      end
+    end
+
+    context 'while it should skip covered classes' do
+      subject do
+        cfg = config
+        cfg.uncovered_only = true
+        Coverfield::Report.new(cfg, [])
+      end
+
+      context 'and there are no relevant methods' do
+        it 'returns false' do
+          expect(subject.instance_eval { should_display_line?(0, true) }).to eq(false)
+          expect(subject.instance_eval { should_display_line?(0, false) }).to eq(false)
+        end
+      end
+
+      context 'and there are relevant methods' do
+        context 'coverage is 100%' do
+          it 'returns false' do
+            expect(subject.instance_eval { should_display_line?(1, true) }).to eq(false)
+          end
+        end
+
+        context 'and coverage is below 100%' do
+          it 'returns true' do
+            expect(subject.instance_eval { should_display_line?(1, false) }).to eq(true)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# Extend loadpath for simpler require statements
+$: << Dir.pwd + '/lib/'
+
+
+RSpec.configure do |config|
+  # Configure the Rspec to only accept the new syntax on new projects, to avoid
+  # having the 2 syntax all over the place.
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coverfield
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Benjamin Klein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description: 'Smarter Ruby/RSpec coverage reports: Tells you which classes, modules
   and methods don''t have any specs'
 email:
@@ -69,6 +83,9 @@ files:
 - bin/coverfield
 - coverfield.gemspec
 - lib/coverfield.rb
+- lib/coverfield/cli.rb
+- lib/coverfield/config.rb
+- lib/coverfield/report.rb
 - lib/coverfield/source/class.rb
 - lib/coverfield/source/file.rb
 - lib/coverfield/source/file_methods.rb
@@ -76,6 +93,8 @@ files:
 - lib/coverfield/source/nocov_range.rb
 - lib/coverfield/source/test_file.rb
 - lib/coverfield/version.rb
+- spec/lib/coverfield/report_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/phortx/coverfield
 licenses:
 - GPL-3.0
@@ -100,4 +119,6 @@ rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Smarter Ruby/RSpec coverage reports
-test_files: []
+test_files:
+- spec/lib/coverfield/report_spec.rb
+- spec/spec_helper.rb