rubocop 0.87.1

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop check to make sure that if safe navigation is used for a method
+      # call in an `&&` or `||` condition that safe navigation is used for all
+      # method calls on that same object.
+      #
+      # @example
+      #   # bad
+      #   foo&.bar && foo.baz
+      #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
+      #   # bad
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
+      #   # good
+      #   foo.bar && foo.baz
+      #
+      #   # good
+      #   foo&.bar || foo&.baz
+      #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo&.baz)
+      #
+      class SafeNavigationConsistency < Cop
+        include IgnoredNode
+        include NilMethods
+
+        MSG = 'Ensure that safe navigation is used consistently ' \
+          'inside of `&&` and `||`.'
+
+        def on_csend(node)
+          return unless node.parent&.operator_keyword?
+
+          check(node)
+        end
+
+        def check(node)
+          ancestor = top_conditional_ancestor(node)
+          conditions = ancestor.conditions
+          safe_nav_receiver = node.receiver
+
+          method_calls = conditions.select(&:send_type?)
+          unsafe_method_calls =
+            unsafe_method_calls(method_calls, safe_nav_receiver)
+
+          unsafe_method_calls.each do |unsafe_method_call|
+            location =
+              node.loc.expression.join(unsafe_method_call.loc.expression)
+            add_offense(unsafe_method_call,
+                        location: location)
+
+            ignore_node(unsafe_method_call)
+          end
+        end
+
+        def autocorrect(node)
+          return unless node.dot?
+
+          lambda do |corrector|
+            corrector.insert_before(node.loc.dot, '&')
+          end
+        end
+
+        private
+
+        def top_conditional_ancestor(node)
+          parent = node.parent
+          unless parent &&
+                 (parent.operator_keyword? ||
+                  (parent.begin_type? &&
+                   parent.parent &&
+                   parent.parent.operator_keyword?))
+            return node
+          end
+
+          top_conditional_ancestor(parent)
+        end
+
+        def unsafe_method_calls(method_calls, safe_nav_receiver)
+          method_calls.select do |method_call|
+            safe_nav_receiver == method_call.receiver &&
+              !nil_methods.include?(method_call.method_name) &&
+              !ignored_node?(method_call)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure safe navigation isn't used with `empty?` in
+      # a conditional.
+      #
+      # While the safe navigation operator is generally a good idea, when
+      # checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      # do the opposite of what the author intends.
+      #
+      # @example
+      #   # bad
+      #   return if foo&.empty?
+      #   return unless foo&.empty?
+      #
+      #   # good
+      #   return if foo && foo.empty?
+      #   return unless foo && foo.empty?
+      #
+      class SafeNavigationWithEmpty < Cop
+        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
+          'in conditionals.'
+
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
+          (if (csend (send ...) :empty?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_empty_in_conditional?(node)
+
+          add_offense(node.condition)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            receiver = node.receiver.source
+
+            corrector.replace(node, "#{receiver} && #{receiver}.#{node.method_name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/script_permission.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if a file which has a shebang line as
+      # its first line is granted execute permission.
+      #
+      # @example
+      #   # bad
+      #
+      #   # A file which has a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has a shebang line as its first line is
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has not a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   puts 'hello, world'
+      #
+      class ScriptPermission < Cop
+        MSG = "Script file %<file>s doesn't have execute permission."
+        SHEBANG = '#!'
+
+        def investigate(processed_source)
+          return if @options.key?(:stdin)
+          return if Platform.windows?
+          return unless processed_source.start_with?(SHEBANG)
+          return if executable?(processed_source)
+
+          comment = processed_source.comments[0]
+          message = format_message_from(processed_source)
+          add_offense(comment, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |_corrector|
+            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          end
+        end
+
+        private
+
+        def executable?(processed_source)
+          # Returns true if stat is executable or if the operating system
+          # doesn't distinguish executable files from nonexecutable files.
+          # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
+          File.stat(processed_source.file_path).executable?
+        end
+
+        def format_message_from(processed_source)
+          basename = File.basename(processed_source.file_path)
+          format(MSG, file: basename)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # when using mix-in.
+      #
+      # `include` and `prepend` methods were private methods until Ruby 2.0,
+      # they were mixed-in via `send` method. This cop uses Ruby 2.1 or
+      # higher style that can be called by public methods.
+      # And `extend` method that was originally a public method is also targeted
+      # for style unification.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:include, Bar)
+      #   Foo.send(:prepend, Bar)
+      #   Foo.send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.public_send(:include, Bar)
+      #   Foo.public_send(:prepend, Bar)
+      #   Foo.public_send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.__send__(:include, Bar)
+      #   Foo.__send__(:prepend, Bar)
+      #   Foo.__send__(:extend, Bar)
+      #
+      #   # good
+      #   Foo.include Bar
+      #   Foo.prepend Bar
+      #   Foo.extend Bar
+      #
+      class SendWithMixinArgument < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
+        MIXIN_METHODS = %i[include prepend extend].freeze
+
+        def_node_matcher :send_with_mixin_argument?, <<~PATTERN
+          (send
+            (const _ _) {:send :public_send :__send__}
+            ({sym str} $#mixin_method?)
+              $(const _ _))
+        PATTERN
+
+        def on_send(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            message = message(
+              method, module_name.source, bad_location(node).source
+            )
+
+            add_offense(node, location: bad_location(node), message: message)
+          end
+        end
+
+        def autocorrect(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            lambda do |corrector|
+              corrector.replace(
+                bad_location(node), "#{method} #{module_name.source}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def bad_location(node)
+          loc = node.loc
+
+          range_between(loc.selector.begin_pos, loc.expression.end_pos)
+        end
+
+        def message(method, module_name, bad_method)
+          format(
+            MSG,
+            method: method, module_name: module_name, bad_method: bad_method
+          )
+        end
+
+        def mixin_method?(node)
+          MIXIN_METHODS.include?(node.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/shadowed_argument.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for shadowed arguments.
+      #
+      # This cop has `IgnoreImplicitReferences` configuration option.
+      # It means argument shadowing is used in order to pass parameters
+      # to zero arity `super` when `IgnoreImplicitReferences` is `true`.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something do |foo|
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   do_something do |foo|
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     puts foo
+      #   end
+      #
+      # @example IgnoreImplicitReferences: false (default)
+      #
+      #   # bad
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      # @example IgnoreImplicitReferences: true
+      #
+      #   # good
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      class ShadowedArgument < Cop
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
+              'before it was used.'
+
+        def_node_search :uses_var?, '(lvar %)'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(argument)
+          return unless argument.method_argument? || argument.block_argument?
+          # Block local variables, i.e., variables declared after ; inside
+          # |...| aren't really arguments.
+          return if argument.explicit_block_local_variable?
+
+          shadowing_assignment(argument) do |node|
+            message = format(MSG, argument: argument.name)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def shadowing_assignment(argument)
+          return unless argument.referenced?
+
+          assignment_without_argument_usage(argument) do |node, location_known|
+            assignment_without_usage_pos = node.source_range.begin_pos
+
+            references = argument_references(argument)
+
+            # If argument was referenced before it was reassigned
+            # then it's not shadowed
+            next if references.any? do |reference|
+              next true if !reference.explicit? && ignore_implicit_references?
+
+              reference_pos(reference.node) <= assignment_without_usage_pos
+            end
+
+            yield location_known ? node : argument.declaration_node
+          end
+        end
+
+        # Find the first argument assignment, which doesn't reference the
+        # argument at the rhs. If the assignment occurs inside a branch or
+        # block, it is impossible to tell whether it's executed, so precise
+        # shadowing location is not known.
+        #
+        def assignment_without_argument_usage(argument)
+          argument.assignments.reduce(true) do |location_known, assignment|
+            assignment_node = assignment.meta_assignment_node || assignment.node
+
+            # Shorthand assignments always use their arguments
+            next false if assignment_node.shorthand_asgn?
+
+            node_within_block_or_conditional =
+              node_within_block_or_conditional?(assignment_node.parent,
+                                                argument.scope.node)
+
+            unless uses_var?(assignment_node, argument.name)
+              # It's impossible to decide whether a branch or block is executed,
+              # so the precise reassignment location is undecidable.
+              next false if node_within_block_or_conditional
+
+              yield(assignment.node, location_known)
+              break
+            end
+
+            location_known
+          end
+        end
+
+        def reference_pos(node)
+          node = node.parent.masgn_type? ? node.parent : node
+
+          node.source_range.begin_pos
+        end
+
+        # Check whether the given node is nested into block or conditional.
+        #
+        def node_within_block_or_conditional?(node, stop_search_node)
+          return false if node == stop_search_node
+
+          node.conditional? || node.block_type? ||
+            node_within_block_or_conditional?(node.parent, stop_search_node)
+        end
+
+        # Get argument references without assignments' references
+        #
+        def argument_references(argument)
+          assignment_references = argument
+                                  .assignments
+                                  .flat_map(&:references)
+                                  .map(&:source_range)
+
+          argument.references.reject do |ref|
+            next false unless ref.explicit?
+
+            assignment_references.include?(ref.node.source_range)
+          end
+        end
+
+        def ignore_implicit_references?
+          cop_config['IgnoreImplicitReferences']
+        end
+      end
+    end
+  end
+end