deep-cover-core 0.6.3.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: debeec0965c606820ce563e1c2fb785d14106c58
+  data.tar.gz: 35883be54022a4cc9340b15df798c3a589f3967e
+SHA512:
+  metadata.gz: 9e0f41ed90e2c47113239eeb0d31cad3663545280aadfc5f9146027002c8e21617759e2627682a23cb3c64d558da41bc065d5f85694401dc88d8c7dc140a6002
+  data.tar.gz: ca966b619af0f4bd829bcc16c34818108f43a398d7ca8b23dc3063697a83d4d542da6d3a7f468ac2057d9cd1fe9742648cd69b65df5a2cb7c2f00c403ac4e6ea

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--exclude-pattern "spec/code_fixtures/**/*.rb"
+--tag ~slow
+--tag ~skip

data/.rspec_all

@@ -0,0 +1,3 @@
+--color
+--exclude-pattern "spec/code_fixtures/**/*.rb"
+--tag ~skip

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: ../.rubocop.yml

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in deep_cover.gemspec
+gemspec
+
+local = File.expand_path('Gemfile.local', __dir__)
+eval_gemfile local if File.exist?(local)

data/deep_cover_core.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'lib/deep_cover/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'deep-cover-core'
+  spec.version       = DeepCover::VERSION
+  spec.authors       = ['Marc-André Lafortune', 'Maxime Lapointe']
+  spec.email         = ['github@marc-andre.ca', 'hunter_spawn@hotmail.com']
+
+  spec.summary       = 'In depth coverage of your Ruby code.'
+  spec.description   = 'Core functionality for the DeepCover gem.'
+  spec.homepage      = 'https://github.com/deep-cover/deep-cover'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  ### Runtime dependencies
+  spec.required_ruby_version = '>= 2.1.0'
+
+  # Main dependency
+  spec.add_runtime_dependency 'parser', '~> 2.5.0'
+
+  # Support
+  spec.add_runtime_dependency 'backports', '>= 3.11.0'
+  spec.add_runtime_dependency 'binding_of_caller'
+
+  # Reporters
+  spec.add_runtime_dependency 'terminal-table'
+
+  # While in 0.x
+  spec.add_runtime_dependency 'pry'
+
+  ### Dev dependencies
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'psych', '>= 2.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '0.53.0' # About every single release breaks something
+  spec.add_development_dependency 'sass'
+end

data/lib/deep-cover.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'deep_cover'

data/lib/deep_cover/analyser/base.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Analyser::Base
+    include Tools::Covered
+
+    attr_reader :source, :options
+
+    def initialize(source, **options)
+      @source = to_source(source, **options)
+      @options = options
+    end
+
+    # Looking exclusively at our subset of nodes, returns the node's direct descendants
+    def node_children(node)
+      @source.node_children(node)
+    end
+
+    # Returns the number of runs of the node (assumed to be in our subset)
+    def node_runs(node)
+      @source.node_runs(node)
+    end
+
+    def node_covered?(node)
+      covered?(node_runs(node))
+    end
+
+    def node_runs_map
+      each_node.map do |node|
+        [node, node_runs(node)]
+      end.to_h
+    end
+
+    # Analyser-specific output
+    def results
+      node_runs_map
+    end
+
+    def node_stat_type(node)
+      return :not_executable unless node.executable?
+      case node_runs(node)
+      when nil
+        :ignored
+      when 0
+        :not_executed
+      else
+        :executed
+      end
+    end
+
+    def node_stat_contributions(nodes)
+      if respond_to? :node_stat_contribution
+        nodes.sum { |n| node_stat_contribution(n) }
+      else
+        nodes.size
+      end
+    end
+
+    def stats
+      st = each_node.group_by { |n| node_stat_type(n) }
+                    .transform_values { |nodes| node_stat_contributions(nodes) }
+      Analyser::Stats.new(**st)
+    end
+
+    # Iterates on nodes in the subset.
+    # Yields the node and it's children (within the subset)
+    def each_node(from = covered_code.root, &block)
+      return to_enum(:each_node) unless block_given?
+      begin
+        yield from unless from.is_a?(Node::Root)
+      rescue ProblemWithDiagnostic
+        raise
+      rescue StandardError, SystemStackError => e
+        raise ProblemWithDiagnostic.new(covered_code, from.diagnostic_expression, e)
+      end
+      node_children(from).each do |child|
+        each_node(child, &block)
+      end
+    end
+
+    def covered_code
+      @source.covered_code
+    end
+
+    protected
+
+    def convert(covered_code, **options)
+      Analyser::Node.new(covered_code, **options)
+    end
+
+    def to_source(source, **options)
+      case source
+      when Analyser
+        source
+      when CoveredCode
+        convert(source, **options)
+      when Node
+        convert(source.covered_code, **options)
+      else
+        raise ArgumentError, "expected Analyser, Node or CoveredCode, got #{source.class}"
+      end
+    end
+  end
+end

data/lib/deep_cover/analyser/branch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Branch < Analyser
+    def self.human_name
+      'Branches'
+    end
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Branch].freeze
+
+    def node_runs(node)
+      runs = super
+      if node.is_a?(Node::Branch) && covered?(runs)
+        worst = worst_branch_runs(node)
+        runs = worst unless covered?(worst)
+      end
+      runs
+    end
+
+    def results
+      each_node.map do |node|
+        branches_runs = node.branches.map { |jump| [jump, branch_runs(jump)] }.to_h
+        [node, branches_runs]
+      end.to_h
+    end
+
+    private
+
+    def worst_branch_runs(fork)
+      fork.branches.map { |jump| branch_runs(jump) }
+          .sort_by { |runs| runs == 0 ? -2 : runs || -1 }
+          .first
+    end
+
+    def branch_runs(branch)
+      branch.flow_entry_count.nonzero? || source.node_runs(branch)
+    end
+  end
+end

data/lib/deep_cover/analyser/covered_code_source.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::CoveredCodeSource < Analyser
+    attr_reader :covered_code
+
+    def initialize(covered_code)
+      @covered_code = covered_code.freeze
+    end
+
+    # Looking exclusively at our subset of nodes, returns the node's direct descendants
+    def node_children(node)
+      node.children_nodes
+    end
+
+    # Returns the number of runs of the node (assumed to be in our subset)
+    def node_runs(node)
+      node.execution_count if node.executable?
+    end
+  end
+end

data/lib/deep_cover/analyser/function.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Function < Analyser
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Block, Node::Defs, Node::Def].freeze
+
+    def node_runs(node)
+      super(node.body)
+    end
+  end
+end

data/lib/deep_cover/analyser/node.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::Node < Analyser
+    include Analyser::Subset
+
+    def self.human_name
+      'Nodes'
+    end
+
+    def initialize(source, ignore_uncovered: [], **options)
+      @cache = {}.compare_by_identity
+      super
+      @allow_filters = Array(ignore_uncovered).map { |kind| Node.filter_to_method_name(kind) }
+      @nocov_ranges = FlagCommentAssociator.new(covered_code)
+    end
+
+    def node_runs(node)
+      @cache.fetch(node) do
+        runs = super
+        runs = nil if runs == 0 && should_be_ignored?(node)
+        @cache[node] = runs
+      end
+    end
+
+    def in_subset?(node, _parent)
+      node.executable?
+    end
+
+    protected
+
+    def convert(node, **) # rubocop:disable Naming/UncommunicativeMethodParamName [#5436]
+      Analyser::CoveredCodeSource.new(node)
+    end
+
+    private
+
+    def should_be_ignored?(node)
+      @nocov_ranges.include?(node) ||
+        @allow_filters.any? { |f| node.public_send(f) } ||
+        is_ignored?(node.parent)
+    end
+
+    def is_ignored?(node)
+      if node == nil
+        false
+      elsif node.executable?
+        node_runs(node).nil?
+      else
+        is_ignored?(node.parent)
+      end
+    end
+  end
+end

data/lib/deep_cover/analyser/per_char.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::PerChar < Analyser
+    def self.human_name
+      'Chars'
+    end
+
+    # Returns an array of characters for each line of code.
+    # Each character is either ' ' (executed), '-' (not executable) or 'x' (not covered)
+    def results
+      bc = buffer.source_lines.map { |line| '-' * line.size }
+      each_node do |node|
+        runs = node_runs(node)
+        next if runs == nil
+        node.proper_range.each do |pos|
+          bc[buffer.line_for_position(pos) - buffer.first_line][buffer.column_for_position(pos)] = runs > 0 ? ' ' : 'x'
+        end
+      end
+      bc.zip(buffer.source_lines) { |cov, line| cov[line.size..-1] = '' } # remove extraneous character for end lines, in any
+      bc
+    end
+
+    def node_stat_contribution(node)
+      node.executed_locs.sum(&:size)
+    end
+
+    def stats
+      s = super
+      actual_total = buffer.source.size
+      s.with not_executable: actual_total - s.total
+    end
+
+    def buffer
+      covered_code.buffer
+    end
+  end
+end

data/lib/deep_cover/analyser/per_line.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::PerLine < Analyser
+    # Returns an array of runs, one per line.
+    # allow_partial can be one of:
+    #   true: Allow any partial covering. Basically ruby's line coverage,
+    #         if any thing is executed, it is considered executed
+    #   branch: Only allow branches to be partially covered.
+    #           if a node is not executed, the line has to be marked as not executed, even if part of it was.
+    #   false: Allow nothing to be partially covered.
+    #          same as :branch, but also:
+    #          if an empty branch is not executed, the line has to be marked as not executed.
+    #          This is only for empty branches because, if they are not empty, there will already
+    #          be some red from the partial node covering. We don't everything to become red,
+    #          just want 100% coverage to be as hard as branch + node coverage.
+    def results
+      allow_partial = options.fetch(:allow_partial, true)
+      line_hits = Array.new(covered_code.nb_lines + covered_code.lineno - 1)
+      disallowed_lines = Set.new
+      each_node do |node|
+        next unless (runs = node_runs(node))
+        node.executed_locs.each do |loc|
+          line_index = loc.line - 1
+
+          next if disallowed_lines.include?(line_index)
+          disallowed_lines << line_index if [nil, false, :branch].include?(allow_partial) && runs == 0
+          disallowed_lines << line_index if !allow_partial && missed_empty_branch?(node)
+
+          line_hits[line_index] = [line_hits[line_index] || 0, runs].max
+        end
+      end
+      disallowed_lines.each { |line_index| line_hits[line_index] = 0 }
+      line_hits
+    end
+
+    def missed_empty_branch?(node)
+      node.is_a?(Node::Branch) && node.branches.any? { |b| b.is_a?(Node::EmptyBody) && !Tools.covered?(node_runs(b)) }
+    end
+  end
+end

data/lib/deep_cover/analyser/ruby25_like_branch.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Ruby25LikeBranch < Analyser
+    def self.human_name
+      'Ruby25 branches'
+    end
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Case, Node::Csend, Node::If, Node::ShortCircuit,
+                      Node::Until, Node::UntilPost, Node::While, Node::WhilePost,
+                     ].freeze
+
+    def initialize(*args)
+      super
+      @loc_index = 0
+    end
+
+    def results
+      extractor = NodeCoverageExtrator.new
+      each_node.map do |node|
+        extractor.branch_coverage(node)
+      end.to_h
+    end
+
+    # This is the class doing the work. Since everything is about the node, the class delegates
+    # missing methods to the node, simplifying the code.
+    class NodeCoverageExtrator < SimpleDelegator
+      def initialize(node = nil)
+        self.node = node
+        @loc_index = 0
+      end
+
+      alias_method :node=, :__setobj__
+      alias_method :node, :__getobj__
+
+      def branch_coverage(node)
+        self.node = node
+        case node
+        when Node::Case
+          handle_case
+        when Node::Csend
+          handle_csend
+        when Node::If
+          handle_if
+        when Node::ShortCircuit
+          handle_short_circuit
+        when Node::Until, Node::While, Node::UntilPost, Node::WhilePost
+          handle_until_while
+        end
+      end
+
+      def handle_case
+        cond_info = [:case, *node_loc_infos]
+
+        sub_keys = [:when] * (branches.size - 1) + [:else]
+        empty_fallbacks = whens.map { |w| (w.loc_hash[:begin] || w.loc_hash[:expression]).wrap_rwhitespace_and_comments.end }
+        empty_fallbacks.map!(&:begin)
+
+        if loc_hash[:else]
+          empty_fallbacks << loc_hash[:end].begin
+        else
+          # DeepCover manually inserts a `else` for Case when there isn't one for tracker purposes.
+          # The normal behavior of ruby25's branch coverage when there is no else is to return the loc of the node
+          # So we sent that fallback.
+          empty_fallbacks << expression
+        end
+
+        branches_locs = whens.map do |when_node|
+          next when_node.body if when_node.body.is_a?(Node::EmptyBody)
+
+          start_at = when_node.loc_hash[:begin]
+          start_at = start_at.wrap_rwhitespace_and_comments.end if start_at
+          start_at ||= when_node.body.expression.begin
+
+          end_at = when_node.body.expression.end
+          start_at.with(end_pos: end_at.end_pos)
+        end
+
+        branches_locs << node.else
+        clauses_infos = infos_for_branches(branches_locs, sub_keys, empty_fallbacks, execution_counts: branches.map(&:execution_count))
+
+        [cond_info, clauses_infos]
+      end
+
+      def handle_csend
+        # csend wraps the comment but not the newlines
+        node_range = node.expression.wrap_rwhitespace_and_comments(whitespaces: /\A[ \t\r\f]+/)
+        cond_info = [:"&.", *node_loc_infos(node_range)]
+        false_branch, true_branch = branches
+        [cond_info, {[:then, *node_loc_infos(node_range)] => true_branch.execution_count,
+                     [:else, *node_loc_infos(node_range)] => false_branch.execution_count,
+                    },
+        ]
+      end
+
+      def handle_if
+        key = style == :unless ? :unless : :if
+
+        node_range = extend_elsif_range
+        cond_info = [key, *node_loc_infos(node_range)]
+
+        sub_keys = [:then, :else]
+        if style == :ternary
+          empty_fallback_locs = [nil, nil]
+        else
+          else_loc = loc_hash[:else]
+
+          first_clause_fallback = loc_hash[:begin]
+          if first_clause_fallback
+            first_clause_fallback = first_clause_fallback.wrap_rwhitespace_and_comments.end
+          elsif else_loc
+            first_clause_fallback = else_loc.begin
+          end
+
+          if else_loc
+            second_clause_fallback = else_loc.wrap_rwhitespace_and_comments.end
+          end
+          end_loc = root_if_node.loc_hash[:end]
+          end_loc = end_loc.begin if end_loc
+
+          empty_fallback_locs = [first_clause_fallback || end_loc, second_clause_fallback || end_loc]
+        end
+        # loc can be nil if the clause can't be empty, such as ternary and modifer if/unless
+
+        if key == :unless
+          sub_keys.reverse!
+          empty_fallback_locs.reverse!
+        end
+
+        branches_locs = branches
+        execution_counts = branches_locs.map(&:execution_count)
+        branches_locs[1] = extend_elsif_range(branches_locs[1])
+
+        clauses_infos = infos_for_branches(branches_locs, sub_keys, empty_fallback_locs, execution_counts: execution_counts, node_range: node_range)
+        [cond_info, clauses_infos]
+      end
+
+      def handle_short_circuit
+        cond_info = [operator, *node_loc_infos]
+        sub_keys = [:then, :else]
+        sub_keys.reverse! if node.is_a?(Node::Or)
+
+        [cond_info, infos_for_branches(branches, sub_keys, [nil, nil])]
+      end
+
+      def handle_until_while
+        key = loc_hash[:keyword].source.to_sym
+        base_info = [key, *node_loc_infos]
+        body_node = if node.is_a?(Node::WhilePost) || node.is_a?(Node::UntilPost)
+                      if !body.instructions.empty?
+                        end_pos = body.instructions.last.expression.end_pos
+                        body.instructions.first.expression.with(end_pos: end_pos)
+                      else
+                        body.loc_hash[:end].begin
+                      end
+                    elsif body.is_a?(Node::Begin) && !node.body.expressions.empty?
+                      end_pos = body.expressions.last.expression.end_pos
+                      body.expressions.first.expression.with(end_pos: end_pos)
+                    else
+                      body
+                    end
+
+        [base_info, {[:body, *node_loc_infos(body_node)] => body.execution_count}]
+      end
+
+      protected
+
+      # If the actual else clause (final one) of an if...elsif...end is empty, then Ruby makes the
+      # node reach the `end` in its branch coverage output
+      def extend_elsif_range(possible_elsif = node)
+        return possible_elsif unless possible_elsif.is_a?(Node::If) && possible_elsif.style == :elsif
+        deepest_if = possible_elsif.deepest_elsif_node
+        if deepest_if.false_branch.is_a?(Node::EmptyBody)
+          return possible_elsif.expression.with(end_pos: possible_elsif.root_if_node.loc_hash[:end].begin_pos)
+        end
+        possible_elsif
+      end
+
+      def infos_for_branch(branch, key, empty_fallback_loc, execution_count: nil, node_range: node)
+        if !branch.is_a?(Node::EmptyBody)
+          loc = branch
+        elsif branch.expression
+          # There is clause, but it is empty
+          loc = empty_fallback_loc
+        else
+          # There is no clause
+          loc = node_range
+        end
+
+        execution_count ||= branch.execution_count
+        [[key, *node_loc_infos(loc)], execution_count]
+      end
+
+      def infos_for_branches(branches, keys, empty_fallback_locs, execution_counts: [], node_range: node)
+        branches_infos = branches.map.with_index do |branch, i|
+          infos_for_branch(branch, keys[i], empty_fallback_locs[i], execution_count: execution_counts[i], node_range: node_range)
+        end
+        branches_infos.to_h
+      end
+
+      def node_loc_infos(node_or_range = node)
+        source_range = node_or_range.is_a?(Node) ? node_or_range.expression : node_or_range
+
+        @loc_index += 1
+        [@loc_index, source_range.line, source_range.column, source_range.last_line, source_range.last_column]
+      end
+    end
+  end
+end

data/lib/deep_cover/analyser/statement.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Statement < Analyser
+    include Analyser::Subset
+    # Returns a map of Range => runs
+    def results
+      each_node.map do |node|
+        [node.expression, node_runs(node)]
+      end.to_h
+    end
+
+    private
+
+    def in_subset?(node, parent)
+      is_statement = node.is_statement
+      if node.expression.nil?
+        false
+      elsif is_statement != :if_incompatible
+        is_statement
+      else
+        !compatible_runs?(node_runs(parent), node_runs(node))
+      end
+    end
+
+    def compatible_runs?(expression_runs, sub_expression_runs)
+      sub_expression_runs.nil? ||
+        (sub_expression_runs == 0) == (expression_runs == 0)
+    end
+  end
+end