rubbycop 0.49.0

data/lib/rubbycop/cop/mixin/min_body_length.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking minimum body length.
+    module MinBodyLength
+      def min_body_length?(node)
+        (node.loc.end.line - node.loc.keyword.line) > min_body_length
+      end
+
+      def min_body_length
+        length = cop_config['MinBodyLength'] || 1
+        return length if length.is_a?(Integer) && length > 0
+
+        raise 'MinBodyLength needs to be a positive integer!'
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/multiline_expression_indentation.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking multiline method calls and binary
+    # operations.
+    module MultilineExpressionIndentation
+      def on_send(node)
+        return if !node.receiver || node.method?(:[])
+        return unless relevant_node?(node)
+
+        lhs = left_hand_side(node.receiver)
+        rhs = right_hand_side(node)
+        range = offending_range(node, lhs, rhs, style)
+        check(range, node, lhs, rhs)
+      end
+
+      # In a chain of method calls, we regard the top send node as the base
+      # for indentation of all lines following the first. For example:
+      # a.
+      #   b c { block }.            <-- b is indented relative to a
+      #   d                         <-- d is indented relative to a
+      def left_hand_side(lhs)
+        lhs = lhs.parent while lhs.parent && lhs.parent.send_type?
+        lhs
+      end
+
+      def right_hand_side(send_node)
+        if send_node.operator_method? && send_node.arguments?
+          send_node.first_argument.source_range # not used for method calls
+        else
+          regular_method_right_hand_side(send_node)
+        end
+      end
+
+      def regular_method_right_hand_side(send_node)
+        dot = send_node.loc.dot
+        selector = send_node.loc.selector
+        if send_node.dot? && selector && dot.line == selector.line
+          dot.join(selector)
+        elsif selector
+          selector
+        elsif send_node.implicit_call?
+          dot.join(send_node.loc.begin)
+        end
+      end
+
+      def correct_indentation(node)
+        if kw_node_with_special_indentation(node)
+          # This cop could have its own IndentationWidth configuration
+          configured_indentation_width +
+            @config.for_cop('Layout/IndentationWidth')['Width']
+        else
+          configured_indentation_width
+        end
+      end
+
+      def check(range, node, lhs, rhs)
+        if range
+          incorrect_style_detected(range, node, lhs, rhs)
+        else
+          correct_style_detected
+        end
+      end
+
+      def incorrect_style_detected(range, node, lhs, rhs)
+        add_offense(range, range, message(node, lhs, rhs)) do
+          if supported_styles.size > 2 ||
+             offending_range(node, lhs, rhs, alternative_style)
+            unrecognized_style_detected
+          else
+            opposite_style_detected
+          end
+        end
+      end
+
+      def indentation(node)
+        node.source_range.source_line =~ /\S/
+      end
+
+      def operation_description(node, rhs)
+        ancestor = kw_node_with_special_indentation(node)
+        if ancestor
+          kw = ancestor.loc.keyword.source
+          kind = kw == 'for' ? 'collection' : 'condition'
+          article = kw =~ /^[iu]/ ? 'an' : 'a'
+          "a #{kind} in #{article} `#{kw}` statement"
+        else
+          'an expression' +
+            (part_of_assignment_rhs(node, rhs) ? ' in an assignment' : '')
+        end
+      end
+
+      def kw_node_with_special_indentation(node)
+        node.each_ancestor.find do |a|
+          next unless a.loc.respond_to?(:keyword)
+
+          case a.type
+          when :for                  then _, expression, = *a
+          when :return               then expression, = *a
+          when *Util::MODIFIER_NODES then expression, = *a
+          end
+
+          within_node?(node, expression) if expression
+        end
+      end
+
+      def argument_in_method_call(node, kind)
+        node.each_ancestor(:send, :block).find do |a|
+          # If the node is inside a block, it makes no difference if that block
+          # is an argument in a method call. It doesn't count.
+          break false if a.block_type?
+
+          next if a.setter_method?
+
+          a.arguments.any? do |arg|
+            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
+                                        kind == :with_parentheses &&
+                                        parentheses?(node.parent))
+          end
+        end
+      end
+
+      def part_of_assignment_rhs(node, candidate)
+        node.each_ancestor.find do |a|
+          case a.type
+          when :if, :while, :until, :for, :return, :array, :kwbegin
+            break # other kinds of alignment
+          when :block
+            break if part_of_block_body?(candidate, a)
+          when :send
+            valid_method_rhs_candidate?(candidate, a)
+          when *Util::ASGN_NODES
+            valid_rhs_candidate?(candidate, assignment_rhs(a))
+          end
+        end
+      end
+
+      # The []= operator and setters (a.b = c) are parsed as :send nodes.
+      def valid_method_rhs_candidate?(candidate, node)
+        node.setter_method? &&
+          valid_rhs_candidate?(candidate, node.last_argument)
+      end
+
+      def valid_rhs_candidate?(candidate, node)
+        !candidate || within_node?(candidate, node)
+      end
+
+      def part_of_block_body?(candidate, node)
+        _method, _args, body = *node
+        body && within_node?(candidate, body)
+      end
+
+      def assignment_rhs(node)
+        case node.type
+        when :casgn   then _scope, _lhs, rhs = *node
+        when :op_asgn then _lhs, _op, rhs = *node
+        when :send    then rhs = node.last_argument
+        else               _lhs, rhs = *node
+        end
+        rhs
+      end
+
+      def not_for_this_cop?(node)
+        node.ancestors.any? do |ancestor|
+          grouped_expression?(ancestor) ||
+            inside_arg_list_parentheses?(node, ancestor)
+        end
+      end
+
+      def grouped_expression?(node)
+        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def inside_arg_list_parentheses?(node, ancestor)
+        return false unless ancestor.send_type? && ancestor.parenthesized?
+
+        node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
+          node.source_range.end_pos < ancestor.loc.end.end_pos
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/multiline_literal_brace_layout.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements, or a new line.
+    module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
+      def check_brace_layout(node)
+        return if ignored_literal?(node)
+
+        # If the last node is or contains a conflicting HEREDOC, we don't want
+        # to adjust the brace layout because this will result in invalid code.
+        return if last_line_heredoc?(node.children.last)
+
+        check(node)
+      end
+
+      def autocorrect(node)
+        if closing_brace_on_same_line?(node)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.end, "\n".freeze)
+          end
+        else
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.end,
+                                                          :left))
+
+            corrector.insert_after(last_element_range_with_trailing_comma(node),
+                                   node.loc.end.source)
+          end
+        end
+      end
+
+      private
+
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
+        end
+      end
+
+      def check_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
+      end
+
+      def check_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
+      end
+
+      def check_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
+        end
+      end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(children(node).last.source_range,
+                                             :right).end.resize(1)
+        range.source == ',' ? range : nil
+      end
+
+      def children(node)
+        node.children
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def opening_brace_on_same_line?(node)
+        node.loc.begin.line == children(node).first.loc.first_line
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.loc.last_line
+      end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.loc.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/negative_conditional.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
+    module NegativeConditional
+      extend NodePattern::Macros
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      def_node_matcher :empty_condition?, '(begin)'
+
+      def check_negative_conditional(node)
+        condition = node.condition
+
+        return if empty_condition?(condition)
+
+        condition = condition.children.last while condition.begin_type?
+
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
+
+        add_offense(node, :expression)
+      end
+
+      def negative_conditional_corrector(node)
+        condition = negated_condition(node)
+
+        lambda do |corrector|
+          corrector.replace(node.loc.keyword, node.inverse_keyword)
+          corrector.replace(condition.source_range,
+                            condition.children.first.source)
+        end
+      end
+
+      def negated_condition(node)
+        condition = node.condition
+        condition = condition.children.first while condition.begin_type?
+        condition
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/on_method_def.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for checking instance methods and singleton methods.
+    module OnMethodDef
+      def on_def(node)
+        method_name, args, body = *node
+        on_method_def(node, method_name, args, body)
+      end
+
+      def on_defs(node)
+        _scope, method_name, args, body = *node
+        on_method_def(node, method_name, args, body)
+      end
+
+      # This method provides scope agnostic method node destructuring by moving
+      # the scope to the end where it can easily be ignored.
+      def method_def_node_parts(node)
+        if node.def_type?
+          method_name, args, body = *node
+        elsif node.defs_type?
+          scope, method_name, args, body = *node
+        else
+          return []
+        end
+
+        [method_name, args, body, scope]
+      end
+
+      private
+
+      # Returns true for constructs such as
+      # private def my_method
+      # which are allowed in Ruby 2.1 and later.
+      def modifier_and_def_on_same_line?(send_node)
+        !send_node.receiver &&
+          send_node.method_name != :def &&
+          send_node.arguments.one? &&
+          %i[def defs].include?(send_node.first_argument.type)
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/mixin/on_normal_if_unless.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Common functionality for cops checking if and unless expressions.
+    module OnNormalIfUnless
+      def on_if(node)
+        return if node.modifier_form? || node.ternary?
+
+        on_normal_if_unless(node)
+      end
+    end
+  end
+end