deep-cover-core 0.6.3.pre

data/lib/deep_cover/node/send.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'literals'
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class SendBase < Node
+      has_child receiver: [Node, nil]
+      has_child message: Symbol
+      has_extra_children arguments: Node
+      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
+
+      def loc_hash
+        hash = super.dup
+        selector = hash.delete(:selector)
+
+        # Special case for foo[bar]=baz, but not for foo.[]= bar, baz: we split selector into begin and end
+        if base_node.location.dot == nil && [:[], :[]=].include?(message)
+          hash[:selector_begin] = selector.resize(1)
+          hash[:selector_end] = Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos)
+        else
+          hash.delete(:dot) if type == :safe_send # Hack. API to get a Parser::AST::Send::Map without the dot is crappy.
+          hash[:selector_begin] = selector
+        end
+
+        hash
+      end
+
+      # Rules must be ordered inner-most first
+      def rewriting_rules
+        rules = super
+        if need_parentheses?
+          range = arguments.last.expression.with(begin_pos: loc_hash[:selector_begin].end_pos)
+          rules.unshift [range, '(%{node})']
+        end
+        rules
+      end
+
+      private
+
+      # In different circumstances, we need ().
+      # Deal with ambiguous cases where a method is hidden by a local. Ex:
+      #   foo 42, 'hello'  #=> Works
+      #   foo (42), 'hello'  #=> Simplification of what DeepCover would generate, still works
+      #   foo = 1; foo 42, 'hello'  #=> works
+      #   foo = 1; foo (42), 'hello'  #=> syntax error.
+      #   foo = 1; foo((42), 'hello')  #=> works
+      # Deal with do/end block. Ex:
+      #   x.foo 42, 43 # => ok
+      #   x.foo (42), 43 # => ok
+      #   x.foo ((42)), 43 # => ok
+      #   x.foo 42, 43 do ; end # => ok
+      #   x.foo (42), 43 do ; end # => ok
+      #   x.foo ((42)), 43 do ; end # => parse error!
+      def need_parentheses?
+        true unless
+          arguments.empty? || # No issue when no arguments
+          loc_hash[:selector_end] || # No issue with foo[bar]= and such
+          loc_hash[:operator] || # No issue with foo.bar=
+          (receiver && !loc_hash[:dot]) || # No issue with foo + bar
+          loc_hash[:begin] # Ok if has parentheses
+      end
+    end
+
+    class Send < SendBase
+      check_completion
+    end
+
+    class CsendInnerSend < SendBase
+      has_tracker :completion
+      include ExecutedAfterChildren
+
+      def has_block?
+        parent.has_block?
+      end
+
+      def rewrite
+        # All the rest of the rewriting logic is in Csend
+        '%{node};%{completion_tracker};' unless has_block?
+      end
+
+      def flow_completion_count
+        return parent.parent.flow_completion_count if has_block?
+        completion_tracker_hits
+      end
+
+      def loc_hash
+        # This is only a partial Send, the receiver param and the dot are actually handled by the parent Csend.
+        h = super.dup
+        h[:expression] = h[:expression].with(begin_pos: h[:selector_begin].begin_pos)
+        h
+      end
+    end
+
+    class Csend < Node
+      # The overall rewriting goal is this:
+      #    temp = *receiver*;
+      #    if nil != temp
+      #      TRACK_my_NOT_NIL
+      #      temp = temp&.*actual_send*{block}
+      #      TRACK_actual_send_COMPLETION
+      #      t
+      #    else
+      #      nil
+      #    end
+      # This is split across the children and the CsendInnerSend
+      include Branch
+      has_tracker :not_nil
+      has_child receiver: Node,
+                rewrite: '(%{local}=%{node};if nil != %{local};%{not_nil_tracker};%{local}=%{local}'
+      REWRITE_SUFFIX = '%{node};%{local};else;nil;end)'
+
+      has_child actual_send: {safe_send: CsendInnerSend},
+                flow_entry_count: :not_nil_tracker_hits
+
+      def initialize(base_node, base_children: base_node.children, **) # rubocop:disable Naming/UncommunicativeMethodParamName [#5436]
+        send_without_receiver = base_node.updated(:safe_send, [nil, *base_node.children.drop(1)])
+        base_children = [base_children.first, send_without_receiver]
+        super
+      end
+
+      executed_loc_keys :dot
+
+      def has_block?
+        parent.is_a?(Block) && parent.child_index_to_name(index) == :call
+      end
+
+      def rewrite
+        REWRITE_SUFFIX unless has_block?
+      end
+
+      def execution_count
+        receiver.flow_completion_count
+      end
+
+      def message
+        actual_send.message
+      end
+
+      def branches
+        [TrivialBranch.new(condition: receiver, other_branch: actual_send),
+         actual_send,
+        ]
+      end
+
+      def branches_summary(of_branches = branches)
+        of_branches.map do |jump|
+          jump == actual_send ? 'safe send' : 'nil shortcut'
+        end.join(' and ')
+      end
+    end
+
+    class MatchWithLvasgn < Node
+      check_completion
+      has_child receiver: Regexp
+      has_child compare_to: Node
+      # TODO: test
+    end
+  end
+end

data/lib/deep_cover/node/short_circuit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class ShortCircuit < Node
+      include Branch
+      has_tracker :conditional
+      has_child lhs: Node
+      has_child conditional: Node, flow_entry_count: :conditional_tracker_hits,
+                rewrite: '(%{conditional_tracker};%{node})'
+
+      def branches
+        [
+          conditional,
+          TrivialBranch.new(condition: lhs, other_branch: conditional),
+        ]
+      end
+
+      def branches_summary(of_branches = branches)
+        of_branches.map do |jump|
+          if jump == conditional
+            'right-hand side'
+          else
+            "#{type == :and ? 'falsy' : 'truthy'} shortcut"
+          end
+        end.join(' and ')
+      end
+
+      def operator
+        loc_hash[:operator].source.to_sym
+      end
+    end
+
+    class And < ShortCircuit
+    end
+
+    class Or < ShortCircuit
+    end
+  end
+end

data/lib/deep_cover/node/splat.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node
+    class Splat < Node
+      check_completion inner: '[%{node}]', outer: '*%{node}'
+      has_child receiver: Node
+    end
+
+    class Kwsplat < Node
+      check_completion inner: '{%{node}}', outer: '**%{node}'
+      has_child receiver: Node
+    end
+  end
+end

data/lib/deep_cover/node/variables.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node
+    class Variable < Node
+      has_child var_name: Symbol
+    end
+    Ivar = Lvar = Cvar = Gvar = BackRef = Variable
+
+    # $1
+    class NthRef < Node
+      has_child n: Integer
+      # TODO
+    end
+  end
+end

data/lib/deep_cover/node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+  load_parser
+
+  class Node
+    # Reopened in base
+    CLASSES = []
+    def self.inherited(parent)
+      CLASSES << parent
+      super
+    end
+  end
+  require_relative_dir 'node/mixin'
+  require_relative 'node/base'
+  require_relative_dir 'node'
+
+  Node.include Memoize
+  Node::CLASSES.freeze.each do |klass|
+    klass.memoize :flow_entry_count, :flow_completion_count, :execution_count, :loc_hash
+  end
+end

data/lib/deep_cover/parser_ext/range.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Parser::Source::Range
+  def succ
+    adjust(begin_pos: +1, end_pos: +1)
+  end
+
+  def wrap_rwhitespace(whitespaces: /\A\s+/)
+    whitespace = @source_buffer.slice(end_pos..-1)[whitespaces] || ''
+    adjust(end_pos: whitespace.size)
+  end
+
+  def wrap_rwhitespace_and_comments(whitespaces: /\A\s+/)
+    current = wrap_rwhitespace(whitespaces: whitespaces)
+    while @source_buffer.slice(current.end_pos) == '#'
+      comment = @source_buffer.slice(current.end_pos..-1)[/\A[^\n]+/] || ''
+      current = current.adjust(end_pos: comment.size).wrap_rwhitespace(whitespaces: whitespaces)
+    end
+    current
+  end
+end

data/lib/deep_cover/problem_with_diagnostic.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class ProblemWithDiagnostic < StandardError
+    attr_reader :covered_code, :line_range, :original_exception
+
+    def initialize(covered_code, line_range, original_exception = nil)
+      @covered_code = covered_code
+      if line_range.respond_to? :last_line
+        @line_range = line_range.line..line_range.last_line
+      else
+        @line_range = line_range
+      end
+      @original_exception = original_exception
+    end
+
+    def message
+      msg = []
+      msg << 'You found a problem with DeepCover!'
+      msg << 'Please open an issue at https://github.com/deep-cover/deep-cover/issues'
+      msg << 'and include the following diagnostic information:'
+      extra = begin
+        diagnostic_information_lines.map { |line| "| #{line}" }
+      rescue ProblemWithDiagnostic
+        ["Oh no! We're in deep trouble!!!"]
+      rescue Exception => e
+        ["Oh no! Even diagnostics are failing: #{e}\n#{e.backtrace}"]
+      end
+      msg.concat(extra)
+      msg.join("\n")
+    end
+
+    def diagnostic_information_lines
+      lines = []
+      lines << "Source file: #{covered_code.path}"
+      lines << "Line numbers: #{line_range}"
+      lines << 'Source lines around location:'
+      lines.concat(source_lines.map { |line| "   #{line}" })
+      if original_exception
+        lines << 'Original exception:'
+        lines << "  #{original_exception.class}: #{original_exception.message}"
+        backtrace = Tools.truncate_backtrace(original_exception)
+        lines.concat(backtrace.map { |line| "    #{line}" })
+      end
+      lines
+    end
+
+    def source_lines(nb_context_line: 7)
+      first_index = line_range.begin - nb_context_line - buffer.first_line
+      first_index = 0 if first_index < 0
+      last_index = line_range.end + nb_context_line - buffer.first_line
+      last_index = 0 if last_index < 0
+
+      lines = buffer.source_lines[first_index..last_index]
+
+      Tools.number_lines(lines, lineno: buffer.first_line, bad_linenos: line_range.to_a)
+    end
+
+    def buffer
+      covered_code.buffer
+    end
+  end
+end

data/lib/deep_cover/reporter/base.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter
+    require_relative 'tree/util'
+
+    class Base
+      include Memoize
+      memoize :map, :tree, :root_path
+
+      attr_reader :options
+
+      def initialize(coverage, **options)
+        @coverage = coverage
+        @options = options
+      end
+
+      def analysis
+        @analysis ||= Coverage::Analysis.new(@coverage.covered_codes, **options)
+      end
+
+      def each(&block)
+        return to_enum :each unless block_given?
+        @coverage.each do |covered_code|
+          yield relative_path(covered_code.path), covered_code
+        end
+        self
+      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
+        return to_enum(__method__) unless block_given?
+        Tree::Util.populate_from_map(
+            tree: tree,
+            map: map,
+            merge: ->(child_data) { Tools.merge(*child_data, :+) }
+        ) do |full_path, partial_path, data, children|
+          yield relative_path(full_path), relative_path(partial_path), data, children
+        end
+      end
+
+      private
+
+      def relative_path(path)
+        path = path.to_s
+        path = path.slice(root_path.length + 1..-1) if path.start_with?(root_path)
+        path
+      end
+
+      def root_path
+        return '' if tree.size > 1
+        path = tree.first.first
+        root = File.dirname(path)
+        root = File.dirname(root) if File.basename(path) == 'dir'
+        root
+      end
+
+      def map
+        analysis.stat_map.transform_keys(&:path).transform_keys(&:to_s)
+      end
+
+      def tree
+        Tree::Util.paths_to_tree(map.keys)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter::HTML::Base
+    include Tools::ContentTag
+    def setup
+      DeepCover::DEFAULTS.keys.map do |setting|
+        value = options[setting]
+        value = value.join(', ') if value.respond_to? :join
+        content_tag :span, value, class: setting
+      end.join
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require_relative 'base'
+
+  module Reporter
+    class HTML::Index < Struct.new(:base)
+      include HTML::Base
+      extend Forwardable
+      def_delegators :base, :analysis, :options, :populate_stats
+
+      def stats_to_data
+        populate_stats 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
+        _covered_code, analyser_map = analysis.analyser_map.first
+        analyser_map ||= []
+        columns = analyser_map.flat_map do |type, analyser|
+          [{
+             value: type,
+             header: analyser.class.human_name,
+           }, {
+                value: :"#{type}_percent",
+                header: '%',
+              },
+          ]
+        end
+        columns.unshift(width: 400, header: 'Path')
+        columns
+      end
+
+      private
+
+      # {per_char: Stat, ...} => {per_char: {ignored: ...}, per_char_percent: 55.55, ...}
+      def transform_data(data)
+        Tools.merge(
+            data.transform_values(&:to_h),
+            *data.map { |type, stat| {:"#{type}_percent" => stat.percent_covered} }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require_relative 'base'
+  require_relative 'index'
+  require_relative 'source'
+
+  module Reporter::HTML
+    class Site < Reporter::Base
+      include Memoize
+      memoize :analysis
+
+      def path
+        Pathname(options[:output])
+      end
+
+      def save
+        clear
+        save_assets
+        save_index
+        save_pages
+      end
+
+      def clear
+        path.mkpath
+        path.rmtree
+        path.mkpath
+      end
+
+      def compile_stylesheet(source, dest)
+        css = Sass::Engine.for_file(source, style: :expanded).to_css
+        File.write(dest, css)
+      end
+
+      def render_index
+        Tools.render_template(:index, Index.new(self))
+      end
+
+      def save_index
+        path.join('index.html').write(render_index)
+      end
+
+      def save_assets
+        require 'fileutils'
+        src = "#{__dir__}/template/assets"
+        dest = path.join('assets')
+        FileUtils.cp_r(src, dest)
+        dest.join('deep_cover.css.sass').delete
+      end
+
+      def render_source(partial_path, covered_code)
+        Tools.render_template(:source, Source.new(analysis.analyser_map.fetch(covered_code), partial_path))
+      end
+
+      def save_pages
+        each do |partial_path, covered_code|
+          dest = path.join("#{partial_path}.html")
+          dest.dirname.mkpath
+          dest.write(render_source(partial_path, covered_code))
+        end
+      end
+
+      def self.save(coverage, output:, **options)
+        Site.new(coverage, output: output, **options).save
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter
+    require_relative 'base'
+
+    class HTML::Source < Struct.new(:analyser_map, :partial_path)
+      include Tools::Covered
+
+      def initialize(analyser_map, partial_path)
+        raise ArgumentError unless analyser_map.values.all? { |a| a.is_a?(Analyser) }
+        super
+      end
+
+      include HTML::Base
+
+      def format_source
+        lines = convert_source.split("\n")
+        lines.map { |line| content_tag(:td, line) }
+        rows = lines.map.with_index do |line, i|
+          nb = content_tag(:td, i + 1, id: "L#{i + 1}", class: :nb)
+          content_tag(:tr, nb + content_tag(:td, line))
+        end
+        content_tag(:table, rows.join, class: :source)
+      end
+
+      def convert_source
+        @rewriter = Parser::Source::TreeRewriter.new(covered_code.buffer)
+        insert_node_tags
+        insert_branch_tags
+        html_escape
+        @rewriter.process
+      end
+
+      def root_path
+        Pathname('.').relative_path_from(Pathname(partial_path).dirname)
+      end
+
+      def stats
+        cells = analyser_map.map do |type, analyser|
+          data = analyser.stats
+          f = ->(kind) { content_tag(:span, data.public_send(kind), class: kind, title: kind) }
+          [content_tag(:th, analyser.class.human_name, class: type),
+           content_tag(:td, "#{f[:executed]} #{f[:ignored] if data.ignored > 0} / #{f[:potentially_executable]}", class: type),
+          ]
+        end
+        rows = cells.transpose.map { |line| content_tag(:tr, line.join) }
+        content_tag(:table, rows.join)
+      end
+
+      def analyser
+        analyser_map[:per_char]
+      end
+
+      def covered_code
+        analyser.covered_code
+      end
+
+      private
+
+      RUNS_CLASS = Hash.new('run').merge!(0 => 'not-run', nil => 'ignored')
+      RUNS_TITLE = Hash.new { |k, runs| "#{runs}x" }.merge!(0 => 'never run', nil => 'ignored')
+
+      def node_span(node, kind)
+        runs = analyser.node_runs(node)
+        %{<span class="node-#{node.type} kind-#{kind} #{RUNS_CLASS[runs]}" title="#{RUNS_TITLE[runs]}">}
+      end
+
+      def insert_node_tags
+        analyser.each_node do |node|
+          h = node.executed_loc_hash
+          h.each do |kind, range|
+            wrap(range, node_span(node, kind), '</span>')
+          end
+          exp = node.expression
+          if (exp.nil? || exp.empty?) && !analyser.node_covered?(node) && !node.parent.is_a?(Node::Branch) # Not executed empty bodies must show!
+            replace(exp, icon(:empty, 'empty node never run'))
+            wrap(exp, node_span(node, :empty))
+          end
+        end
+      end
+
+      ICONS = {
+                fork: 'code-fork',
+                empty: 'code',
+              }.freeze
+      def icon(type, title)
+        %{<i class="#{type}-icon fa fa-#{ICONS[type]}" aria-hidden="true" title="#{title}"></i>}
+      end
+
+      def fork_span(node, kind, id, title: nil, klass: nil)
+        runs = analyser_map[:branch].node_runs(node)
+        title ||= RUNS_TITLE[runs]
+        %{<span class="fork fork-#{kind} fork-#{RUNS_CLASS[runs]} #{klass}" data-fork-id="#{id}">#{icon(:fork, title)}}
+      end
+
+      def insert_branch_tags
+        analyser_map[:branch].each_node.with_index do |node, id|
+          node.branches.each do |branch|
+            exp = branch.expression
+            wrap(exp, fork_span(branch, :branch, id), '</span>') if exp
+          end
+          runs = analyser_map[:branch].node_runs(node)
+          if !covered?(runs) && analyser.node_covered?(node)
+            jumps_missing = node.branches.reject { |jump| analyser.node_covered?(jump) }
+            title = "#{node.branches_summary(jumps_missing)} not covered"
+            klass = 'fork-with-uncovered-branches'
+          end
+          wrap(node.expression, fork_span(node, :whole, id, title: title, klass: klass))
+        end
+      end
+
+      def replace(range, with)
+        @rewriter.replace(range, with)
+      end
+
+      def wrap(range, before, after = '</span>')
+        line = @rewriter.source_buffer.line_range(range.first_line)
+        pinned = range.with(end_pos: [range, line].map(&:end_pos).min)
+        @rewriter.wrap(pinned, before, after)
+      end
+
+      def html_escape
+        buffer = analyser.covered_code.buffer
+        source = buffer.source
+        {'<' => '&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))
+            @rewriter.replace(range, escaped)
+          end
+        end
+      end
+    end
+  end
+end