deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep-cover.rb

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

data/lib/deep_cover.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  require_relative 'deep_cover/load'
-
-  load_absolute_basics
-
-  extend Base
-  extend ConfigSetter
-end
-DeepCover::GLOBAL_BINDING = binding
-
-require './.deep_cover.rb' if File.exist?('./.deep_cover.rb')
-
-if ENV['DEEP_COVER_OPTIONS']
-  DeepCover.config.set(YAML.load(ENV['DEEP_COVER_OPTIONS']))
-end
-if %w[1 t true].include?(ENV['DEEP_COVER'])
-  DeepCover.start
-  require_relative 'deep_cover/auto_run'
-  DeepCover::AutoRun.run!('.').report!(**DeepCover.config)
-end

data/lib/deep_cover/analyser.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-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
-  # the analyser for information about a node's children
-  # (i.e. with respect to this subset), or runs for any node
-  # in this subset.
-
-  # An analyser can summarize information with `results`.
-  # While CoveredCodeSource is based on a CoveredCode, all
-  # other analysers are based on another source analyser.
-
-  class Analyser
-  end
-
-  require_relative_dir 'analyser'
-
-  Analyser.include Analyser::Base
-end

data/lib/deep_cover/analyser/base.rb

@@ -1,104 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,54 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,211 +0,0 @@
-# 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