cuke_linter 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef55f6c2d957526d16d14a9f9624fe5ea7638ba0f1b7ea2ea52244fe9805e60b
-  data.tar.gz: df6e881179035f9edb0f3c7b50a2826ff302049c2926399cee1e1570c0bcfad2
+  metadata.gz: 064456ffb63c27969a361497f8c1d6c9f9b96f5a59f488506db5611faa695f0f
+  data.tar.gz: b31161d84e3bda65527caa854bdcfcb2e1bdaca8a0f94b4dc540d00274d54bdf
 SHA512:
-  metadata.gz: a62718d8b395cddf100152b9a6c6b63cc0c4349c2715fc0261ef985000047853753835ff7d341894ad0ce6eef37b032885c75a3a569b2afaf62a2b33809b9a99
-  data.tar.gz: 9b239647d5f4f45c7454f0cfbe9c31777b8fe56064c7f99b3cab9ac237551dccc71404afa1cc4e462c10295220f1c3bfd6de7cc60d88e71da7961a13fced62c9
+  metadata.gz: b83fad28c5cd56da418697695f4333659f8cd16f750e4be51cd796e62a979c125413aa7b9d443ef56a832e1585b7247e9eb07512acb62e9071a074ed3593e079
+  data.tar.gz: 414f730e30415505687acc8abc8a197ba7d49e1bdb6ff9337d079d4450e928cb88d3582f85124b047bd554d13a0f2cf6fbb13f6c43e6a58db26b8ffb41e36d8a

data/.travis.yml

@@ -3,6 +3,9 @@ os:
   - osx
 sudo: false
 
+# JRuby isn't working on the new default distribution
+dist: trusty
+
 language: ruby
 rvm:
   - 2.3.3

data/CHANGELOG.md

@@ -8,6 +8,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [0.9.0] - 2019-09-11
+
+### Added
+ - Linters can now be temporarily enabled/disabled within arbitrary portions of a feature file, in order to allow for exceptions to the otherwise blanket set of linting rules. 
+
 ## [0.8.0] - 2019-09-07
 
 ### Changed
@@ -85,7 +90,8 @@ Nothing yet...
 - Custom linters, formatters, and command line usability
 
 
-[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/enkessler/cuke_linter/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/enkessler/cuke_linter/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/enkessler/cuke_linter/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/enkessler/cuke_linter/compare/v0.5.0...v0.6.0

data/lib/cuke_linter.rb

@@ -115,7 +115,8 @@ module CukeLinter
 
     model_sets.each do |model_tree|
       model_tree.each_model do |model|
-        linters.each do |linter|
+        applicable_linters = relevant_linters_for_model(linters, model)
+        applicable_linters.each do |linter|
           # TODO: have linters lint only certain types of models
           #         linting_data.concat(linter.lint(model)) if relevant_model?(linter, model)
 
@@ -147,6 +148,75 @@ module CukeLinter
   end
 
 
+  def self.relevant_linters_for_model(base_linters, model)
+    feature_file_model = model.get_ancestor(:feature_file)
+
+    # Linter directives are not applicable for directory and feature file models. Every other model type should have a feature file ancestor from which to grab linter directive comments.
+    return base_linters if feature_file_model.nil?
+
+    linter_modifications_for_model = {}
+
+    linter_directives_for_feature_file(feature_file_model).each do |directive|
+      # Assuming that the directives are in the same order that they appear in the file
+      break if directive[:source_line] > model.source_line
+
+      linter_modifications_for_model[directive[:linter_class]] = directive[:enabled_status]
+    end
+
+    disabled_linter_classes = linter_modifications_for_model.reject { |_name, status| status }.keys
+    enabled_linter_classes  = linter_modifications_for_model.select { |_name, status| status }.keys
+
+    final_linters = base_linters.reject { |linter| disabled_linter_classes.include?(linter.class) }
+    enabled_linter_classes.each do |clazz|
+      final_linters << dynamic_linters[clazz] unless final_linters.map(&:class).include?(clazz)
+    end
+
+    final_linters
+  end
+
+  private_class_method(:relevant_linters_for_model)
+
+
+  def self.linter_directives_for_feature_file(feature_file_model)
+    # IMPORTANT ASSUMPTION: Models never change during the life of the program, so data only has to be gathered once
+    @directives_for_feature_file ||= {}
+    return @directives_for_feature_file[feature_file_model.object_id] if @directives_for_feature_file[feature_file_model.object_id]
+
+
+    @directives_for_feature_file[feature_file_model.object_id] = []
+
+    feature_file_model.comments.each do |comment|
+      pieces = comment.text.match(/#\s*cuke_linter:(disable|enable)\s+(.*)/)
+      next unless pieces # Skipping non-directive file comments
+
+      linter_classes = pieces[2].gsub(',', ' ').split(' ')
+      linter_classes.each do |clazz|
+        @directives_for_feature_file[feature_file_model.object_id] << { linter_class:   Kernel.const_get(clazz),
+                                                                        enabled_status: pieces[1] != 'disable',
+                                                                        source_line:    comment.source_line }
+      end
+    end
+
+    # Make sure that the directives are in the same order as they appear in the source file
+    @directives_for_feature_file[feature_file_model.object_id] = @directives_for_feature_file[feature_file_model.object_id].sort { |a, b| a[:source_line] <=> b[:source_line] }
+
+
+    @directives_for_feature_file[feature_file_model.object_id]
+  end
+
+  private_class_method(:linter_directives_for_feature_file)
+
+  def self.dynamic_linters
+    # No need to keep making new ones over and over...
+    @dynamic_linters ||= Hash.new { |hash, key| hash[key] = key.new }
+    # return @dynamic_linters if @dynamic_linters
+    #
+    # @dynamic_linters = {}
+  end
+
+  private_class_method(:dynamic_linters)
+
+
 # #   def self.relevant_model?(linter, model)
 # #     model_classes = linter.class.target_model_types.map { |type| CukeModeler.const_get(type.to_s.capitalize.chop) }
 # #     model_classes.any? { |clazz| model.is_a?(clazz) }

data/lib/cuke_linter/version.rb

@@ -1,4 +1,4 @@
 module CukeLinter
   # The release version of this gem
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/testing/cucumber/features/configuration/locally_scoping_linters.feature

@@ -0,0 +1,50 @@
+Feature: Locally scoping linters
+
+  As a writer of documentation
+  I want to be able to limit the scope of linters for certain portions of the documentation
+  So that exceptions to rules can be made
+
+  In addition to using configurations to change whether or not a given linter is used when linting, linters can be enabled/disabled for specific portions of a `.feature` file. To enable/disable one (or more) linters, add a comment line before the portion of the file where the change should apply. Add a comment with the opposite change at the point in the file when the default behavior should resume. Unless so countermanded, changes remain in effect for the remainder of the feature file.
+
+
+  Scenario: Enabling/disabling a linter within a feature file
+
+  Note: This example disables linters that are enabled by default but enabling a linter that is disabled by default works in the same manner
+
+    Given the default linters are being used
+    And a feature file model based on the following text:
+      """
+      # The comma is optional when listing linters. The following two lines are equivalent (although the second line is redundant in this case).
+      # cuke_linter:disable CukeLinter::TestWithNoNameLinter, CukeLinter::FeatureWithoutDescriptionLinter
+      # cuke_linter:disable CukeLinter::TestWithNoNameLinter CukeLinter::FeatureWithoutDescriptionLinter
+
+      Feature: Feature with no description
+
+        # cuke_linter:disable CukeLinter::ElementWithTooManyTagsLinter
+        @tag_1 @tag_2 @tag_3 @tag_4 @tag_5 @tag_one_too_many
+        Scenario:
+          This scenario has no name and too many tags
+
+          Given a step
+          When a step
+          Then a step
+        # cuke_linter:enable CukeLinter::ElementWithTooManyTagsLinter
+
+        @tag_1 @tag_2 @tag_3 @tag_4 @tag_5 @tag_one_too_many
+        Scenario:
+          This scenario also has no name and too many tags
+
+          Given a step
+          When a step
+          Then a step
+      """
+    When the feature is linted
+    Then the following problems are reported:
+      | linter                       | problem                                           | location          |
+      | ElementWithTooManyTagsLinter | Scenario has too many tags. 6 tags found (max 5). | <path_to_file>:18 |
+    And the following problems are not reported:
+      | linter                          | problem                                           | location          |
+      | FeatureWithoutDescriptionLinter | Feature has no description                        | <path_to_file>:5  |
+      | TestWithNoNameLinter            | Test does not have a name.                        | <path_to_file>:9  |
+      | TestWithNoNameLinter            | Test does not have a name.                        | <path_to_file>:18 |
+      | ElementWithTooManyTagsLinter    | Scenario has too many tags. 6 tags found (max 5). | <path_to_file>:9  |

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -148,3 +148,16 @@ Given(/^the following(?: feature)? file "([^"]*)":$/) do |file_path, text|
   @created_files ||= []
   @created_files << CukeLinter::FileHelper.create_file(directory: @root_test_directory, name: path, extension: ".#{extension}", text: text)
 end
+
+Given(/^the default linters are being used$/) do
+  CukeLinter.reset_linters
+end
+
+And(/^a feature file model based on the following text:$/) do |text|
+  file_path = CukeLinter::FileHelper.create_file(directory: @root_test_directory, extension: '.feature', text: text)
+
+  @created_files ||= []
+  @created_files << file_path
+
+  @model = CukeModeler::FeatureFile.new(file_path)
+end

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -22,6 +22,24 @@ Then(/^an error is reported:$/) do |table|
   end
 end
 
+Then(/^the following problems are( not)? reported:$/) do |exclude, table|
+  assertion_method = exclude ? :to_not : :to
+
+  if @model.is_a?(CukeModeler::FeatureFile)
+    feature_file_model = @model
+    source_line        = ''
+  else
+    feature_file_model = @model.get_ancestor(:feature_file)
+    source_line        = @model.source_line.to_s
+  end
+
+  table.hashes.each do |error_record|
+    expect(@results).send(assertion_method, include({ linter:   error_record['linter'],
+                                                      problem:  error_record['problem'],
+                                                      location: error_record['location'].sub('<path_to_file>', feature_file_model.path).sub('<model_line_number>', source_line) }))
+  end
+end
+
 Then(/^the following linters are registered(?: by default)?$/) do |linter_names|
   expect(CukeLinter.registered_linters.keys).to match_array(linter_names.raw.flatten)
 end

data/testing/linter_factory.rb

@@ -28,5 +28,33 @@ module CukeLinter
       linter
     end
 
+    def self.generate_fake_linter_class(module_name: nil, class_name: 'FakeLinter', name: 'Some Name', finds_problems: true)
+
+      if module_name
+        parent_module = Kernel.const_defined?(module_name) ? Kernel.const_get(module_name) : Kernel.const_set(module_name, Module.new)
+      end
+
+      (parent_module || Kernel).const_set(class_name, Class.new do
+
+        define_method('lint') do |model|
+          location = model.respond_to?(:source_line) ? "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" : model.path
+          problem  = @problem || "#{name} problem"
+
+          if finds_problems
+            { problem:  problem,
+              location: location }
+          else
+            nil
+          end
+        end
+
+        define_method('name') do
+          name
+        end
+
+      end)
+
+    end
+
   end
 end

data/testing/rspec/spec/integration/configuration_spec.rb

@@ -4,115 +4,806 @@ RSpec.describe CukeLinter do
 
   describe 'configuration' do
 
-    let(:test_model_tree) { CukeLinter::ModelFactory.generate_lintable_model }
-    let(:test_linters) { [CukeLinter::LinterFactory.generate_fake_linter] }
-    let(:test_formatters) { [[CukeLinter::FormatterFactory.generate_fake_formatter, "#{CukeLinter::FileHelper::create_directory}/junk_output_file.txt"]] }
-    let(:linting_options) { { model_trees: [test_model_tree], linters: test_linters, formatters: test_formatters } }
+    describe 'blanket linters' do
 
+      let(:test_model_tree) { CukeLinter::ModelFactory.generate_lintable_model }
+      let(:test_linters) { [CukeLinter::LinterFactory.generate_fake_linter] }
+      let(:test_formatters) { [[CukeLinter::FormatterFactory.generate_fake_formatter, "#{CukeLinter::FileHelper::create_directory}/junk_output_file.txt"]] }
+      let(:linting_options) { { model_trees: [test_model_tree], linters: test_linters, formatters: test_formatters } }
 
-    it 'unregisters disabled linters' do
-      config             = { 'FakeLinter1' => { 'Enabled' => false } }
-      configuration_file = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
 
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
-      expect(subject.registered_linters['FakeLinter1']).to_not be nil
+      it 'unregisters disabled linters' do
+        config             = { 'FakeLinter1' => { 'Enabled' => false } }
+        configuration_file = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
 
-      subject.load_configuration(config_file_path: configuration_file)
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
+        expect(subject.registered_linters['FakeLinter1']).to_not be nil
 
-      expect(subject.registered_linters['FakeLinter1']).to be nil
-    end
+        subject.load_configuration(config_file_path: configuration_file)
 
-    it 'can apply a property to all linters' do
-      configuration = { 'AllLinters' => { 'Enabled' => false } }
+        expect(subject.registered_linters['FakeLinter1']).to be nil
+      end
 
-      # Restore the default linters
-      CukeLinter.reset_linters
+      it 'can apply a property to all linters' do
+        configuration = { 'AllLinters' => { 'Enabled' => false } }
 
-      # Also add some custom ones
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter, name: 'Foo')
+        # Restore the default linters
+        CukeLinter.reset_linters
 
+        # Also add some custom ones
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter, name: 'Foo')
 
-      subject.load_configuration(config: configuration)
 
-      expect(subject.registered_linters).to be_empty
-    end
+        subject.load_configuration(config: configuration)
 
-    it 'uses linter specific properties over general properties' do
-      configuration = { 'AllLinters'  => { 'Enabled' => false },
-                        'FakeLinter1' => { 'Enabled' => true } }
+        expect(subject.registered_linters).to be_empty
+      end
 
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter, name: 'FakeLinter1')
-      expect(subject.registered_linters['FakeLinter1']).to_not be nil
+      it 'uses linter specific properties over general properties' do
+        configuration = { 'AllLinters'  => { 'Enabled' => false },
+                          'FakeLinter1' => { 'Enabled' => true } }
 
-      subject.load_configuration(config: configuration)
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter, name: 'FakeLinter1')
+        expect(subject.registered_linters['FakeLinter1']).to_not be nil
 
-      expect(subject.registered_linters['FakeLinter1']).to_not be nil
-    end
+        subject.load_configuration(config: configuration)
 
-    it 'even unregisters non-configurable disabled linters' do
-      config                  = { 'FakeLinter' => { 'Enabled' => false } }
-      configuration_file      = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
-      non_configurable_linter = CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter')
-      non_configurable_linter.instance_eval('undef :configure')
+        expect(subject.registered_linters['FakeLinter1']).to_not be nil
+      end
 
-      CukeLinter.register_linter(linter: non_configurable_linter, name: 'FakeLinter')
-      expect(subject.registered_linters['FakeLinter']).to_not be nil
+      it 'even unregisters non-configurable disabled linters' do
+        config                  = { 'FakeLinter' => { 'Enabled' => false } }
+        configuration_file      = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
+        non_configurable_linter = CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter')
+        non_configurable_linter.instance_eval('undef :configure')
 
-      subject.load_configuration(config_file_path: configuration_file)
+        CukeLinter.register_linter(linter: non_configurable_linter, name: 'FakeLinter')
+        expect(subject.registered_linters['FakeLinter']).to_not be nil
 
-      expect(subject.registered_linters['FakeLinter']).to be nil
-    end
+        subject.load_configuration(config_file_path: configuration_file)
 
-    it 'uses the default configuration file in the current directory if no configuration file is provided' do
-      config             = { 'FakeLinter1' => { 'Enabled' => false } }
-      configuration_file = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
+        expect(subject.registered_linters['FakeLinter']).to be nil
+      end
 
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
-      expect(subject.registered_linters['FakeLinter1']).to_not be nil
+      it 'uses the default configuration file in the current directory if no configuration file is provided' do
+        config             = { 'FakeLinter1' => { 'Enabled' => false } }
+        configuration_file = CukeLinter::FileHelper.create_file(name: '.cuke_linter', extension: '', text: config.to_yaml)
 
-      Dir.chdir(File.dirname(configuration_file)) do
-        subject.load_configuration
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
+        expect(subject.registered_linters['FakeLinter1']).to_not be nil
+
+        Dir.chdir(File.dirname(configuration_file)) do
+          subject.load_configuration
+        end
+
+        expect(subject.registered_linters['FakeLinter1']).to be nil
       end
 
-      expect(subject.registered_linters['FakeLinter1']).to be nil
-    end
+      it 'raises an exception if no default configuration file is found and no configuration or file is provided' do
+        some_empty_directory = CukeLinter::FileHelper.create_directory
+
+        Dir.chdir(File.dirname(some_empty_directory)) do
+          expect { subject.load_configuration }.to raise_error('No configuration or configuration file given and no .cuke_linter file found')
+        end
+      end
+
+      it 'configures every linter for which it has a configuration' do
+        config = { 'FakeLinter1' => { 'Problem' => 'My custom message for FakeLinter1' },
+                   'FakeLinter2' => { 'Problem' => 'My custom message for FakeLinter2' } }
+
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
+        CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter2'), name: 'FakeLinter2')
+        linting_options.delete(:linters)
 
-    it 'raises an exception if no default configuration file is found and no configuration or file is provided' do
-      some_empty_directory = CukeLinter::FileHelper.create_directory
+        subject.load_configuration(config: config)
+        results = subject.lint(linting_options)
 
-      Dir.chdir(File.dirname(some_empty_directory)) do
-        expect { subject.load_configuration }.to raise_error('No configuration or configuration file given and no .cuke_linter file found')
+        expect(results).to match_array([{ linter: 'FakeLinter1', location: 'path_to_file:1', problem: 'My custom message for FakeLinter1' },
+                                        { linter: 'FakeLinter2', location: 'path_to_file:1', problem: 'My custom message for FakeLinter2' }])
       end
-    end
 
-    it 'configures every linter for which it has a configuration' do
-      config = { 'FakeLinter1' => { 'Problem' => 'My custom message for FakeLinter1' },
-                 'FakeLinter2' => { 'Problem' => 'My custom message for FakeLinter2' } }
+      it "does not try to configure linters that don't know how to be configured" do
+        config                  = { 'FakeLinter' => { 'Problem' => 'My custom message for FakeLinter' } }
+        non_configurable_linter = CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter')
+        non_configurable_linter.instance_eval('undef :configure')
+
+        CukeLinter.clear_registered_linters
+        CukeLinter.register_linter(linter: non_configurable_linter, name: 'FakeLinter')
+        linting_options.delete(:linters)
 
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'), name: 'FakeLinter1')
-      CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter2'), name: 'FakeLinter2')
-      linting_options.delete(:linters)
+        subject.load_configuration(config: config)
+        results = subject.lint(linting_options)
 
-      subject.load_configuration(config: config)
-      results = subject.lint(linting_options)
+        expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:1', problem: 'FakeLinter problem' }])
+      end
 
-      expect(results).to match_array([{ linter: 'FakeLinter1', location: 'path_to_file:1', problem: 'My custom message for FakeLinter1' },
-                                      { linter: 'FakeLinter2', location: 'path_to_file:1', problem: 'My custom message for FakeLinter2' }])
     end
 
-    it "does not try to configure linters that don't know how to be configured" do
-      config                  = { 'FakeLinter' => { 'Problem' => 'My custom message for FakeLinter' } }
-      non_configurable_linter = CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter')
-      non_configurable_linter.instance_eval('undef :configure')
+    describe 'targeted linters' do
+
+      before(:all) do
+        @targeted_linter_class             = CukeLinter::LinterFactory.generate_fake_linter_class(class_name: 'ATargetedLinterClass', name: 'ATargetedLinter')
+        @another_targeted_linter_class     = CukeLinter::LinterFactory.generate_fake_linter_class(class_name: 'AnotherTargetedLinterClass', name: 'AnotherTargetedLinter')
+        @yet_another_targeted_linter_class = CukeLinter::LinterFactory.generate_fake_linter_class(class_name: 'YetAnotherTargetedLinterClass', name: 'YetAnotherTargetedLinter')
+
+        @a_non_nested_targeted_linter_class       = CukeLinter::LinterFactory.generate_fake_linter_class(module_name: nil, class_name: 'ANonNestedTargetedLinterClass', name: 'ANonNestedTargetedLinter')
+        @another_non_nested_targeted_linter_class = CukeLinter::LinterFactory.generate_fake_linter_class(module_name: nil, class_name: 'AnotherNonNestedTargetedLinterClass', name: 'AnotherNonNestedTargetedLinter')
+
+        @a_nested_targeted_linter_class       = CukeLinter::LinterFactory.generate_fake_linter_class(module_name: 'Foo', class_name: 'ANestedTargetedLinterClass', name: 'ANestedTargetedLinter')
+        @another_nested_targeted_linter_class = CukeLinter::LinterFactory.generate_fake_linter_class(module_name: 'Foo', class_name: 'AnotherNestedTargetedLinterClass', name: 'AnotherNestedTargetedLinter')
+      end
+
+
+      let(:linter_name) { 'ATargetedLinter' }
+      let(:another_linter_name) { 'AnotherTargetedLinter' }
+      let(:yet_another_linter_name) { 'YetAnotherTargetedLinter' }
+
+      let(:non_nested_linter_name) { 'ANonNestedTargetedLinter' }
+      let(:another_non_nested_linter_name) { 'AnotherNonNestedTargetedLinter' }
+      let(:nested_linter_name) { 'ANestedTargetedLinter' }
+      let(:another_nested_linter_name) { 'AnotherNestedTargetedLinter' }
+
+      let(:linter_class_name) { 'ATargetedLinterClass' }
+      let(:another_linter_class_name) { 'AnotherTargetedLinterClass' }
+      let(:yet_another_linter_class_name) { 'YetAnotherTargetedLinterClass' }
+      let(:non_nested_linter_class_name) { 'ANonNestedTargetedLinterClass' }
+      let(:another_non_nested_linter_class_name) { 'AnotherNonNestedTargetedLinterClass' }
+      let(:nested_linter_class_name) { 'Foo::ANestedTargetedLinterClass' }
+      let(:another_nested_linter_class_name) { 'Foo::AnotherNestedTargetedLinterClass' }
+
+      let(:targeted_linter) { @targeted_linter_class.new }
+      let(:another_targeted_linter) { @another_targeted_linter_class.new }
+      let(:yet_another_targeted_linter) { @yet_another_targeted_linter_class.new }
+      let(:non_nested_targeted_linter) { @a_non_nested_targeted_linter_class.new }
+      let(:nested_targeted_linter) { @a_nested_targeted_linter_class.new }
+
+      let(:test_linters) { [targeted_linter] }
+      let(:test_linter_names) { [linter_name] }
+      let(:test_formatters) { [[CukeLinter::FormatterFactory.generate_fake_formatter, "#{CukeLinter::FileHelper::create_directory}/junk_output_file.txt"]] }
+      let(:test_model_trees) { [CukeModeler::FeatureFile.new(linted_file)] }
+
+      let(:test_directory) { CukeLinter::FileHelper.create_directory }
+      let(:linted_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                             extension: '.feature',
+                                                             text:      file_text) }
+
+
+      [:provided, :registered].each do |linter_type|
+
+        context "using #{linter_type} linters" do
+
+          if linter_type == :provided
+            let(:linting_options) { { model_trees: test_model_trees, linters: test_linters, formatters: test_formatters } }
+          else
+            let(:linting_options) { { model_trees: test_model_trees, formatters: test_formatters } }
+
+            before(:each) do
+              subject.clear_registered_linters
+
+              test_linters.each_with_index { |linter, index| subject.register_linter(linter: linter, name: test_linter_names[index]) }
+            end
+          end
+
+
+          context 'with non-nested class names' do
+
+            let(:test_linters) { [non_nested_targeted_linter] }
+            let(:test_linter_names) { [non_nested_linter_name] }
+
+            let(:file_text) { "Feature:
+
+                                 # cuke_linter:disable #{non_nested_linter_class_name}
+                                 # cuke_linter:enable #{another_non_nested_linter_class_name}
+                                 Scenario:" }
+
+
+            it 'handles the directives correctly' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: non_nested_linter_name, location: linted_file, problem: "#{non_nested_linter_name} problem" },
+                                              { linter: non_nested_linter_name, location: "#{linted_file}:1", problem: "#{non_nested_linter_name} problem" },
+                                              { linter: another_non_nested_linter_name, location: "#{linted_file}:5", problem: "#{another_non_nested_linter_name} problem" }])
+            end
+
+          end
+
+          context 'with nested class names' do
+
+            let(:test_linters) { [nested_targeted_linter] }
+            let(:test_linter_names) { [nested_linter_name] }
+
+            let(:file_text) { "Feature:
+
+                                 # cuke_linter:disable #{nested_linter_class_name}
+                                 # cuke_linter:enable #{another_nested_linter_class_name}
+                                 Scenario:" }
+
+
+            it 'handles the directives correctly' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: nested_linter_name, location: linted_file, problem: "#{nested_linter_name} problem" },
+                                              { linter: nested_linter_name, location: "#{linted_file}:1", problem: "#{nested_linter_name} problem" },
+                                              { linter: another_nested_linter_name, location: "#{linted_file}:5", problem: "#{another_nested_linter_name} problem" }])
+            end
+
+          end
+
+          context 'with multiple linters in the directive' do
+
+            let(:commas_text) { "Feature:
+
+                                   # cuke_linter:disable #{linter_class_name}, #{another_linter_class_name}, #{yet_another_linter_class_name}
+                                   Scenario:" }
+            let(:commas_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                   extension: '.feature',
+                                                                   text:      commas_text,
+                                                                   name:      'commas_text') }
+
+            let(:spaces_text) { "Feature:
+
+                                   # cuke_linter:disable #{linter_class_name} #{another_linter_class_name} #{yet_another_linter_class_name}
+                                   Scenario:" }
+            let(:spaces_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                   extension: '.feature',
+                                                                   text:      spaces_text,
+                                                                   name:      'spaces_text') }
+
+            let(:test_model_trees) { [CukeModeler::FeatureFile.new(commas_file),
+                                      CukeModeler::FeatureFile.new(spaces_file)] }
+
+            let(:test_linters) { [targeted_linter, another_targeted_linter, yet_another_targeted_linter] }
+            let(:test_linter_names) { [linter_name, another_linter_name, yet_another_linter_name] }
+
+
+            it 'handles the directives correctly' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: linter_name, location: spaces_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{spaces_file}:1", problem: "#{linter_name} problem" },
+                                              { linter: another_linter_name, location: spaces_file, problem: "#{another_linter_name} problem" },
+                                              { linter: another_linter_name, location: "#{spaces_file}:1", problem: "#{another_linter_name} problem" },
+                                              { linter: yet_another_linter_name, location: spaces_file, problem: "#{yet_another_linter_name} problem" },
+                                              { linter: yet_another_linter_name, location: "#{spaces_file}:1", problem: "#{yet_another_linter_name} problem" },
+
+                                              { linter: linter_name, location: commas_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{commas_file}:1", problem: "#{linter_name} problem" },
+                                              { linter: another_linter_name, location: commas_file, problem: "#{another_linter_name} problem" },
+                                              { linter: another_linter_name, location: "#{commas_file}:1", problem: "#{another_linter_name} problem" },
+                                              { linter: yet_another_linter_name, location: commas_file, problem: "#{yet_another_linter_name} problem" },
+                                              { linter: yet_another_linter_name, location: "#{commas_file}:1", problem: "#{yet_another_linter_name} problem" }])
+            end
+
+          end
+
+          context 'with multiple files' do
+
+            let(:modified_text) { "Feature:
+
+                                     # cuke_linter:disable #{linter_class_name}
+                                     Scenario:" }
+            let(:modified_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                     extension: '.feature',
+                                                                     text:      modified_text) }
+            let(:unmodified_text) { "Feature:
+
+                                       Scenario:" }
+            let(:unmodified_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                       extension: '.feature',
+                                                                       text:      unmodified_text) }
+
+            let(:test_model_trees) { [CukeModeler::FeatureFile.new(modified_file),
+                                      CukeModeler::FeatureFile.new(unmodified_file)] }
+
+            it 'does not use targeted linting changes outside of the file in which they occur' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: linter_name, location: modified_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{modified_file}:1", problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: unmodified_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{unmodified_file}:1", problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{unmodified_file}:3", problem: "#{linter_name} problem" }])
+            end
+
+          end
+
+          context 'with other comments in the file' do
+
+            let(:file_text) { "# I'm just a comment
+                                   Feature:
+
+                                     # cuke_linter:disable #{linter_class_name}
+                                     #Me too
+                                     Scenario:" }
+
+
+            it 'handles the directive correctly' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{linted_file}:2", problem: "#{linter_name} problem" }])
+            end
+
+          end
+
+          context 'with varying whitespace' do
+
+            let(:extra_whitespace_text) { "Feature:
+
+                                             #      cuke_linter:disable       #{linter_class_name}
+                                             Scenario:" }
+            let(:extra_whitespace_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                             extension: '.feature',
+                                                                             text:      extra_whitespace_text) }
+            let(:minimal_whitespace_text) { "Feature:
+
+                                               #cuke_linter:disable #{linter_class_name}
+                                               Scenario:" }
+            let(:minimal_whitespace_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                               extension: '.feature',
+                                                                               text:      minimal_whitespace_text) }
+
+            let(:test_model_trees) { [CukeModeler::FeatureFile.new(extra_whitespace_file),
+                                      CukeModeler::FeatureFile.new(minimal_whitespace_file)] }
+
+
+            it 'handles the directives correctly' do
+              results = subject.lint(linting_options)
+
+              expect(results).to match_array([{ linter: linter_name, location: extra_whitespace_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{extra_whitespace_file}:1", problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: minimal_whitespace_file, problem: "#{linter_name} problem" },
+                                              { linter: linter_name, location: "#{minimal_whitespace_file}:1", problem: "#{linter_name} problem" }])
+            end
+
+
+            context 'and multiple targeted linters' do
+
+              let(:spaced_commas_text) { "Feature:
+
+                                            # cuke_linter:disable #{linter_class_name}    ,    #{another_linter_class_name} , #{yet_another_linter_class_name}
+                                            Scenario:" }
+              let(:spaced_commas_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                            extension: '.feature',
+                                                                            text:      spaced_commas_text,
+                                                                            name:      'spaced_commas_text') }
+
+              let(:compact_commas_text) { "Feature:
+
+                                             # cuke_linter:disable #{linter_class_name},#{another_linter_class_name},#{yet_another_linter_class_name}
+                                             Scenario:" }
+              let(:compact_commas_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                             extension: '.feature',
+                                                                             text:      compact_commas_text,
+                                                                             name:      'compact_commas_text') }
+
+              let(:spaced_space_text) { "Feature:
+
+                                           # cuke_linter:disable #{linter_class_name}        #{another_linter_class_name}  #{yet_another_linter_class_name}
+                                           Scenario:" }
+              let(:spaced_space_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                           extension: '.feature',
+                                                                           text:      spaced_space_text,
+                                                                           name:      'spaced_space_text') }
+
+              let(:compact_space_text) { "Feature:
+
+                                            # cuke_linter:disable #{linter_class_name} #{another_linter_class_name} #{yet_another_linter_class_name}
+                                            Scenario:" }
+              let(:compact_space_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
+                                                                            extension: '.feature',
+                                                                            text:      compact_space_text,
+                                                                            name:      'compact_space_text') }
+
+              let(:test_model_trees) { [CukeModeler::FeatureFile.new(spaced_commas_file),
+                                        CukeModeler::FeatureFile.new(compact_commas_file),
+                                        CukeModeler::FeatureFile.new(spaced_space_file),
+                                        CukeModeler::FeatureFile.new(compact_space_file)] }
+
+              let(:test_linters) { [targeted_linter, another_targeted_linter, yet_another_targeted_linter] }
+              let(:test_linter_names) { [linter_name, another_linter_name, yet_another_linter_name] }
+
+
+              it 'handles the directives correctly' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: linter_name, location: spaced_commas_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{spaced_commas_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: another_linter_name, location: spaced_commas_file, problem: "#{another_linter_name} problem" },
+                                                { linter: another_linter_name, location: "#{spaced_commas_file}:1", problem: "#{another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: spaced_commas_file, problem: "#{yet_another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: "#{spaced_commas_file}:1", problem: "#{yet_another_linter_name} problem" },
+
+                                                { linter: linter_name, location: compact_commas_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{compact_commas_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: another_linter_name, location: compact_commas_file, problem: "#{another_linter_name} problem" },
+                                                { linter: another_linter_name, location: "#{compact_commas_file}:1", problem: "#{another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: compact_commas_file, problem: "#{yet_another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: "#{compact_commas_file}:1", problem: "#{yet_another_linter_name} problem" },
+
+                                                { linter: linter_name, location: spaced_space_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{spaced_space_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: another_linter_name, location: spaced_space_file, problem: "#{another_linter_name} problem" },
+                                                { linter: another_linter_name, location: "#{spaced_space_file}:1", problem: "#{another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: spaced_space_file, problem: "#{yet_another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: "#{spaced_space_file}:1", problem: "#{yet_another_linter_name} problem" },
+
+                                                { linter: linter_name, location: compact_space_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{compact_space_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: another_linter_name, location: compact_space_file, problem: "#{another_linter_name} problem" },
+                                                { linter: another_linter_name, location: "#{compact_space_file}:1", problem: "#{another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: compact_space_file, problem: "#{yet_another_linter_name} problem" },
+                                                { linter: yet_another_linter_name, location: "#{compact_space_file}:1", problem: "#{yet_another_linter_name} problem" }])
+              end
+
+            end
+
+          end
+
+          context 'with a disabled(i.e. unregistered)/not provided linter' do
+
+            if linter_type == :provided
+              before(:each) do
+                test_linters.delete(targeted_linter)
+              end
+            else
+              before(:each) do
+                subject.unregister_linter(linter_name)
+              end
+            end
+
+
+            context 'that is explicitly disabled' do
+
+              # Used so that the linting process is not entirely bypassed due to no other linters being registered/provided
+              let(:baseline_linter_name) { 'BaselineLinter' }
+              let(:baseline_linter) { CukeLinter::LinterFactory.generate_fake_linter(name: baseline_linter_name) }
+
+              let(:test_linters) { [baseline_linter, targeted_linter] }
+              let(:test_linter_names) { [baseline_linter_name, linter_name] }
+
+
+              let(:file_text) { "Feature:
+
+                                   # cuke_linter:disable #{linter_class_name}
+                                   Scenario:" }
+
+              let(:baseline_linter_results) { [{ linter: baseline_linter_name, location: linted_file, problem: "#{baseline_linter_name} problem" },
+                                               { linter: baseline_linter_name, location: "#{linted_file}:1", problem: "#{baseline_linter_name} problem" },
+                                               { linter: baseline_linter_name, location: "#{linted_file}:4", problem: "#{baseline_linter_name} problem" }] }
 
-      CukeLinter.clear_registered_linters
-      CukeLinter.register_linter(linter: non_configurable_linter, name: 'FakeLinter')
-      linting_options.delete(:linters)
 
-      subject.load_configuration(config: config)
-      results = subject.lint(linting_options)
+              it 'does not use the linter' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array(baseline_linter_results + [])
+              end
+
+
+              context 'multiple times' do
+
+                context 'with separate targetings' do
+
+                  let(:file_text) { "Feature:
+                                       # cuke_linter:disable #{linter_class_name}
+                                       # cuke_linter:disable #{linter_class_name}
+                                       Scenario:" }
+
+
+                  it 'does not use the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array(baseline_linter_results + [])
+                  end
+
+                end
+
+                context 'with the same targeting' do
+
+                  let(:file_text) { "Feature:
+
+                                       # cuke_linter:disable #{linter_class_name}, #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'does not use the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array(baseline_linter_results + [])
+                  end
+
+                end
+
+              end
+
+            end
+
+            context 'that is explicitly enabled' do
+
+              let(:file_text) { "Feature:
+
+                                   # cuke_linter:enable #{linter_class_name}
+                                   Scenario:" }
+
+              it 'uses the linter' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+              end
+
+              context 'multiple times' do
+
+                context 'with separate targetings' do
+
+                  let(:file_text) { "Feature:
+                                       # cuke_linter:enable #{linter_class_name}
+                                       # cuke_linter:enable #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'uses the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                  it 'does not include redundant linting results' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                end
+
+                context 'with the same targeting' do
+
+                  let(:file_text) { "Feature:
+
+                                       # cuke_linter:enable #{linter_class_name}, #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'uses the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                  it 'does not include redundant linting results' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                end
+
+              end
+
+              context 'and then re-disabled' do
+
+                let(:file_text) { "Feature:
+
+                                     # cuke_linter:enable #{linter_class_name}
+                                     Scenario:
+                                     # cuke_linter:disable #{linter_class_name}
+                                     Scenario:" }
+
+                it 'ceases using the linter' do
+                  results = subject.lint(linting_options)
+
+                  expect(results).to match_array([{ linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                end
+
+              end
+
+            end
+
+          end
+
+          context 'with an enabled(i.e. registered)/provided linter' do
+
+            if linter_type == :provided
+              before(:each) do
+                test_linters << targeted_linter unless test_linters.include?(targeted_linter)
+              end
+            else
+              before(:each) do
+                subject.register_linter(linter: targeted_linter, name: linter_name)
+              end
+            end
+
+
+            context 'that is explicitly disabled' do
+
+              let(:file_text) { "Feature:
+
+                                   # cuke_linter:disable #{linter_class_name}
+                                   Scenario:" }
+
+
+              it 'does not use the linter' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" }])
+              end
+
+              context 'multiple times' do
+
+                context 'with separate targetings' do
+
+                  let(:file_text) { "Feature:
+                                       # cuke_linter:disable #{linter_class_name}
+                                       # cuke_linter:disable #{linter_class_name}
+                                       Scenario:" }
+
+
+                  it 'does not use the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" }])
+                  end
+
+                end
+
+                context 'with the same targeting' do
+
+                  let(:file_text) { "Feature:
+
+                                       # cuke_linter:disable #{linter_class_name}, #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'does not use the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" }])
+                  end
+                end
+
+              end
+
+              context 'and then re-enabled' do
+
+                let(:file_text) { "Feature:
+
+                                     # cuke_linter:disable #{linter_class_name}
+                                     Scenario:
+                                     # cuke_linter:enable #{linter_class_name}
+                                     Scenario:" }
+
+
+                it 'resumes using the linter' do
+                  results = subject.lint(linting_options)
+
+                  expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                  { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                  { linter: linter_name, location: "#{linted_file}:6", problem: "#{linter_name} problem" }])
+                end
+
+                it 'does not include redundant linting results' do
+                  results = subject.lint(linting_options)
+
+                  expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                  { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                  { linter: linter_name, location: "#{linted_file}:6", problem: "#{linter_name} problem" }])
+                end
+
+              end
+
+            end
+
+            context 'that is explicitly enabled' do
+
+              let(:file_text) { "Feature:
+
+                                   # cuke_linter:enable #{linter_class_name}
+                                   Scenario:" }
+
+
+              it 'uses the linter' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+              end
+
+              it 'does not include redundant linting results' do
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+              end
+
+              it 'prefers the provided (or registered) linter over having to make a new one' do
+
+                # Tweaking the linter objects that will already exist so that any linter created from the same class will be noticeably different
+                provided_linter   = test_linters.find { |linter| linter.is_a?(Kernel.const_get(linter_class_name)) }
+                registered_linter = CukeLinter.registered_linters.values.find { |linter| linter.is_a?(Kernel.const_get(linter_class_name)) }
+
+                if provided_linter
+                  def provided_linter.name
+                    'Pre-existing Linter'
+                  end
+                end
+
+                if registered_linter
+                  def registered_linter.name
+                    'Pre-existing Linter'
+                  end
+                end
+
+
+                results = subject.lint(linting_options)
+
+                expect(results).to match_array([{ linter: 'Pre-existing Linter', location: linted_file, problem: "#{linter_name} problem" },
+                                                { linter: 'Pre-existing Linter', location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                { linter: 'Pre-existing Linter', location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+              end
+
+
+              context 'multiple times' do
+
+                context 'with separate targetings' do
+
+                  let(:file_text) { "Feature:
+                                       # cuke_linter:enable #{linter_class_name}
+                                       # cuke_linter:enable #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'uses the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                  it 'does not include redundant linting results' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                end
+
+                context 'with the same targeting' do
+
+                  let(:file_text) { "Feature:
+
+                                       # cuke_linter:enable #{linter_class_name}, #{linter_class_name}
+                                       Scenario:" }
+
+                  it 'uses the linter' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                  it 'does not include redundant linting results' do
+                    results = subject.lint(linting_options)
+
+                    expect(results).to match_array([{ linter: linter_name, location: linted_file, problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:1", problem: "#{linter_name} problem" },
+                                                    { linter: linter_name, location: "#{linted_file}:4", problem: "#{linter_name} problem" }])
+                  end
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
 
-      expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:1', problem: 'FakeLinter problem' }])
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_linter
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-07 00:00:00.000000000 Z
+date: 2019-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cuke_modeler
@@ -194,11 +194,12 @@ files:
 - lib/cuke_linter/version.rb
 - testing/cucumber/features/command_line.feature
 - testing/cucumber/features/configuration/configuring_linters.feature
+- testing/cucumber/features/configuration/locally_scoping_linters.feature
 - testing/cucumber/features/configuration/using_configurations.feature
+- testing/cucumber/features/custom_linters.feature
+- testing/cucumber/features/default_linters.feature
 - testing/cucumber/features/formatters/pretty_formatter.feature
 - testing/cucumber/features/linters/background_does_more_than_setup.feature
-- testing/cucumber/features/linters/custom_linters.feature
-- testing/cucumber/features/linters/default_linters.feature
 - testing/cucumber/features/linters/element_with_too_many_tags.feature
 - testing/cucumber/features/linters/example_without_name.feature
 - testing/cucumber/features/linters/feature_without_description.feature