coco 0.13.0 → 0.14.0

data/Rakefile

@@ -3,49 +3,22 @@ require 'rake/dsl_definition'
 require 'rake'
 require 'rspec/core/rake_task'
 
-def ruby_files_for_shell
-  files = Dir.glob 'lib/**/*.rb'
-  files.join(' ')
-end
-
-desc 'Test coco'
-task :default => :spec
+desc 'Test with all tools'
+task :default => :all_tests
 
-desc 'Test coco'
-RSpec::Core::RakeTask.new(:spec) do |t|
+desc 'Test with RSpec'
+RSpec::Core::RakeTask.new(:rspec) do |t|
   t.rspec_opts = ['--color --order=random']
 end
 
-desc 'Check for code smells with reek'
-task :reek do
-  puts 'Checking for code smells.'
-  puts '-------------------------'
-  system "reek #{ruby_files_for_shell}"
+desc 'Test with Cucumber'
+task :cucumber do
+  exec 'cucumber'
 end
 
-desc 'Check for duplicate code with flay'
-task :flay do
-  puts 'Checking for duplicate code.'
-  puts '----------------------------'
-  exec "flay lib"
+task :all_tests do
+  Rake::Task['rspec'].execute
+  Rake::Task['cucumber'].execute
 end
 
-desc 'Check various code metrics'
-task :metrics do
-  puts 'Checking various metrics.'
-  puts '========================='
-  Rake::Task['reek'].execute
-  Rake::Task['flay'].execute
-end
 
-namespace :doc do
-  desc 'Generate documentation for developpers'
-  task :create do 
-    exec 'yardoc'
-  end
-
-  desc 'Delete documentation'
-  task :clean do
-    rm_rf 'doc'
-  end
-end

data/VERSION

@@ -1 +1 @@
-0.13.0
+0.14.0

data/lib/coco.rb

@@ -1,38 +1,26 @@
+require 'coco/project'
+require 'coco/theme'
 require 'coco/formatter'
 require 'coco/cover'
 require 'coco/writer'
 require 'coco/helpers'
 require 'coco/configuration'
 require 'coco/lister'
+require 'coco/deprecated_message'
 
 require 'coverage'
 
 # Public: Main namespace of Coco, a code coverage utilily for
-# Ruby from 1.9.3 to 2.1.
+# Ruby from 2.0 to 2.3.
+#
 module Coco
-	ROOT = File.expand_path(File.dirname(__FILE__) + '/..').freeze
+  ROOT = File.expand_path(File.dirname(__FILE__) + '/..').freeze
 end
 
 Coverage.start
 
+# The coverage's analysis happens at the very end of the test suite.
+#
 at_exit do
-  config = Coco::Configuration.new
-  if config.user_wants_to_run?
-    result = Coco::CoverageResult.new(config, Coverage.result)
-    covered = result.covered_from_domain
-
-    sources = Coco::SourceLister.new(config).list
-    uncovered = Coco::UncoveredLister.new(sources, result.all_from_domain).list
-
-    console_formatter = Coco::ConsoleFormatter.new(covered, uncovered,
-                                                   config[:threshold])
-    puts console_formatter.format(config[:single_line_report])
-    puts console_formatter.link if config[:show_link_in_terminal]
-
-    html_files = Coco::HtmlFormatter.new(covered).format
-    Coco::HtmlFilesWriter.new(html_files).write
-
-    index = Coco::HtmlIndexFormatter.new(covered, uncovered).format
-    Coco::HtmlIndexWriter.new(index).write
-  end
+  Coco::Project.run(Coverage.result)
 end

data/lib/coco/configuration.rb

@@ -18,27 +18,36 @@ module Coco
   #
   # Note you can set the threshold above 100% (to be sure to see all
   # files) but you cannot set it under 0.
+  #
   class Configuration < Hash
 
+    DEFAULT_OPTIONS = {
+      threshold: 100,
+      include: ['lib'],
+      exclude: %w( spec test ),
+      single_line_report: true,
+      always_run: true,
+      show_link_in_terminal: false,
+      exclude_above_threshold: true,
+      theme: 'light',
+    }.freeze
+
     # Public: Initialize a Configuration.
+    #
     def initialize
-      self[:threshold] = 100
-      self[:directories] = ['lib']
-      self[:excludes] = ['spec', 'test']
-      self[:single_line_report] = false
-      self[:always_run] = true
-      self[:show_link_in_terminal] = false
-      self[:exclude_above_threshold] = true
+      merge!(DEFAULT_OPTIONS)
       if File.exist?('.coco.yml')
-        self.merge!(YAML.load_file('.coco.yml'))
+        merge!(YAML.load_file('.coco.yml'))
       # Deprecated: Support of '.coco' file will be removed in v1.0.
       elsif File.exist?('.coco')
-        warn('Please use `.coco.yml` instead of `.coco`.')
-        warn('Support for `.coco` will be removed in future versions.')
-        self.merge!(YAML.load_file('.coco'))
+        warn(DeprecatedMessage.for_legacy_config_file)
+        merge!(YAML.load_file('.coco'))
       end
 
+      ensure_known_theme
       ensure_threeshold_compatibility
+      ensure_directories_compatibility
+      ensure_excludes_compatibility
       expand_directories
       remove_directories
     end
@@ -49,13 +58,13 @@ module Coco
     # If the configuration key :always_run is set to true, we always
     # run the coverage.
     # In case the configuration key :always_run is set to false, we have
-    # to check for an environement variable named 'COCO' to decide if
+    # to check for an environment variable named 'COCO' to decide if
     # we launch the coverage or not. When 'COCO' doesn't exist, or is
     # the empty string, or '0', or 'false', we don't run coverage.
     # When 'COCO' is set to any other value, we start coverage.
     #
     # Returns true if coverage should start.
-    def user_wants_to_run?
+    def run_this_time?
       if self[:always_run]
         true
       else
@@ -66,27 +75,57 @@ module Coco
     private
 
     def expand_directories
-      self[:excludes].each do |file_or_dir|
+      self[:exclude].each do |file_or_dir|
         add_files file_or_dir if File.directory?(file_or_dir)
       end
     end
 
     def add_files(dir)
-      Helpers.rb_files_from(dir).each {|file| self[:excludes] << file }
+      Helpers.rb_files_from(dir).each { |file| self[:exclude] << file }
     end
 
     def remove_directories
-      self[:excludes].delete_if {|file_or_dir| File.directory?(file_or_dir) }
+      self[:exclude].delete_if { |file_or_dir| File.directory?(file_or_dir) }
     end
 
     def ensure_threeshold_compatibility
-      if !self[:threeshold].nil?
-        warn('Please change `threeshold` to `threshold`.')
-        warn('Support for the misspelt `threeshold` configuration key will be removed in future COCO versions.')
+      if threeshold_present?
+        warn(DeprecatedMessage.for_threeshold)
         self[:threshold] = self[:threeshold]
       end
     end
 
-  end
+    def threeshold_present?
+      self[:threeshold]
+    end
+
+    def ensure_directories_compatibility
+      if directories_present?
+        warn(DeprecatedMessage.for_directories)
+        self[:include] = self[:directories]
+      end
+    end
+
+    def directories_present?
+      self[:directories]
+    end
 
+    def ensure_excludes_compatibility
+      if excludes_present?
+        warn(DeprecatedMessage.for_excludes)
+        self[:exclude] = self[:excludes]
+      end
+    end
+
+    def excludes_present?
+      self[:excludes]
+    end
+
+    def ensure_known_theme
+      unless %w( light dark ).include?(self[:theme])
+        warn("\n\nThe theme '#{self[:theme]}' didn't exist.\n\n")
+        self[:theme] = 'light'
+      end
+    end
+  end
 end

data/lib/coco/cover.rb

@@ -1,2 +1,3 @@
 require 'coco/cover/coverage_stat'
 require 'coco/cover/coverage_result'
+require 'coco/cover/summary'

data/lib/coco/cover/coverage_result.rb

@@ -2,56 +2,112 @@ module Coco
 
   # Compute results of interest from the big results information (from
   # Coverage.result)
+  #
   class CoverageResult
 
     # Returns a Hash coverage for all the sources that live in the root
     # project folder.
-    attr_reader :all_from_domain
+    #
+    attr_reader :coverable_files
 
     # Returns a Hash coverage for sources that are not sufficiently
     # covered. More technically, the sources that live in the root
     # project folder and for which the coverage percentage is under the
     # threshold.
-    attr_reader :covered_from_domain
+    #
+    attr_reader :not_covered_enough
 
     # Public: Initialize a CoverageResult.
     #
     # config      - Hash
-    # raw_results - Hash results obtained from Coverage.result.
+    # raw_results - The Hash from Coverage.result. Keys are filenames
+    #               and values are an Array representing each lines of
+    #               the file :
+    #               + nil       : Unreacheable (comments, etc).
+    #               + 0         : Not hit.
+    #               + 1 or more : Number of hits.
+    #
     def initialize(config, raw_results)
-      @exclude_files = config[:excludes]
+      raise ArgumentError if config[:threshold] < 0
+
+      @exclude_files = config[:exclude]
       @threshold = config[:threshold]
-      raise ArgumentError if @threshold < 0
       @result = raw_results
+
       exclude_external_sources
-      exclude_files_user_dont_want
-      if config[:exclude_above_threshold]
-        @covered_from_domain = exclude_sources_above_threshold
-      else
-        @covered_from_domain = @all_from_domain
-      end
+      exclude_files_user_dont_want if @exclude_files
+
+      @not_covered_enough = if config[:exclude_above_threshold]
+                              exclude_sources_above_threshold
+                            else
+                              @coverable_files
+                            end
+    end
+
+    # Public: Count the number of "coverable" files.
+    #
+    # Returns the Fixnum number of files.
+    #
+    def count
+      coverable_files.size
+    end
+
+    # Public: Count the number of uncovered files, that is, files with a
+    # coverage rate of 0%.
+    #
+    # Returns the Fixnum number of uncovered files.
+    #
+    def uncovered_count
+      not_covered_enough.select do |_, hits|
+        CoverageStat.coverage_percent(hits).zero?
+      end.size
+    end
+
+    # Public: Computes the average coverage rate.
+    # The formula is simple:
+    #
+    # N = number of files
+    # f = a file
+    # average = sum(f_i%) / N
+    #
+    # In words: Take the sum of the coverage's percentage of all files
+    # and divide this sum by the number of files.
+    #
+    # Returns the Fixnum rounded average rate of coverage.
+    #
+    def average
+      files_present? ? (sum / count).round : 0
     end
 
     private
 
     def exclude_external_sources
       here = Dir.pwd
-      @all_from_domain = @result.select {|key, value| key.start_with?(here) }
+      @coverable_files = @result.select { |key, _| key.start_with?(here) }
     end
 
     def exclude_files_user_dont_want
-      return if @exclude_files.nil?
       @exclude_files.each do |filename|
-        @all_from_domain.delete(File.expand_path(filename))
+        @coverable_files.delete(File.expand_path(filename))
       end
     end
 
     def exclude_sources_above_threshold
-      @all_from_domain.select do |key, value|
+      @coverable_files.select do |_, value|
         CoverageStat.coverage_percent(value) < @threshold
       end
     end
 
-  end
+    # Returns the Float sum of all files' percentage.
+    #
+    def sum
+      @coverable_files.values.map do |hits|
+        CoverageStat.real_percent(hits)
+      end.reduce(&:+)
+    end
 
+    def files_present?
+      count > 0
+    end
+  end
 end

data/lib/coco/cover/coverage_stat.rb

@@ -9,20 +9,32 @@ module Coco
   # * nil: source line will never be reached (like comments).
   # * 0: source line could be reached, but was not.
   # * 1 and above: number of time the source line has been reached.
+  #
   module CoverageStat
-    extend self
 
-    # Public: Compute the percentage of code coverage for a file.
+    # Public: Compute the decimal percentage of code coverage for a file.
     # The file is represented by an array of hits.
     #
     # hits - Array of Integer.
     #
-    # Returns a Integer (rounded) percentage.
-    def coverage_percent(hits)
+    # Returns a Float percentage of coverage.
+    #
+    def self.real_percent(hits)
       hits = hits.compact
       return 0 if hits.empty?
       one_percent = 100.0 / hits.size
-      (number_of_covered_lines(hits) * one_percent).to_i
+      number_of_covered_lines(hits) * one_percent
+    end
+
+    # Public: Compute the integer percentage of code coverage for a file.
+    # The file is represented by an array of hits.
+    #
+    # hits - Array of Integer.
+    #
+    # Returns a Integer rounded percentage of coverage.
+    #
+    def self.coverage_percent(hits)
+      real_percent(hits).round
     end
 
     # Compute the total of covered lines in a hits array.
@@ -30,9 +42,9 @@ module Coco
     # hits - Array of Integer.
     #
     # Returns Integer.
-    def number_of_covered_lines(hits)
-      hits.select {|hit| hit > 0 }.size
+    #
+    def self.number_of_covered_lines(hits)
+      hits.select { |hit| hit > 0 }.size
     end
-
   end
 end

data/lib/coco/cover/summary.rb

@@ -0,0 +1,50 @@
+module Coco
+
+  # A very brief summary of the coverage result.
+  #
+  class Summary
+    attr_reader :count, :uncovered_count
+
+    def initialize(result, uncovered)
+      @uncovered_count = uncovered.size
+      @coverable_files = result.coverable_files
+      @count = @coverable_files.size + @uncovered_count
+    end
+
+    def to_s
+      "Cover #{average}% | #{uncovered_count} uncovered | #{count} files"
+    end
+
+    # Public: Computes the average coverage rate.
+    # The formula is simple:
+    #
+    # N = number of files
+    # f = a file
+    # average = sum(f_i%) / N
+    #
+    # In words: Take the sum of the coverage's percentage of all files
+    # and divide this sum by the number of files.
+    #
+    # Returns the Fixnum rounded average rate of coverage.
+    #
+    def average
+      files_present? ? (sum / count).round : 0
+    end
+
+    private
+
+    attr_reader :coverable_files
+
+    # Returns the Float sum of all files' percentage.
+    #
+    def sum
+      coverable_files.values.map do |hits|
+        CoverageStat.real_percent(hits)
+      end.reduce(&:+)
+    end
+
+    def files_present?
+      count > 0
+    end
+  end
+end