deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/node/short_circuit.rb

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

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

@@ -1,16 +0,0 @@
-# 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/parser_ext/range.rb

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

@@ -1,63 +0,0 @@
-# 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.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  bootstrap
-
-  module Reporter
-  end
-  require_relative 'node'
-  require_relative_dir 'reporter'
-end

data/lib/deep_cover/reporter/base.rb

@@ -1,68 +0,0 @@
-# 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.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  Reporter::HTML = Module.new
-
-  require_relative_dir 'html'
-
-  module Reporter::HTML
-    class << self
-      def report(coverage, **options)
-        Site.save(coverage, **options)
-      end
-    end
-  end
-end

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

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

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  require 'sass'
-  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)
-        compile_stylesheet "#{src}/deep_cover.css.sass", dest.join('deep_cover.css')
-        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

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