rubbycop 0.49.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous parentheses around the
+      # condition of if/unless/while/until.
+      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
+
+        def on_until(node)
+          process_control_op(node)
+        end
+
+        private
+
+        def process_control_op(node)
+          cond = node.condition
+
+          return unless cond.begin_type?
+          return if cond.children.empty?
+          return if modifier_op?(cond.children.first)
+          return if parens_required?(node.children.first)
+          return if safe_assignment?(cond) && safe_assignment_allowed?
+
+          add_offense(cond, :expression, message(node))
+        end
+
+        def modifier_op?(node)
+          return false if node.if_type? && node.ternary?
+          return true if node.rescue_type?
+
+          MODIFIER_NODES.include?(node.type) &&
+            node.modifier_form?
+        end
+
+        def message(node)
+          kw = node.keyword
+          article = kw == 'while' ? 'a' : 'an'
+          "Don't use parentheses around the condition of #{article} `#{kw}`."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+
+        private
+
+        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
+
+        def on_percent_literal(node)
+          type = type(node)
+          return if uses_preferred_delimiter?(node, type) ||
+                    contains_preferred_delimiter?(node, type)
+
+          add_offense(node, :expression)
+        end
+
+        def uses_preferred_delimiter?(node, type)
+          preferred_delimiters_for(type)[0] == begin_source(node)[-1]
+        end
+
+        def contains_preferred_delimiter?(node, type)
+          preferred_delimiters = preferred_delimiters_for(type)
+          node
+            .children.map { |n| string_source(n) }.compact
+            .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
+        end
+
+        def string_source(node)
+          if node.is_a?(String)
+            node
+          elsif node.respond_to?(:type) && node.str_type?
+            node.source
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %Q() syntax when %q() would do.
+      class PercentQLiterals < Cop
+        include PercentLiteral
+        include ConfigurableEnforcedStyle
+
+        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
+                           'needed.  Use `%q`.'.freeze
+        UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'.freeze
+
+        def on_str(node)
+          process(node, '%Q', '%q')
+        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, :begin, message)
+        end
+
+        def correct_literal_style?(node)
+          style == :lower_case_q && type(node) == '%q' ||
+            style == :upper_case_q && type(node) == '%Q'
+        end
+
+        def message
+          style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node.source))
+          end
+        end
+
+        def corrected(src)
+          src.sub(src[1], src[1].swapcase)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      class PerlBackrefs < Cop
+        MSG = 'Avoid the use of Perl-style backrefs.'.freeze
+
+        def on_nth_ref(node)
+          add_offense(node, :expression)
+        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.source_range,
+                                "{Regexp.last_match(#{backref})}")
+            else
+              corrector.replace(node.source_range,
+                                "Regexp.last_match(#{backref})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that predicates are named properly.
+      #
+      # @example
+      #   # bad
+      #   def is_even?(value) ...
+      #
+      #   # good
+      #   def even?(value)
+      #
+      #   # bad
+      #   def has_value? ...
+      #
+      #   # good
+      #   def value? ...
+      class PredicateName < Cop
+        include OnMethodDef
+
+        private
+
+        def on_method_def(node, method_name, _args, _body)
+          predicate_prefixes.each do |prefix|
+            method_name = method_name.to_s
+            next unless method_name.start_with?(prefix)
+            next if method_name == expected_name(method_name, prefix)
+            next if predicate_whitelist.include?(method_name)
+            add_offense(
+              node,
+              :name,
+              message(method_name, expected_name(method_name, prefix))
+            )
+          end
+        end
+
+        def expected_name(method_name, prefix)
+          new_name = if prefix_blacklist.include?(prefix)
+                       method_name.sub(prefix, '')
+                     else
+                       method_name.dup
+                     end
+          new_name << '?' unless method_name.end_with?('?')
+          new_name
+        end
+
+        def message(method_name, new_name)
+          "Rename `#{method_name}` to `#{new_name}`."
+        end
+
+        def prefix_blacklist
+          cop_config['NamePrefixBlacklist']
+        end
+
+        def predicate_prefixes
+          cop_config['NamePrefix']
+        end
+
+        def predicate_whitelist
+          cop_config['NameWhitelist']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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#%s` instead of `Hash#%s`.'.freeze
+
+        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, :selector)
+        end
+
+        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, proper_method_name(node.method_name), 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/rubbycop/cop/style/proc.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cops checks for uses of Proc.new where Kernel#proc
+      # would be more appropriate.
+      class Proc < Cop
+        MSG = 'Use `proc` instead of `Proc.new`.'.freeze
+
+        def_node_matcher :proc_new?,
+                         '(block $(send (const nil :Proc) :new) ...)'
+
+        def on_block(node)
+          proc_new?(node) do |block_method|
+            add_offense(block_method, :expression)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.source_range, 'proc') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks the args passed to `fail` and `raise`. For exploded
+      # style (default), it recommends passing the exception class and message
+      # to `raise`, rather than construct an instance of the error. It will
+      # still allow passing just a message, or the construction of an error
+      # with more than one argument.
+      #
+      # The exploded style works identically, but with the addition that it
+      # will also suggest constructing error objects when the exception is
+      # passed multiple arguments.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: exploded
+      #
+      #   # bad
+      #   raise StandardError.new("message")
+      #
+      #   # good
+      #   raise StandardError, "message"
+      #   fail "message"
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   raise MyKwArgError.new(key1: val1, key2: val2)
+      #
+      # @example
+      #
+      #   # EnforcedStyle: compact
+      #
+      #   # bad
+      #   raise StandardError, "message"
+      #   raise RuntimeError, arg1, arg2, arg3
+      #
+      #   # good
+      #   raise StandardError.new("message")
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   fail "message"
+      class RaiseArgs < Cop
+        include ConfigurableEnforcedStyle
+
+        EXPLODED_MSG = 'Provide an exception class and message ' \
+          'as arguments to `%s`.'.freeze
+        COMPACT_MSG = 'Provide an exception object ' \
+          'as an argument to `%s`.'.freeze
+
+        def on_send(node)
+          return unless node.command?(:raise) || node.command?(:fail)
+
+          case style
+          when :compact
+            check_compact(node)
+          when :exploded
+            check_exploded(node)
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          new_exception = if style == :compact
+                            correction_exploded_to_compact(node.arguments)
+                          else
+                            correction_compact_to_exploded(node.first_argument)
+                          end
+          replacement = "#{node.method_name} #{new_exception}"
+
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
+        end
+
+        def correction_compact_to_exploded(node)
+          exception_node, _new, message_node = *node
+
+          message = message_node && message_node.source
+
+          correction = exception_node.const_name.to_s
+          correction = "#{correction}, #{message}" if message
+
+          correction
+        end
+
+        def correction_exploded_to_compact(node)
+          exception_node, *message_nodes = *node
+
+          messages = message_nodes.map(&:source).join(', ')
+
+          "#{exception_node.const_name}.new(#{messages})"
+        end
+
+        def check_compact(node)
+          if node.arguments.size > 1
+            add_offense(node, :expression, message(node.method_name)) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def check_exploded(node)
+          return correct_style_detected unless node.arguments.one?
+
+          first_arg = node.first_argument
+
+          return unless first_arg.send_type? && first_arg.method?(:new)
+
+          return if acceptable_exploded_args?(first_arg.arguments)
+
+          add_offense(node, :expression, message(node.method_name)) do
+            opposite_style_detected
+          end
+        end
+
+        def acceptable_exploded_args?(args)
+          # Allow code like `raise Ex.new(arg1, arg2)`.
+          return true if args.size > 1
+
+          # Disallow zero arguments.
+          return false if args.empty?
+
+          arg = args.first
+
+          # Allow code like `raise Ex.new(kw: arg)`.
+          # Allow code like `raise Ex.new(*args)`.
+          arg.hash_type? || arg.splat_type?
+        end
+
+        def message(method)
+          if style == :compact
+            format(COMPACT_MSG, method)
+          else
+            format(EXPLODED_MSG, method)
+          end
+        end
+      end
+    end
+  end
+end