rubocop 0.56.0 → 0.57.0

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

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This Cop checks whether alter queries are combinable.
+      # If combinable queries are detected, it suggests to you
+      # to use `change_table` with `bulk: true` instead.
+      # When use this method, make combinable alter queries
+      # a bulk alter query.
+      #
+      # The `bulk` option is only supported on the MySQL and
+      # the PostgreSQL (5.2 later) adapter; thus it will
+      # automatically detect an adapter from `development` environment
+      # in `config/database.yml` when the `Database` option is not set.
+      # If the adapter is not `mysql2` or `postgresql`,
+      # this Cop ignores offenses.
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     add_column :users, :name, :string, null: false
+      #     add_column :users, :nickname, :string
+      #
+      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL
+      #     # ALTER TABLE `users` ADD `nickname` varchar(255)
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_table :users, bulk: true do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #
+      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL,
+      #     #                     ADD `nickname` varchar(255)
+      #   end
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_table :users, bulk: true do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      #   # good
+      #   # When you don't want to combine alter queries.
+      #   def change
+      #     change_table :users, bulk: false do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      # @see http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
+      # @see http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
+      class BulkChangeTable < Cop
+        MSG_FOR_CHANGE_TABLE = <<-MSG.strip_indent.chomp
+          You can combine alter queries using `bulk: true` options.
+        MSG
+        MSG_FOR_ALTER_METHODS = <<-MSG.strip_indent.chomp
+          You can use `change_table :%<table>s, bulk: true` to combine alter queries.
+        MSG
+
+        MYSQL = 'mysql'.freeze
+        POSTGRESQL = 'postgresql'.freeze
+
+        MIGRATIION_METHODS = %i[change up down].freeze
+
+        COMBINABLE_TRANSFORMATIONS = %i[
+          primary_key
+          column
+          string
+          text
+          integer
+          bigint
+          float
+          decimal
+          numeric
+          datetime
+          timestamp
+          time
+          date
+          binary
+          boolean
+          json
+          virtual
+          remove
+          change
+          timestamps
+          remove_timestamps
+        ].freeze
+
+        COMBINABLE_ALTER_METHODS = %i[
+          add_column
+          remove_column
+          remove_columns
+          change_column
+          add_timestamps
+          remove_timestamps
+        ].freeze
+
+        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[
+          rename
+          index
+          remove_index
+        ].freeze
+
+        MYSQL_COMBINABLE_ALTER_METHODS = %i[
+          rename_column
+          add_index
+          remove_index
+        ].freeze
+
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[
+          change_default
+        ].freeze
+
+        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[
+          change_column_default
+          change_column_null
+        ].freeze
+
+        def on_def(node)
+          return unless support_bulk_alter?
+          return unless MIGRATIION_METHODS.include?(node.method_name)
+
+          recorder = AlterMethodsRecorder.new
+
+          node.body.each_child_node(:send) do |send_node|
+            if combinable_alter_methods.include?(send_node.method_name)
+              recorder.process(send_node)
+            else
+              recorder.flush
+            end
+          end
+
+          recorder.offensive_nodes.each { |n| add_offense_for_alter_methods(n) }
+        end
+
+        def on_send(node)
+          return unless support_bulk_alter?
+          return unless node.command?(:change_table)
+          return if include_bulk_options?(node)
+          return unless node.block_node
+          send_nodes = node.block_node.body.each_child_node(:send).to_a
+
+          transformations = send_nodes.select do |send_node|
+            combinable_transformations.include?(send_node.method_name)
+          end
+
+          add_offense_for_change_table(node) if transformations.size > 1
+        end
+
+        private
+
+        # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
+        def include_bulk_options?(node)
+          # arguments: [(sym :table) (hash (pair (sym :bulk) _))]
+          options = node.arguments[1]
+          return false unless options
+          options.hash_type? &&
+            options.keys.any? { |key| key.sym_type? && key.value == :bulk }
+        end
+
+        def database
+          cop_config['Database'] || database_from_yaml
+        end
+
+        def database_from_yaml
+          return nil unless database_yaml
+          case database_yaml['adapter']
+          when 'mysql2'
+            MYSQL
+          when 'postgresql'
+            POSTGRESQL
+          end
+        end
+
+        def database_yaml
+          return nil unless File.exist?('config/database.yml')
+          yaml = YAML.load_file('config/database.yml')
+          return nil unless yaml.is_a? Hash
+          config = yaml['development']
+          return nil unless config.is_a?(Hash)
+          config
+        end
+
+        def support_bulk_alter?
+          case database
+          when MYSQL
+            true
+          when POSTGRESQL
+            # Add bulk alter support for PostgreSQL in 5.2.0
+            # @see https://github.com/rails/rails/pull/31331
+            target_rails_version >= 5.2
+          else
+            false
+          end
+        end
+
+        def combinable_alter_methods
+          case database
+          when MYSQL
+            COMBINABLE_ALTER_METHODS + MYSQL_COMBINABLE_ALTER_METHODS
+          when POSTGRESQL
+            COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+          end
+        end
+
+        def combinable_transformations
+          case database
+          when MYSQL
+            COMBINABLE_TRANSFORMATIONS + MYSQL_COMBINABLE_TRANSFORMATIONS
+          when POSTGRESQL
+            COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        def add_offense_for_alter_methods(node)
+          # arguments: [(sym :table) ...]
+          table_name = node.arguments[0].value
+          message = format(MSG_FOR_ALTER_METHODS, table: table_name)
+          add_offense(node, message: message)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        def add_offense_for_change_table(node)
+          add_offense(node, message: MSG_FOR_CHANGE_TABLE)
+        end
+
+        # Record combinable alter methods and register offensive nodes.
+        class AlterMethodsRecorder
+          def initialize
+            @nodes = []
+            @offensive_nodes = []
+          end
+
+          # @param new_node [RuboCop::AST::SendNode]
+          def process(new_node)
+            # arguments: [(sym :table) ...]
+            table_name = new_node.arguments[0]
+            flush unless @nodes.all? { |node| node.arguments[0] == table_name }
+            @nodes << new_node
+          end
+
+          def flush
+            @offensive_nodes << @nodes.first if @nodes.size > 1
+            @nodes = []
+          end
+
+          def offensive_nodes
+            flush
+            @offensive_nodes
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # This cop checks dynamic `find_by_*` methods.
       # Use `find_by` instead of dynamic method.
-      # See. https://github.com/bbatsov/rails-style-guide#find_by
+      # See. https://github.com/rubocop-hq/rails-style-guide#find_by
       #
       # @example
       #   # bad

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

@@ -4,21 +4,35 @@ module RuboCop
   module Cop
     module Rails
       # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause. This is to avoid bugs on operating
-      # system that don't use '/' as the path separator.
+      # to use `Rails.root.join` clause. It is used to add uniformity when
+      # joining paths.
       #
-      # @example
-      #  # bad
-      #  Rails.root.join('app/models/goober')
-      #  File.join(Rails.root, 'app/models/goober')
-      #  "#{Rails.root}/app/models/goober"
+      # @example EnforcedStyle: arguments (default)
+      #   # 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')
+      #
+      # @example EnforcedStyle: slashes
+      #   # 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')
       #
-      #  # good
-      #  Rails.root.join('app', 'models', 'goober')
       class FilePath < Cop
+        include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
+        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
+                      'instead.'.freeze
+        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
+                        'instead.'.freeze
 
         def_node_matcher :file_join_nodes?, <<-PATTERN
           (send (const nil? :File) :join ...)
@@ -43,6 +57,7 @@ module RuboCop
         def on_send(node)
           check_for_file_join_with_rails_root(node)
           check_for_rails_root_join_with_slash_separated_path(node)
+          check_for_rails_root_join_with_string_arguments(node)
         end
 
         private
@@ -54,7 +69,18 @@ module RuboCop
           register_offense(node)
         end
 
+        def check_for_rails_root_join_with_string_arguments(node)
+          return unless style == :slashes
+          return unless rails_root_nodes?(node)
+          return unless rails_root_join_nodes?(node)
+          return unless node.arguments.size > 1
+          return unless node.arguments.all?(&:str_type?)
+
+          register_offense(node)
+        end
+
         def check_for_rails_root_join_with_slash_separated_path(node)
+          return unless style == :arguments
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
           return unless node.arguments.any? { |arg| string_with_slash?(arg) }
@@ -72,6 +98,10 @@ module RuboCop
                                       line_range)
           add_offense(node, location: source_range)
         end
+
+        def message(_node)
+          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
+        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%<verb>s`.'.freeze
         KEYWORD_ARGS = %i[
-          method params session body flash xhr as
+          method params session body flash xhr as headers env
         ].freeze
         HTTP_METHODS = %i[get post put patch delete head].freeze
 

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

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # This cop checks for the use of Time methods without zone.
       #
-      # Built on top of Ruby on Rails style guide (https://github.com/bbatsov/rails-style-guide#time)
+      # Built on top of Ruby on Rails style guide (https://github.com/rubocop-hq/rails-style-guide#time)
       # and the article http://danilenko.org/2012/7/6/rails_timezones/ .
       #
       # Two styles are supported for this cop. When EnforcedStyle is 'strict'
@@ -66,8 +66,8 @@ module RuboCop
                                parse at current].freeze
 
         ACCEPTED_METHODS = %i[in_time_zone utc getlocal
-                              iso8601 jisx0301 rfc3339
-                              to_i to_f].freeze
+                              xmlschema iso8601 jisx0301 rfc3339
+                              httpdate to_i to_f].freeze
 
         def on_const(node)
           mod, klass = *node

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Access modifiers should be declared to apply to a group of methods
+      # or inline before each method, depending on configuration.
+      #
+      # @example EnforcedStyle: group (default)
+      #
+      #   # bad
+      #
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      # @example EnforcedStyle: inline
+      #
+      #   # bad
+      #
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      class AccessModifierDeclarations < Cop
+        include ConfigurableEnforcedStyle
+
+        GROUP_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should not be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        INLINE_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        def on_send(node)
+          return unless node.access_modifier?
+
+          if offense?(node)
+            add_offense(node, location: :selector) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def offense?(node)
+          (group_style? && access_modifier_is_inlined?(node)) ||
+            (inline_style? && access_modifier_is_not_inlined?(node))
+        end
+
+        def group_style?
+          style == :group
+        end
+
+        def inline_style?
+          style == :inline
+        end
+
+        def access_modifier_is_inlined?(node)
+          node.arguments.any?
+        end
+
+        def access_modifier_is_not_inlined?(node)
+          !access_modifier_is_inlined?(node)
+        end
+
+        def message(node)
+          access_modifier = node.loc.selector.source
+
+          if group_style?
+            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
+          elsif inline_style?
+            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
+          end
+        end
+      end
+    end
+  end
+end