dirwatch 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/unreachable_code.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unreachable code.
+      # The check are based on the presence of flow of control
+      # statement in non-final position in *begin*(implicit) blocks.
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'.freeze
+
+        NODE_TYPES = [:return, :next, :break, :retry, :redo].freeze
+        FLOW_COMMANDS = [:throw, :raise, :fail].freeze
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions.each_cons(2) do |e1, e2|
+            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
+            add_offense(e2, :expression)
+          end
+        end
+
+        private
+
+        def flow_command?(node)
+          FLOW_COMMANDS.any? { |c| node.command?(c) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unused block arguments.
+      #
+      # @example
+      #
+      #   #good
+      #
+      #   do_something do |used, unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |_bar|
+      #     puts :baz
+      #   end
+      #
+      #   # bad
+      #
+      #   do_something do |used, _unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do |bar|
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |bar|
+      #     puts :baz
+      #   end
+      class UnusedBlockArgument < Cop
+        include UnusedArgument
+
+        private
+
+        def check_argument(variable)
+          return if allowed_block?(variable) ||
+                    allowed_keyword_argument?(variable)
+
+          super
+        end
+
+        def allowed_block?(variable)
+          !variable.block_argument? ||
+            (ignore_empty_blocks? && empty_block?(variable))
+        end
+
+        def allowed_keyword_argument?(variable)
+          variable.keyword_argument? &&
+            allow_unused_keyword_arguments?
+        end
+
+        def message(variable)
+          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
+
+          if variable.explicit_block_local_variable?
+            message
+          else
+            augment_message(message, variable)
+          end
+        end
+
+        def augment_message(message, variable)
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:block_argument?)
+
+          augmentation = if scope.node.lambda?
+                           message_for_lambda(variable, all_arguments)
+                         else
+                           message_for_normal_block(variable, all_arguments)
+                         end
+
+          [message, augmentation].join(' ')
+        end
+
+        def variable_type(variable)
+          if variable.explicit_block_local_variable?
+            'block local variable'
+          else
+            'block argument'
+          end
+        end
+
+        def message_for_normal_block(variable, all_arguments)
+          if all_arguments.none?(&:referenced?) &&
+             !define_method_call?(variable)
+            if all_arguments.count > 1
+              "You can omit all the arguments if you don't care about them."
+            else
+              "You can omit the argument if you don't care about it."
+            end
+          else
+            message_for_underscore_prefix(variable)
+          end
+        end
+
+        def message_for_lambda(variable, all_arguments)
+          message = message_for_underscore_prefix(variable)
+
+          if all_arguments.none?(&:referenced?)
+            proc_message = 'Also consider using a proc without arguments ' \
+                           'instead of a lambda if you want it ' \
+                           "to accept any arguments but don't care about them."
+          end
+
+          [message, proc_message].compact.join(' ')
+        end
+
+        def message_for_underscore_prefix(variable)
+          "If it's necessary, use `_` or `_#{variable.name}` " \
+          "as an argument name to indicate that it won't be used."
+        end
+
+        def define_method_call?(variable)
+          call, = *variable.scope.node
+          _, method, = *call
+
+          method == :define_method
+        end
+
+        def empty_block?(variable)
+          _send, _args, body = *variable.scope.node
+
+          body.nil?
+        end
+
+        def allow_unused_keyword_arguments?
+          cop_config['AllowUnusedKeywordArguments']
+        end
+
+        def ignore_empty_blocks?
+          cop_config['IgnoreEmptyBlocks']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unused method arguments.
+      #
+      # @example
+      #
+      #   def some_method(used, unused, _unused_but_allowed)
+      #     puts used
+      #   end
+      class UnusedMethodArgument < Cop
+        include UnusedArgument
+
+        def check_argument(variable)
+          return unless variable.method_argument?
+          return if variable.keyword_argument? &&
+                    cop_config['AllowUnusedKeywordArguments']
+
+          if cop_config['IgnoreEmptyMethods']
+            _name, _args, body = *variable.scope.node
+            return if body.nil?
+          end
+
+          super
+        end
+
+        def message(variable)
+          message = String.new("Unused method argument - `#{variable.name}`.")
+
+          unless variable.keyword_argument?
+            message << " If it's necessary, use `_` or `_#{variable.name}` " \
+                       "as an argument name to indicate that it won't be used."
+          end
+
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:method_argument?)
+
+          if all_arguments.none?(&:referenced?)
+            message << " You can also write as `#{scope.name}(*)` " \
+                       'if you want the method to accept any arguments ' \
+                       "but don't care about them."
+          end
+
+          message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+# 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.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/useless_assignment.rb

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