rubbycop 0.49.0

data/lib/rubbycop/cop/lint/unneeded_splat_expansion.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for unneeded usages of splat expansion
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   a = *[1, 2, 3]
+      #   a = *'a'
+      #   a = *1
+      #
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   c = [1, 2, 3]
+      #   a = *c
+      #   a, b = *c
+      #   a, *b = *c
+      #   a = *1..10
+      #   a = ['a']
+      #
+      #   begin
+      #     foo
+      #   rescue StandardError, ApplicationError
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      class UnneededSplatExpansion < Cop
+        MSG = 'Unnecessary splat expansion.'.freeze
+        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'.freeze
+        PERCENT_W = '%w'.freeze
+        PERCENT_CAPITAL_W = '%W'.freeze
+        PERCENT_I = '%i'.freeze
+        PERCENT_CAPITAL_I = '%I'.freeze
+        ARRAY_NEW_PATTERN = '$(send (const nil :Array) :new ...)'.freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        def_node_matcher :literal_expansion?, <<-PATTERN
+          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
+        PATTERN
+
+        def on_splat(node)
+          literal_expansion?(node) do |object|
+            if object.send_type?
+              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
+            end
+
+            if array_splat?(node) &&
+               (method_argument?(node) || part_of_an_array?(node))
+              add_offense(node, :expression, ARRAY_PARAM_MSG)
+            else
+              add_offense(node, :expression)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          variable, = *node
+          loc = node.loc
+
+          lambda do |corrector|
+            if !variable.array_type?
+              corrector.replace(loc.expression, "[#{variable.source}]")
+            elsif unneeded_brackets?(node)
+              corrector.replace(loc.expression, remove_brackets(variable))
+            else
+              corrector.remove(loc.operator)
+            end
+          end
+        end
+
+        def array_splat?(node)
+          node.children.first.array_type?
+        end
+
+        def method_argument?(node)
+          node.parent.send_type?
+        end
+
+        def part_of_an_array?(node)
+          # The parent of a splat expansion is an array that does not have
+          # `begin` or `end`
+          parent = node.parent
+          parent.array_type? && parent.loc.begin && parent.loc.end
+        end
+
+        def unneeded_brackets?(node)
+          parent = node.parent
+          grandparent = node.parent.parent
+
+          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+            (grandparent && grandparent.resbody_type?)
+        end
+
+        def remove_brackets(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map(&:source)
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/unreachable_code.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'.freeze
+
+        NODE_TYPES = %i[return next break retry redo].freeze
+        FLOW_COMMANDS = %i[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)
+          return false unless node.send_type?
+
+          FLOW_COMMANDS.any? { |c| node.command?(c) }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/unused_block_argument.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for unused block arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   do_something do |used, unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do |bar|
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |bar|
+      #     puts :baz
+      #   end
+      #
+      # @example
+      #
+      #   #good
+      #
+      #   do_something do |used, _unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do
+      #     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/lib/rubbycop/cop/lint/unused_method_argument.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for unused method arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method(used, unused, _unused_but_allowed)
+      #     puts used
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   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/lib/rubbycop/cop/lint/useless_access_modifier.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+      #
+      # @example
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   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) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            matcher_name = "#{m}_method?".to_sym
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<-PATTERN
+                {def (send nil :#{m} ...)}
+              PATTERN
+            end
+
+            send(matcher_name, child)
+          end
+        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