rubocop 0.75.1

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
+      class UnneededPercentQ < Cop
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
+                      'double quotes'
+        SINGLE_QUOTE = "'"
+        QUOTE = '"'
+        EMPTY = ''
+        PERCENT_Q = '%q'
+        PERCENT_CAPITAL_Q = '%Q'
+        STRING_INTERPOLATION_REGEXP = /#\{.+}/.freeze
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
+
+        def on_dstr(node)
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        def autocorrect(node)
+          delimiter =
+            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
+        private
+
+        def check(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
+
+          add_offense(node)
+        end
+
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
+
+        def allowed_percent_q?(node)
+          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
+            node.source.start_with?(PERCENT_CAPITAL_Q) &&
+              acceptable_capital_q?(node)
+        end
+
+        def message(node)
+          src = node.source
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
+                  else
+                    EMPTY
+                  end
+          format(MSG, q_type: src[0, 2], extra: extra)
+        end
+
+        def string_literal?(node)
+          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
+            node.loc.begin && node.loc.end
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+        end
+
+        def acceptable_q?(node)
+          src = node.source
+
+          return true if src =~ STRING_INTERPOLATION_REGEXP
+
+          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
+        end
+
+        def acceptable_capital_q?(node)
+          src = node.source
+          src.include?(QUOTE) &&
+            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (node.str_type? && double_quotes_required?(src)))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is used to identify instances of sorting and then
+      # taking only the first or last element. The same behavior can
+      # be accomplished without a relatively expensive sort by using
+      # `Enumerable#min` instead of sorting and taking the first
+      # element and `Enumerable#max` instead of sorting and taking the
+      # last element. Similarly, `Enumerable#min_by` and
+      # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+      # after which only the first or last element is used.
+      #
+      # @example
+      #   # bad
+      #   [2, 1, 3].sort.first
+      #   [2, 1, 3].sort[0]
+      #   [2, 1, 3].sort.at(0)
+      #   [2, 1, 3].sort.slice(0)
+      #
+      #   # good
+      #   [2, 1, 3].min
+      #
+      #   # bad
+      #   [2, 1, 3].sort.last
+      #   [2, 1, 3].sort[-1]
+      #   [2, 1, 3].sort.at(-1)
+      #   [2, 1, 3].sort.slice(-1)
+      #
+      #   # good
+      #   [2, 1, 3].max
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).first
+      #   arr.sort_by(&:foo)[0]
+      #   arr.sort_by(&:foo).at(0)
+      #   arr.sort_by(&:foo).slice(0)
+      #
+      #   # good
+      #   arr.min_by(&:foo)
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).last
+      #   arr.sort_by(&:foo)[-1]
+      #   arr.sort_by(&:foo).at(-1)
+      #   arr.sort_by(&:foo).slice(-1)
+      #
+      #   # good
+      #   arr.max_by(&:foo)
+      #
+      class UnneededSort < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<suggestion>s` instead of '\
+              '`%<sorter>s...%<accessor_source>s`.'
+
+        def_node_matcher :unneeded_sort?, <<~MATCHER
+          {
+            (send $(send _ $:sort ...) ${:last :first})
+            (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send $(send _ $:sort_by _) ${:last :first})
+            (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send (block $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send
+              (block $(send _ ${:sort_by :sort}) ...)
+              ${:[] :at :slice} {(int 0) (int -1)}
+            )
+          }
+        MATCHER
+
+        def on_send(node)
+          unneeded_sort?(node) do |sort_node, sorter, accessor|
+            range = range_between(
+              sort_node.loc.selector.begin_pos,
+              node.loc.expression.end_pos
+            )
+
+            add_offense(node,
+                        location: range,
+                        message: message(node,
+                                         sorter,
+                                         accessor))
+          end
+        end
+
+        def autocorrect(node)
+          sort_node, sorter, accessor = unneeded_sort?(node)
+
+          lambda do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(
+              range_between(
+                accessor_start(node),
+                node.loc.expression.end_pos
+              )
+            )
+
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(
+              sort_node.loc.selector,
+              suggestion(sorter, accessor, arg_value(node))
+            )
+          end
+        end
+
+        private
+
+        def message(node, sorter, accessor)
+          accessor_source = range_between(
+            node.loc.selector.begin_pos,
+            node.loc.expression.end_pos
+          ).source
+
+          format(MSG,
+                 suggestion: suggestion(sorter,
+                                        accessor,
+                                        arg_value(node)),
+                 sorter: sorter,
+                 accessor_source: accessor_source)
+        end
+
+        def suggestion(sorter, accessor, arg)
+          base(accessor, arg) + suffix(sorter)
+        end
+
+        def base(accessor, arg)
+          if accessor == :first || (arg&.zero?)
+            'min'
+          elsif accessor == :last || arg == -1
+            'max'
+          end
+        end
+
+        def suffix(sorter)
+          if sorter == :sort
+            ''
+          elsif sorter == :sort_by
+            '_by'
+          end
+        end
+
+        def arg_node(node)
+          node.arguments.first
+        end
+
+        def arg_value(node)
+          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+        end
+
+        # This gets the start of the accessor whether it has a dot
+        # (e.g. `.first`) or doesn't (e.g. `[0]`)
+        def accessor_start(node)
+          if node.loc.dot
+            node.loc.dot.begin_pos
+          else
+            node.loc.selector.begin_pos
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        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.source_range, "{#{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