rubocop 0.71.0 → 0.72.0

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for delegations that could have been created
-      # automatically with the `delegate` method.
-      #
-      # Safe navigation `&.` is ignored because Rails' `allow_nil`
-      # option checks not just for nil but also delegates if nil
-      # responds to the delegated method.
-      #
-      # The `EnforceForPrefixed` option (defaulted to `true`) means that
-      # using the target object as a prefix of the method name
-      # without using the `delegate` method will be a violation.
-      # When set to `false`, this case is legal.
-      #
-      # @example
-      #   # bad
-      #   def bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo
-      #
-      #   # good
-      #   def bar
-      #     foo&.bar
-      #   end
-      #
-      #   # good
-      #   private
-      #   def bar
-      #     foo.bar
-      #   end
-      #
-      # @example EnforceForPrefixed: true (default)
-      #   # bad
-      #   def foo_bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo, prefix: true
-      #
-      # @example EnforceForPrefixed: false
-      #   # good
-      #   def foo_bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo, prefix: true
-      class Delegate < Cop
-        MSG = 'Use `delegate` to define delegations.'
-
-        def_node_matcher :delegate?, <<-PATTERN
-          (def _method_name _args
-            (send (send nil? _) _ ...))
-        PATTERN
-
-        def on_def(node)
-          return unless trivial_delegate?(node)
-          return if private_or_protected_delegation(node)
-
-          add_offense(node, location: :keyword)
-        end
-
-        def autocorrect(node)
-          delegation = ["delegate :#{node.body.method_name}",
-                        "to: :#{node.body.receiver.method_name}"]
-
-          if node.method_name == prefixed_method_name(node.body)
-            delegation << ['prefix: true']
-          end
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, delegation.join(', '))
-          end
-        end
-
-        private
-
-        def trivial_delegate?(def_node)
-          delegate?(def_node) &&
-            method_name_matches?(def_node.method_name, def_node.body) &&
-            arguments_match?(def_node.arguments, def_node.body)
-        end
-
-        def arguments_match?(arg_array, body)
-          argument_array = body.arguments
-
-          return false if arg_array.size != argument_array.size
-
-          arg_array.zip(argument_array).all? do |arg, argument|
-            arg.arg_type? &&
-              argument.lvar_type? &&
-              arg.children == argument.children
-          end
-        end
-
-        def method_name_matches?(method_name, body)
-          method_name == body.method_name ||
-            include_prefix_case? && method_name == prefixed_method_name(body)
-        end
-
-        def include_prefix_case?
-          cop_config['EnforceForPrefixed']
-        end
-
-        def prefixed_method_name(body)
-          [body.receiver.method_name, body.method_name].join('_').to_sym
-        end
-
-        def private_or_protected_delegation(node)
-          line = node.first_line
-          private_or_protected_before(line) ||
-            private_or_protected_inline(line)
-        end
-
-        def private_or_protected_before(line)
-          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
-        end
-
-        def private_or_protected_inline(line)
-          processed_source[line - 1].strip =~ /\A(private )|(protected )/
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for delegations that pass :allow_blank as an option
-      # instead of :allow_nil. :allow_blank is not a valid option to pass
-      # to ActiveSupport#delegate.
-      #
-      # @example
-      #   # bad
-      #   delegate :foo, to: :bar, allow_blank: true
-      #
-      #   # good
-      #   delegate :foo, to: :bar, allow_nil: true
-      class DelegateAllowBlank < Cop
-        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
-
-        def_node_matcher :allow_blank_option, <<-PATTERN
-          (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
-        PATTERN
-
-        def on_send(node)
-          allow_blank_option(node) do |offending_node|
-            add_offense(offending_node)
-          end
-        end
-
-        def autocorrect(pair_node)
-          lambda do |corrector|
-            corrector.replace(pair_node.key.source_range, 'allow_nil')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks dynamic `find_by_*` methods.
-      # Use `find_by` instead of dynamic method.
-      # See. https://github.com/rubocop-hq/rails-style-guide#find_by
-      #
-      # @example
-      #   # bad
-      #   User.find_by_name(name)
-      #
-      #   # bad
-      #   User.find_by_name_and_email(name)
-      #
-      #   # bad
-      #   User.find_by_email!(name)
-      #
-      #   # good
-      #   User.find_by(name: name)
-      #
-      #   # good
-      #   User.find_by(name: name, email: email)
-      #
-      #   # good
-      #   User.find_by!(email: email)
-      class DynamicFindBy < Cop
-        MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
-        METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
-
-        def on_send(node)
-          method_name = node.method_name.to_s
-
-          return if whitelist.include?(method_name)
-
-          static_name = static_method_name(method_name)
-
-          return unless static_name
-
-          add_offense(node,
-                      message: format(MSG, static_name: static_name,
-                                           method: node.method_name))
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          keywords = column_keywords(node.method_name)
-
-          return if keywords.size != node.arguments.size
-
-          lambda do |corrector|
-            autocorrect_method_name(corrector, node)
-            autocorrect_argument_keywords(corrector, node, keywords)
-          end
-        end
-
-        private
-
-        def autocorrect_method_name(corrector, node)
-          corrector.replace(node.loc.selector,
-                            static_method_name(node.method_name.to_s))
-        end
-
-        def autocorrect_argument_keywords(corrector, node, keywords)
-          keywords.each.with_index do |keyword, idx|
-            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
-          end
-        end
-
-        def whitelist
-          cop_config['Whitelist']
-        end
-
-        def column_keywords(method)
-          keyword_string = method.to_s[METHOD_PATTERN, 1]
-          keyword_string.split('_and_').map { |keyword| "#{keyword}: " }
-        end
-
-        # Returns static method name.
-        # If code isn't wrong, returns nil
-        def static_method_name(method_name)
-          match = METHOD_PATTERN.match(method_name)
-          return nil unless match
-
-          match[2] ? 'find_by!' : 'find_by'
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# 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
-        include Duplication
-
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
-
-        def_node_matcher :enum_declaration, <<-PATTERN
-          (send nil? :enum (hash (pair (_ $_) ${array hash})))
-        PATTERN
-
-        def on_send(node)
-          enum_declaration(node) do |name, args|
-            items = args.values
-
-            return unless duplicates?(items)
-
-            consecutive_duplicates(items).each do |item|
-              add_offense(item, message: format(MSG, value: item.source,
-                                                     enum: name))
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that Rails.env is compared using `.production?`-like
-      # methods instead of equality against a string or symbol.
-      #
-      # @example
-      #   # bad
-      #   Rails.env == 'production'
-      #
-      #   # bad, always returns false
-      #   Rails.env == :test
-      #
-      #   # good
-      #   Rails.env.production?
-      class EnvironmentComparison < Cop
-        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`."
-
-        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
-          'evaluate to `false`.'
-
-        def_node_matcher :environment_str_comparison?, <<-PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            :==
-            $str
-          )
-        PATTERN
-
-        def_node_matcher :environment_sym_comparison?, <<-PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            :==
-            $sym
-          )
-        PATTERN
-
-        def on_send(node)
-          environment_str_comparison?(node) do |env_node|
-            env, = *env_node
-            add_offense(node, message: format(MSG, env: env))
-          end
-          environment_sym_comparison?(node) do |_|
-            add_offense(node, message: SYM_MSG)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
-          end
-        end
-
-        private
-
-        def replacement(node)
-          "#{node.receiver.source}.#{content(node.first_argument)}?"
-        end
-
-        def_node_matcher :content, <<-PATTERN
-          ({str sym} $_)
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop enforces that `exit` calls are not used within a rails app.
-      # Valid options are instead to raise an error, break, return, or some
-      # other form of stopping execution of current request.
-      #
-      # There are two obvious cases where `exit` is particularly harmful:
-      #
-      # - Usage in library code for your application. Even though Rails will
-      # rescue from a `SystemExit` and continue on, unit testing that library
-      # code will result in specs exiting (potentially silently if `exit(0)`
-      # is used.)
-      # - Usage in application code outside of the web process could result in
-      # the program exiting, which could result in the code failing to run and
-      # do its job.
-      #
-      # @example
-      #   # bad
-      #   exit(0)
-      #
-      #   # good
-      #   raise 'a bad error has happened'
-      class Exit < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `exit` in Rails applications.'
-        TARGET_METHODS = %i[exit exit!].freeze
-        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
-
-        def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
-        end
-
-        private
-
-        def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
-        end
-
-        # More than 1 argument likely means it is a different
-        # `exit` implementation than the one we are preventing.
-        def right_argument_count?(arg_nodes)
-          arg_nodes.size <= 1
-        end
-
-        # Only register if exit is being called explicitly on `Kernel`,
-        # `Process`, or if receiver node is nil for plain `exit` calls.
-        def right_receiver?(receiver_node)
-          return true unless receiver_node
-
-          _a, receiver_node_class, _c = *receiver_node
-
-          EXPLICIT_RECEIVERS.include?(receiver_node_class)
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# 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. It is used to add uniformity when
-      # joining paths.
-      #
-      # @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')
-      #
-      class FilePath < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
-                      'instead.'
-        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
-                        'instead.'
-
-        def_node_matcher :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_matcher :rails_root_join_nodes?, <<-PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
-        PATTERN
-
-        def on_dstr(node)
-          return unless rails_root_nodes?(node)
-          return unless node.children.last.source.start_with?('.') ||
-                        node.children.last.source.include?(File::SEPARATOR)
-
-          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)
-          check_for_rails_root_join_with_string_arguments(node)
-        end
-
-        private
-
-        def check_for_file_join_with_rails_root(node)
-          return unless file_join_nodes?(node)
-          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
-
-          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) }
-
-          register_offense(node)
-        end
-
-        def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
-        end
-
-        def register_offense(node)
-          line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
-          add_offense(node, location: source_range)
-        end
-
-        def message(_node)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
-        end
-      end
-    end
-  end
-end