rubocop 0.46.0 → 0.47.0

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

@@ -61,8 +61,8 @@ module RuboCop
 
         def delegate?(body)
           receiver, = *body
-          return false unless receiver.is_a?(Node) && receiver.send_type?
-          receiver.child_nodes.empty?
+          receiver.respond_to?(:type) && receiver.send_type? &&
+            receiver.child_nodes.empty?
         end
 
         def arguments_match?(args, body)

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

@@ -17,44 +17,35 @@ module RuboCop
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
 
         def_node_matcher :delegate, <<-PATTERN
-          (send _ :delegate _ $hash)
+          (send nil :delegate _ $hash)
         PATTERN
 
-        def_node_matcher :delegate_options, <<-PATTERN
-          (hash $...)
-        PATTERN
-
-        def_node_matcher :allow_blank?, <<-PATTERN
-          (pair $(sym :allow_blank) true)
+        def_node_matcher :allow_blank_option?, <<-PATTERN
+          (pair (sym :allow_blank) true)
         PATTERN
 
         def on_send(node)
           offending_node = allow_blank_option(node)
+
           return unless offending_node
 
-          allow_blank = offending_node.children.first
-          add_offense(node, allow_blank.source_range, MSG)
+          add_offense(offending_node, :expression, MSG)
         end
 
-        def autocorrect(node)
-          offending_node = allow_blank_option(node)
-          return unless offending_node
+        private
 
-          allow_blank = offending_node.children.first
+        def autocorrect(pair_node)
           lambda do |corrector|
-            corrector.replace(allow_blank.source_range, 'allow_nil')
+            corrector.replace(pair_node.key.source_range, 'allow_nil')
           end
         end
 
-        private
-
         def allow_blank_option(node)
           options_hash = delegate(node)
+
           return unless options_hash
-          options = delegate_options(options_hash)
-          return unless options
 
-          options.detect { |opt| allow_blank?(opt) }
+          options_hash.pairs.find { |opt| allow_blank_option?(opt) }
         end
       end
     end

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

@@ -18,53 +18,25 @@ module RuboCop
       #   # 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)
+        include Duplication
 
-          dupes = arr_dupes(enum_values(enum_args))
-          return if dupes.empty?
-
-          add_offense(node, :selector, format(MSG, dupes.join(','), enum_name))
-        end
+        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
 
-        private
+        def_node_matcher :enum_declaration, <<-END
+          (send nil :enum (hash (pair (_ $_) $_)))
+        END
 
-        def enum_values(enum_args)
-          if enum_args.type == :array
-            enum_array_keys(enum_args)
-          else
-            enum_hash_values(enum_args)
-          end
-        end
+        def on_send(node)
+          enum_declaration(node) do |name, args|
+            items = args.values
 
-        def enum_array_keys(array_node)
-          array_node.each_child_node.map(&:source)
-        end
+            return unless duplicates?(items)
 
-        def enum_hash_values(hash_node)
-          hash_node.each_child_node.map do |child_node|
-            child_node.child_nodes.last.source
+            consecutive_duplicates(items).each do |item|
+              add_offense(item, :expression, format(MSG, item.source, name))
+            end
           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

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of file path joining process
+      # to use `Rails.root.join` clause.
+      #
+      # @example
+      #  # bad
+      #  Rails.root.join('app/models/goober')
+      #  File.join(Rails.root, 'app/models/goober')
+      #  "#{Rails.root}/app/models/goober"
+      #
+      #  # good
+      #  Rails.root.join('app', 'models', 'goober')
+      class FilePath < Cop
+        MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
+
+        def_node_search :file_join_nodes, <<-PATTERN
+          (send (const nil :File) :join ...)
+        PATTERN
+
+        def_node_search :file_join_nodes?, <<-PATTERN
+          (send (const nil :File) :join ...)
+        PATTERN
+
+        def_node_search :rails_root_nodes?, <<-PATTERN
+          (send (const nil :Rails) :root)
+        PATTERN
+
+        def_node_search :rails_root_join_nodes, <<-PATTERN
+          (send (send (const nil :Rails) :root) :join ...)
+        PATTERN
+
+        def on_dstr(node)
+          return unless rails_root_nodes?(node)
+          register_offense(node)
+        end
+
+        def on_send(node)
+          check_for_file_join_with_rails_root(node)
+          check_for_rails_root_join_with_slash_separated_path(node)
+        end
+
+        private
+
+        def check_for_file_join_with_rails_root(node)
+          return unless file_join_nodes?(node)
+          return unless file_join_nodes(node).map(&:method_args)
+                                             .flatten
+                                             .any? { |e| rails_root_nodes?(e) }
+
+          register_offense(node)
+        end
+
+        def check_for_rails_root_join_with_slash_separated_path(node)
+          return unless rails_root_nodes?(node)
+          return unless rails_root_join_nodes(node).map(&:method_args)
+                                                   .flatten
+                                                   .any? do |arg|
+                                                     arg.source =~ %r{/}
+                                                   end
+
+          register_offense(node)
+        end
+
+        def register_offense(node)
+          line_range = node.loc.column...node.loc.last_column
+
+          add_offense(
+            node,
+            source_range(processed_source.buffer, node.loc.line, line_range),
+            MSG
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -18,12 +18,11 @@ module RuboCop
         SCOPE_METHODS = [:all, :where, :not].freeze
 
         def on_send(node)
-          receiver, second_method, _selector = *node
-          return unless second_method == :each
-          return if receiver.nil?
+          receiver, method, _selector = *node
+          return unless receiver && method == :each
 
-          _model, first_method = *receiver
-          return unless SCOPE_METHODS.include?(first_method)
+          _model, preceding_method = *receiver
+          return unless SCOPE_METHODS.include?(preceding_method)
           return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
 
           add_offense(node, node.loc.selector, MSG)
@@ -38,15 +37,7 @@ module RuboCop
         private
 
         def method_chain(node)
-          if (node.send_type? || node.block_type?) && !node.receiver.nil?
-            if node.parent
-              method_chain(node.parent) << node.method_name
-            else
-              [node.method_name]
-            end
-          else
-            []
-          end
+          [*node.ancestors, node].map(&:method_name)
         end
 
         def ignored_by_find_each?(relation_method)

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of http methods
-      # like `get`, `post`, `put`, `path` without the usage of keyword arguments
-      # in your tests and change them to use keyword arguments.
+      # This cop is used to identify usages of http methods like `get`, `post`,
+      # `put`, `patch` without the usage of keyword arguments in your tests and
+      # change them to use keyword arguments.
       #
       # @example
       #   # bad
@@ -17,45 +17,50 @@ module RuboCop
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%s`.'.freeze
         KEYWORD_ARGS = [
-          :headers, :env, :params, :body, :flash, :as,
-          :xhr, :session, :method, :format
+          :headers, :env, :params, :body, :flash, :as, :xhr, :session, :method
         ].freeze
         HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head].freeze
 
+        def_node_matcher :http_request?, <<-END
+          (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
+        END
+
         def on_send(node)
-          receiver, http_method, http_path, data = *node
-          # if the first word on the line is not an http method, then skip
-          return unless HTTP_METHODS.include?(http_method)
+          data = http_request?(node)
           # if the data is nil then we don't need to add keyword arguments
           # because there is no data to put in params or headers, so skip
           return if data.nil?
           return unless needs_conversion?(data)
-          # ensures this is the first method on the line
-          # there is an edge case here where sometimes the http method is
-          # wrapped into another method, but its just safer to skip those
-          # cases and process manually
-          return unless receiver.nil?
-          # a http_method without a path?, must be something else
-          return if http_path.nil?
+
           add_offense(node, node.loc.selector, format(MSG, node.method_name))
         end
 
         # @return [Boolean] true if the line needs to be converted
         def needs_conversion?(data)
-          # if the line has already been converted to use keyword args
-          # then skip
-          # ie. get :new, params: { user_id: 1 }  (looking for keyword arg)
-          value = data.descendants.find do |d|
-            KEYWORD_ARGS.include?(d.children.first) if d.type == :sym
+          return true unless data.hash_type?
+          children = data.child_nodes
+
+          value = children.find do |d|
+            special_keyword_arg?(d.children.first) ||
+              (format_arg?(d.children.first) && children.size == 1)
           end
+
           value.nil?
         end
 
+        def special_keyword_arg?(node)
+          KEYWORD_ARGS.include?(node.children.first) if node.type == :sym
+        end
+
+        def format_arg?(node)
+          node.children.first == :format if node.type == :sym
+        end
+
         def convert_hash_data(data, type)
           # empty hash or no hash return empty string
-          return '' if data.nil? || data.children.count < 1
+          return '' if data.nil? || data.children.empty?
           hash_data = if data.hash_type?
-                        format('{ %s }', data.children.map(&:source).join(', '))
+                        format('{ %s }', data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces
@@ -78,11 +83,12 @@ module RuboCop
           _receiver, http_method, http_path, *data = *node
           controller_action = http_path.source
           params = convert_hash_data(data.first, 'params')
-          headers = convert_hash_data(data.last, 'headers') if data.count > 1
+          headers = convert_hash_data(data.last, 'headers') if data.size > 1
           # the range of the text to replace, which is the whole line
           code_to_replace = node.loc.expression
           # what to replace with
-          new_code = format('%s %s%s%s', http_method, controller_action,
+          format = parentheses?(node) ? '%s(%s%s%s)' : '%s %s%s%s'
+          new_code = format(format, http_method, controller_action,
                             params, headers)
           ->(corrector) { corrector.replace(code_to_replace, new_code) }
         end

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

@@ -9,10 +9,13 @@ module RuboCop
       # @example
       #   # bad
       #   add_column :users, :name, :string, null: false
+      #   add_reference :products, :category, null: false
       #
       #   # good
       #   add_column :users, :name, :string, null: true
       #   add_column :users, :name, :string, null: false, default: ''
+      #   add_reference :products, :category
+      #   add_reference :products, :category, null: false, default: 1
       class NotNullColumn < Cop
         MSG = 'Do not add a NOT NULL column without a default value.'.freeze
 
@@ -20,6 +23,10 @@ module RuboCop
           (send nil :add_column _ _ _ (hash $...))
         PATTERN
 
+        def_node_matcher :add_not_null_reference?, <<-PATTERN
+          (send nil :add_reference _ _ (hash $...))
+        PATTERN
+
         def_node_matcher :null_false?, <<-PATTERN
           (pair (sym :null) (false))
         PATTERN
@@ -29,7 +36,23 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          check_add_column(node)
+          check_add_reference(node)
+        end
+
+        private
+
+        def check_add_column(node)
           pairs = add_not_null_column?(node)
+          check_pairs(pairs)
+        end
+
+        def check_add_reference(node)
+          pairs = add_not_null_reference?(node)
+          check_pairs(pairs)
+        end
+
+        def check_pairs(pairs)
           return unless pairs
           return if pairs.any? { |pair| has_default?(pair) }
 

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether the change method of the migration file is
+      # reversible.
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.column :name, :string
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     create_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       change_table :users do |t|
+      #         dir.up do
+      #           t.column :name, :string
+      #         end
+      #
+      #         dir.down do
+      #           t.remove :name
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #   # drop_table
+      #
+      #   # bad
+      #   def change
+      #     drop_table :users
+      #   end
+      #
+      #   # good
+      #   def change
+      #     drop_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      # @example
+      #   # change_column_default
+      #
+      #   # bad
+      #   def change
+      #     change_column_default(:suppliers, :qualification, 'new')
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_column_default(:posts, :state, from: nil, to: "draft")
+      #   end
+      #
+      # @example
+      #   # remove_column
+      #
+      #   # bad
+      #   def change
+      #     remove_column(:suppliers, :qualification)
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_column(:suppliers, :qualification, :string)
+      #   end
+      #
+      # @example
+      #   # remove_foreign_key
+      #
+      #   # bad
+      #   def change
+      #     remove_foreign_key :accounts, column: :owner_id
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, :branches
+      #   end
+      #
+      # @see http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
+      class ReversibleMigration < Cop
+        MSG = '%s is not reversible.'.freeze
+
+        def_node_matcher :irreversible_schema_statement_call, <<-END
+          (send nil ${:change_table :change_table_comment :execute :remove_belongs_to} ...)
+        END
+
+        def_node_matcher :drop_table_call, <<-END
+          (send nil :drop_table ...)
+        END
+
+        def_node_matcher :change_column_default_call, <<-END
+          (send nil :change_column_default _ _ $...)
+        END
+
+        def_node_matcher :remove_column_call, <<-END
+          (send nil :remove_column $...)
+        END
+
+        def_node_matcher :remove_foreign_key_call, <<-END
+          (send nil :remove_foreign_key _ $_)
+        END
+
+        def on_send(node)
+          return unless within_change_method?(node)
+          return if within_reversible_block?(node)
+
+          check_irreversible_schema_statement_node(node)
+          check_drop_table_node(node)
+          check_change_column_default_node(node)
+          check_remove_column_node(node)
+          check_remove_foreign_key_node(node)
+        end
+
+        private
+
+        def check_irreversible_schema_statement_node(node)
+          irreversible_schema_statement_call(node) do |method_name|
+            add_offense(node, :expression, format(MSG, method_name))
+          end
+        end
+
+        def check_drop_table_node(node)
+          drop_table_call(node) do
+            unless node.parent.block_type?
+              add_offense(
+                node, :expression,
+                format(MSG, 'drop_table(without block)')
+              )
+            end
+          end
+        end
+
+        def check_change_column_default_node(node)
+          change_column_default_call(node) do |args|
+            unless all_hash_key?(args.first, :from, :to)
+              add_offense(
+                node, :expression,
+                format(MSG, 'change_column_default(without :from and :to)')
+              )
+            end
+          end
+        end
+
+        def check_remove_column_node(node)
+          remove_column_call(node) do |args|
+            if args.to_a.size < 3
+              add_offense(
+                node, :expression,
+                format(MSG, 'remove_column(without type)')
+              )
+            end
+          end
+        end
+
+        def check_remove_foreign_key_node(node)
+          remove_foreign_key_call(node) do |arg|
+            if arg.hash_type?
+              add_offense(
+                node, :expression,
+                format(MSG, 'remove_foreign_key(without table)')
+              )
+            end
+          end
+        end
+
+        def within_change_method?(node)
+          parent = node.parent
+          while parent
+            if parent.def_type?
+              method_name, = *parent
+              return true if method_name == :change
+            end
+            parent = parent.parent
+          end
+          false
+        end
+
+        def within_reversible_block?(node)
+          parent = node.parent
+          while parent
+            if parent.block_type?
+              _, block_name = *parent.to_a.first
+              return true if block_name == :reversible
+            end
+            parent = parent.parent
+          end
+          false
+        end
+
+        def all_hash_key?(args, *keys)
+          return false unless args
+          return false unless args.hash_type?
+
+          hash_keys = args.to_a.map do |arg|
+            arg.to_a.first.children.first.to_sym
+          end
+
+          hash_keys & keys == keys
+        end
+      end
+    end
+  end
+end