rubocop 0.70.0 → 0.75.0

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that environments called with `Rails.env` predicates
-      # exist.
-      #
-      # @example
-      #   # bad
-      #   Rails.env.proudction?
-      #
-      #   # good
-      #   Rails.env.production?
-      class UnknownEnv < Cop
-        include NameSimilarity
-
-        MSG = 'Unknown environment `%<name>s`.'
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'
-
-        def_node_matcher :unknown_environment?, <<-PATTERN
-          (send
-            (send
-              {(const nil? :Rails) (const (cbase) :Rails)}
-              :env)
-            $#unknown_env_name?)
-        PATTERN
-
-        def on_send(node)
-          unknown_environment?(node) do |name|
-            add_offense(node, location: :selector, message: message(name))
-          end
-        end
-
-        private
-
-        def collect_variable_like_names(_scope)
-          environments.map { |env| env + '?' }
-        end
-
-        def message(name)
-          similar = find_similar_name(name.to_s, [])
-          if similar
-            format(MSG_SIMILAR, name: name, similar: similar)
-          else
-            format(MSG, name: name)
-          end
-        end
-
-        def unknown_env_name?(name)
-          name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
-        end
-
-        def environments
-          cop_config['Environments']
-        end
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of old-style attribute validation macros.
-      #
-      # @example
-      #   # bad
-      #   validates_acceptance_of :foo
-      #   validates_confirmation_of :foo
-      #   validates_exclusion_of :foo
-      #   validates_format_of :foo
-      #   validates_inclusion_of :foo
-      #   validates_length_of :foo
-      #   validates_numericality_of :foo
-      #   validates_presence_of :foo
-      #   validates_absence_of :foo
-      #   validates_size_of :foo
-      #   validates_uniqueness_of :foo
-      #
-      #   # good
-      #   validates :foo, acceptance: true
-      #   validates :foo, confirmation: true
-      #   validates :foo, exclusion: true
-      #   validates :foo, format: true
-      #   validates :foo, inclusion: true
-      #   validates :foo, length: true
-      #   validates :foo, numericality: true
-      #   validates :foo, presence: true
-      #   validates :foo, absence: true
-      #   validates :foo, size: true
-      #   validates :foo, uniqueness: true
-      #
-      class Validation < Cop
-        MSG = 'Prefer the new style validations `%<prefer>s` over ' \
-              '`%<current>s`.'
-
-        TYPES = %w[
-          acceptance
-          confirmation
-          exclusion
-          format
-          inclusion
-          length
-          numericality
-          presence
-          absence
-          size
-          uniqueness
-        ].freeze
-
-        DENYLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-        ALLOWLIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
-
-        def on_send(node)
-          return unless !node.receiver && DENYLIST.include?(node.method_name)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          last_argument = node.arguments.last
-          return if !last_argument.literal? && !last_argument.splat_type?
-
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'validates')
-            correct_validate_type(corrector, node)
-          end
-        end
-
-        private
-
-        def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
-        end
-
-        def preferred_method(method)
-          ALLOWLIST[DENYLIST.index(method.to_sym)]
-        end
-
-        def correct_validate_type(corrector, node)
-          last_argument = node.arguments.last
-          validate_type = node.method_name.to_s.split('_')[1]
-
-          if last_argument.hash_type?
-            corrector.replace(
-              last_argument.loc.expression,
-              "#{validate_type}: #{braced_options(last_argument)}"
-            )
-          else
-            range = last_argument.source_range
-
-            corrector.insert_after(range, ", #{validate_type}: true")
-          end
-        end
-
-        def braced_options(options)
-          if options.braces?
-            options.source
-          else
-            "{ #{options.source} }"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/rspec/shared_examples.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-# `cop` and `source` must be declared with #let.
-
-RSpec.shared_examples_for 'misaligned' do |annotated_source, used_style|
-  config_to_allow_offenses = if used_style
-                               { 'EnforcedStyleAlignWith' => used_style.to_s }
-                             else
-                               { 'Enabled' => false }
-                             end
-  annotated_source.strip_indent.split(/\n\n/).each do |chunk|
-    chunk << "\n" unless chunk.end_with?("\n")
-    source = chunk.lines.reject { |line| line =~ /^ *\^/ }.join
-    name = source.gsub(/\n(?=[a-z ])/, ' <newline> ').gsub(/\s+/, ' ')
-
-    it "registers an offense for mismatched #{name}" do
-      expect_offense(chunk)
-      expect(cop.config_to_allow_offenses).to eq(config_to_allow_offenses)
-    end
-
-    it "auto-corrects mismatched #{name}" do
-      raise if chunk !~
-               /\^\^\^ `end` at (\d), \d is not aligned with `.*` at \d, (\d)./
-
-      line_index = Integer(Regexp.last_match(1)) - 1
-      correct_indentation = ' ' * Integer(Regexp.last_match(2))
-      expect(autocorrect_source(source))
-        .to eq(source.lines[0...line_index].join +
-               "#{correct_indentation}#{source.lines[line_index].strip}\n")
-    end
-  end
-end
-
-RSpec.shared_examples_for 'aligned' do |alignment_base, arg, end_kw, name|
-  name ||= alignment_base
-  name = name.gsub(/\n/, ' <newline>')
-  it "accepts matching #{name} ... end" do
-    inspect_source("#{alignment_base} #{arg}\n#{end_kw}")
-    expect(cop.offenses).to be_empty
-  end
-end
-
-RSpec.shared_examples_for 'debugger' do |name, src|
-  it "reports an offense for a #{name} call" do
-    inspect_source(src)
-    src = [src] if src.is_a? String
-    expect(cop.offenses.size).to eq(src.size)
-    expect(cop.messages)
-      .to eq(src.map { |s| "Remove debugger entry point `#{s}`." })
-    expect(cop.highlights).to eq(src)
-  end
-end
-
-RSpec.shared_examples_for 'non-debugger' do |name, src|
-  it "does not report an offense for #{name}" do
-    inspect_source(src)
-    expect(cop.offenses).to be_empty
-  end
-end