rubocop 0.45.0 → 0.46.0

data/lib/rubocop/cop/rails/enum_uniqueness.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for duplicate values in enum declarations.
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum status: [:active, :archived, :active]
+      #
+      #   # good
+      #   enum status: [:active, :archived]
+      class EnumUniqueness < Cop
+        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          return unless method_name == :enum
+
+          enum_name, enum_args = parse_args(args)
+
+          dupes = arr_dupes(enum_values(enum_args))
+          return if dupes.empty?
+
+          add_offense(node, :selector, format(MSG, dupes.join(','), enum_name))
+        end
+
+        private
+
+        def enum_values(enum_args)
+          if enum_args.type == :array
+            enum_array_keys(enum_args)
+          else
+            enum_hash_values(enum_args)
+          end
+        end
+
+        def enum_array_keys(array_node)
+          array_node.each_child_node.map(&:source)
+        end
+
+        def enum_hash_values(hash_node)
+          hash_node.each_child_node.map do |child_node|
+            child_node.child_nodes.last.source
+          end
+        end
+
+        def arr_dupes(array)
+          array.select { |element| array.count(element) > 1 }.uniq
+        end
+
+        def parse_args(args)
+          enum_config = args.first.each_child_node.first.child_nodes
+
+          enum_name = enum_config.first.source
+          enum_opts = enum_config.last
+
+          [enum_name, enum_opts]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -18,7 +18,7 @@ module RuboCop
               'positional arguments for http call: `%s`.'.freeze
         KEYWORD_ARGS = [
           :headers, :env, :params, :body, :flash, :as,
-          :xhr, :session, :method
+          :xhr, :session, :method, :format
         ].freeze
         HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head].freeze
 

data/lib/rubocop/cop/rails/output.rb

@@ -6,22 +6,18 @@ module RuboCop
       # This cop checks for the use of output calls like puts and print
       class Output < Cop
         MSG = 'Do not write to stdout. ' \
-              'Use Rails\' logger if you want to log.'.freeze
+              "Use Rails's logger if you want to log.".freeze
 
-        BLACKLIST = [:puts,
-                     :print,
-                     :p,
-                     :pp,
-                     :pretty_print,
-                     :ap].freeze
+        def_node_matcher :output?, <<-PATTERN
+          (send nil {:ap :p :pp :pretty_print :print :puts} $...)
+        PATTERN
 
         def on_send(node)
-          receiver, method_name, *args = *node
-          return unless receiver.nil? &&
-                        !args.empty? &&
-                        BLACKLIST.include?(method_name)
+          output?(node) do |args|
+            return if args.empty?
 
-          add_offense(node, :selector)
+            add_offense(node, :selector)
+          end
         end
       end
     end

data/lib/rubocop/cop/rails/read_write_attribute.rb

@@ -18,13 +18,17 @@ module RuboCop
       class ReadWriteAttribute < Cop
         MSG = 'Prefer `%s` over `%s`.'.freeze
 
-        def on_send(node)
-          receiver, method_name, *_args = *node
-          return if receiver
-          return unless [:read_attribute,
-                         :write_attribute].include?(method_name)
+        def_node_matcher :read_write_attribute?, <<-PATTERN
+          {
+            (send nil :read_attribute _)
+            (send nil :write_attribute _ _)
+          }
+        PATTERN
 
-          add_offense(node, :selector)
+        def on_send(node)
+          read_write_attribute?(node) do
+            add_offense(node, :selector)
+          end
         end
 
         def message(node)

data/lib/rubocop/cop/rails/request_referer.rb

@@ -8,10 +8,15 @@ module RuboCop
       class RequestReferer < Cop
         include ConfigurableEnforcedStyle
 
-        def on_send(node)
-          return unless offense?(node)
+        def_node_matcher :referer?, <<-PATTERN
+          (send (send nil :request) ${:referer :referrer})
+        PATTERN
 
-          add_offense(node.source_range, node.source_range, message)
+        def on_send(node)
+          referer?(node) do |method_name|
+            return unless method_name == wrong_method_name
+            add_offense(node.source_range, node.source_range, message)
+          end
         end
 
         def autocorrect(node)
@@ -20,12 +25,6 @@ module RuboCop
 
         private
 
-        def offense?(node)
-          return false unless node.receiver
-          receiver_name = node.receiver.method_name
-          receiver_name == :request && node.method_name == wrong_method_name
-        end
-
         def message
           "Use `request.#{style}` instead of `request.#{wrong_method_name}`."
         end

data/lib/rubocop/cop/rails/scope_args.rb

@@ -16,18 +16,12 @@ module RuboCop
       class ScopeArgs < Cop
         MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
 
-        def on_send(node)
-          return unless node.command?(:scope)
-
-          _receiver, _method_name, *args = *node
-
-          return unless args.size == 2
+        def_node_matcher :scope?, '(send nil :scope _ $send)'
 
-          second_arg = args[1]
-
-          return unless second_arg.send_type?
-
-          add_offense(second_arg, :expression)
+        def on_send(node)
+          scope?(node) do |second_arg|
+            add_offense(second_arg, :expression)
+          end
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
         def check_body(body, node)
           return if body.nil? # Empty class etc.
 
-          modifiers = body.children.select { |c| modifier_node?(c) }
+          modifiers = body.each_child_node.select { |c| modifier_node?(c) }
           class_column = node.source_range.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }

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

@@ -131,7 +131,7 @@ module RuboCop
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
-          end_paren += 1 unless node.source =~ /\?[!\S]/
+          end_paren += 1 unless node.source =~ /\?\S/
           range_between(begin_paren, end_paren)
         end
       end

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

@@ -11,18 +11,14 @@ module RuboCop
       class ArrayJoin < Cop
         MSG = 'Favor `Array#join` over `Array#*`.'.freeze
 
-        def on_send(node)
-          receiver_node, method_name, *arg_nodes = *node
-          return unless receiver_node && receiver_node.array_type? &&
-                        method_name == :* && arg_nodes.first.str_type?
+        def_node_matcher :join_candidate?, '(send $array :* $str)'
 
-          add_offense(node, :selector)
+        def on_send(node)
+          join_candidate?(node) { add_offense(node, :selector) }
         end
 
         def autocorrect(node)
-          receiver_node, _method_name, *arg_nodes = *node
-          array = receiver_node.source
-          join_arg = arg_nodes.first.source
+          array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
             corrector.replace(node.source_range, "#{array}.join(#{join_arg})")

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

@@ -27,7 +27,7 @@ module RuboCop
                                 contents.source
                                   .gsub(/\A/, '# ')
                                   .gsub(/\n\n/, "\n#\n")
-                                  .gsub(/\n(?=[^\z#])/, "\n# "))
+                                  .gsub(/\n(?=[^#])/, "\n# "))
             end
             corrector.remove(eq_end)
           end

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

@@ -7,10 +7,10 @@ module RuboCop
       class CaseEquality < Cop
         MSG = 'Avoid the use of the case equality operator `===`.'.freeze
 
-        def on_send(node)
-          _receiver, method_name, *_args = *node
+        def_node_matcher :case_equality?, '(send _ :=== _)'
 
-          add_offense(node, :selector) if method_name == :===
+        def on_send(node)
+          case_equality?(node) { add_offense(node, :selector) }
         end
       end
     end

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

@@ -32,13 +32,11 @@ module RuboCop
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is
         # called from StringHelp.
-        def opposite_style_detected
-        end
+        def opposite_style_detected; end
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is
         # called from StringHelp.
-        def correct_style_detected
-        end
+        def correct_style_detected; end
       end
     end
   end

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

@@ -9,13 +9,13 @@ module RuboCop
 
         MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
 
-        def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless [:is_a?,
-                         :kind_of?].include?(method_name)
+        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
 
-          return if style == method_name
-          add_offense(node, :selector)
+        def on_send(node)
+          class_check?(node) do |method_name|
+            return if style == method_name
+            add_offense(node, :selector)
+          end
         end
 
         def message(node)

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

@@ -8,15 +8,15 @@ module RuboCop
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'.freeze
 
-        JAVA_TYPES = [:byte, :boolean, :byte, :short, :char,
-                      :int, :long, :float, :double].freeze
-
-        JAVA_TYPE_NODES =
-          JAVA_TYPES.map { |t| s(:send, s(:const, nil, :Java), t) }
+        def_node_matcher :java_type_node?, <<-PATTERN
+          (send
+            (const nil :Java)
+            {:boolean :byte :char :double :float :int :long :short})
+        PATTERN
 
         def on_send(node)
           # ignore Java interop code like Java::int
-          return if JAVA_TYPE_NODES.include?(node)
+          return if java_type_node?(node)
 
           receiver, method_name, *_args = *node
 

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

@@ -20,19 +20,22 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%s`.'.freeze
         METHODS = [:inject, :reduce].freeze
 
-        def on_block(node)
-          method, args, body = *node
-          return unless reduce_method?(method)
+        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
 
-          _, method_name, method_arg = *method
-          return if simple_method_arg?(method_arg)
+        def on_block(node)
+          each_with_object_candidate?(node) do |method, args, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
 
-          return_value = return_value(body)
-          return unless return_value
-          return unless first_argument_returned?(args, return_value)
-          return if accumulator_param_assigned_to?(body, args)
+            return_value = return_value(body)
+            return unless return_value
+            return unless first_argument_returned?(args, return_value)
+            return if accumulator_param_assigned_to?(body, args)
 
-          add_offense(node, method.loc.selector, format(MSG, method_name))
+            add_offense(node, method.loc.selector, format(MSG, method_name))
+          end
         end
 
         def autocorrect(node)
@@ -47,13 +50,6 @@ module RuboCop
 
         private
 
-        def reduce_method?(method)
-          return false unless method.send_type?
-
-          _, method_name, _method_arg = *method
-          METHODS.include? method_name
-        end
-
         def simple_method_arg?(method_arg)
           method_arg && method_arg.basic_literal?
         end

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

@@ -12,34 +12,21 @@ module RuboCop
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
         STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
 
-        # Empty array node
-        #
-        # (send
-        #   (const nil :Array) :new)
-        ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
-
-        # Empty hash node
-        #
-        # (send
-        #   (const nil :Hash) :new)
-        HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
-
-        # Empty string node
-        #
-        # (send
-        #   (const nil :String) :new)
-        STR_NODE = s(:send, s(:const, nil, :String), :new)
+        def_node_matcher :array_node, '(send (const nil :Array) :new)'
+        def_node_matcher :hash_node, '(send (const nil :Hash) :new)'
+        def_node_matcher :str_node, '(send (const nil :String) :new)'
 
         def on_send(node)
-          case node
-          when ARRAY_NODE
-            add_offense(node, :expression, ARR_MSG)
-          when HASH_NODE
+          array_node(node) { add_offense(node, :expression, ARR_MSG) }
+
+          hash_node(node) do
             # If Hash.new takes a block, it can't be changed to {}.
             return if node.parent && node.parent.block_type?
 
             add_offense(node, :expression, HASH_MSG)
-          when STR_NODE
+          end
+
+          str_node(node) do
             return if frozen_string_literals_enabled?(processed_source)
 
             add_offense(node, :expression,
@@ -48,20 +35,9 @@ module RuboCop
         end
 
         def autocorrect(node)
-          name = case node
-                 when ARRAY_NODE
-                   '[]'
-                 when HASH_NODE
-                   # `some_method {}` is not same as `some_method Hash.new`
-                   # because the braces are interpreted as a block, so we avoid
-                   # the correction. Parentheses around the arguments would
-                   # solve the problem, but we let the user add those manually.
-                   return if first_arg_in_method_call_without_parentheses?(node)
-                   '{}'
-                 when STR_NODE
-                   preferred_string_literal
-                 end
-          ->(corrector) { corrector.replace(node.source_range, name) }
+          lambda do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
         end
 
         private
@@ -84,6 +60,40 @@ module RuboCop
           _receiver, _method_name, *args = *node.parent
           node.object_id == args.first.object_id && !parentheses?(node.parent)
         end
+
+        def replacement_range(node)
+          if hash_node(node) &&
+             first_arg_in_method_call_without_parentheses?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            _receiver, _method_name, *args = *node.parent
+
+            Parser::Source::Range.new(node.parent.loc.expression,
+                                      args[0].loc.expression.begin_pos - 1,
+                                      args[-1].loc.expression.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def correction(node)
+          if array_node(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif hash_node(node)
+            if first_arg_in_method_call_without_parentheses?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              _receiver, _method_name, *args = *node.parent
+              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
       end
     end
   end