rubocop-rspec 1.7.0 → 3.0.2

data/lib/rubocop/rspec/top_level_describe.rb

@@ -1,61 +0,0 @@
-module RuboCop
-  module RSpec
-    # Helper methods for top level describe cops
-    module TopLevelDescribe
-      extend NodePattern::Macros
-
-      def_node_matcher :described_constant, <<-PATTERN
-        (block $(send _ :describe $(const ...)) (args) $_)
-      PATTERN
-
-      def on_send(node)
-        return unless respond_to?(:on_top_level_describe)
-        return unless top_level_describe?(node)
-
-        _receiver, _method_name, *args = *node
-
-        on_top_level_describe(node, args)
-      end
-
-      private
-
-      def top_level_describe?(node)
-        _receiver, method_name, *_args = *node
-        return false unless method_name == :describe
-
-        top_level_nodes.include?(node)
-      end
-
-      def top_level_nodes
-        nodes = describe_statement_children(root_node)
-        # If we have no top level describe statements, we need to check any
-        # blocks on the top level (e.g. after a require).
-        if nodes.empty?
-          nodes = node_children(root_node).map do |child|
-            describe_statement_children(child) if child.type == :block
-          end.flatten.compact
-        end
-
-        nodes
-      end
-
-      def root_node
-        processed_source.ast
-      end
-
-      def single_top_level_describe?
-        top_level_nodes.count == 1
-      end
-
-      def describe_statement_children(node)
-        node_children(node).select do |element|
-          element.type == :send && element.children[1] == :describe
-        end
-      end
-
-      def node_children(node)
-        node.children.select { |e| e.is_a? Parser::AST::Node }
-      end
-    end
-  end
-end

data/lib/rubocop/rspec/util.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Utility methods
-    module Util
-      # Error raised by `Util.one` if size is less than zero or greater than one
-      SizeError = Class.new(IndexError)
-
-      # Return only element in array if it contains exactly one member
-      def one(array)
-        return array.first if array.one?
-
-        raise SizeError,
-              "expected size to be exactly 1 but size was #{array.size}"
-      end
-    end
-  end
-end

data/rubocop-rspec.gemspec

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-require 'rubocop/rspec/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'rubocop-rspec'
-  spec.summary = 'Code style checking for RSpec files'
-  spec.description = <<-end_description
-    Code style checking for RSpec files.
-    A plugin for the RuboCop code style enforcing & linting tool.
-  end_description
-  spec.homepage = 'http://github.com/nevir/rubocop-rspec'
-  spec.authors = ['Ian MacLeod', 'Nils Gemeinhardt']
-  spec.email = ['ian@nevir.net', 'git@nilsgemeinhardt.de']
-  spec.licenses = ['MIT']
-
-  spec.version = RuboCop::RSpec::Version::STRING
-  spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.2.0'
-
-  spec.require_paths = ['lib']
-  spec.files = Dir[
-    '{config,lib,spec}/**/*',
-    '*.md',
-    '*.gemspec',
-    'Gemfile',
-    'Rakefile'
-  ]
-  spec.test_files = spec.files.grep(%r{^spec/})
-  spec.extra_rdoc_files = ['MIT-LICENSE.md', 'README.md']
-
-  spec.add_runtime_dependency 'rubocop', '>= 0.42.0'
-
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '>= 3.4'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'anima'
-  spec.add_development_dependency 'concord'
-  spec.add_development_dependency 'adamantium'
-  spec.add_development_dependency 'yard'
-end

data/spec/expect_violation/expectation_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe ExpectViolation::Expectation do
-  subject(:expectation) { described_class.new(string) }
-
-  context 'when given a single assertion on class end' do
-    let(:string) do
-      <<-SRC
-      class Foo
-      end
-      ^^^ The end of `Foo` should be annotated.
-      SRC
-    end
-
-    let(:assertion) { expectation.assertions.first }
-
-    it 'has one assertion' do
-      expect(expectation.assertions.size).to be(1)
-    end
-
-    it 'has an assertion on line 2' do
-      expect(assertion.line_number).to be(2)
-    end
-
-    it 'has an assertion on column range 1-3' do
-      expect(assertion.column_range).to eql(6...9)
-    end
-
-    it 'has an assertion with correct violation message' do
-      expect(assertion.message).to eql('The end of `Foo` should be annotated.')
-    end
-
-    it 'recreates source' do
-      expect(expectation.source).to eql(<<-RUBY)
-      class Foo
-      end
-      RUBY
-    end
-  end
-
-  context 'when given many assertions on two lines' do
-    let(:string) do
-      <<-SRC
-      foo bar
-          ^ Charlie
-         ^^ Charlie
-          ^^ Bronco
-          ^^ Alpha
-      baz
-      ^ Delta
-      SRC
-    end
-
-    let(:assertions) { expectation.assertions.sort }
-
-    it 'has two assertions' do
-      expect(expectation.assertions.size).to be(5)
-    end
-
-    it 'has assertions on lines 1 and 2' do
-      expect(assertions.map(&:line_number)).to eql(
-        [1, 1, 1, 1, 2]
-      )
-    end
-
-    it 'has assertions on column range 1-3' do
-      expect(assertions.map(&:column_range)).to eql(
-        [9...11, 10...11, 10...12, 10...12, 6...7]
-      )
-    end
-
-    it 'has an assertion with correct violation message' do
-      expect(assertions.map(&:message)).to eql(
-        %w(Charlie Charlie Alpha Bronco Delta)
-      )
-    end
-
-    it 'recreates source' do
-      expect(expectation.source).to eql(<<-RUBY)
-      foo bar
-      baz
-      RUBY
-    end
-  end
-end

data/spec/project/changelog_spec.rb

@@ -1,81 +0,0 @@
-describe 'CHANGELOG.md' do
-  subject(:changelog) { SpecHelper::ROOT.join('CHANGELOG.md').read }
-
-  it 'has link definitions for all implicit links' do
-    implicit_link_names = changelog.scan(/\[([^\]]+)\]\[\]/).flatten.uniq
-    implicit_link_names.each do |name|
-      expect(changelog).to include("[#{name}]: http")
-    end
-  end
-
-  describe 'entry' do
-    subject(:entries) { lines.grep(/^\*/).map(&:chomp) }
-    let(:lines) { changelog.each_line }
-
-    it 'has a whitespace between the * and the body' do
-      entries.each do |entry|
-        expect(entry).to match(/^\* \S/)
-      end
-    end
-
-    it 'has a link to the contributors at the end' do
-      entries.each do |entry|
-        expect(entry).to match(/\(\[@\S+\]\[\](?:, \[@\S+\]\[\])*\)$/)
-      end
-    end
-
-    describe 'link to related issue on github' do
-      let(:issues) do
-        entries.map do |entry|
-          entry.match(/\[(?<number>[#\d]+)\]\((?<url>[^\)]+)\)/)
-        end.compact
-      end
-
-      it 'has an issue number prefixed with #' do
-        issues.each do |issue|
-          expect(issue[:number]).to match(/^#\d+$/)
-        end
-      end
-
-      it 'has a valid URL' do
-        issues.each do |issue|
-          number = issue[:number].gsub(/\D/, '')
-          pattern = %r{^https://github\.com/.+/.+/(?:issues|pull)/#{number}$} # rubocop:disable LineLength
-          expect(issue[:url]).to match(pattern)
-        end
-      end
-
-      it 'has a colon and a whitespace at the end' do
-        entries_including_issue_link = entries.select do |entry|
-          entry.match(/^\*\s*\[/)
-        end
-
-        entries_including_issue_link.each do |entry|
-          expect(entry).to include('): ')
-        end
-      end
-    end
-
-    describe 'body' do
-      let(:bodies) do
-        entries.map do |entry|
-          entry
-            .sub(/^\*\s*(?:\[.+?\):\s*)?/, '')
-            .sub(/\s*\([^\)]+\)$/, '')
-        end
-      end
-
-      it 'does not start with a lower case' do
-        bodies.each do |body|
-          expect(body).not_to match(/^[a-z]/)
-        end
-      end
-
-      it 'ends with a punctuation' do
-        bodies.each do |body|
-          expect(body).to match(/[\.\!]$/)
-        end
-      end
-    end
-  end
-end

data/spec/project/default_config_spec.rb

@@ -1,52 +0,0 @@
-describe 'config/default.yml' do
-  subject(:default_config) do
-    RuboCop::ConfigLoader.load_file('config/default.yml')
-  end
-
-  let(:cop_names) do
-    glob = SpecHelper::ROOT.join('lib', 'rubocop', 'cop', 'rspec', '*.rb')
-
-    Pathname.glob(glob).map do |file|
-      file_name = file.basename('.rb').to_s
-      cop_name  = file_name.gsub(/(^|_)(.)/) { Regexp.last_match(2).upcase }
-
-      "RSpec/#{cop_name}"
-    end
-  end
-
-  let(:config_keys) do
-    cop_names + %w(AllCops)
-  end
-
-  def cop_configuration(config_key)
-    cop_names.map do |cop_name|
-      cop_config = default_config.fetch(cop_name)
-
-      cop_config.fetch(config_key) do
-        raise "Expected #{cop_name} to have #{config_key} configuration key"
-      end
-    end
-  end
-
-  it 'has configuration for all cops' do
-    expect(default_config.keys.sort).to eq(config_keys.sort)
-  end
-
-  it 'has descriptions for all cops' do
-    expect(cop_configuration('Description')).to all(be_a(String))
-  end
-
-  it 'does not have newlines in cop descriptions' do
-    cop_configuration('Description').each do |value|
-      expect(value).not_to include("\n")
-    end
-  end
-
-  it 'ends every description with a period' do
-    expect(cop_configuration('Description')).to all(end_with('.'))
-  end
-
-  it 'includes Enabled: true for every cop' do
-    expect(cop_configuration('Enabled')).to all(be(true))
-  end
-end

data/spec/project/project_requires_spec.rb

@@ -1,8 +0,0 @@
-describe 'Project requires' do
-  it 'alphabetizes cop requires' do
-    source   = SpecHelper::ROOT.join('lib', 'rubocop-rspec.rb').read
-    requires = source.split("\n").grep(%r{rubocop/cop})
-
-    expect(requires.join("\n")).to eql(requires.sort.join("\n"))
-  end
-end

data/spec/rubocop/cop/rspec/any_instance_spec.rb

@@ -1,30 +0,0 @@
-describe RuboCop::Cop::RSpec::AnyInstance do
-  subject(:cop) { described_class.new }
-
-  it 'finds `allow_any_instance_of` instead of an instance double' do
-    expect_violation(<<-RUBY)
-      before do
-        allow_any_instance_of(Object).to receive(:foo)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `allow_any_instance_of`
-      end
-    RUBY
-  end
-
-  it 'finds `expect_any_instance_of` instead of an instance double' do
-    expect_violation(<<-RUBY)
-      before do
-        expect_any_instance_of(Object).to receive(:foo)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `expect_any_instance_of`
-      end
-    RUBY
-  end
-
-  it 'finds old `any_instance` syntax instead of an instance double' do
-    expect_violation(<<-RUBY)
-      before do
-        Object.any_instance.should_receive(:foo)
-        ^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `any_instance`
-      end
-    RUBY
-  end
-end

data/spec/rubocop/cop/rspec/be_eql_spec.rb

@@ -1,59 +0,0 @@
-describe RuboCop::Cop::RSpec::BeEql do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for `eql` when argument is a boolean' do
-    expect_violation(<<-RUBY)
-      it { expect(foo).to eql(true) }
-                          ^^^ Prefer `be` over `eql`
-      it { expect(foo).to eql(false) }
-                          ^^^ Prefer `be` over `eql`
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is an integer' do
-    expect_violation(<<-RUBY)
-      it { expect(foo).to eql(0) }
-                          ^^^ Prefer `be` over `eql`
-      it { expect(foo).to eql(123) }
-                          ^^^ Prefer `be` over `eql`
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is a float' do
-    expect_violation(<<-RUBY)
-      it { expect(foo).to eql(1.0) }
-                          ^^^ Prefer `be` over `eql`
-      it { expect(foo).to eql(1.23) }
-                          ^^^ Prefer `be` over `eql`
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is a symbol' do
-    expect_violation(<<-RUBY)
-      it { expect(foo).to eql(:foo) }
-                          ^^^ Prefer `be` over `eql`
-    RUBY
-  end
-
-  it 'does not register an offense for `eql` when argument is a string' do
-    expect_no_violations(<<-RUBY)
-      it { expect(foo).to eql('foo') }
-    RUBY
-  end
-
-  it 'does not register an offense for `eql` when expectation is negated' do
-    expect_no_violations(<<-RUBY)
-      it { expect(foo).to_not eql(1) }
-    RUBY
-  end
-
-  it 'autocorrects offense to use `be`' do
-    corrected =
-      autocorrect_source(
-        cop,
-        ['it { expect(foo).to eql(1) }'],
-        'spec/foo_spec.rb'
-      )
-    expect(corrected).to eq 'it { expect(foo).to be(1) }'
-  end
-end

data/spec/rubocop/cop/rspec/describe_class_spec.rb

@@ -1,113 +0,0 @@
-describe RuboCop::Cop::RSpec::DescribeClass do
-  subject(:cop) { described_class.new }
-
-  it 'checks first-line describe statements' do
-    expect_violation(<<-RUBY)
-      describe "bad describe" do
-               ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
-
-  it 'supports RSpec.describe' do
-    expect_no_violations(<<-RUBY)
-      RSpec.describe Foo do
-      end
-    RUBY
-  end
-
-  it 'checks describe statements after a require' do
-    expect_violation(<<-RUBY)
-      require 'spec_helper'
-      describe "bad describe" do
-               ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
-
-  it 'checks highlights the first argument of a describe' do
-    expect_violation(<<-RUBY)
-      describe "bad describe", "blah blah" do
-               ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
-
-  it 'ignores nested describe statements' do
-    expect_no_violations(<<-RUBY)
-      describe Some::Class do
-        describe "bad describe" do
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores request specs' do
-    expect_no_violations(<<-RUBY)
-      describe 'my new feature', type: :request do
-      end
-    RUBY
-  end
-
-  it 'ignores feature specs' do
-    expect_no_violations(<<-RUBY)
-      describe 'my new feature', type: :feature do
-      end
-    RUBY
-  end
-
-  it 'ignores feature specs when RSpec.describe is used' do
-    expect_no_violations(<<-RUBY)
-      RSpec.describe 'my new feature', type: :feature do
-      end
-    RUBY
-  end
-
-  it 'flags specs with non :type metadata' do
-    expect_violation(<<-RUBY)
-      describe 'my new feature', foo: :feature do
-               ^^^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
-
-  it 'flags normal metadata in describe' do
-    expect_violation(<<-RUBY)
-      describe 'my new feature', blah, type: :wow do
-               ^^^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
-
-  it 'ignores feature specs - also with complex options' do
-    expect_no_violations(<<-RUBY)
-      describe 'my new feature', :test, :type => :feature, :foo => :bar do
-      end
-    RUBY
-  end
-
-  it 'ignores an empty describe' do
-    expect_no_violations(<<-RUBY)
-      describe do
-      end
-    RUBY
-  end
-
-  it 'ignores routing specs' do
-    expect_no_violations(<<-RUBY)
-      describe 'my new route', type: :routing do
-      end
-    RUBY
-  end
-
-  it 'ignores view specs' do
-    expect_no_violations(<<-RUBY)
-      describe 'widgets/index', type: :view do
-      end
-    RUBY
-  end
-
-  it "doesn't blow up on single-line describes" do
-    expect_no_violations('describe Some::Class')
-  end
-end

data/spec/rubocop/cop/rspec/describe_method_spec.rb

@@ -1,32 +0,0 @@
-describe RuboCop::Cop::RSpec::DescribeMethod do
-  subject(:cop) { described_class.new }
-
-  it 'ignores describes with only a class' do
-    expect_no_violations('describe Some::Class do; end')
-  end
-
-  it 'enforces non-method names' do
-    expect_violation(<<-RUBY)
-      describe Some::Class, 'nope', '.incorrect_usage' do
-                            ^^^^^^ The second argument to describe should be the method being tested. '#instance' or '.class'
-      end
-    RUBY
-  end
-
-  it 'skips methods starting with a . or #' do
-    expect_no_violations(<<-RUBY)
-      describe Some::Class, '.asdf' do
-      end
-
-      describe Some::Class, '#fdsa' do
-      end
-    RUBY
-  end
-
-  it 'skips specs not having a string second argument' do
-    expect_no_violations(<<-RUBY)
-      describe Some::Class, :config do
-      end
-    RUBY
-  end
-end