deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/flag_comment_associator.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  ##
-  # A processor which computes which lines to be considered flagged with the
-  # given lookup
-  #
-  class FlagCommentAssociator
-    ##
-    # @param [DeepCover::RootNode] ast
-    # @param [Array(Parser::Source::Comment)] comments
-    def initialize(covered_code, lookup = 'nocov')
-      @covered_code = covered_code
-      @lookup      = /^#[\s#*-]*#{lookup}[\s#*-]*$/
-      @ranges      = nil
-    end
-
-    def include?(range)
-      return false unless (exp = range.expression)
-      lineno = exp.line
-      ranges.any? { |r| r.cover? lineno }
-    end
-
-    def ranges
-      @ranges ||= compute_ranges
-    end
-
-    private
-
-    def compute_ranges
-      @ranges     = []
-      @flag_start = nil
-      index_ast_lines
-      @covered_code.comments.each { |comment| process(comment) }
-      toggle_flag(@covered_code.buffer.last_line) # handle end of file in case of opened flag
-      @ranges
-    end
-
-    def process(comment)
-      return unless comment.text =~ @lookup
-      ln = comment.location.expression.line
-      toggle_flag(ln) unless line_has_only_comments?(ln)
-      toggle_flag(ln + 1)
-    end
-
-    def toggle_flag(lineno)
-      if @flag_start
-        @ranges << (@flag_start..(lineno - 1))
-        @flag_start = nil
-      else
-        @flag_start = lineno
-      end
-    end
-
-    def index_ast_lines
-      @starts = []
-      @covered_code.each_node do |node|
-        if (exp = node.expression)
-          @starts[exp.line] = true
-        end
-      end
-    end
-
-    def line_has_only_comments?(line)
-      !@starts[line]
-    end
-  end
-end

data/lib/deep_cover/load.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Load
-    AUTOLOAD = %i[analyser autoload_tracker auto_run config
-                  coverage covered_code custom_requirer
-                  tracker_hits_per_path tracker_storage_per_path
-                  flag_comment_associator memoize module_override node
-                  problem_with_diagnostic reporter tracker_bucket
-                 ]
-
-    def load_absolute_basics
-      require_relative 'base'
-      require_relative 'basics'
-      require_relative 'config_setter'
-      require_relative 'tools/camelize'
-      AUTOLOAD.each do |module_name|
-        DeepCover.autoload(Tools::Camelize.camelize(module_name), "#{__dir__}/#{module_name}")
-      end
-      DeepCover.autoload :VERSION, "#{__dir__}/version"
-      Object.autoload :Term, 'term/ansicolor'
-      Object.autoload :Terminal, 'terminal-table'
-      Object.autoload :YAML, 'yaml'
-      Object.autoload :Forwardable, 'forwardable'
-    end
-
-    def bootstrap
-      @bootstrapped ||= false # Avoid warning
-      return if @bootstrapped
-      require_relative 'backports'
-      require_relative 'tools'
-      @bootstrapped = true
-    end
-
-    def load_parser
-      @parser_loaded ||= false # Avoid warning
-      return if @parser_loaded
-      silence_warnings do
-        require 'parser'
-        require 'parser/current'
-      end
-      require_relative_dir 'parser_ext'
-      @parser_loaded = true
-    end
-
-    def load_pry
-      silence_warnings do # Avoid "WARN: Unresolved specs during Gem::Specification.reset"
-        require 'pry'     # after `pry` calls `Gem.refresh`
-      end
-    end
-
-    def load_all
-      @all_loaded ||= false
-      return if @all_loaded
-      bootstrap
-      load_parser
-      AUTOLOAD.each do |module_name|
-        DeepCover.const_get(Tools::Camelize.camelize(module_name))
-      end
-      DeepCover.const_get(:VERSION)
-      @all_loaded = true
-    end
-  end
-
-  extend Load
-end

data/lib/deep_cover/memoize.rb

@@ -1,48 +0,0 @@
-# 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
-  #
-  module Memoize
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    def freeze
-      self.class.memoized.each do |method|
-        send method
-      end
-      super
-    end
-
-    module ClassMethods
-      def memoized
-        @memoized ||= [].freeze
-      end
-
-      def memoizer_module
-        @memoizer_module ||= begin
-          mod = const_set(:Memoizer, Module.new)
-          prepend mod
-          mod
-        end
-      end
-
-      def memoize(*methods)
-        @memoized = (memoized | methods).freeze
-
-        methods.each do |method|
-          memoizer_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}                    # def foo
-              @_#{method} ||= super.freeze   #   @_foo ||= super.freeze
-            end                              # end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/deep_cover/module_override.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  # Helps redefine methods in overriden_modules.
-  # For each methods in Mod, this defines `<method>_with{out}_deep_cover`.
-  # Set `active` to true or false to alias <method> to one or the other.
-  module ModuleOverride
-    attr_reader :overriden_modules
-
-    def active=(active)
-      each do |mod, method_name|
-        mod.send :alias_method, method_name, :"#{method_name}_#{active ? 'with' : 'without'}_deep_cover"
-        if mod == ::Kernel
-          mod.send :private, method_name
-        end
-      end
-    end
-
-    def override(*modules)
-      @overriden_modules = modules
-      each do |mod, method_name|
-        mod.send :alias_method, :"#{method_name}_without_deep_cover", method_name
-        mod.send :define_method, :"#{method_name}_with_deep_cover", instance_method(method_name)
-        if mod == ::Kernel
-          mod.send :private, :"#{method_name}_without_deep_cover"
-          mod.send :private, :"#{method_name}_with_deep_cover"
-        end
-      end
-    end
-
-    def each(&block)
-      overriden_modules.each do |mod|
-        instance_methods(false).each do |method_name|
-          yield mod, method_name
-        end
-      end
-    end
-  end
-end

data/lib/deep_cover/node.rb

@@ -1,23 +0,0 @@
-# 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/node/arguments.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'assignments'
-
-module DeepCover
-  class Node
-    class Arg < Node
-      has_child name: Symbol
-      def executable?
-        false
-      end
-    end
-    Kwarg = Arg
-
-    class Restarg < Node
-      has_child name: [Symbol, nil]
-      def executable?
-        false
-      end
-    end
-    Kwrestarg = Restarg
-
-    class Optarg < Node
-      has_tracker :default
-      has_child name: Symbol
-      has_child default: Node, flow_entry_count: :default_tracker_hits, rewrite: '(%{default_tracker};%{node})'
-
-      def executable?
-        false
-      end
-    end
-    Kwoptarg = Optarg
-
-    # foo(&block)
-    class Blockarg < Node
-      has_child name: Symbol
-
-      def executable?
-        false
-      end
-    end
-
-    class Args < Node
-      has_extra_children arguments: [Arg, Optarg, Restarg, Kwarg, Kwoptarg, Kwrestarg, Blockarg, Mlhs]
-
-      def executable?
-        false
-      end
-    end
-  end
-end

data/lib/deep_cover/node/assignments.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'const'
-require_relative 'literals'
-require_relative 'keywords'
-
-module DeepCover
-  class Node
-    class VariableAssignment < Node
-      has_child var_name: Symbol
-      has_child value: [Node, nil]
-      executed_loc_keys :name, :operator
-
-      def execution_count
-        return super unless value
-        value.flow_completion_count
-      end
-    end
-    Cvasgn = Gvasgn = Ivasgn = Lvasgn = VariableAssignment
-
-    class Casgn < Node
-      has_child cbase: [Cbase, Const, nil, Self, Begin, Kwbegin]
-      has_child var_name: Symbol
-      has_child value: [Node, nil]
-
-      def execution_count
-        return super unless value
-        value.flow_completion_count
-      end
-    end
-
-    class Mlhs < Node
-      has_extra_children being_set: Node
-      # TODO
-    end
-
-    module BackwardsStrategy
-      # Instead of assuming our parent tracks our entry and we are responsible
-      # for tracking our completion, we go the other way and assume our parent
-      # tracks our completion and we are responsible for our entry.
-      def flow_completion_count
-        if (s = next_sibling)
-          s.flow_entry_count
-        else
-          parent.flow_completion_count
-        end
-      end
-
-      def flow_entry_count
-        if (first_child = children_nodes.first)
-          first_child.flow_entry_count
-        else
-          flow_completion_count
-        end
-      end
-    end
-
-    # Some multiple assignments are the only cases where Ruby
-    # syntax rules won't allow us to insert tracking code
-    # where we'd like it to be run.
-    #
-    # For example:
-    #
-    #   method.a, b, method_2.c = [...]
-    #
-    # We'd like to add a tracker after the call to `a=` and
-    # before the assignment to b and the call to `method_2`.
-    #
-    # We can't really do this with simple insertions, so
-    # we temporarily of strategy for BackwardsStrategy
-    #
-    class Masgn < Node
-      class BackwardsNode < Node
-        include BackwardsStrategy
-      end
-
-      # We can't rewrite `self.bar` within a multiple assignment in the
-      # case that `bar=` is private, so remain conservative and don't add
-      # trackers.
-      class SelfReceiver < BackwardsNode
-        executed_loc_keys :expression
-      end
-
-      class ConstantCbase < BackwardsNode
-      end
-
-      class DynamicReceiverWrap < Node
-        include Wrapper
-        has_tracker :entry
-        has_child actual_receiver: Node
-        def rewrite
-          '(%{entry_tracker};%{node})'
-        end
-        alias_method :flow_entry_count, :entry_tracker_hits
-      end
-
-      class Setter < Node
-        include BackwardsStrategy
-        has_child receiver: {self: SelfReceiver, Parser::AST::Node => DynamicReceiverWrap}
-        has_child method_name: Symbol
-        has_child arg: [Node, nil] # When method is :[]=
-        executed_loc_keys :dot, :selector_begin, :selector_end
-
-        def loc_hash
-          base = super
-          if method_name == :[]=
-            selector = base[:selector]
-            {
-              expression: base[:expression],
-              selector_begin: selector.resize(1),
-              # The = is implicit, so only backtrack the end by one
-              selector_end: Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos),
-            }
-          else
-            {
-              dot: base[:dot],
-              expression: base[:expression],
-              selector_begin: base[:selector],
-              selector_end: nil, # ,
-            }
-          end
-        end
-
-        def execution_count
-          receiver.flow_completion_count
-        end
-      end
-
-      class ConstantScopeWrapper < Node
-        include Wrapper
-        has_tracker :entry
-        has_child actual_node: Node
-
-        def rewrite
-          '(%{entry_tracker};%{node})'
-        end
-
-        def flow_entry_count
-          entry_tracker_hits
-        end
-      end
-
-      class ConstantAssignment < Node
-        include BackwardsStrategy
-        has_child scope: [nil], remap: {cbase: ConstantCbase, Parser::AST::Node => ConstantScopeWrapper}
-        has_child constant_name: Symbol
-
-        def execution_count
-          scope ? scope.flow_completion_count : super
-        end
-      end
-
-      class VariableAssignment < Node
-        include BackwardsStrategy
-        has_child var_name: Symbol
-      end
-
-      BASE_MAP = {
-                   cvasgn: VariableAssignment, gvasgn: VariableAssignment,
-                   ivasgn: VariableAssignment, lvasgn: VariableAssignment,
-                   casgn: ConstantAssignment,
-                   send: Setter,
-                 }.freeze
-      class Splat < Node
-        include BackwardsStrategy
-        has_child rest_arg: [nil], remap: BASE_MAP
-        executed_loc_keys :operator
-      end
-
-      class LeftSide < Node
-        include BackwardsStrategy
-        has_extra_children receivers: {
-                                        splat: Splat,
-                                        mlhs: LeftSide,
-                                        **BASE_MAP,
-                                      }
-        executed_loc_keys # none
-
-        def flow_completion_count
-          parent.flow_completion_count
-        end
-      end
-
-      check_completion
-
-      has_child left: {mlhs: LeftSide}
-      has_child value: Node
-
-      executed_loc_keys :operator
-
-      def execution_count
-        value.flow_completion_count
-      end
-
-      def children_nodes_in_flow_order
-        [value, left]
-      end
-    end
-
-    class VariableOperatorAssign < Node
-      has_child var_name: Symbol
-    end
-
-    class ConstantOperatorAssign < Node
-      has_child scope: [Node, nil]
-      has_child const_name: Symbol
-      def execution_count
-        flow_completion_count
-      end
-    end
-
-    class SendOperatorAssign < Node
-      has_child receiver: [Node, nil]
-      has_child method_name: Symbol
-      has_extra_children arguments: Node
-      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
-
-      def loc_hash
-        base = super
-        hash = {expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
-        selector = base[:selector]
-
-        if [:[], :[]=].include?(method_name)
-          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[:selector_begin] = base[:selector]
-        end
-
-        hash
-      end
-    end
-
-    # foo += bar
-    class OpAsgn < Node
-      check_completion
-      has_tracker :reader
-      has_child receiver: {
-                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
-                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
-                            casgn: Casgn, # TODO
-                            send: SendOperatorAssign,
-                          }
-      has_child operator: Symbol
-      has_child value: Node, rewrite: '(%{reader_tracker};%{node})', flow_entry_count: :reader_tracker_hits
-      executed_loc_keys :operator
-
-      def execution_count
-        flow_completion_count
-      end
-    end
-
-    # foo ||= bar, foo &&= base
-    class BooleanAssignment < Node
-      check_completion
-      has_tracker :long_branch
-      has_child receiver: {
-                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
-                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
-                            casgn: ConstantOperatorAssign,
-                            send: SendOperatorAssign,
-                          }
-      has_child value: Node, rewrite: '(%{long_branch_tracker};%{node})', flow_entry_count: :long_branch_tracker_hits
-      executed_loc_keys :operator
-
-      def execution_count
-        flow_completion_count
-      end
-    end
-
-    OrAsgn = AndAsgn = BooleanAssignment
-  end
-end