rubocop 0.75.1

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks with no body.
+      #
+      # @example AllowComments: false (default)
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example AllowComments: true
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing but comment
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing but comment
+      #   end
+      class HandleExceptions < Cop
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          return if node.body
+          return if cop_config['AllowComments'] && comment_lines?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the ordering of a method call where
+      # the receiver of the call is a HEREDOC.
+      #
+      # @example
+      #   # bad
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #      .trim
+      #
+      #   # good
+      #
+      #      <<~SQL
+      #        bar
+      #      SQL
+      #
+      #      <<~SQL.trim
+      #        bar
+      #      SQL
+      #
+      class HeredocMethodCallPosition < Cop
+        include RangeHelp
+
+        MSG = 'Put a method call with a HEREDOC receiver on the ' \
+        'same line as the HEREDOC opening.'
+
+        def on_send(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+          return unless heredoc
+          return if correctly_positioned?(node, heredoc)
+
+          add_offense(node, location: call_after_heredoc_range(heredoc))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+
+          lambda do |corrector|
+            call_range = call_range_to_safely_reposition(node, heredoc)
+            return if call_range.nil?
+
+            call_source = call_range.source.strip
+            corrector.remove(call_range)
+            corrector.insert_after(heredoc_begin_line_range(node), call_source)
+          end
+        end
+
+        private
+
+        def heredoc_node_descendent_receiver(node)
+          while send_node?(node)
+            return node.receiver if heredoc_node?(node.receiver)
+
+            node = node.receiver
+          end
+        end
+
+        def send_node?(node)
+          return nil unless node
+
+          node.call_type?
+        end
+
+        def heredoc_node?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def call_after_heredoc_range(heredoc)
+          pos = heredoc_end_pos(heredoc)
+          range_between(pos + 1, pos + 2)
+        end
+
+        def correctly_positioned?(node, heredoc)
+          heredoc_end_pos(heredoc) > call_end_pos(node)
+        end
+
+        def calls_on_multiple_lines?(node, _heredoc)
+          last_line = node.last_line
+          while send_node?(node)
+            return true unless last_line == node.last_line
+            return true unless all_on_same_line?(node.arguments)
+
+            node = node.receiver
+          end
+          false
+        end
+
+        def all_on_same_line?(nodes)
+          return true if nodes.empty?
+
+          nodes.first.first_line == nodes.last.last_line
+        end
+
+        def heredoc_end_pos(heredoc)
+          heredoc.location.heredoc_end.end_pos
+        end
+
+        def call_end_pos(node)
+          node.source_range.end_pos
+        end
+
+        def heredoc_begin_line_range(heredoc)
+          pos = heredoc.source_range.begin_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        def call_line_range(node)
+          pos = node.source_range.end_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        # Returns nil if no range can be safely repositioned.
+        def call_range_to_safely_reposition(node, heredoc)
+          return nil if calls_on_multiple_lines?(node, heredoc)
+
+          heredoc_end_pos = heredoc_end_pos(heredoc)
+          call_end_pos = call_end_pos(node)
+
+          call_range = range_between(heredoc_end_pos, call_end_pos)
+          call_line_range = call_line_range(node)
+
+          call_source = call_range.source.strip
+          call_line_source = call_line_range.source.strip
+
+          return call_range if call_source == call_line_source
+
+          if trailing_comma?(call_source, call_line_source)
+            # If there's some on the last line other than the call, e.g.
+            # a trailing comma, then we leave the "\n" following the
+            # heredoc_end in place.
+            return range_between(heredoc_end_pos, call_end_pos + 1)
+          end
+
+          nil
+        end
+
+        def trailing_comma?(call_source, call_line_source)
+          call_source + ',' == call_line_source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for implicit string concatenation of string literals
+      # which are on the same line.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   array = ['Item 1' 'Item 2']
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   array = ['Item 1Item 2']
+      #   array = ['Item 1' + 'Item 2']
+      #   array = [
+      #     'Item 1' \
+      #     'Item 2'
+      #   ]
+      class ImplicitStringConcatenation < Cop
+        MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
+              'literal, rather than using implicit string concatenation.'
+        FOR_ARRAY = ' Or, if they were intended to be separate array ' \
+                    'elements, separate them with a comma.'
+        FOR_METHOD = ' Or, if they were intended to be separate method ' \
+                     'arguments, separate them with a comma.'
+
+        def on_dstr(node)
+          each_bad_cons(node) do |child_node1, child_node2|
+            range   = child_node1.source_range.join(child_node2.source_range)
+            message = format(MSG,
+                             string1: display_str(child_node1),
+                             string2: display_str(child_node2))
+            if node.parent&.array_type?
+              message << FOR_ARRAY
+            elsif node.parent&.send_type?
+              message << FOR_METHOD
+            end
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        private
+
+        def each_bad_cons(node)
+          node.children.each_cons(2) do |child_node1, child_node2|
+            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
+            next unless string_literals?(child_node1, child_node2)
+            next unless child_node1.last_line == child_node2.first_line
+
+            # Make sure we don't flag a string literal which simply has
+            # embedded newlines
+            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
+            next unless child_node1.source[-1] == ending_delimiter(child_node1)
+
+            yield child_node1, child_node2
+          end
+        end
+
+        def ending_delimiter(str)
+          # implicit string concatenation does not work with %{}, etc.
+          if str.source[0] == "'"
+            "'"
+          elsif str.source[0] == '"'
+            '"'
+          end
+        end
+
+        def string_literal?(node)
+          node.str_type? ||
+            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+        end
+
+        def string_literals?(node1, node2)
+          string_literal?(node1) && string_literal?(node2)
+        end
+
+        def display_str(node)
+          if node.source =~ /\n/
+            str_content(node).inspect
+          else
+            node.source
+          end
+        end
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `private` or `protected` access modifiers which are
+      # applied to a singleton method. These access modifiers do not make
+      # singleton methods private/protected. `private_class_method` can be
+      # used for that.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class C
+      #     private
+      #
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #
+      #     private_class_method :method
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     class << self
+      #       private
+      #
+      #       def method
+      #         puts 'hi'
+      #       end
+      #     end
+      #   end
+      class IneffectiveAccessModifier < Cop
+        MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
+              'methods %<modifier>s. Use %<alternative>s instead.'
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
+                              '`class << self` block'
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
+                                'block'
+
+        def_node_search :private_class_methods, <<~PATTERN
+          (send nil? :private_class_method $...)
+        PATTERN
+
+        def on_class(node)
+          check_node(node.children[2]) # class body
+        end
+
+        def on_module(node)
+          check_node(node.children[1]) # module body
+        end
+
+        private
+
+        def check_node(node)
+          return unless node&.begin_type?
+
+          ignored_methods = private_class_method_names(node)
+
+          ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
+            add_offense(defs_node,
+                        location: :keyword,
+                        message: format_message(modifier))
+          end
+        end
+
+        def private_class_method_names(node)
+          private_class_methods(node).to_a.flatten
+                                     .select(&:basic_literal?)
+                                     .map(&:value)
+        end
+
+        def format_message(modifier)
+          visibility = modifier.method_name
+          alternative = if visibility == :private
+                          ALTERNATIVE_PRIVATE
+                        else
+                          ALTERNATIVE_PROTECTED
+                        end
+          format(MSG, modifier: visibility,
+                      line: modifier.location.expression.line,
+                      alternative: alternative)
+        end
+
+        def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
+          node.each_child_node do |child|
+            case child.type
+            when :send
+              modifier = child if access_modifier?(child)
+            when :defs
+              next if correct_visibility?(child, modifier, ignored_methods)
+
+              yield child, modifier
+            when :kwbegin
+              ineffective_modifier(child, ignored_methods, modifier, &block)
+            end
+          end
+        end
+
+        def access_modifier?(node)
+          node.bare_access_modifier? && !node.method?(:module_function)
+        end
+
+        def correct_visibility?(node, modifier, ignored_methods)
+          return true if modifier.nil? || modifier.method_name == :public
+
+          ignored_methods.include?(node.method_name)
+        end
+      end
+    end
+  end
+end