cuke_linter 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07f2dd742bac2e9218abe46eed4c60d925c9735cb36e416b247f351f5318edd9
-  data.tar.gz: cd3cbe140a04bb6fcb372ef4637ea567b83693f716808a3d157aad50c9212a1c
+  metadata.gz: 232cb6cefe917fc75ea2c3b21da060298a4b4f1d4c392dd0853ee2cef91bb80d
+  data.tar.gz: b8365e3d6b4b82bb494a9af552ee06db6467dac7e73d144a5c7dcc4df8d7b59c
 SHA512:
-  metadata.gz: 5d6c601cebde0cf6adbb604368266b454060dc7bd1469f49a9504210f4197530455f08218ba5e0a95ea18aec3e2735dd41c9f41165ced06926081b861a1bc9eb
-  data.tar.gz: b852cc1f217e681e5d0c23a2f05ca19d54027700d4b30db5845977d0c9c29aa8416128430d34f37ab77dc7d8d623838cee406fabe190c487a1b1cbe17197ebe2
+  metadata.gz: e2ad543a81bd093b5856e82fe7fb2bcf74447dcd96f1816adc47dcb220253d4a5e581e2e7fa7414cbb595b34815e217f431fb658f4ce70f4a779f8ff1bbc603c
+  data.tar.gz: b721820908884a39d786de81e8b87ff3c77daa4ff77037ad87384e301f3391f005328c0147aae9b093aea40552cf35a030db62c563c893838bef275f61dd44f9

data/CHANGELOG.md

@@ -8,6 +8,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [0.4.0] - 2019-05-11
+
+### Added
+ - A base linter class has been added that can be used to create custom linters more easily by providing common boilerplate code that every linter would need.
+
+### Changed
+ - Linters now return only a single problem instead of returning a collection of problems.
+
 ## [0.3.1] - 2019-04-13
 
 ### Added
@@ -33,7 +41,8 @@ Nothing yet...
 - Custom linters, formatters, and command line usability
 
 
-[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/enkessler/cuke_linter/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/enkessler/cuke_linter/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/enkessler/cuke_linter/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/enkessler/cuke_linter/compare/v0.1.0...v0.2.0

data/README.md

@@ -56,20 +56,17 @@ CukeLinter.lint
 
 The linting will happen against a tree of `CukeModeler` models that is generated based on the current directory. You can generate your own model tree and use that instead, if desired.
 
-Custom linters can be any object that responds to `#lint` and returns a collection of detected issues in the format of
+Custom linters can be any object that responds to `#lint` and returns a detected issue (or `nil`) in the format of
 
 ```
-[
- { problem: 'some linting issue',
-   location: 'path/to/file:line_number' },
- { problem: 'some linting issue',
-   location: 'path/to/file:line_number' },
-   # etc.
-]
+{ problem: 'some linting issue',
+  location: 'path/to/file:line_number' }
 ```
 
 Note that a linter will receive, in turn, *every model* in the model tree in order for it to have the chance to detect problems with it. Checking the model's class before attempting to lint it is recommended.
 
+**In order to simplify the process of creating custom linters a base class is provided (see [documentation](#documentation)).**
+
 Custom formatters can be any object that responds to `#format` and takes input data in the following format:
 
 ```
@@ -98,12 +95,12 @@ class MyCustomLinter
   end
 
   def lint(model)
-    return [] unless model.is_a?(CukeModeler::Scenario)
+    return nil unless model.is_a?(CukeModeler::Scenario)
 
     if model.name.empty?
-      [{ problem: 'Scenario has no name', location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }]
+      { problem: 'Scenario has no name', location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
     else
-      []
+      nil
     end
   end
 

data/Rakefile

@@ -50,11 +50,11 @@ namespace 'cuke_linter' do
       Rake::Task['cuke_linter:test_everything'].invoke
       Rake::Task['cuke_linter:check_documentation'].invoke
     rescue => e
-      puts Rainbow("Something isn't right!").red
+      puts Rainbow("-----------------------\nSomething isn't right!").red
       raise e
     end
 
-    puts Rainbow('All is well. :)').green
+    puts Rainbow("-----------------------\nAll is well. :)").green
   end
 
 end

data/lib/cuke_linter.rb

@@ -2,6 +2,7 @@ require 'cuke_modeler'
 
 require "cuke_linter/version"
 require 'cuke_linter/formatters/pretty_formatter'
+require 'cuke_linter/linters/linter'
 require 'cuke_linter/linters/example_without_name_linter'
 require 'cuke_linter/linters/feature_without_scenarios_linter'
 require 'cuke_linter/linters/outline_with_single_example_row_linter'
@@ -73,9 +74,12 @@ module CukeLinter
         # TODO: have linters lint only certain types of models
         #         linting_data.concat(linter.lint(model)) if relevant_model?(linter, model)
 
-        linted_data = linter.lint(model)
-        linted_data.each { |data_point| data_point[:linter] = linter.name }
-        linting_data.concat(linted_data)
+        result = linter.lint(model)
+
+        if result
+          result[:linter] = linter.name
+          linting_data << result
+        end
       end
     end
 

data/lib/cuke_linter/linters/example_without_name_linter.rb

@@ -2,22 +2,18 @@ module CukeLinter
 
   # A linter that detects unnamed example groups
 
-  class ExampleWithoutNameLinter
+  class ExampleWithoutNameLinter < Linter
 
-    # Returns the name of the linter
-    def name
-      'ExampleWithoutNameLinter'
-    end
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Example)
 
-    # Lints the given model and returns linting data about said model
-    def lint(model)
-      return [] unless model.is_a?(CukeModeler::Example)
+      model.name.nil? || model.name.empty?
+    end
 
-      if model.name.nil? || model.name.empty?
-        [{ problem: 'Example has no name', location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }]
-      else
-        []
-      end
+    # The message used to describe the problem that has been found
+    def message
+      'Example has no name'
     end
 
   end

data/lib/cuke_linter/linters/feature_without_scenarios_linter.rb

@@ -2,22 +2,18 @@ module CukeLinter
 
   # A linter that detects empty features
 
-  class FeatureWithoutScenariosLinter
+  class FeatureWithoutScenariosLinter < Linter
 
-    # Returns the name of the linter
-    def name
-      'FeatureWithoutScenariosLinter'
-    end
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Feature)
 
-    # Lints the given model and returns linting data about said model
-    def lint(model)
-      return [] unless model.is_a?(CukeModeler::Feature)
+      model.tests.nil? || model.tests.empty?
+    end
 
-      if model.tests.nil? || model.tests.empty?
-        [{ problem: 'Feature has no scenarios', location: "#{model.parent_model.path}:#{model.source_line}" }]
-      else
-        []
-      end
+    # The message used to describe the problem that has been found
+    def message
+      'Feature has no scenarios'
     end
 
   end

data/lib/cuke_linter/linters/linter.rb

@@ -0,0 +1,35 @@
+module CukeLinter
+
+  # A generic linter that can be used to make arbitrary linting rules
+
+  class Linter
+
+    # Creates a new linter object
+    def initialize(name: nil, message: nil, rule: nil)
+      @name    = name || self.class.name.split('::').last
+      @message = message || "#{self.name} problem detected"
+      @rule    = rule
+    end
+
+    # Returns the name of the linter
+    def name
+      @name
+    end
+
+    # Lints the given model and returns linting data about said model
+    def lint(model)
+      raise 'No linting rule provided!' unless @rule || respond_to?(:rule)
+
+      problem_found = respond_to?(:rule) ? rule(model) : @rule.call(model)
+
+      if problem_found
+        problem_message = respond_to?(:message) ? message : @message
+
+        { problem: problem_message, location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/cuke_linter/linters/outline_with_single_example_row_linter.rb

@@ -2,25 +2,21 @@ module CukeLinter
 
   # A linter that detects outlines that don't have multiple example rows
 
-  class OutlineWithSingleExampleRowLinter
+  class OutlineWithSingleExampleRowLinter < Linter
 
-    # Returns the name of the linter
-    def name
-      'OutlineWithSingleExampleRowLinter'
-    end
-
-    # Lints the given model and returns linting data about said model
-    def lint(model)
-      return [] unless model.is_a?(CukeModeler::Outline)
-      return [] if model.examples.nil?
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Outline)
+      return false if model.examples.nil?
 
       examples_rows = model.examples.collect(&:argument_rows).flatten
 
-      if examples_rows.count == 1
-        [{ problem: 'Outline has only one example row', location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }]
-      else
-        []
-      end
+      examples_rows.count == 1
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Outline has only one example row'
     end
 
   end

data/lib/cuke_linter/linters/test_with_too_many_steps_linter.rb

@@ -2,30 +2,26 @@ module CukeLinter
 
   # A linter that detects scenarios and outlines that have too many steps
 
-  class TestWithTooManyStepsLinter
-
-    # Returns the name of the linter
-    def name
-      'TestWithTooManyStepsLinter'
-    end
+  class TestWithTooManyStepsLinter < Linter
 
     # Changes the linting settings on the linter using the provided configuration
     def configure(options)
       @step_threshold = options['StepThreshold'] if options['StepThreshold']
     end
 
-    # Lints the given model and returns linting data about said model
-    def lint(model)
-      return [] unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
 
-      step_count     = model.steps.nil? ? 0 : model.steps.count
-      step_threshold = @step_threshold || 10
+      @linted_step_count     = model.steps.nil? ? 0 : model.steps.count
+      @linted_step_threshold = @step_threshold || 10
+
+      @linted_step_count > @linted_step_threshold
+    end
 
-      if step_count > step_threshold
-        [{ problem: "Test has too many steps. #{step_count} steps found (max #{step_threshold})", location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }]
-      else
-        []
-      end
+    # The message used to describe the problem that has been found
+    def message
+      "Test has too many steps. #{@linted_step_count} steps found (max #{@linted_step_threshold})"
     end
 
   end

data/lib/cuke_linter/version.rb

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

data/testing/cucumber/features/linters/custom_linters.feature

@@ -0,0 +1,54 @@
+Feature: Custom linters
+
+  In addition to the linters provided by CukeSlicer, custom linters can be used. A linter is essentially any object that provides a few needed methods. In order to simplify the creation of custom linters, a base linter class is available that provides these needed methods.
+
+
+  Scenario: Creating a custom linter object
+    Given the following custom linter object:
+      """
+      custom_name    = 'MyCustomLinter'
+      custom_message = 'My custom message'
+      custom_rule    = lambda do |model|
+                         # Your logic here, return true for a problem and false for not problem
+                         true
+                       end
+
+      @linter = CukeLinter::Linter.new(name: custom_name,
+                                       message: custom_message,
+                                       rule: custom_rule)
+      """
+    And a model to lint
+    When the model is linted
+    Then an error is reported
+      | linter         | problem           | location                           |
+      | MyCustomLinter | My custom message | <path_to_file>:<model_line_number> |
+
+  Scenario: Creating a custom linter class
+    Given the following custom linter class:
+      """
+      class MyCustomLinter < CukeLinter::Linter
+
+        def name
+          'MyCustomLinter'
+        end
+
+        def message
+          'My custom message'
+        end
+
+        def rule(model)
+          # Your logic here, return true for a problem and false for not problem
+          true
+        end
+
+      end
+      """
+    And the following code is used:
+      """
+      @linter = MyCustomLinter.new
+      """
+    And a model to lint
+    When the model is linted
+    Then an error is reported
+      | linter         | problem           | location                           |
+      | MyCustomLinter | My custom message | <path_to_file>:<model_line_number> |

data/testing/cucumber/step_definitions/action_steps.rb

@@ -8,7 +8,7 @@ When(/^it is formatted by the "([^"]*)" formatter$/) do |linter_name|
   @results = CukeLinter.const_get("#{linter_name.capitalize}Formatter").new.format(@linter_data)
 end
 
-When(/^(?:the feature|it) is linted$/) do
+When(/^(?:the feature|the model|it) is linted$/) do
   options           = { model_tree: @model,
                         formatters: [[CukeLinter::FormatterFactory.generate_fake_formatter, "#{CukeLinter::FileHelper::create_directory}/junk_output_file.txt"]] }
   options[:linters] = [@linter] if @linter

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -66,3 +66,30 @@ end
 Given(/^no linters are currently registered$/) do
   CukeLinter.clear_registered_linters
 end
+
+Given(/^the following custom linter object:$/) do |code|
+  code.sub!('<path_to>', @root_test_directory)
+  code.sub!('<code_to_generate_a_new_linter_instance>', 'CukeLinter::LinterFactory.generate_fake_linter')
+
+  if @working_directory
+    Dir.chdir(@working_directory) do
+      eval(code)
+    end
+  else
+    eval(code)
+  end
+end
+
+And(/^a model to lint$/) do
+  # Any old model should be fine
+  @model = CukeModeler::Feature.new
+
+  fake_file_model      = CukeModeler::FeatureFile.new
+  fake_file_model.path = 'path_to_file'
+
+  @model.parent_model = fake_file_model
+end
+
+Given(/^the following custom linter class:$/) do |code|
+  eval(code)
+end

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -10,7 +10,7 @@ Then(/^an error is reported$/) do |table|
   table.hashes.each do |error_record|
     expect(@results).to include({ linter:   error_record['linter'],
                                   problem:  error_record['problem'],
-                                  location: error_record['location'].sub('<path_to_file>', @model.get_ancestor(:feature_file).path) })
+                                  location: error_record['location'].sub('<path_to_file>', @model.get_ancestor(:feature_file).path).sub('<model_line_number>', @model.source_line.to_s) })
   end
 end
 

data/testing/linter_factory.rb

@@ -1,15 +1,19 @@
 module CukeLinter
   module LinterFactory
 
-    def self.generate_fake_linter(name: 'FakeLinter')
+    def self.generate_fake_linter(name: 'FakeLinter', finds_problems: true)
       linter = Object.new
 
       linter.define_singleton_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"
 
-        [{ problem:  problem,
-           location: location }]
+        if finds_problems
+          { problem:  problem,
+            location: location }
+        else
+          nil
+        end
       end
 
       linter.define_singleton_method('name') do

data/testing/model_factory.rb

@@ -17,41 +17,38 @@ module CukeLinter
   module ModelFactory
 
     def self.generate_feature_model(source_text: 'Feature:', parent_file_path: 'path_to_file')
-      fake_file_model      = CukeModeler::FeatureFile.new
-      fake_file_model.path = parent_file_path
+      fake_parent_model      = CukeModeler::FeatureFile.new
+      fake_parent_model.path = parent_file_path
 
       model              = CukeModeler::Feature.new(source_text)
-      model.parent_model = fake_file_model
+      model.parent_model = fake_parent_model
 
       model
     end
 
     def self.generate_example_model(source_text: 'Examples:', parent_file_path: 'path_to_file')
-      fake_file_model      = CukeModeler::FeatureFile.new
-      fake_file_model.path = parent_file_path
+      fake_parent_model = generate_outline_model(parent_file_path: parent_file_path)
 
       model              = CukeModeler::Example.new(source_text)
-      model.parent_model = fake_file_model
+      model.parent_model = fake_parent_model
 
       model
     end
 
     def self.generate_outline_model(source_text: "Scenario Outline:\n*a step\nExamples:\n|param|", parent_file_path: 'path_to_file')
-      fake_file_model      = CukeModeler::FeatureFile.new
-      fake_file_model.path = parent_file_path
+      fake_parent_model = generate_feature_model(parent_file_path: parent_file_path)
 
       model              = CukeModeler::Outline.new(source_text)
-      model.parent_model = fake_file_model
+      model.parent_model = fake_parent_model
 
       model
     end
 
     def self.generate_scenario_model(source_text: 'Scenario:', parent_file_path: 'path_to_file')
-      fake_file_model      = CukeModeler::FeatureFile.new
-      fake_file_model.path = parent_file_path
+      fake_parent_model = generate_feature_model(parent_file_path: parent_file_path)
 
       model              = CukeModeler::Scenario.new(source_text)
-      model.parent_model = fake_file_model
+      model.parent_model = fake_parent_model
 
       model
     end

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

@@ -82,16 +82,21 @@ RSpec.describe CukeLinter do
   end
 
   it 'uses all registered linters if none are provided', :linter_registration do
+    CukeLinter.clear_registered_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')
     CukeLinter.register_linter(linter: CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter3'), name: 'FakeLinter3')
-    linting_options.delete(:linters)
 
-    results = subject.lint(linting_options)
+    begin
+      linting_options.delete(:linters)
+      results = subject.lint(linting_options)
 
-    expect(results).to match_array([{ linter: 'FakeLinter1', location: 'path_to_file:1', problem: 'FakeLinter1 problem' },
-                                    { linter: 'FakeLinter2', location: 'path_to_file:1', problem: 'FakeLinter2 problem' },
-                                    { linter: 'FakeLinter3', location: 'path_to_file:1', problem: 'FakeLinter3 problem' }])
+      expect(results).to match_array([{ linter: 'FakeLinter1', location: 'path_to_file:1', problem: 'FakeLinter1 problem' },
+                                      { linter: 'FakeLinter2', location: 'path_to_file:1', problem: 'FakeLinter2 problem' },
+                                      { linter: 'FakeLinter3', location: 'path_to_file:1', problem: 'FakeLinter3 problem' }])
+    ensure
+      CukeLinter.reset_linters
+    end
   end
 
   it 'includes the name of the linter in the linting data' do
@@ -136,6 +141,12 @@ RSpec.describe CukeLinter do
     expect(CukeLinter.registered_linters.values.map(&:object_id)).to_not match_array(original_linter_ids)
   end
 
+  it 'can handle a mixture of problematic and non-problematic models' do
+    linting_options[:linters] = [CukeLinter::LinterFactory.generate_fake_linter(finds_problems: true),
+                                 CukeLinter::LinterFactory.generate_fake_linter(finds_problems: false)]
+
+    expect { subject.lint(linting_options) }.to_not raise_error
+  end
 
   describe 'configuration' do
 

data/testing/rspec/spec/integration/linters/linter_integration_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::Linter do
+
+  it_should_behave_like 'a linter at the integration level'
+
+end

data/testing/rspec/spec/unit/linters/example_without_name_linter_unit_spec.rb

@@ -44,13 +44,13 @@ RSpec.describe CukeLinter::ExampleWithoutNameLinter do
       end
 
       it 'records a problem' do
-        results = subject.lint(test_model_with_nil_name)
+        result = subject.lint(test_model_with_nil_name)
 
-        expect(results.first[:problem]).to eq('Example has no name')
+        expect(result[:problem]).to eq('Example has no name')
 
-        results = subject.lint(test_model_with_blank_name)
+        result = subject.lint(test_model_with_blank_name)
 
-        expect(results.first[:problem]).to eq('Example has no name')
+        expect(result[:problem]).to eq('Example has no name')
       end
 
       it 'records the location of the problem' do
@@ -61,21 +61,21 @@ RSpec.describe CukeLinter::ExampleWithoutNameLinter do
         model_2.name        = nil
         model_2.source_line = 3
 
-        results = subject.lint(model_1)
-        expect(results.first[:location]).to eq('path_to_file:1')
+        result = subject.lint(model_1)
+        expect(result[:location]).to eq('path_to_file:1')
 
-        results = subject.lint(model_2)
-        expect(results.first[:location]).to eq('path_to_file:3')
+        result = subject.lint(model_2)
+        expect(result[:location]).to eq('path_to_file:3')
       end
 
     end
 
     context 'a non-example model' do
 
-      it 'returns an empty set of results' do
-        results = subject.lint(CukeModeler::Model.new)
+      it 'returns no result' do
+        result = subject.lint(CukeModeler::Model.new)
 
-        expect(results).to eq([])
+        expect(result).to eq(nil)
       end
 
     end

data/testing/rspec/spec/unit/linters/feature_without_scenarios_linter_unit_spec.rb

@@ -44,13 +44,13 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
       end
 
       it 'records a problem' do
-        results = subject.lint(test_model_with_empty_scenarios)
+        result = subject.lint(test_model_with_empty_scenarios)
 
-        expect(results.first[:problem]).to eq('Feature has no scenarios')
+        expect(result[:problem]).to eq('Feature has no scenarios')
 
-        results = subject.lint(test_model_with_nil_scenarios)
+        result = subject.lint(test_model_with_nil_scenarios)
 
-        expect(results.first[:problem]).to eq('Feature has no scenarios')
+        expect(result[:problem]).to eq('Feature has no scenarios')
       end
 
       it 'records the location of the problem' do
@@ -61,11 +61,11 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
         model_2.tests       = []
         model_2.source_line = 3
 
-        results = subject.lint(model_1)
-        expect(results.first[:location]).to eq('path_to_file:1')
+        result = subject.lint(model_1)
+        expect(result[:location]).to eq('path_to_file:1')
 
-        results = subject.lint(model_2)
-        expect(results.first[:location]).to eq('path_to_file:3')
+        result = subject.lint(model_2)
+        expect(result[:location]).to eq('path_to_file:3')
       end
 
     end
@@ -83,7 +83,7 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -102,7 +102,7 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -111,10 +111,10 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
     context 'a non-feature model' do
 
-      it 'returns an empty set of results' do
-        results = subject.lint(CukeModeler::Model.new)
+      it 'returns no result' do
+        result = subject.lint(CukeModeler::Model.new)
 
-        expect(results).to eq([])
+        expect(result).to eq(nil)
       end
 
     end

data/testing/rspec/spec/unit/linters/linter_unit_spec.rb

@@ -0,0 +1,180 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::Linter do
+
+  let(:linter_name) { 'FooLinter' }
+  let(:linter_message) { 'Foo!' }
+  let(:linter_rule) { lambda { |model| !model.is_a?(CukeModeler::Example) } }
+  let(:linter_options) { { name: linter_name, message: linter_message, rule: linter_rule } }
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_example_model
+  end
+
+  let(:bad_data) do
+    CukeLinter::ModelFactory.generate_outline_model
+  end
+
+
+  context 'with custom values' do
+
+    subject { CukeLinter::Linter.new(linter_options) }
+
+
+    it_should_behave_like 'a linter at the unit level'
+
+    it 'uses the provided name' do
+      expect(subject.name).to eq(linter_name)
+    end
+
+    it 'uses the provided rule' do
+      expect(subject.lint(good_data)).to be_nil
+      expect(subject.lint(bad_data)).to_not be_nil
+    end
+
+    it 'uses the provided message' do
+      result = subject.lint(bad_data)
+
+      expect(result[:problem]).to eq(linter_message)
+    end
+
+  end
+
+  context 'with custom methods' do
+
+    subject { linter = CukeLinter::Linter.new
+
+              linter.define_singleton_method('rule') do |model|
+                !model.is_a?(CukeModeler::Example)
+              end
+
+              linter.define_singleton_method('name') do
+                'FooLinter'
+              end
+
+              linter.define_singleton_method('message') do
+                'Foo!'
+              end
+
+
+              linter }
+
+
+    it_should_behave_like 'a linter at the unit level'
+
+    it 'uses the provided #name' do
+      expect(subject.name).to eq(linter_name)
+    end
+
+    it 'uses the provided #rule' do
+      expect(subject.lint(good_data)).to be_nil
+      expect(subject.lint(bad_data)).to_not be_nil
+    end
+
+    it 'uses the provided #message' do
+      result = subject.lint(bad_data)
+
+      expect(result[:problem]).to eq(linter_message)
+    end
+
+  end
+
+  context 'with both custom values and methods' do
+
+    let(:good_data) do
+      CukeLinter::ModelFactory.generate_outline_model
+    end
+
+    let(:bad_data) do
+      CukeLinter::ModelFactory.generate_example_model
+    end
+
+    subject { linter = CukeLinter::Linter.new(linter_options)
+
+              linter.define_singleton_method('rule') do |model|
+                model.is_a?(CukeModeler::Example)
+              end
+
+              linter.define_singleton_method('name') do
+                'Method Linter'
+              end
+
+              linter.define_singleton_method('message') do
+                'Method Foo!'
+              end
+
+
+              linter }
+
+
+    it 'uses #name instead of the provided name' do
+      expect(subject.name).to eq('Method Linter')
+    end
+
+    it 'uses #rule instead of the provided rule' do
+      expect(subject.lint(good_data)).to be_nil
+      expect(subject.lint(bad_data)).to_not be_nil
+    end
+
+    it 'uses #message instead of the provided message' do
+      result = subject.lint(bad_data)
+
+      expect(result[:problem]).to eq('Method Foo!')
+    end
+
+  end
+
+  context 'with neither custom values nor methods' do
+
+    subject { CukeLinter::Linter.new }
+
+
+    it 'complains if not provided with a rule' do
+      expect { subject.lint('Anything') }.to raise_error('No linting rule provided!')
+    end
+
+
+    it 'has a default name based on its class' do
+      expect(subject.name).to eq('Linter')
+
+      class CustomLinter < CukeLinter::Linter;
+      end
+
+      expect(CustomLinter.new.name).to eq('CustomLinter')
+    end
+
+    it 'has a default message based on its name' do
+      linter_options[:message] = nil
+
+      # Default name
+      linter_options[:name] = nil
+      linter                = CukeLinter::Linter.new(linter_options)
+      result                = linter.lint(bad_data)
+
+      expect(result[:problem]).to eq('Linter problem detected')
+
+      # Value name
+      linter_options[:name] = 'Value name'
+      linter                = CukeLinter::Linter.new(linter_options)
+      result                = linter.lint(bad_data)
+
+      expect(result[:problem]).to eq('Value name problem detected')
+
+      # Method name
+      class CustomLinter < CukeLinter::Linter;
+        def name
+          'Method name'
+        end
+      end
+
+      linter_options[:name] = nil
+      linter                = CustomLinter.new(linter_options)
+      result                = linter.lint(bad_data)
+
+      expect(result[:problem]).to eq('Method name problem detected')
+    end
+
+  end
+
+end

data/testing/rspec/spec/unit/linters/linter_unit_specs.rb

@@ -16,22 +16,22 @@ shared_examples_for 'a linter at the unit level' do
 
   context 'with good data' do
 
-    it 'returns an empty set of results' do
-      expect(subject.lint(good_data)).to eq([])
+    it 'returns no problem' do
+      expect(subject.lint(good_data)).to be_nil
     end
 
   end
 
   context 'with bad data' do
 
-    it 'returns a set of detected problems' do
-      expect(subject.lint(bad_data)).to_not be_empty
+    it 'returns a detected problems' do
+      expect(subject.lint(bad_data)).to_not be_nil
     end
 
-    it 'includes the problems and their locations in its results' do
-      results = subject.lint(bad_data)
+    it 'includes the problem and its locations in its result' do
+      result = subject.lint(bad_data)
 
-      results.each { |result| expect(result.keys).to match_array([:problem, :location]) }
+      expect(result.keys).to match_array([:problem, :location])
     end
 
   end

data/testing/rspec/spec/unit/linters/outline_with_single_example_row_linter_unit_spec.rb

@@ -49,9 +49,9 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'records a problem' do
-          results = subject.lint(test_model)
+          result = subject.lint(test_model)
 
-          expect(results.first[:problem]).to eq('Outline has only one example row')
+          expect(result[:problem]).to eq('Outline has only one example row')
         end
 
       end
@@ -71,9 +71,9 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'records a problem' do
-          results = subject.lint(test_model)
+          result = subject.lint(test_model)
 
-          expect(results.first[:problem]).to eq('Outline has only one example row')
+          expect(result[:problem]).to eq('Outline has only one example row')
         end
 
       end
@@ -92,11 +92,11 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         model_1.source_line = 1
         model_2.source_line = 3
 
-        results = subject.lint(model_1)
-        expect(results.first[:location]).to eq('path_to_file:1')
+        result = subject.lint(model_1)
+        expect(result[:location]).to eq('path_to_file:1')
 
-        results = subject.lint(model_2)
-        expect(results.first[:location]).to eq('path_to_file:3')
+        result = subject.lint(model_2)
+        expect(result[:location]).to eq('path_to_file:3')
       end
 
     end
@@ -117,7 +117,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -138,7 +138,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -159,7 +159,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
           end
 
           it 'does not record a problem' do
-            expect(subject.lint(test_model)).to eq([])
+            expect(subject.lint(test_model)).to eq(nil)
           end
 
         end
@@ -173,7 +173,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
           end
 
           it 'does not record a problem' do
-            expect(subject.lint(test_model)).to eq([])
+            expect(subject.lint(test_model)).to eq(nil)
           end
 
         end
@@ -192,7 +192,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -211,7 +211,7 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
         end
 
         it 'does not record a problem' do
-          expect(subject.lint(test_model)).to eq([])
+          expect(subject.lint(test_model)).to eq(nil)
         end
 
       end
@@ -220,10 +220,10 @@ RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter do
 
     context 'a non-outline model' do
 
-      it 'returns an empty set of results' do
-        results = subject.lint(CukeModeler::Model.new)
+      it 'returns no result' do
+        result = subject.lint(CukeModeler::Model.new)
 
-        expect(results).to eq([])
+        expect(result).to eq(nil)
       end
 
     end

data/testing/rspec/spec/unit/linters/test_with_too_many_steps_linter_unit_spec.rb

@@ -60,29 +60,29 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
         end
 
         it 'records a problem' do
-          results = subject.lint(test_model)
+          result = subject.lint(test_model)
 
-          expect(results.first[:problem]).to match(/^Test has too many steps. \d+ steps found \(max 10\)/)
+          expect(result[:problem]).to match(/^Test has too many steps. \d+ steps found \(max 10\)/)
         end
 
         it 'records the location of the problem' do
           test_model.source_line = 1
-          results                = subject.lint(test_model)
-          expect(results.first[:location]).to eq('path_to_file:1')
+          result                 = subject.lint(test_model)
+          expect(result[:location]).to eq('path_to_file:1')
 
           test_model.source_line = 3
-          results                = subject.lint(test_model)
-          expect(results.first[:location]).to eq('path_to_file:3')
+          result                 = subject.lint(test_model)
+          expect(result[:location]).to eq('path_to_file:3')
         end
 
         it 'includes the number of steps found in the problem record' do
           step_count = test_model.steps.count
-          results    = subject.lint(test_model)
-          expect(results.first[:problem]).to eq("Test has too many steps. #{step_count} steps found (max 10)")
+          result     = subject.lint(test_model)
+          expect(result[:problem]).to eq("Test has too many steps. #{step_count} steps found (max 10)")
 
           test_model.steps << :another_step
-          results = subject.lint(test_model)
-          expect(results.first[:problem]).to eq("Test has too many steps. #{step_count + 1} steps found (max 10)")
+          result = subject.lint(test_model)
+          expect(result[:problem]).to eq("Test has too many steps. #{step_count + 1} steps found (max 10)")
         end
 
       end
@@ -99,7 +99,7 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
           end
 
           it 'does not record a problem' do
-            expect(subject.lint(test_model)).to eq([])
+            expect(subject.lint(test_model)).to eq(nil)
           end
 
         end
@@ -116,7 +116,7 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
             end
 
             it 'does not record a problem' do
-              expect(subject.lint(test_model)).to eq([])
+              expect(subject.lint(test_model)).to eq(nil)
             end
 
           end
@@ -131,7 +131,7 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
             end
 
             it 'does not record a problem' do
-              expect(subject.lint(test_model)).to eq([])
+              expect(subject.lint(test_model)).to eq(nil)
             end
 
           end
@@ -158,9 +158,9 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
             end
 
             it 'defaults to a step threshold of 10 steps' do
-              results = subject.lint(unconfigured_test_model)
+              result = subject.lint(unconfigured_test_model)
 
-              expect(results.first[:problem]).to match(/^Test has too many steps. #{unconfigured_test_model.steps.count} steps found \(max 10\)/)
+              expect(result[:problem]).to match(/^Test has too many steps. #{unconfigured_test_model.steps.count} steps found \(max 10\)/)
             end
 
           end
@@ -178,9 +178,9 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
             end
 
             it 'defaults to a step threshold of 10 steps' do
-              results = subject.lint(configured_test_model)
+              result = subject.lint(configured_test_model)
 
-              expect(results.first[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max 10\)/)
+              expect(result[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max 10\)/)
             end
 
           end
@@ -203,9 +203,9 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
           end
 
           it 'the step threshold used is the configured value' do
-            results = subject.lint(configured_test_model)
+            result = subject.lint(configured_test_model)
 
-            expect(results.first[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max #{step_threshhold}\)/)
+            expect(result[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max #{step_threshhold}\)/)
           end
 
         end
@@ -218,10 +218,10 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
 
       let(:test_model) { CukeModeler::Model.new }
 
-      it 'returns an empty set of results' do
-        results = subject.lint(test_model)
+      it 'returns no result' do
+        result = subject.lint(test_model)
 
-        expect(results).to eq([])
+        expect(result).to eq(nil)
       end
 
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_linter
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-13 00:00:00.000000000 Z
+date: 2019-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cuke_modeler
@@ -178,6 +178,7 @@ files:
 - lib/cuke_linter/formatters/pretty_formatter.rb
 - lib/cuke_linter/linters/example_without_name_linter.rb
 - lib/cuke_linter/linters/feature_without_scenarios_linter.rb
+- lib/cuke_linter/linters/linter.rb
 - lib/cuke_linter/linters/outline_with_single_example_row_linter.rb
 - lib/cuke_linter/linters/test_with_too_many_steps_linter.rb
 - lib/cuke_linter/version.rb
@@ -185,6 +186,7 @@ files:
 - testing/cucumber/features/configuration/configuring_linters.feature
 - testing/cucumber/features/configuration/using_configurations.feature
 - testing/cucumber/features/formatters/pretty_formatter.feature
+- testing/cucumber/features/linters/custom_linters.feature
 - testing/cucumber/features/linters/default_linters.feature
 - testing/cucumber/features/linters/example_without_name.feature
 - testing/cucumber/features/linters/feature_without_scenarios.feature
@@ -202,6 +204,7 @@ files:
 - testing/rspec/spec/integration/formatters/pretty_formatter_integration_spec.rb
 - testing/rspec/spec/integration/linters/example_without_name_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/feature_without_scenarios_linter_integration_spec.rb
+- testing/rspec/spec/integration/linters/linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/linter_integration_specs.rb
 - testing/rspec/spec/integration/linters/outline_with_single_example_row_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/test_with_too_many_steps_linter_integration_spec.rb
@@ -211,6 +214,7 @@ files:
 - testing/rspec/spec/unit/linters/configurable_linter_unit_specs.rb
 - testing/rspec/spec/unit/linters/example_without_name_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/feature_without_scenarios_linter_unit_spec.rb
+- testing/rspec/spec/unit/linters/linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/linter_unit_specs.rb
 - testing/rspec/spec/unit/linters/outline_with_single_example_row_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/test_with_too_many_steps_linter_unit_spec.rb