rubocop 0.48.1 → 0.49.0

data/lib/rubocop/cop/style/percent_literal_delimiters.rb

@@ -12,8 +12,8 @@ module RuboCop
       # @example
       #   # Style/PercentLiteralDelimiters:
       #   #   PreferredDelimiters:
-      #   #     default: []
-      #   #     %i:      ()
+      #   #     default: '[]'
+      #   #     '%i':    '()'
       #
       #   # good
       #   %w[alpha beta] + %i(gamma delta)

data/lib/rubocop/cop/style/self_assignment.rb

@@ -16,6 +16,10 @@ module RuboCop
         MSG = 'Use self-assignment shorthand `%s=`.'.freeze
         OPS = %i[+ - * ** / | &].freeze
 
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceAroundOperators]
+        end
+
         def on_lvasgn(node)
           check(node, :lvar)
         end

data/lib/rubocop/cop/style/single_line_block_params.rb

@@ -9,32 +9,34 @@ module RuboCop
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
       # parameters.
       class SingleLineBlockParams < Cop
+        MSG = 'Name `%s` block params `|%s|`.'.freeze
+
         def on_block(node)
-          # we care only for single line blocks
-          return unless block_length(node).zero?
+          return unless node.single_line?
+
+          send_node = node.send_node
 
-          method_node, args_node, _body_node = *node
-          receiver, method_name, _method_args = *method_node
+          return unless send_node.receiver
+          return unless method_names.include?(send_node.method_name)
 
-          # discard other scenarios
-          return unless receiver
-          return unless method_names.include?(method_name)
+          return unless node.arguments?
 
-          args = *args_node
+          arguments = node.arguments.to_a
 
-          return if args.empty?
           # discard cases with argument destructuring
-          return true unless args.all?(&:arg_type?)
-          return if args_match?(method_name, args)
+          return true unless arguments.all?(&:arg_type?)
+          return if args_match?(send_node.method_name, arguments)
 
-          add_offense(args_node, :expression, message(method_name))
+          add_offense(node.arguments, :expression)
         end
 
         private
 
-        def message(method_name)
-          args = target_args(method_name).join(', ')
-          "Name `#{method_name}` block params `|#{args}|`."
+        def message(node)
+          method_name = node.parent.send_node.method_name
+          arguments   = target_args(method_name).join(', ')
+
+          format(MSG, method_name, arguments)
         end
 
         def methods
@@ -42,12 +44,16 @@ module RuboCop
         end
 
         def method_names
-          methods.map { |e| e.keys.first.to_sym }
+          methods.map { |method| method_name(method).to_sym }
+        end
+
+        def method_name(method)
+          method.keys.first
         end
 
         def target_args(method_name)
           method_name = method_name.to_s
-          method_hash = methods.find { |m| m.keys.first == method_name }
+          method_hash = methods.find { |m| method_name(m) == method_name }
           method_hash[method_name]
         end
 

data/lib/rubocop/cop/style/symbol_array.rb

@@ -10,6 +10,11 @@ module RuboCop
       # projects which do not want to use that syntax, perhaps because they
       # support a version of Ruby lower than 2.0.
       #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize of `3` will not enforce a style on an array
+      # of 2 or fewer elements.
+      #
       # @example
       #   EnforcedStyle: percent (default)
       #
@@ -28,8 +33,9 @@ module RuboCop
       #   # bad
       #   %i[foo bar baz]
       class SymbolArray < Cop
-        include ConfigurableEnforcedStyle
+        include ArrayMinSize
         include ArraySyntax
+        include ConfigurableEnforcedStyle
         include PercentLiteral
         extend TargetRubyVersion
 
@@ -38,6 +44,10 @@ module RuboCop
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
 
+        class << self
+          attr_accessor :largest_brackets
+        end
+
         def on_array(node)
           if bracketed_array_of?(:sym, node)
             check_bracketed_array(node)
@@ -46,18 +56,27 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          if style == :percent
+            correct_percent(node, 'i')
+          else
+            correct_bracketed(node)
+          end
+        end
+
         private
 
         def check_bracketed_array(node)
-          return if comments_in_array?(node)
-          return if symbols_contain_spaces?(node)
+          return if comments_in_array?(node) ||
+                    symbols_contain_spaces?(node) ||
+                    below_array_length?(node)
 
-          style_detected(:brackets)
+          array_style_detected(:brackets, node.values.size)
           add_offense(node, :expression, PERCENT_MSG) if style == :percent
         end
 
         def check_percent_array(node)
-          style_detected(:percent)
+          array_style_detected(:percent, node.values.size)
           add_offense(node, :expression, ARRAY_MSG) if style == :brackets
         end
 
@@ -77,14 +96,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            correct_percent(node, 'i')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         def correct_bracketed(node)
           syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
 

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -23,6 +23,10 @@ module RuboCop
             $(send lvar $_))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceBeforeBlockBraces]
+        end
+
         def on_block(node)
           symbol_proc?(node) do |send_or_super, block_args, block_body, method|
             block_method_name = resolve_block_method_name(send_or_super)

data/lib/rubocop/cop/style/ternary_parentheses.rb

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for the presence of parentheses around ternary
       # conditions. It is configurable to enforce inclusion or omission of
       # parentheses using `EnforcedStyle`. Omission is only enforced when
-      # removing the parentheses won't cause a different behaviour.
+      # removing the parentheses won't cause a different behavior.
       #
       # @example
       #

data/lib/rubocop/cop/style/unneeded_interpolation.rb

@@ -20,6 +20,10 @@ module RuboCop
 
         MSG = 'Prefer `to_s` over string interpolation.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::LineEndConcatenation]
+        end
+
         def on_dstr(node)
           add_offense(node, :expression, MSG) if single_interpolation?(node)
         end

data/lib/rubocop/cop/style/word_array.rb

@@ -8,7 +8,31 @@ module RuboCop
       #
       # Alternatively, it can check for uses of the %w() syntax, in projects
       # which do not want to include that syntax.
+      #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize of `3` will not enforce a style on an array
+      # of 2 or fewer elements.
+      #
+      # @example
+      #   EnforcedStyle: percent (default)
+      #
+      #   # good
+      #   %w[foo bar baz]
+      #
+      #   # bad
+      #   ['foo', 'bar', 'baz']
+      #
+      # @example
+      #   EnforcedStyle: brackets
+      #
+      #   # good
+      #   ['foo', 'bar', 'baz']
+      #
+      #   # bad
+      #   %w[foo bar baz]
       class WordArray < Cop
+        include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentLiteral
@@ -23,9 +47,9 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
-            check_bracketed(node)
+            check_bracketed_array(node)
           elsif node.percent_literal?(:string)
-            check_percent(node)
+            check_percent_array(node)
           end
         end
 
@@ -39,18 +63,17 @@ module RuboCop
 
         private
 
-        def check_bracketed(node)
+        def check_bracketed_array(node)
           return if complex_content?(node.values) ||
-                    comments_in_array?(node)
-          style_detected(:brackets, node.values.size)
+                    comments_in_array?(node) ||
+                    below_array_length?(node)
 
-          return unless style == :percent && node.values.size >= min_size
-
-          add_offense(node, :expression, PERCENT_MSG)
+          array_style_detected(:brackets, node.values.size)
+          add_offense(node, :expression, PERCENT_MSG) if style == :percent
         end
 
-        def check_percent(node)
-          style_detected(:percent, node.values.size)
+        def check_percent_array(node)
+          array_style_detected(:percent, node.values.size)
           add_offense(node, :expression, ARRAY_MSG) if style == :brackets
         end
 
@@ -74,10 +97,6 @@ module RuboCop
           end
         end
 
-        def min_size
-          cop_config['MinSize']
-        end
-
         def word_regex
           Regexp.new(cop_config['WordRegex'])
         end
@@ -89,45 +108,6 @@ module RuboCop
             corrector.replace(node.source_range, "[#{words.join(', ')}]")
           end
         end
-
-        def style_detected(style, ary_size)
-          cfg = config_to_allow_offenses
-          return if cfg['Enabled'] == false
-
-          largest_brackets = largest_brackets_size(style, ary_size)
-          smallest_percent = smallest_percent_size(style, ary_size)
-
-          if cfg['EnforcedStyle'] == style.to_s
-            # do nothing
-          elsif cfg['EnforcedStyle'].nil?
-            cfg['EnforcedStyle'] = style.to_s
-          elsif smallest_percent <= largest_brackets
-            self.config_to_allow_offenses = { 'Enabled' => false }
-          else
-            cfg['EnforcedStyle'] = 'percent'
-            cfg['MinSize'] = largest_brackets + 1
-          end
-        end
-
-        def largest_brackets_size(style, ary_size)
-          self.class.largest_brackets ||= -Float::INFINITY
-
-          if style == :brackets && ary_size > self.class.largest_brackets
-            self.class.largest_brackets = ary_size
-          end
-
-          self.class.largest_brackets
-        end
-
-        def smallest_percent_size(style, ary_size)
-          @smallest_percent ||= Float::INFINITY
-
-          if style == :percent && ary_size < @smallest_percent
-            @smallest_percent = ary_size
-          end
-
-          @smallest_percent
-        end
       end
     end
   end

data/lib/rubocop/cop/style/yoda_condition.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for Yoda conditions, i.e. comparison operations where
+      # readability is reduced because the operands are not ordered the same
+      # way as they would be ordered in spoken English.
+      #
+      # @example
+      #
+      #   # bad
+      #   99 == foo
+      #   "bar" == foo
+      #   42 >= foo
+      #
+      # @example
+      #
+      #   # good
+      #   foo == 99
+      #   foo == "bar"
+      #   for <= 42
+      class YodaCondition < Cop
+        MSG = 'Reverse the order of the operands `%s`.'.freeze
+        WHITELIST_TYPES = %i[lvar ivar send const regexp begin].freeze
+        REVERSE_COMPARISON = {
+          '<' => '>',
+          '<=' => '>=',
+          '>' => '<',
+          '>=' => '<='
+        }.freeze
+
+        def on_send(node)
+          return unless yoda_condition?(node)
+
+          register_offense(node)
+        end
+
+        private
+
+        def yoda_condition?(node)
+          return false unless comparison_operator?(node)
+
+          !WHITELIST_TYPES.include?(node.receiver.type)
+        end
+
+        def comparison_operator?(node)
+          RuboCop::AST::Node::COMPARISON_OPERATORS.include?(node.method_name)
+        end
+
+        def register_offense(node)
+          add_offense(node, :expression, format(MSG, node.source))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(actual_code_range(node), corrected_code(node))
+          end
+        end
+
+        def corrected_code(node)
+          first, operator, last = node.children
+          "#{last.source} #{reverse_comparison(operator)} #{first.source}"
+        end
+
+        def actual_code_range(node)
+          range_between(
+            node.loc.expression.begin_pos, node.loc.expression.end_pos
+          )
+        end
+
+        def reverse_comparison(operator)
+          REVERSE_COMPARISON.fetch(operator.to_s, operator)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/team.rb

@@ -4,18 +4,6 @@ module RuboCop
   module Cop
     # FIXME
     class Team
-      # If these cops try to autocorrect the same file at the same time,
-      # bad things are liable to happen
-      INCOMPATIBLE_COPS = {
-        Style::SymbolProc => [Style::SpaceBeforeBlockBraces],
-        Style::SpaceBeforeBlockBraces => [Style::SymbolProc],
-        Style::LineEndConcatenation => [Style::UnneededInterpolation],
-        Style::UnneededInterpolation => [Style::LineEndConcatenation],
-        Style::SelfAssignment => [Style::SpaceAroundOperators],
-        Style::SpaceAroundOperators => [Style::SelfAssignment],
-        Style::BracesAroundHashParameters => [Style::MultilineHashBraceLayout]
-      }.freeze
-
       DEFAULT_OPTIONS = {
         auto_correct: false,
         debug: false
@@ -135,8 +123,7 @@ module RuboCop
           next if cop.corrections.empty?
           next if skip.include?(cop.class)
           corrector.corrections.concat(cop.corrections)
-          incompatible = INCOMPATIBLE_COPS[cop.class]
-          skip.merge(incompatible) if incompatible
+          skip.merge(cop.class.autocorrect_incompatible_with)
         end
 
         if !corrector.corrections.empty?

data/lib/rubocop/cop/util.rb

@@ -152,6 +152,22 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
+      def range_by_whole_lines(range, include_final_newline: false)
+        buffer = @processed_source.buffer
+
+        begin_pos = range.begin_pos
+        begin_offset = range.column
+        begin_of_first_line = begin_pos - begin_offset
+
+        last_line = buffer.source_line(range.last_line)
+        end_pos = range.end_pos
+        end_offset = last_line.length - range.last_column
+        end_offset += 1 if include_final_newline
+        end_of_last_line = end_pos + end_offset
+
+        Parser::Source::Range.new(buffer, begin_of_first_line, end_of_last_line)
+      end
+
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0
         pos += step while condition && src[pos + offset] =~ regexp