rubbycop 0.49.0

data/lib/rubbycop/cop/style/mutable_constant.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # @example
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      class MutableConstant < Cop
+        include FrozenStringLiteral
+
+        MSG = 'Freeze mutable objects assigned to constants.'.freeze
+
+        def on_casgn(node)
+          _scope, _const_name, value = *node
+          on_assignment(value)
+        end
+
+        def on_or_asgn(node)
+          lhs, value = *node
+
+          return unless lhs && lhs.casgn_type?
+
+          on_assignment(value)
+        end
+
+        private
+
+        def on_assignment(value)
+          value = splat_value(value) if splat_value(value)
+
+          return unless value && value.mutable_literal?
+          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
+                    frozen_string_literals_enabled?
+
+          add_offense(value, :expression)
+        end
+
+        def autocorrect(node)
+          expr = node.source_range
+
+          lambda do |corrector|
+            if unbracketed_array?(node)
+              corrector.insert_before(expr, '[')
+              corrector.insert_after(expr, '].freeze')
+            else
+              corrector.insert_after(expr, '.freeze')
+            end
+          end
+        end
+
+        def unbracketed_array?(node)
+          node.array_type? && !node.square_brackets? && !node.percent_literal?
+        end
+
+        def_node_matcher :splat_value, <<-PATTERN
+          (array (splat $_))
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/negated_if.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example
+      #
+      #   # EnforcedStyle: both
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      # @example
+      #
+      #   # EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example
+      #
+      #   # EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
+      class NegatedIf < Cop
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+
+        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
+
+        def on_if(node)
+          return if node.elsif? || node.ternary?
+          return if style == :prefix && node.modifier_form?
+          return if style == :postfix && !node.modifier_form?
+
+          check_negative_conditional(node)
+        end
+
+        def message(node)
+          format(MSG, node.inverse_keyword, node.keyword)
+        end
+
+        private
+
+        def autocorrect(node)
+          negative_conditional_corrector(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/negated_while.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      class NegatedWhile < Cop
+        include NegativeConditional
+
+        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
+
+        def on_while(node)
+          check_negative_conditional(node)
+        end
+
+        def on_until(node)
+          check_negative_conditional(node)
+        end
+
+        def message(node)
+          format(MSG, node.inverse_keyword, node.keyword)
+        end
+
+        private
+
+        def autocorrect(node)
+          negative_conditional_corrector(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/nested_modifier.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for nested use of if, unless, while and until in their
+      # modifier form.
+      #
+      # @example
+      #
+      #   # bad
+      #   something if a if b
+      #
+      #   # good
+      #   something if b && a
+      class NestedModifier < Cop
+        MSG = 'Avoid using nested modifiers.'.freeze
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def on_if(node)
+          check(node)
+        end
+
+        def check(node)
+          return if part_of_ignored_node?(node)
+          return unless modifier?(node) && modifier?(node.parent)
+
+          add_offense(node, :keyword)
+          ignore_node(node)
+        end
+
+        def modifier?(node)
+          node && MODIFIER_NODES.include?(node.type) && node.modifier_form?
+        end
+
+        def autocorrect(node)
+          return unless node.if_type? && node.parent.if_type?
+
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.parent.condition.source_range.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, new_expression(node.parent, node))
+          end
+        end
+
+        def new_expression(outer_node, inner_node)
+          operator = replacement_operator(outer_node.keyword)
+          lh_operand = left_hand_operand(outer_node, operator)
+          rh_operand = right_hand_operand(inner_node, outer_node.keyword)
+
+          "#{outer_node.keyword} #{lh_operand} #{operator} #{rh_operand}"
+        end
+
+        def replacement_operator(keyword)
+          keyword == 'if'.freeze ? '&&'.freeze : '||'.freeze
+        end
+
+        def left_hand_operand(node, operator)
+          expr = node.condition.source
+          expr = "(#{expr})" if node.condition.or_type? &&
+                                operator == '&&'.freeze
+          expr
+        end
+
+        def right_hand_operand(node, left_hand_keyword)
+          expr = node.condition.source
+          expr = "(#{expr})" if requires_parens?(node.condition)
+          expr = "!#{expr}" unless left_hand_keyword == node.keyword
+          expr
+        end
+
+        def requires_parens?(node)
+          node.or_type? ||
+            !(RubbyCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/nested_parenthesized_calls.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for unparenthesized method calls in the argument list
+      # of a parenthesized method call.
+      #
+      # @example
+      #   @good
+      #   method1(method2(arg), method3(arg))
+      #
+      #   @bad
+      #   method1(method2 arg, method3, arg)
+      class NestedParenthesizedCalls < Cop
+        MSG = 'Add parentheses to nested method call `%s`.'.freeze
+        RSPEC_MATCHERS = %i[be eq eql equal be_kind_of be_instance_of
+                            respond_to be_between match be_within
+                            start_with end_with include raise_error].freeze
+
+        def on_send(node)
+          return unless node.parenthesized?
+
+          node.each_child_node(:send) do |nested|
+            next if allowed_omission?(nested)
+
+            add_offense(nested, nested.source_range, format(MSG, nested.source))
+          end
+        end
+
+        private
+
+        def allowed_omission?(send_node)
+          !send_node.arguments? || send_node.parenthesized? ||
+            send_node.setter_method? || send_node.operator_method? ||
+            rspec_matcher?(send_node)
+        end
+
+        # TODO: Relegate this from RubbyCop core
+        def rspec_matcher?(send_node)
+          send_node.parent.arguments.one? && # .to, .not_to, etc
+            RSPEC_MATCHERS.include?(send_node.method_name) &&
+            send_node.arguments.one?
+        end
+
+        def autocorrect(nested)
+          first_arg = nested.first_argument.source_range
+          last_arg = nested.last_argument.source_range
+
+          leading_space =
+            range_with_surrounding_space(first_arg, :left).begin.resize(1)
+
+          lambda do |corrector|
+            corrector.replace(leading_space, '(')
+            corrector.insert_after(last_arg, ')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/nested_ternary_operator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for nested ternary op expressions.
+      class NestedTernaryOperator < Cop
+        MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
+              'constructs instead.'.freeze
+
+        def on_if(node)
+          return unless node.ternary?
+
+          node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
+            add_offense(nested_ternary, :expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/next.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Use `next` to skip iteration instead of a condition at the end.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      class Next < Cop
+        include ConfigurableEnforcedStyle
+        include MinBodyLength
+
+        MSG = 'Use `next` to skip iteration.'.freeze
+        EXIT_TYPES = %i[break return].freeze
+        EACH_ = 'each_'.freeze
+        ENUMERATORS = %i[collect collect_concat detect downto each
+                         find find_all find_index inject loop map!
+                         map reduce reject reject! reverse_each select
+                         select! times upto].freeze
+
+        def investigate(_processed_source)
+          # When correcting nested offenses, we need to keep track of how much
+          # we have adjusted the indentation of each line
+          @reindented_lines = Hash.new(0)
+        end
+
+        def on_block(node)
+          block_owner, _, body = *node
+          return unless block_owner.send_type?
+          return unless body && ends_with_condition?(body)
+
+          _, method_name = *block_owner
+          return unless enumerator?(method_name)
+
+          offense_node = offense_node(body)
+          add_offense(offense_node, offense_location(offense_node), MSG)
+        end
+
+        def on_while(node)
+          return unless node.body && ends_with_condition?(node.body)
+
+          offending_node = offense_node(node.body)
+
+          add_offense(offending_node, offense_location(offending_node), MSG)
+        end
+        alias on_until on_while
+        alias on_for on_while
+
+        private
+
+        def enumerator?(method_name)
+          ENUMERATORS.include?(method_name) ||
+            method_name.to_s.start_with?(EACH_)
+        end
+
+        def ends_with_condition?(body)
+          return true if simple_if_without_break?(body)
+
+          body.begin_type? && simple_if_without_break?(body.children.last)
+        end
+
+        def simple_if_without_break?(node)
+          return false unless if_without_else?(node)
+          return false if if_else_children?(node)
+          return false if allowed_modifier_if?(node)
+
+          !exit_body_type?(node)
+        end
+
+        def allowed_modifier_if?(node)
+          if node.modifier_form?
+            style == :skip_modifier_ifs
+          else
+            !min_body_length?(node)
+          end
+        end
+
+        def if_else_children?(node)
+          node.each_child_node(:if).any?(&:else?)
+        end
+
+        def if_without_else?(node)
+          node && node.if_type? && !node.ternary? && !node.else?
+        end
+
+        def exit_body_type?(node)
+          return false unless node.if_branch
+
+          EXIT_TYPES.include?(node.if_branch.type)
+        end
+
+        def offense_node(body)
+          *_, condition = *body
+          condition && condition.if_type? ? condition : body
+        end
+
+        def offense_location(offense_node)
+          condition_expression, = *offense_node
+          offense_begin_pos = offense_node.source_range.begin
+          offense_begin_pos.join(condition_expression.source_range)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.modifier_form?
+              autocorrect_modifier(corrector, node)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_modifier(corrector, node)
+          cond, if_body, else_body = *node
+          body = if_body || else_body
+
+          replacement = "next #{opposite_kw(if_body)} #{cond.source}\n" \
+                        "#{' ' * node.source_range.column}#{body.source}"
+
+          corrector.replace(node.source_range, replacement)
+        end
+
+        def autocorrect_block(corrector, node)
+          cond, if_body, = *node
+
+          next_code = "next #{opposite_kw(if_body)} #{cond.source}"
+          corrector.insert_before(node.source_range, next_code)
+
+          corrector.remove(cond_range(node, cond))
+          corrector.remove(end_range(node))
+
+          lines = reindentable_lines(node)
+          return if lines.empty?
+
+          reindent(lines, cond, corrector)
+        end
+
+        def opposite_kw(if_body)
+          if_body.nil? ? 'if' : 'unless'
+        end
+
+        def cond_range(node, cond)
+          end_pos = if node.loc.begin
+                      node.loc.begin.end_pos # after "then"
+                    else
+                      cond.source_range.end_pos
+                    end
+
+          range_between(node.source_range.begin_pos, end_pos)
+        end
+
+        def end_range(node)
+          source_buffer = node.source_range.source_buffer
+          end_pos = node.loc.end.end_pos
+          begin_pos = node.loc.end.begin_pos - node.source_range.column
+          begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
+                                                             end_pos)
+
+          range_between(begin_pos, end_pos)
+        end
+
+        def end_followed_by_whitespace_only?(source_buffer, end_pos)
+          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+        end
+
+        def reindentable_lines(node)
+          buffer = node.source_range.source_buffer
+
+          # end_range starts with the final newline of the if body
+          lines = (node.source_range.line + 1)...node.loc.end.line
+          lines = lines.to_a - heredoc_lines(node)
+          # Skip blank lines
+          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+        end
+
+        # Adjust indentation of `lines` to match `node`
+        def reindent(lines, node, corrector)
+          range  = node.source_range
+          buffer = range.source_buffer
+
+          target_indent = range.source_line =~ /\S/
+          delta = actual_indent(lines, buffer) - target_indent
+          lines.each do |lineno|
+            reindent_line(corrector, lineno, delta, buffer)
+          end
+        end
+
+        def actual_indent(lines, buffer)
+          lines.map { |lineno| buffer.source_line(lineno) =~ /\S/ }.min
+        end
+
+        def heredoc_lines(node)
+          node.each_node(:dstr)
+              .select { |n| n.loc.respond_to?(:heredoc_body) }
+              .map { |n| n.loc.heredoc_body }
+              .flat_map { |b| (b.line...b.last_line).to_a }
+        end
+
+        def reindent_line(corrector, lineno, delta, buffer)
+          adjustment = delta + @reindented_lines[lineno]
+          @reindented_lines[lineno] = adjustment
+
+          if adjustment > 0
+            corrector.remove_leading(buffer.line_range(lineno), adjustment)
+          elsif adjustment < 0
+            corrector.insert_before(buffer.line_range(lineno),
+                                    ' ' * -adjustment)
+          end
+        end
+      end
+    end
+  end
+end