rubocop 0.87.1

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for accessing the first element of `String#unpack`
+      # which can be replaced with the shorter method `unpack1`.
+      #
+      # @example
+      #
+      #   # bad
+      #   'foo'.unpack('h*').first
+      #   'foo'.unpack('h*')[0]
+      #   'foo'.unpack('h*').slice(0)
+      #   'foo'.unpack('h*').at(0)
+      #
+      #   # good
+      #   'foo'.unpack1('h*')
+      #
+      class UnpackFirst < Cop
+        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
+          '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+
+        def_node_matcher :unpack_and_first_element?, <<~PATTERN
+          {
+            (send $(send (...) :unpack $(...)) :first)
+            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+          }
+        PATTERN
+
+        def on_send(node)
+          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
+            range = first_element_range(node, unpack_call)
+            message = format(MSG,
+                             receiver: unpack_call.receiver.source,
+                             format: unpack_arg.source,
+                             method: range.source)
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
+            lambda do |corrector|
+              corrector.remove(first_element_range(node, unpack_call))
+              corrector.replace(unpack_call.loc.selector, 'unpack1')
+            end
+          end
+        end
+
+        private
+
+        def first_element_range(node, unpack_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    unpack_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for variable interpolation (like "#@ivar").
+      #
+      # @example
+      #   # bad
+      #   "His name is #$name"
+      #   /check #$pattern/
+      #   "Let's go to the #@store"
+      #
+      #   # good
+      #   "His name is #{$name}"
+      #   /check #{$pattern}/
+      #   "Let's go to the #{@store}"
+      class VariableInterpolation < Cop
+        include Interpolation
+
+        MSG = 'Replace interpolated variable `%<variable>s` ' \
+              'with expression `#{%<variable>s}`.'
+
+        def on_node_with_interpolations(node)
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, "{#{node.source}}")
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, variable: node.source)
+        end
+
+        def var_nodes(nodes)
+          nodes.select { |n| n.variable? || n.reference? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for `when;` uses in `case` expressions.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when 1; 'baz'
+      #   when 2; 'bar'
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1 then 'baz'
+      #   when 2 then 'bar'
+      #   end
+      class WhenThen < Cop
+        MSG = 'Do not use `when x;`. Use `when x then` instead.'
+
+        def on_when(node)
+          return if node.multiline? || node.then? || !node.body
+
+          add_offense(node, location: :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `do` in multi-line `while/until` statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   while x.any? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   while x.any?
+      #     do_something(x.pop)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   until x.empty? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   until x.empty?
+      #     do_something(x.pop)
+      #   end
+      class WhileUntilDo < Cop
+        MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
+
+        def on_while(node)
+          handle(node)
+        end
+
+        def on_until(node)
+          handle(node)
+        end
+
+        def handle(node)
+          return unless node.multiline? && node.do?
+
+          add_offense(node, location: :begin,
+                            message: format(MSG, keyword: node.keyword))
+        end
+
+        def autocorrect(node)
+          do_range = node.condition.source_range.end.join(node.loc.begin)
+
+          lambda do |corrector|
+            corrector.remove(do_range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for while and until statements that would fit on one line
+      # if written as a modifier while/until. The maximum line length is
+      # configured in the `Layout/LineLength` cop.
+      #
+      # @example
+      #   # bad
+      #   while x < 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #
+      # @example
+      #   # bad
+      #   until x > 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 until x > 10
+      class WhileUntilModifier < Cop
+        include StatementModifier
+
+        MSG = 'Favor modifier `%<keyword>s` usage when ' \
+              'having a single-line body.'
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def autocorrect(node)
+          oneline = "#{node.body.source} #{node.keyword} " \
+                    "#{node.condition.source}"
+
+          lambda do |corrector|
+            corrector.replace(node, oneline)
+          end
+        end
+
+        private
+
+        def check(node)
+          return unless node.multiline? && single_line_as_modifier?(node)
+
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of word-like
+      # strings, that are not using the %w() syntax.
+      #
+      # 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 PercentArray
+
+        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
+        ARRAY_MSG = 'Use `[]` for an array of words.'
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:str, node)
+            return if complex_content?(node.values)
+
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:string)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'w')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def check_bracketed_array(node)
+          return if allowed_bracket_array?(node)
+
+          array_style_detected(:brackets, node.values.size)
+          add_offense(node) if style == :percent
+        end
+
+        def complex_content?(strings)
+          strings.any? do |s|
+            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
+            !string.valid_encoding? ||
+              !word_regex.match?(string) || / /.match?(string)
+          end
+        end
+
+        def word_regex
+          Regexp.new(cop_config['WordRegex'])
+        end
+
+        def correct_bracketed(node)
+          words = node.children.map do |word|
+            if word.dstr_type?
+              string_literal = to_string_literal(word.source)
+
+              trim_string_interporation_escape_character(string_literal)
+            else
+              to_string_literal(word.children[0])
+            end
+          end
+
+          lambda do |corrector|
+            corrector.replace(node, "[#{words.join(', ')}]")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can either enforce or forbid Yoda conditions,
+      # i.e. comparison operations where the order of expression is reversed.
+      # eg. `5 == x`
+      #
+      # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #   42 >= foo
+      #   10 < bar
+      #
+      #   # good
+      #   foo == 99
+      #   foo == "bar"
+      #   foo <= 42
+      #   bar > 10
+      #   "#{interpolation}" == foo
+      #   /#{interpolation}/ == foo
+      #
+      # @example EnforcedStyle: forbid_for_equality_operators_only
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #
+      #   # good
+      #   99 >= foo
+      #   3 < a && a < 5
+      #
+      # @example EnforcedStyle: require_for_all_comparison_operators
+      #   # bad
+      #   foo == 99
+      #   foo == "bar"
+      #   foo <= 42
+      #   bar > 10
+      #
+      #   # good
+      #   99 == foo
+      #   "bar" != foo
+      #   42 >= foo
+      #   10 < bar
+      #
+      # @example EnforcedStyle: require_for_equality_operators_only
+      #   # bad
+      #   99 >= foo
+      #   3 < a && a < 5
+      #
+      #   # good
+      #   99 == foo
+      #   "bar" != foo
+      class YodaCondition < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Reverse the order of the operands `%<source>s`.'
+
+        REVERSE_COMPARISON = {
+          '<' => '>',
+          '<=' => '>=',
+          '>' => '<',
+          '>=' => '<='
+        }.freeze
+
+        EQUALITY_OPERATORS = %i[== !=].freeze
+
+        NONCOMMUTATIVE_OPERATORS = %i[===].freeze
+
+        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+
+        def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
+          (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
+        PATTERN
+
+        def on_send(node)
+          return unless yoda_compatible_condition?(node)
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
+
+          valid_yoda?(node) || add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(actual_code_range(node), corrected_code(node))
+          end
+        end
+
+        private
+
+        def enforce_yoda?
+          style == :require_for_all_comparison_operators ||
+            style == :require_for_equality_operators_only
+        end
+
+        def equality_only?
+          style == :forbid_for_equality_operators_only ||
+            style == :require_for_equality_operators_only
+        end
+
+        def yoda_compatible_condition?(node)
+          node.comparison_method? &&
+            !noncommutative_operator?(node)
+        end
+
+        def valid_yoda?(node)
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          return true if lhs.literal? && rhs.literal? ||
+                         !lhs.literal? && !rhs.literal? ||
+                         interpolation?(lhs)
+
+          enforce_yoda? ? lhs.literal? : rhs.literal?
+        end
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        def corrected_code(node)
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.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
+
+        def non_equality_operator?(node)
+          !EQUALITY_OPERATORS.include?(node.method_name)
+        end
+
+        def noncommutative_operator?(node)
+          NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
+        end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          # TODO: Use `RegexpNode#interpolation?` when the following is released.
+          # https://github.com/rubocop-hq/rubocop-ast/pull/18
+          if node.regexp_type?
+            return true if node.children.any? do |child|
+              child.respond_to?(:begin_type?) && child.begin_type?
+            end
+          end
+
+          false
+        end
+      end
+    end
+  end
+end