rubocop 0.87.1

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous parentheses around the
+      # condition of if/unless/while/until.
+      #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
+      # @example
+      #   # bad
+      #   x += 1 while (x < 10)
+      #   foo unless (bar || baz)
+      #
+      #   if (x > 10)
+      #   elsif (x < 3)
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #   foo unless bar || baz
+      #
+      #   if x > 10
+      #   elsif x < 3
+      #   end
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo unless (bar = baz)
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo unless (bar = baz)
+      #
+      # @example AllowInMultilineConditions: false (default)
+      #   # bad
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      #   # good
+      #    if x > 10 &&
+      #       y > 10
+      #    end
+      #
+      # @example AllowInMultilineConditions: true
+      #   # good
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      class ParenthesesAroundCondition < Cop
+        include SafeAssignment
+        include Parentheses
+
+        def on_if(node)
+          return if node.ternary?
+
+          process_control_op(node)
+        end
+
+        def on_while(node)
+          process_control_op(node)
+        end
+        alias on_until on_while
+
+        def autocorrect(node)
+          ParenthesesCorrector.correct(node)
+        end
+
+        private
+
+        def_node_matcher :control_op_condition, <<~PATTERN
+          (begin $_ ...)
+        PATTERN
+
+        def process_control_op(node)
+          cond = node.condition
+
+          control_op_condition(cond) do |first_child|
+            return if modifier_op?(first_child)
+            return if parens_allowed?(cond)
+
+            add_offense(cond)
+          end
+        end
+
+        def modifier_op?(node)
+          return false if node.if_type? && node.ternary?
+          return true if node.rescue_type?
+
+          node.basic_conditional? && node.modifier_form?
+        end
+
+        def message(node)
+          kw = node.parent.keyword
+          article = kw == 'while' ? 'a' : 'an'
+          "Don't use parentheses around the condition of #{article} `#{kw}`."
+        end
+
+        def parens_allowed?(node)
+          parens_required?(node) ||
+            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (node.multiline? && allow_multiline_conditions?)
+        end
+
+        def allow_multiline_conditions?
+          cop_config['AllowInMultilineConditions']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the consistent usage of `%`-literal delimiters.
+      #
+      # Specify the 'default' key to set all preferred delimiters at once. You
+      # can continue to specify individual preferred delimiters to override the
+      # default.
+      #
+      # @example
+      #   # Style/PercentLiteralDelimiters:
+      #   #   PreferredDelimiters:
+      #   #     default: '[]'
+      #   #     '%i':    '()'
+      #
+      #   # good
+      #   %w[alpha beta] + %i(gamma delta)
+      #
+      #   # bad
+      #   %W(alpha #{beta})
+      #
+      #   # bad
+      #   %I(alpha beta)
+      class PercentLiteralDelimiters < Cop
+        include PercentLiteral
+
+        def on_array(node)
+          process(node, '%w', '%W', '%i', '%I')
+        end
+
+        def on_regexp(node)
+          process(node, '%r')
+        end
+
+        def on_str(node)
+          process(node, '%', '%Q', '%q')
+        end
+        alias on_dstr on_str
+
+        def on_sym(node)
+          process(node, '%s')
+        end
+
+        def on_xstr(node)
+          process(node, '%x')
+        end
+
+        def message(node)
+          type = type(node)
+          delimiters = preferred_delimiters_for(type)
+
+          "`#{type}`-literals should be delimited by " \
+          "`#{delimiters[0]}` and `#{delimiters[1]}`."
+        end
+
+        def autocorrect(node)
+          type = type(node)
+
+          opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
+            corrector.replace(node.loc.end, closing_delimiter)
+          end
+        end
+
+        private
+
+        def on_percent_literal(node)
+          type = type(node)
+          return if uses_preferred_delimiter?(node, type) ||
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
+
+          add_offense(node)
+        end
+
+        def preferred_delimiters_for(type)
+          PreferredDelimiters
+            .new(type, @config, nil)
+            .delimiters
+        end
+
+        def uses_preferred_delimiter?(node, type)
+          preferred_delimiters_for(type)[0] == begin_source(node)[-1]
+        end
+
+        def contains_preferred_delimiter?(node, type)
+          contains_delimiter?(node, preferred_delimiters_for(type))
+        end
+
+        def include_same_character_as_used_for_delimiter?(node, type)
+          return false unless %w[%w %i].include?(type)
+
+          used_delimiters = matchpairs(begin_source(node)[-1])
+          contains_delimiter?(node, used_delimiters)
+        end
+
+        def contains_delimiter?(node, delimiters)
+          delimiters_regexp = Regexp.union(delimiters)
+          node
+            .children.map { |n| string_source(n) }.compact
+            .any? { |s| delimiters_regexp.match?(s) }
+        end
+
+        def string_source(node)
+          if node.is_a?(String)
+            node
+          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
+            node.source
+          end
+        end
+
+        def matchpairs(begin_delimiter)
+          {
+            '(' => %w[( )],
+            '[' => %w[[ ]],
+            '{' => %w[{ }],
+            '<' => %w[< >]
+          }.fetch(begin_delimiter, [begin_delimiter])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %Q() syntax when %q() would do.
+      #
+      # @example EnforcedStyle: lower_case_q (default)
+      #   # The `lower_case_q` style prefers `%q` unless
+      #   # interpolation is needed.
+      #   # bad
+      #   %Q[Mix the foo into the baz.]
+      #   %Q(They all said: 'Hooray!')
+      #
+      #   # good
+      #   %q[Mix the foo into the baz]
+      #   %q(They all said: 'Hooray!')
+      #
+      # @example EnforcedStyle: upper_case_q
+      #   # The `upper_case_q` style requires the sole use of `%Q`.
+      #   # bad
+      #   %q/Mix the foo into the baz./
+      #   %q{They all said: 'Hooray!'}
+      #
+      #   # good
+      #   %Q/Mix the foo into the baz./
+      #   %Q{They all said: 'Hooray!'}
+      class PercentQLiterals < Cop
+        include PercentLiteral
+        include ConfigurableEnforcedStyle
+
+        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
+                           'needed. Use `%q`.'
+        UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'
+
+        def on_str(node)
+          process(node, '%Q', '%q')
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, corrected(node.source))
+          end
+        end
+
+        private
+
+        def on_percent_literal(node)
+          return if correct_literal_style?(node)
+
+          # Report offense only if changing case doesn't change semantics,
+          # i.e., if the string would become dynamic or has special characters.
+          return if node.children != parse(corrected(node.source)).ast.children
+
+          add_offense(node, location: :begin)
+        end
+
+        def correct_literal_style?(node)
+          style == :lower_case_q && type(node) == '%q' ||
+            style == :upper_case_q && type(node) == '%Q'
+        end
+
+        def message(_node)
+          style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
+        end
+
+        def corrected(src)
+          src.sub(src[1], src[1].swapcase)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      #
+      # @example
+      #   # bad
+      #   puts $1
+      #
+      #   # good
+      #   puts Regexp.last_match(1)
+      class PerlBackrefs < Cop
+        MSG = 'Avoid the use of Perl-style backrefs.'
+
+        def on_nth_ref(node)
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            backref, = *node
+            parent_type = node.parent ? node.parent.type : nil
+            if %i[dstr xstr regexp].include?(parent_type)
+              corrector.replace(node,
+                                "{Regexp.last_match(#{backref})}")
+            else
+              corrector.replace(node,
+                                "Regexp.last_match(#{backref})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop (by default) checks for uses of methods Hash#has_key? and
+      # Hash#has_value? where it enforces Hash#key? and Hash#value?
+      # It is configurable to enforce the inverse, using `verbose` method
+      # names also.
+      #
+      # @example EnforcedStyle: short (default)
+      #  # bad
+      #  Hash#has_key?
+      #  Hash#has_value?
+      #
+      #  # good
+      #  Hash#key?
+      #  Hash#value?
+      #
+      # @example EnforcedStyle: verbose
+      #  # bad
+      #  Hash#key?
+      #  Hash#value?
+      #
+      #  # good
+      #  Hash#has_key?
+      #  Hash#has_value?
+      class PreferredHashMethods < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
+
+        OFFENDING_SELECTORS = {
+          short: %i[has_key? has_value?],
+          verbose: %i[key? value?]
+        }.freeze
+
+        def on_send(node)
+          return unless node.arguments.one? &&
+                        offending_selector?(node.method_name)
+
+          add_offense(node, location: :selector)
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              proper_method_name(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: proper_method_name(node.method_name),
+                 current: node.method_name)
+        end
+
+        def proper_method_name(method_name)
+          if style == :verbose
+            "has_#{method_name}"
+          else
+            method_name.to_s.sub(/has_/, '')
+          end
+        end
+
+        def offending_selector?(method_name)
+          OFFENDING_SELECTORS[style].include?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of Proc.new where Kernel#proc
+      # would be more appropriate.
+      #
+      # @example
+      #   # bad
+      #   p = Proc.new { |n| puts n }
+      #
+      #   # good
+      #   p = proc { |n| puts n }
+      #
+      class Proc < Cop
+        MSG = 'Use `proc` instead of `Proc.new`.'
+
+        def_node_matcher :proc_new?,
+                         '(block $(send (const {nil? cbase} :Proc) :new) ...)'
+
+        def on_block(node)
+          proc_new?(node) do |block_method|
+            add_offense(block_method)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node, 'proc') }
+        end
+      end
+    end
+  end
+end