dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for redundant access modifiers, including those with no
-      # code, those which are repeated, and leading `public` modifiers in a
-      # class or module body. Conditionally-defined methods are considered as
-      # always being defined, and thus access modifiers guarding such methods
-      # are not redundant.
-      #
-      # @example
-      #
-      #   class Foo
-      #     public # this is redundant (default access is public)
-      #
-      #     def method
-      #     end
-      #
-      #     private # this is not redundant (a method is defined)
-      #     def method2
-      #     end
-      #
-      #     private # this is redundant (no following methods are defined)
-      #   end
-      #
-      # @example
-      #
-      #   class Foo
-      #     # The following is not redundant (conditionally defined methods are
-      #     # considered as always defining a method)
-      #     private
-      #
-      #     if condition?
-      #       def method
-      #       end
-      #     end
-      #
-      #     protected # this is not redundant (method is defined)
-      #
-      #     define_method(:method2) do
-      #     end
-      #
-      #     protected # this is redundant (repeated from previous modifier)
-      #
-      #     [1,2,3].each do |i|
-      #       define_method("foo#{i}") do
-      #       end
-      #     end
-      #
-      #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
-      #
-      #     def self.method3
-      #     end
-      #   end
-      #
-      # @example
-      #   # Lint/UselessAccessModifier:
-      #   #   ContextCreatingMethods:
-      #   #     - concerning
-      #   require 'active_support/concern'
-      #   class Foo
-      #     concerning :Bar do
-      #       def some_public_method
-      #       end
-      #
-      #       private
-      #
-      #       def some_private_method
-      #       end
-      #     end
-      #
-      #     # this is not redundant because `concerning` created its own context
-      #     private
-      #
-      #     def some_other_private_method
-      #     end
-      #   end
-      class UselessAccessModifier < Cop
-        MSG = 'Useless `%s` access modifier.'.freeze
-
-        def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
-        end
-
-        def on_block(node)
-          return unless eval_call?(node)
-
-          check_node(node.children[2]) # block body
-        end
-
-        def on_sclass(node)
-          check_node(node.children[1]) # singleton class body
-        end
-
-        private
-
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
-        def_node_matcher :static_method_definition?, <<-PATTERN
-          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
-        PATTERN
-
-        def_node_matcher :dynamic_method_definition?, <<-PATTERN
-          {(send nil :define_method ...) (block (send nil :define_method ...) ...)}
-        PATTERN
-
-        def_node_matcher :class_or_instance_eval?, <<-PATTERN
-          (block (send _ {:class_eval :instance_eval}) ...)
-        PATTERN
-
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
-        PATTERN
-
-        def check_node(node)
-          return if node.nil?
-
-          if node.begin_type?
-            check_scope(node)
-          elsif (vis = access_modifier(node))
-            add_offense(node, :expression, format(MSG, vis))
-          end
-        end
-
-        def check_scope(node)
-          cur_vis, unused = check_child_nodes(node, nil, :public)
-
-          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
-        end
-
-        def check_child_nodes(node, unused, cur_vis)
-          node.child_nodes.each do |child|
-            if (new_vis = access_modifier(child))
-              cur_vis, unused =
-                check_new_visibility(child, unused, new_vis, cur_vis)
-            elsif method_definition?(child)
-              unused = nil
-            elsif start_of_new_scope?(child)
-              check_scope(child)
-            elsif !child.defs_type?
-              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
-            end
-          end
-
-          [cur_vis, unused]
-        end
-
-        def check_new_visibility(node, unused, new_vis, cur_vis)
-          # does this modifier just repeat the existing visibility?
-          if new_vis == cur_vis
-            add_offense(node, :expression, format(MSG, cur_vis))
-          else
-            # was the previous modifier never applied to any defs?
-            add_offense(unused, :expression, format(MSG, cur_vis)) if unused
-            # once we have already warned about a certain modifier, don't
-            # warn again even if it is never applied to any method defs
-            unused = node
-          end
-
-          [new_vis, unused]
-        end
-
-        def method_definition?(child)
-          static_method_definition?(child) || dynamic_method_definition?(child)
-        end
-
-        def start_of_new_scope?(child)
-          child.module_type? || child.class_type? ||
-            child.sclass_type? || eval_call?(child)
-        end
-
-        def eval_call?(child)
-          class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
-            any_context_creating_methods?(child)
-        end
-
-        def any_context_creating_methods?(child)
-          cop_config.fetch('ContextCreatingMethods', []).any? do |m|
-            matcher_name = "#{m}_block?".to_sym
-            unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
-                (block (send {nil const} {:#{m}} ...) ...)
-              PATTERN
-            end
-
-            send(matcher_name, child)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_assignment.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for every useless assignment to local variable in every
-      # scope.
-      # The basic idea for this cop was from the warning of `ruby -cw`:
-      #
-      #   assigned but unused variable - foo
-      #
-      # Currently this cop has advanced logic that detects unreferenced
-      # reassignments and properly handles varied cases such as branch, loop,
-      # rescue, ensure, etc.
-      class UselessAssignment < Cop
-        include NameSimilarity
-        MSG = 'Useless assignment to variable - `%s`.'.freeze
-
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_for_unused_assignments(variable)
-          end
-        end
-
-        def check_for_unused_assignments(variable)
-          return if variable.should_be_unused?
-
-          variable.assignments.each do |assignment|
-            next if assignment.used?
-
-            message = message_for_useless_assignment(assignment)
-
-            location = if assignment.regexp_named_capture?
-                         assignment.node.children.first.source_range
-                       else
-                         assignment.node.loc.name
-                       end
-
-            add_offense(nil, location, message)
-          end
-        end
-
-        def message_for_useless_assignment(assignment)
-          variable = assignment.variable
-
-          format(MSG, variable.name) +
-            message_specification(assignment, variable).to_s
-        end
-
-        def message_specification(assignment, variable)
-          if assignment.multiple_assignment?
-            multiple_assignment_message(variable.name)
-          elsif assignment.operator_assignment?
-            operator_assignment_message(variable.scope, assignment)
-          else
-            similar_name_message(variable)
-          end
-        end
-
-        def multiple_assignment_message(variable_name)
-          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
-            "that it won't be used."
-        end
-
-        def operator_assignment_message(scope, assignment)
-          return_value_node = return_value_node_of_scope(scope)
-          return unless assignment.meta_assignment_node
-                                  .equal?(return_value_node)
-
-          " Use just operator `#{assignment.operator.sub(/=$/, '')}`."
-        end
-
-        def similar_name_message(variable)
-          similar_name = find_similar_name(variable.name, variable.scope)
-          " Did you mean `#{similar_name}`?" if similar_name
-        end
-
-        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
-        def return_value_node_of_scope(scope)
-          body_node = scope.body_node
-
-          if body_node.begin_type?
-            body_node.children.last
-          else
-            body_node
-          end
-        end
-
-        def collect_variable_like_names(scope)
-          names = scope.each_node.with_object(Set.new) do |node, set|
-            if variable_like_method_invocation?(node)
-              _receiver, method_name, = *node
-              set << method_name
-            end
-          end
-
-          variable_names = scope.variables.each_value.map(&:name)
-          names.merge(variable_names)
-        end
-
-        def variable_like_method_invocation?(node)
-          return false unless node.send_type?
-          receiver, _method_name, *args = *node
-          receiver.nil? && args.empty?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_comparison.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for comparison of something with itself.
-      #
-      # @example
-      #
-      #  x.top >= x.top
-      class UselessComparison < Cop
-        MSG = 'Comparison of something with itself detected.'.freeze
-        OPS = %w(== === != < > <= >= <=>).freeze
-
-        def_node_matcher :comparison?, "(send $_ {:#{OPS.join(' :')}} $_)"
-
-        def on_send(node)
-          comparison?(node) do |receiver, args|
-            add_offense(node, :selector) if receiver == args
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_else_without_rescue.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for useless `else` in `begin..end` without `rescue`.
-      #
-      # @example
-      #   begin
-      #     do_something
-      #   else
-      #     handle_errors # This will never be run.
-      #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
-        MSG = '`else` without `rescue` is useless.'.freeze
-
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
-
-        def alternative_message(_diagnostic)
-          MSG
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for setter call to local variable as the final
-      # expression of a function definition.
-      #
-      # @example
-      #
-      #  def something
-      #    x = Something.new
-      #    x.attr = 5
-      #  end
-      class UselessSetterCall < Cop
-        include OnMethodDef
-
-        MSG = 'Useless setter call to local variable `%s`.'.freeze
-        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
-
-        private
-
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          last_expr = last_expression(body)
-          return unless setter_call_to_local_variable?(last_expr)
-
-          tracker = MethodVariableTracker.new(body)
-          receiver, = *last_expr
-          variable_name, = *receiver
-          return unless tracker.contain_local_object?(variable_name)
-
-          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
-        end
-
-        def last_expression(body)
-          expression = body.begin_type? ? body.children : body
-
-          expression.is_a?(Array) ? expression.last : expression
-        end
-
-        def setter_call_to_local_variable?(node)
-          return unless node && node.send_type?
-          receiver, method, _args = *node
-          return unless receiver && receiver.lvar_type?
-          method =~ /(?:\w|\[\])=$/
-        end
-
-        # This class tracks variable assignments in a method body
-        # and if a variable contains object passed as argument at the end of
-        # the method.
-        class MethodVariableTracker
-          def initialize(body_node)
-            @body_node = body_node
-            @local = nil
-          end
-
-          def contain_local_object?(variable_name)
-            return @local[variable_name] if @local
-
-            @local = {}
-
-            scan(@body_node) { |node| process_assignment_node(node) }
-
-            @local[variable_name]
-          end
-
-          def scan(node, &block)
-            catch(:skip_children) do
-              yield node
-
-              node.each_child_node do |child_node|
-                scan(child_node, &block)
-              end
-            end
-          end
-
-          def process_assignment_node(node)
-            case node.type
-            when :masgn
-              process_multiple_assignment(node)
-            when :or_asgn, :and_asgn
-              process_logical_operator_assignment(node)
-            when :op_asgn
-              process_binary_operator_assignment(node)
-            when *ASSIGNMENT_TYPES
-              _, rhs_node = *node
-              process_assignment(node, rhs_node) if rhs_node
-            end
-          end
-
-          def process_multiple_assignment(masgn_node)
-            mlhs_node, mrhs_node = *masgn_node
-
-            mlhs_node.children.each_with_index do |lhs_node, index|
-              next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-
-              lhs_variable_name, = *lhs_node
-              rhs_node = mrhs_node.children[index]
-
-              if mrhs_node.array_type? && rhs_node
-                process_assignment(lhs_variable_name, rhs_node)
-              else
-                @local[lhs_variable_name] = true
-              end
-            end
-
-            throw :skip_children
-          end
-
-          def process_logical_operator_assignment(asgn_node)
-            lhs_node, rhs_node = *asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-            process_assignment(lhs_node, rhs_node)
-
-            throw :skip_children
-          end
-
-          def process_binary_operator_assignment(op_asgn_node)
-            lhs_node, = *op_asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-            lhs_variable_name, = *lhs_node
-            @local[lhs_variable_name] = true
-
-            throw :skip_children
-          end
-
-          def process_assignment(asgn_node, rhs_node)
-            lhs_variable_name, = *asgn_node
-
-            @local[lhs_variable_name] = if rhs_node.variable?
-                                          rhs_variable_name, = *rhs_node
-                                          @local[rhs_variable_name]
-                                        else
-                                          constructor?(rhs_node)
-                                        end
-          end
-
-          def constructor?(node)
-            return true if node.literal?
-            return false unless node.send_type?
-            _receiver, method = *node
-            method == :new
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/void.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for operators, variables and literals used
-      # in void context.
-      class Void < Cop
-        OP_MSG = 'Operator `%s` used in void context.'.freeze
-        VAR_MSG = 'Variable `%s` used in void context.'.freeze
-        LIT_MSG = 'Literal `%s` used in void context.'.freeze
-
-        OPS = %w(* / % + - == === != < > <= >= <=>).freeze
-
-        def on_begin(node)
-          check_begin(node)
-        end
-
-        def on_kwbegin(node)
-          check_begin(node)
-        end
-
-        private
-
-        def check_begin(node)
-          expressions = *node
-
-          expressions.drop_last(1).each do |expr|
-            check_for_void_op(expr)
-            check_for_literal(expr)
-            check_for_var(expr)
-          end
-        end
-
-        def check_for_void_op(node)
-          return unless node.send_type? && node.loc.selector
-
-          op = node.loc.selector.source
-
-          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
-        end
-
-        def check_for_var(node)
-          return unless node.variable? || node.const_type?
-          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
-        end
-
-        def check_for_literal(node)
-          return if !node.literal? || node.xstr_type?
-
-          add_offense(node, :expression, format(LIT_MSG, node.source))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/metrics/abc_size.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks that the ABC size of methods is not higher than the
-      # configured maximum. The ABC size is based on assignments, branches
-      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
-      class AbcSize < Cop
-        include MethodComplexity
-
-        MSG = 'Assignment Branch Condition size for %s is too high. ' \
-              '[%.4g/%.4g]'.freeze
-        BRANCH_NODES = [:send, :csend].freeze
-        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
-
-        private
-
-        def complexity(node)
-          assignment = 0
-          branch = 0
-          condition = 0
-
-          node.each_node do |child|
-            if child.assignment?
-              assignment += 1
-            elsif BRANCH_NODES.include?(child.type)
-              branch += 1
-            elsif CONDITION_NODES.include?(child.type)
-              condition += 1
-            end
-          end
-
-          Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/metrics/block_length.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks if the length of a block exceeds some maximum value.
-      # Comment lines can optionally be ignored.
-      # The maximum allowed length is configurable.
-      class BlockLength < Cop
-        include TooManyLines
-
-        LABEL = 'Block'.freeze
-
-        def on_block(node)
-          check_code_length(node)
-        end
-
-        private
-
-        def cop_label
-          LABEL
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/metrics/block_nesting.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks for excessive nesting of conditional and looping
-      # constructs. Despite the cop's name, blocks are not considered as an
-      # extra level of nesting.
-      #
-      # The maximum level of nesting allowed is configurable.
-      class BlockNesting < Cop
-        include ConfigurableMax
-        include IfNode
-
-        NESTING_BLOCKS = [
-          :case, :if, :while, :while_post,
-          :until, :until_post, :for, :resbody
-        ].freeze
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          max = cop_config['Max']
-          check_nesting_level(processed_source.ast, max, 0)
-        end
-
-        private
-
-        def check_nesting_level(node, max, current_level)
-          if NESTING_BLOCKS.include?(node.type)
-            current_level += 1 unless elsif?(node)
-            if current_level > max
-              self.max = current_level
-              unless part_of_ignored_node?(node)
-                add_offense(node, :expression, message(max)) do
-                  ignore_node(node)
-                end
-              end
-            end
-          end
-
-          node.each_child_node do |child_node|
-            check_nesting_level(child_node, max, current_level)
-          end
-        end
-
-        def message(max)
-          "Avoid more than #{max} levels of block nesting."
-        end
-      end
-    end
-  end
-end