deep-cover 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de76a03a06ec4a16d33c5a24a9c510678f83b33a
-  data.tar.gz: db775778d2b7d2c65ce0c299f3ff4f3900796e02
+  metadata.gz: 3a8450fe7655e95139f1443a7e81f3c73b726e03
+  data.tar.gz: b04f9ef3b69060ff9568cae7224bc89a845137bf
 SHA512:
-  metadata.gz: 246c598d3da7d0fca5d5c4e453dc134f2e36cc59e7529f4148fa159c8e31c3288316e731faec5d08be37167fdd605454f0155b12cea3fdcbd22235f3e9ad9df3
-  data.tar.gz: 96fea731d9cd93158718857999a9da092b9ec619126dc0814b339b8e3c460a224dca594194b35d686b8dbf5c5c4cde03de69bd17a1bcd482e92ab1851bbb4ee7
+  metadata.gz: 822e717af608dd6b6ed0010ce00f75aff18f4f60cfddc866df90ceefaf6131820a19f8a7a0e2d5eb00d961412dbcac23295e4b3aebb8be9cd1ae7ca7ecf13ab5
+  data.tar.gz: a5849e499b6f4eb7975af2e4529f5564e99a982d0cda525e0d246e6bce698f289e24cadf9a44ba3a85c4e78ae60da41813ef443f3f7114a261a6a856cd6a024e

data/.rubocop.yml

@@ -220,3 +220,18 @@ Style/StructInheritance:
 
 Security/YAMLLoad:
   Enabled: false
+
+Style/ExtendSelf:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false # See https://github.com/bbatsov/rubocop/issues/5259
+
+Gemspec/RequiredRubyVersion:
+  Enabled: false # See https://github.com/bbatsov/rubocop/issues/5260
+
+Style/MixinUsage:
+  Enabled: false # See https://github.com/bbatsov/rubocop/issues/5261
+
+Style/EvalWithLocation:
+  Enabled: false

data/.travis.yml

@@ -13,7 +13,7 @@ before_install:
 before_script:
   - bundle exec rake dev:install
 script:
-  - rake test:all
+  - bundle exec rake test:all
 matrix:
   allow_failures:
   - rvm: jruby-9.1.9.0

data/deep_cover.gemspec

@@ -38,6 +38,9 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'term-ansicolor'
   spec.add_runtime_dependency 'with_progress'
 
+  # Reporters
+  spec.add_runtime_dependency 'terminal-table'
+
   # While in 0.x
   spec.add_runtime_dependency 'pry'
 

data/lib/deep_cover.rb

@@ -1,24 +1,9 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/MixinUsage (See https://github.com/bbatsov/rubocop/issues/5055)
 module DeepCover
-  # External dependencies (ex parser)
-  require 'parser'
-  require 'term/ansicolor'
-  require 'pry'
+  require_relative 'deep_cover/load'
 
-  # Bootstrapping
-  require_relative 'deep_cover/backports'
-  require_relative 'deep_cover/tools'
-
-  # Parser
-  silence_warnings do
-    require 'parser/current'
-  end
-  require_relative_dir 'deep_cover/parser_ext'
-
-  # Main
-  require_relative_dir 'deep_cover', except: %w[auto_run builtin_takeover]
+  load_absolute_basics
 
   extend Base
   extend Config::Setter

data/lib/deep_cover/analyser.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-require_relative 'covered_code'
-
 module DeepCover
+  bootstrap
+
   # An analyser works on a subset of the original Node AST.
   # The Root node is always considered part of the subset.
   # One can iterate this subset with `each_node`, or ask

data/lib/deep_cover/base.rb

@@ -21,6 +21,7 @@ module DeepCover
     end
 
     def stop
+      require_relative 'core_ext/require_overrides'
       AutoloadOverride.active = false if defined? AutoloadOverride
       RequireOverride.active = false
       @started = false
@@ -72,6 +73,8 @@ module DeepCover
       @autoload_tracker ||= AutoloadTracker.new
     end
 
+    private
+
     def handle_relative_filename(filename)
       unless Pathname.new(filename).absolute?
         relative_to = File.dirname(caller(2..2).first.partition(/\.rb:\d/).first)
@@ -80,12 +83,5 @@ module DeepCover
       filename += '.rb' unless filename =~ /\.rb$/
       filename
     end
-
-    def parser
-      Parser::CurrentRuby.new.tap do |parser|
-        parser.diagnostics.all_errors_are_fatal = true
-        parser.diagnostics.ignore_warnings      = true
-      end
-    end
   end
 end

data/lib/deep_cover/builtin_takeover.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../deep_cover'
-require_relative '../deep_cover/core_ext/coverage_replacement'
+require_relative 'coverage'
+require_relative 'core_ext/coverage_replacement'
 
 require 'coverage'
 BuiltinCoverage = Coverage

data/lib/deep_cover/cli/deep_cover.rb

@@ -4,84 +4,83 @@ module DeepCover
   require 'bundler/setup'
   require 'slop'
   require 'deep_cover'
+  bootstrap
   require_relative_dir '.'
 
-  module CLI
-    module DeepCover
-      extend self
+  module CLI::DeepCover
+    extend self
 
-      def show_version
-        puts "deep-cover v#{::DeepCover::VERSION}; parser v#{::Parser::VERSION}"
-      end
+    def show_version
+      puts "deep-cover v#{DeepCover::VERSION}; parser v#{Parser::VERSION}"
+    end
 
-      def show_help
-        puts menu
-      end
+    def show_help
+      puts menu
+    end
 
-      class Parser < Struct.new(:delegate)
-        def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
-          options = args.last
-          if options.is_a?(Hash) && options.has_key?(:default)
-            args[-2] += " [#{options[:default]}]"
-          end
-          delegate.public_send(method, *args, &block)
+    class OptionParser < Struct.new(:delegate)
+      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
+        options = args.last
+        if options.is_a?(Hash) && options.has_key?(:default)
+          args[-2] += " [#{options[:default]}]"
         end
+        delegate.public_send(method, *args, &block)
       end
+    end
 
-      def parse
-        Slop.parse do |o|
-          yield Parser.new(o)
-        end
+    def parse
+      Slop.parse do |o|
+        yield OptionParser.new(o)
       end
+    end
 
-      def menu
-        @menu ||= parse do |o|
-          o.banner = 'usage: deep-cover [options] [path/to/app/or/gem]'
-          o.separator ''
-          o.string '-o', '--output', 'output folder', default: './coverage'
-          o.string '-c', '--command', 'command to run tests', default: 'bundle exec rake'
-          o.string '--reporter', 'reporter', default: 'html'
-          o.bool '--bundle', 'run bundle before the tests', default: true
-          o.bool '--process', 'turn off to only redo the reporting', default: true
-          o.bool '--open', 'open the output coverage', default: false
-          o.separator 'Coverage options'
-          @ignore_uncovered_map = Analyser::Node.optionally_covered.map do |option|
-            default = Config::DEFAULTS[:ignore_uncovered].include?(option)
-            o.bool "--ignore-#{Tools.dasherize(option)}", '', default: default
-            [:"ignore_#{option}", option]
-          end.to_h
-          o.separator "\nFor testing purposes:"
-          o.bool '--profile', 'use profiler' unless RUBY_PLATFORM == 'java'
-          o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
-          o.bool '-d', '--debug', 'enter debugging after cover'
+    def menu
+      @menu ||= parse do |o|
+        o.banner = 'usage: deep-cover [options] [path/to/app/or/gem]'
+        o.separator ''
+        o.string '-o', '--output', 'output folder', default: './coverage'
+        o.string '-c', '--command', 'command to run tests', default: 'bundle exec rake'
+        o.string '--reporter', 'reporter', default: 'html'
+        o.bool '--bundle', 'run bundle before the tests', default: true
+        o.bool '--process', 'turn off to only redo the reporting', default: true
+        o.bool '--open', 'open the output coverage', default: false
+        o.separator 'Coverage options'
+        @ignore_uncovered_map = Analyser::Node.optionally_covered.map do |option|
+          default = Config::DEFAULTS[:ignore_uncovered].include?(option)
+          o.bool "--ignore-#{Tools.dasherize(option)}", '', default: default
+          [:"ignore_#{option}", option]
+        end.to_h
+        o.separator "\nFor testing purposes:"
+        o.bool '--profile', 'use profiler' unless RUBY_PLATFORM == 'java'
+        o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
+        o.bool '-d', '--debug', 'enter debugging after cover'
 
-          o.separator "\nOther available commands:"
-          o.on('--version', 'print the version') do
-            show_version
-            exit
-          end
-          o.boolean('-h', '--help')
+        o.separator "\nOther available commands:"
+        o.on('--version', 'print the version') do
+          show_version
+          exit
         end
+        o.boolean('-h', '--help')
       end
+    end
 
-      def convert_options(options)
-        iu = options[:ignore_uncovered] = []
-        @ignore_uncovered_map.each do |cli_option, option|
-          iu << option if options.delete(cli_option)
-        end
-        options
+    def convert_options(options)
+      iu = options[:ignore_uncovered] = []
+      @ignore_uncovered_map.each do |cli_option, option|
+        iu << option if options.delete(cli_option)
       end
+      options
+    end
 
-      def go
-        options = convert_options(menu.to_h)
-        if options[:help]
-          show_help
-        elsif options[:expression]
-          Debugger.new(options[:expression], **options).show
-        else
-          path = menu.arguments.first || '.'
-          InstrumentedCloneReporter.new(path, **options).run
-        end
+    def go
+      options = convert_options(menu.to_h)
+      if options[:help]
+        show_help
+      elsif options[:expression]
+        CLI::Debugger.new(options[:expression], **options).show
+      else
+        path = menu.arguments.first || '.'
+        CLI::InstrumentedCloneReporter.new(path, **options).run
       end
     end
   end

data/lib/deep_cover/config.rb

@@ -3,14 +3,16 @@
 module DeepCover
   class Config
     DEFAULTS = {
-                 ignore_uncovered: [],
-                 paths: %w[./app ./lib],
+                 ignore_uncovered: [].freeze,
+                 paths: %w[./app ./lib].freeze,
                  allow_partial: false,
                }.freeze
 
-    def initialize(notify = nil, **options)
+    OPTIONALLY_COVERED = %i[raise default_argument case_implicit_else trivial_if]
+
+    def initialize(notify = nil)
       @notify = notify
-      @options = copy(DEFAULTS.merge(options))
+      @options = DEFAULTS.dup
     end
 
     def to_hash
@@ -29,7 +31,7 @@ module DeepCover
 
     def detect_uncovered(*keywords)
       if keywords.empty?
-        Analyser::Node.optionally_covered - @options[:ignore_uncovered]
+        OPTIONALLY_COVERED - @options[:ignore_uncovered]
       else
         check_uncovered(keywords)
         change(:ignore_uncovered, @options[:ignore_uncovered] - keywords)
@@ -53,7 +55,7 @@ module DeepCover
     private
 
     def check_uncovered(keywords)
-      unknown = keywords - Analyser::Node.optionally_covered
+      unknown = keywords - OPTIONALLY_COVERED
       raise ArgumentError, "unknown options: #{unknown.join(', ')}" unless unknown.empty?
     end
 
@@ -65,10 +67,6 @@ module DeepCover
       self
     end
 
-    def copy(h)
-      h.dup.transform_values(&:dup).transform_values(&:freeze)
-    end
-
     module Setter
       def config(notify = self)
         @config ||= Config.new(notify)

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -7,6 +7,8 @@
 # overrides Kernel#require)
 
 module DeepCover
+  load_all
+
   module RequireOverride
     def require(path)
       result = catch(:use_fallback) { DeepCover.custom_requirer.require(path) }

data/lib/deep_cover/coverage.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module DeepCover
-  require_relative 'covered_code'
-  Coverage = Class.new
+  bootstrap
+
+  class Coverage
+  end
   require_relative_dir 'coverage'
   Coverage.include Coverage::Istanbul
 end

data/lib/deep_cover/coverage/analysis.rb

@@ -15,6 +15,10 @@ module DeepCover
       analyser_map.transform_values { |a| a.transform_values(&:stats) }
     end
 
+    def self.template
+      {node: Analyser::Node, per_char: Analyser::PerChar, branch: Analyser::Branch}
+    end
+
     private
 
     def compute_analysers(covered_code)

data/lib/deep_cover/coverage/base.rb

@@ -37,6 +37,7 @@ module DeepCover
       case (reporter = options.fetch(:reporter, :html).to_sym)
       when :html
         Reporter::HTML.report(self, **options)
+        Reporter::Text.report(self, **options) + "\n\nHTML generated: open #{options[:output]}/index.html"
       when :istanbul
         if Reporter::Istanbul.available?
           report_istanbul(**options)
@@ -44,28 +45,12 @@ module DeepCover
           warn 'nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`'
         end
       when :text
-        basic_report
+        Reporter::Text.report(self, **options)
       else
         raise ArgumentError, "Unknown reporter: #{reporter}"
       end
     end
 
-    def basic_report
-      missing = map do |covered_code|
-        if covered_code.has_executed?
-          missed = covered_code.line_coverage.each_with_index.map do |line_cov, line_index|
-            line_index + 1 if line_cov == 0
-          end.compact
-        else
-          missed = ['all']
-        end
-        [covered_code.buffer.name, missed] unless missed.empty?
-      end.compact.to_h
-      missing.map do |path, lines|
-        "#{File.basename(path)}: #{lines.join(', ')}"
-      end.join("\n")
-    end
-
     def self.load(dest_path, dirname = 'deep_cover', with_trackers: true)
       Persistence.new(dest_path, dirname).load(with_trackers: with_trackers)
     end

data/lib/deep_cover/coverage/persistence.rb

@@ -3,7 +3,6 @@
 module DeepCover
   require 'securerandom'
   class Coverage::Persistence
-    # rubocop:disable Security/MarshalLoad
     BASENAME = 'coverage.dc'
     TRACKER_TEMPLATE = 'trackers%{unique}.dct'
 
@@ -56,6 +55,7 @@ module DeepCover
       ))
     end
 
+    # rubocop:disable Security/MarshalLoad
     def load_coverage
       Marshal.load(dir_path.join(BASENAME).binread).tap do |version: raise, coverage: raise|
         raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
@@ -71,6 +71,7 @@ module DeepCover
         end
       end
     end
+    # rubocop:enable Security/MarshalLoad
 
     def merge_trackers(hash, to_merge)
       hash.merge!(to_merge) do |_key, current, to_add|

data/lib/deep_cover/covered_code.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module DeepCover
+  bootstrap
+  load_parser
+
   class CoveredCode
     DEFAULT_TRACKER_GLOBAL = '$_cov'
 
@@ -11,7 +14,7 @@ module DeepCover
     def initialize(path: nil, source: nil, lineno: 1, tracker_global: DEFAULT_TRACKER_GLOBAL, local_var: '_temp', name: nil)
       raise 'Must provide either path or source' unless path || source
 
-      @buffer = ::Parser::Source::Buffer.new(path, lineno)
+      @buffer = Parser::Source::Buffer.new(path, lineno)
       @buffer.source = source || File.read(path)
       @tracker_count = 0
       @tracker_global = tracker_global
@@ -88,7 +91,7 @@ module DeepCover
 
     def root
       @root ||= begin
-        ast = DeepCover.parser.parse(@buffer)
+        ast = parser.parse(@buffer)
         Node::Root.new(ast, self)
       end
     end
@@ -98,7 +101,7 @@ module DeepCover
     end
 
     def instrument_source
-      rewriter = ::Parser::Source::TreeRewriter.new(@buffer)
+      rewriter = Parser::Source::TreeRewriter.new(@buffer)
       covered_ast.each_node(:postorder) do |node|
         node.rewriting_rules.each do |range, rule|
           prefix, _node, suffix = rule.partition('%{node}')
@@ -132,5 +135,14 @@ module DeepCover
     def global
       @@globals[tracker_global]
     end
+
+    private
+
+    def parser
+      Parser::CurrentRuby.new.tap do |parser|
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings      = true
+      end
+    end
   end
 end

data/lib/deep_cover/load.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Load
+    AUTOLOAD = %i[analyser autoload_tracker coverage covered_code custom_requirer memoize
+                  module_override node problem_with_diagnostic reporter
+                 ]
+
+    def load_absolute_basics
+      require_relative 'base'
+      require_relative 'config'
+      require_relative 'tools/camelize'
+      AUTOLOAD.each do |module_name|
+        DeepCover.autoload(Tools::Camelize.camelize(module_name), "#{__dir__}/#{module_name}")
+      end
+      Object.autoload :Term, 'term/ansicolor'
+      Object.autoload :Terminal, 'terminal-table'
+      require 'pry'
+    end
+
+    def bootstrap
+      return if @bootstrapped
+      require_relative 'backports'
+      require_relative 'tools'
+      @bootstrapped = true
+    end
+
+    def load_parser
+      return if @parser_loaded
+      require 'parser'
+      silence_warnings do
+        require 'parser/current'
+      end
+      require_relative_dir 'parser_ext'
+      @parser_loaded
+    end
+
+    def load_all
+      return if @all_loaded
+      bootstrap
+      load_parser
+      AUTOLOAD.each do |module_name|
+        DeepCover.const_get(Tools::Camelize.camelize(module_name))
+      end
+      @all_loaded = true
+    end
+  end
+
+  extend Load
+end

data/lib/deep_cover/memoize.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module DeepCover
+  bootstrap
+
   # Memoize is a quick way to prepend a module that defines
   # the memoized methods as `@_cache ||= super.freeze`
   # It also refines `freeze` to precache memoized methods

data/lib/deep_cover/node.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module DeepCover
+  bootstrap
+  load_parser
+
   class Node
     # Reopened in base
     CLASSES = []
@@ -13,7 +16,6 @@ module DeepCover
   require_relative 'node/base'
   require_relative_dir 'node'
 
-  require_relative 'memoize'
   Node.include Memoize
   Node::CLASSES.freeze.each do |klass|
     klass.memoize :flow_entry_count, :flow_completion_count, :execution_count, :loc_hash

data/lib/deep_cover/node/root.rb

@@ -4,7 +4,7 @@ module DeepCover
   class Node::Root < Node
     has_tracker :root
     has_child main: Node,
-              can_be_empty: -> { ::Parser::Source::Range.new(covered_code.buffer, 0, 0) },
+              can_be_empty: -> { Parser::Source::Range.new(covered_code.buffer, 0, 0) },
               is_statement: true,
               rewrite: -> {
                 "#{covered_code.trackers_setup_source};%{root_tracker};%{local}=nil;%{node}"

data/lib/deep_cover/problem_with_diagnostic.rb

@@ -6,7 +6,7 @@ module DeepCover
 
     def initialize(covered_code, line_range, original_exception = nil)
       @covered_code = covered_code
-      if line_range.is_a?(Parser::Source::Range)
+      if line_range.respond_to? :last_line
         @line_range = line_range.line..line_range.last_line
       else
         @line_range = line_range

data/lib/deep_cover/reporter.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 module DeepCover
+  bootstrap
+
   module Reporter
   end
   require_relative 'node'
+  require_relative_dir 'reporter/util'
   require_relative_dir 'reporter'
 end

data/lib/deep_cover/reporter/html/index.rb

@@ -1,23 +1,35 @@
 # frozen_string_literal: true
 
 module DeepCover
-  module Reporter
-    require_relative 'tree'
-    require_relative 'base'
+  require_relative 'base'
 
+  module Reporter
     class HTML::Index < Struct.new(:analysis, :options)
       def initialize(analysis, **options)
         raise ArgumentError unless analysis.is_a? Coverage::Analysis
         super
       end
 
-      include HTML::Tree
+      include Util::Tree
       include HTML::Base
 
       def stats_to_data
-        @map = Tools.transform_keys(analysis.stat_map, &:name)
-        tree = paths_to_tree(@map.keys)
-        transform_data(populate(tree))
+        populate_stats(analysis) do |full_path, partial_path, data, children|
+          data = transform_data(data)
+          if children.empty?
+            {
+              text: %{<a href="#{full_path}.html">#{partial_path}</a>},
+              data: data,
+            }
+          else
+            {
+              text: partial_path,
+              data: data,
+              children: children,
+              state: {opened: true},
+            }
+          end
+        end
       end
 
       def columns
@@ -38,40 +50,12 @@ module DeepCover
 
       private
 
-      # {a: {}}    => [{text: a, data: stat_map[a]}]
-      # {b: {...}} => [{text: b, data: sum(stats), children: [...]}]
-      def populate(tree, dir = '')
-        tree.map do |path, children_hash|
-          full_path = [dir, path].join
-          if children_hash.empty?
-            {
-              text: %{<a href="#{full_path}.html">#{path}</a>},
-              data: @map[full_path],
-            }
-          else
-            children = populate(children_hash, "#{full_path}/")
-            data = Tools.merge(*children.map { |c| c[:data] }, :+)
-            {
-              text: path,
-              data: data,
-              children: children,
-              state: {opened: true},
-            }
-          end
-        end
-      end
-
-      # Modifies in place the tree:
       # {per_char: Stat, ...} => {per_char: {ignored: ...}, per_char_percent: 55.55, ...}
-      def transform_data(tree)
-        return unless tree
-        tree.each do |node|
-          node[:data] = Tools.merge(
-              node[:data].transform_values(&:to_h),
-              *node[:data].map { |type, stat| {:"#{type}_percent" => stat.percent_covered} }
-          )
-          transform_data(node[:children])
-        end
+      def transform_data(data)
+        Tools.merge(
+            data.transform_values(&:to_h),
+            *data.map { |type, stat| {:"#{type}_percent" => stat.percent_covered} }
+        )
       end
     end
   end

data/lib/deep_cover/reporter/html/source.rb

@@ -25,7 +25,7 @@ module DeepCover
       end
 
       def convert_source
-        @rewriter = ::Parser::Source::TreeRewriter.new(covered_code.buffer)
+        @rewriter = Parser::Source::TreeRewriter.new(covered_code.buffer)
         insert_node_tags
         insert_branch_tags
         html_escape
@@ -126,7 +126,7 @@ module DeepCover
         {'<' => '&lt;', '>' => '&gt;', '&' => '&amp;'}.each do |char, escaped|
           source.scan(char) do
             m = Regexp.last_match
-            range = ::Parser::Source::Range.new(buffer, m.begin(0), m.end(0))
+            range = Parser::Source::Range.new(buffer, m.begin(0), m.end(0))
             @rewriter.replace(range, escaped)
           end
         end

data/lib/deep_cover/reporter/text.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter
+    class Text
+      include Util::Tree
+      def initialize(coverage, **options)
+        @coverage = coverage
+        @options = options
+      end
+
+      def analysis
+        Coverage::Analysis.new(@coverage.covered_codes, **@options)
+      end
+
+      INDENT = '  '
+      def report
+        formatted_headings = headings.map.with_index { |h, i| {value: h, alignment: :center} }
+        columns = rows.transpose
+        (1...columns.size).step(2) { |i| columns[i] = formatted_stats(columns[i]) }
+        table = Terminal::Table.new(
+            headings: formatted_headings,
+            rows: columns.transpose,
+            style: {border_bottom: false, border_top: false, alignment: :right},
+        )
+        table.align_column 0, :left
+        table.render
+      end
+
+      def self.report(coverage, **options)
+        Text.new(coverage, **options).report
+      end
+
+      private
+
+      def formatted_stats(data)
+        columns = data.transpose
+        columns[1..1] = [] if columns[1].none?
+        Terminal::Table.new(
+            rows: columns.transpose,
+            style: {border_x: '', border_bottom: false, border_top: false, alignment: :right}
+        ).render.gsub(' | ', ' ').gsub(/ ?\| ?/, '').split("\n")
+      end
+
+      def rows
+        populate_stats(analysis).map do |full_path, partial_path, data, children|
+          [partial_path, *transform_data(data)]
+        end
+      end
+
+      def headings
+        Coverage::Analysis.template.values.flat_map do |analyser|
+          [analyser.human_name, '%']
+        end.unshift('Path')
+      end
+
+      # {per_char: Stat, ...} => ['1 [+2] / 3', '100 %', ...]
+      def transform_data(data)
+        data.flat_map do |type, stat|
+          ignored = "[+#{stat.ignored}]" if stat.ignored > 0
+          [[stat.executed, ignored, '/', stat.potentially_executable], format('%.2f', stat.percent_covered)]
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/reporter/util/tree.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter
+    module Util
+      # Utility functions to deal with trees
+      module Tree
+        def paths_to_tree(paths)
+          twigs = paths.map do |path|
+            partials = path_to_partial_paths(path)
+            list_to_twig(partials)
+          end
+          tree = deep_merge(twigs)
+          simplify(tree)
+        end
+
+        # 'some/example/path' => %w[some example path]
+        def path_to_partial_paths(path)
+          path.to_s.split('/')
+        end
+
+        # A twig is a tree with only single branches
+        # [a, b, c] =>
+        #   {a: {b: {c: {} } } }
+        def list_to_twig(items)
+          result = {}
+          items.inject(result) do |parent, value|
+            parent[value] = {}
+          end
+          result
+        end
+
+        #   [{a: {b: {c: {} } } }
+        #    {a: {b: {d: {} } } }]
+        # => {a: {b: {c: {}, d: {} }}}
+        def deep_merge(trees)
+          trees.inject do |result, h|
+            result.merge(h) { |k, val, val_b| deep_merge([val, val_b]) }
+          end
+        end
+
+        # {a: {b: {c: {}, d: {} }}}
+        # => {a/b: {c: {}, d: {} }}
+        def simplify(tree)
+          tree.map do |key, sub_tree|
+            sub_tree = simplify(sub_tree)
+            if sub_tree.size == 1
+              key2, sub_tree = sub_tree.first
+              key = "#{key}/#{key2}"
+            end
+            [key, sub_tree]
+          end.to_h
+        end
+
+        # {a: {b: {}}}    => [ra, rb]
+        # where rb = yield('a/b', 'b', [])
+        # and ra = yield('a', 'a', [rb])
+        def populate(tree, dir = '', &block)
+          return to_enum(__method__, tree, dir) unless block_given?
+          tree.map do |path, children_hash|
+            full_path = [dir, path].join
+            children = populate(children_hash, "#{full_path}/", &block)
+            yield full_path, path, children
+          end
+        end
+
+        # Same as populate, but also yields data, which is either the analysis data (for leaves)
+        # of the sum of the children (for subtrees)
+        def populate_stats(analysis)
+          return to_enum(__method__, analysis) unless block_given?
+          map = Tools.transform_keys(analysis.stat_map, &:name)
+          tree = paths_to_tree(map.keys)
+          final_results, _final_data = populate(tree) do |full_path, partial_path, children|
+            if children.empty?
+              data = map[full_path]
+            else
+              child_results, child_data = children.transpose
+              data = Tools.merge(*child_data, :+)
+            end
+            result = yield full_path, partial_path, data, child_results || []
+            [result, data]
+          end.transpose
+          final_results
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/tools.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module DeepCover
-  Tools = Module.new
+  module Tools
+  end
 
   require_relative 'tools/require_relative_dir'
   extend Tools::RequireRelativeDir

data/lib/deep_cover/tools/builtin_coverage.rb

@@ -2,9 +2,8 @@
 
 module DeepCover
   module Tools::BuiltinCoverage
-    require 'coverage'
-
     def builtin_coverage(source, fn, lineno)
+      require 'coverage'
       fn = File.absolute_path(File.expand_path(fn))
       ::Coverage.start
       Tools.silence_warnings do

data/lib/deep_cover/tools/camelize.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 module DeepCover
-  module Tools::Camelize
-    # Poor man's camelize. 'an_example' => 'AnExample'
-    def camelize(string)
-      string.to_s.gsub(/([a-z\d]*)[_?!]?/) { Regexp.last_match(1).capitalize }
+  module Tools
+    module Camelize
+      extend self # Loaded before bootstrap
+      # Poor man's camelize. 'an_example' => 'AnExample'
+      def camelize(string)
+        string.to_s.gsub(/([a-z\d]*)[_?!]?/) { Regexp.last_match(1).capitalize }
+      end
     end
   end
 end

data/lib/deep_cover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepCover
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deep-cover
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Marc-André Lafortune
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-08 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -109,6 +109,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -271,6 +285,7 @@ files:
 - lib/deep_cover/coverage/persistence.rb
 - lib/deep_cover/covered_code.rb
 - lib/deep_cover/custom_requirer.rb
+- lib/deep_cover/load.rb
 - lib/deep_cover/memoize.rb
 - lib/deep_cover/module_override.rb
 - lib/deep_cover/node.rb
@@ -327,8 +342,9 @@ files:
 - lib/deep_cover/reporter/html/template/assets/throbber.gif
 - lib/deep_cover/reporter/html/template/index.html.erb
 - lib/deep_cover/reporter/html/template/source.html.erb
-- lib/deep_cover/reporter/html/tree.rb
 - lib/deep_cover/reporter/istanbul.rb
+- lib/deep_cover/reporter/text.rb
+- lib/deep_cover/reporter/util/tree.rb
 - lib/deep_cover/tools.rb
 - lib/deep_cover/tools/builtin_coverage.rb
 - lib/deep_cover/tools/camelize.rb

data/lib/deep_cover/reporter/html/tree.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Reporter
-    # Utility functions to deal with trees
-    module HTML::Tree
-      def paths_to_tree(paths)
-        twigs = paths.map do |path|
-          partials = path_to_partial_paths(path)
-          list_to_twig(partials)
-        end
-        tree = deep_merge(twigs)
-        simplify(tree)
-      end
-
-      # 'some/example/path' => %w[some example path]
-      def path_to_partial_paths(path)
-        path.to_s.split('/')
-      end
-
-      # A twig is a tree with only single branches
-      # [a, b, c] =>
-      #   {a: {b: {c: {} } } }
-      def list_to_twig(items)
-        result = {}
-        items.inject(result) do |parent, value|
-          parent[value] = {}
-        end
-        result
-      end
-
-      #   [{a: {b: {c: {} } } }
-      #    {a: {b: {d: {} } } }]
-      # => {a: {b: {c: {}, d: {} }}}
-      def deep_merge(trees)
-        trees.inject do |result, h|
-          result.merge(h) { |k, val, val_b| deep_merge([val, val_b]) }
-        end
-      end
-
-      # {a: {b: {c: {}, d: {} }}}
-      # => {a/b: {c: {}, d: {} }}
-      def simplify(tree)
-        tree.map do |key, sub_tree|
-          sub_tree = simplify(sub_tree)
-          if sub_tree.size == 1
-            key2, sub_tree = sub_tree.first
-            key = "#{key}/#{key2}"
-          end
-          [key, sub_tree]
-        end.to_h
-      end
-    end
-  end
-end