cuke_linter 0.5.0 → 0.6.0

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

@@ -5,7 +5,7 @@ RSpec.describe CukeLinter 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_tree: test_model_tree, linters: test_linters, formatters: test_formatters } }
+  let(:linting_options) { { model_trees: [test_model_tree], linters: test_linters, formatters: test_formatters } }
 
 
   it 'returns the un-formatted linting data when linting' do
@@ -14,7 +14,7 @@ RSpec.describe CukeLinter do
     expect(results).to eq([{ linter: 'FakeLinter', location: 'path_to_file:1', problem: 'FakeLinter problem' }])
   end
 
-  it 'uses evey formatter provided' do
+  it 'uses every formatter provided' do
     linting_options[:formatters] = [[CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter1')],
                                     [CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter2')]]
 
@@ -47,28 +47,92 @@ RSpec.describe CukeLinter do
     expect { subject.lint(linting_options) }.to output("Formatter1: FakeLinter problem: path_to_file:1\n").to_stdout
   end
 
-  it 'lints every model in the model tree' do
-    child_model                  = CukeLinter::ModelFactory.generate_lintable_model(source_line: 3)
-    parent_model                 = CukeLinter::ModelFactory.generate_lintable_model(source_line: 5, children: [child_model])
-    linting_options[:model_tree] = parent_model
+  context 'with only model trees' do
 
-    results = subject.lint(linting_options)
+    before(:each) do
+      child_model      = CukeLinter::ModelFactory.generate_lintable_model(source_line: 3)
+      parent_model     = CukeLinter::ModelFactory.generate_lintable_model(source_line: 5, children: [child_model])
+      multi_node_tree  = parent_model
+      single_node_tree = CukeLinter::ModelFactory.generate_lintable_model(source_line: 7)
+
+      linting_options[:model_trees] = [single_node_tree, multi_node_tree]
+      linting_options.delete(:file_paths)
+    end
+
+    it 'lints every model in each model tree' do
+      results = subject.lint(linting_options)
+
+      expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:3', problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: 'path_to_file:5', problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: 'path_to_file:7', problem: 'FakeLinter problem' }])
+    end
+
+  end
+
+  context 'with only file paths' do
+
+    before(:each) do
+      @a_feature_file    = CukeLinter::FileHelper::create_file(text: "\nFeature:", extension: '.feature')
+      a_non_feature_file = CukeLinter::FileHelper::create_file(text: 'Some text', extension: '.foo')
+      @a_directory       = CukeLinter::FileHelper::create_directory
+      File.write("#{@a_directory}/test_feature.feature", "Feature:")
+
+      linting_options[:file_paths] = [@a_feature_file, a_non_feature_file, @a_directory]
+      linting_options.delete(:model_trees)
+    end
+
+    it 'lints every model in each path' do
+      results = subject.lint(linting_options)
+
+      expect(results).to match_array([{ linter: 'FakeLinter', location: @a_directory, problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: "#{@a_directory}/test_feature.feature", problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: "#{@a_directory}/test_feature.feature:1", problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: @a_feature_file, problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: "#{@a_feature_file}:2", problem: 'FakeLinter problem' }])
+    end
 
-    expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:3', problem: 'FakeLinter problem' },
-                                    { linter: 'FakeLinter', location: 'path_to_file:5', problem: 'FakeLinter problem' }])
   end
 
-  it 'models the current directory if a model tree is not provided' do
-    test_dir = CukeLinter::FileHelper::create_directory
-    File.write("#{test_dir}/test_feature.feature", "Feature:")
-    linting_options.delete(:model_tree)
+  context 'with both model trees and file paths' do
+
+    before(:each) do
+      a_model         = CukeLinter::ModelFactory.generate_lintable_model(source_line: 3)
+      @a_feature_file = CukeLinter::FileHelper::create_file(text: 'Feature:', extension: '.feature')
 
-    Dir.chdir(test_dir) do
-      @results = subject.lint(linting_options)
+      linting_options[:model_trees] = [a_model]
+      linting_options[:file_paths]  = [@a_feature_file]
+    end
+
+
+    it 'lints every model in each model tree and file path' do
+      results = subject.lint(linting_options)
+
+      expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:3', problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: @a_feature_file, problem: 'FakeLinter problem' },
+                                      { linter: 'FakeLinter', location: "#{@a_feature_file}:1", problem: 'FakeLinter problem' }])
+    end
+
+  end
+
+  context 'with neither model trees or file paths' do
+
+    before(:each) do
+      linting_options.delete(:model_trees)
+      linting_options.delete(:file_paths)
+    end
+
+    it 'models the current directory' do
+      test_dir = CukeLinter::FileHelper::create_directory
+      File.write("#{test_dir}/test_feature.feature", "Feature:")
+
+      Dir.chdir(test_dir) do
+        @results = subject.lint(linting_options)
+      end
+
+      # There should be 3 models to lint: the directory, the feature file, and the feature
+      expect(@results.count).to eq(3)
     end
 
-    # There should be 3 models to lint: the directory, the file, and the feature
-    expect(@results.count).to eq(3)
   end
 
   it 'uses evey linter provided' do
@@ -172,6 +236,20 @@ RSpec.describe CukeLinter do
       expect(subject.registered_linters['FakeLinter1']).to be nil
     end
 
+    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')
+
+      CukeLinter.register_linter(linter: non_configurable_linter, name: 'FakeLinter')
+      expect(subject.registered_linters['FakeLinter']).to_not be nil
+
+      subject.load_configuration(config_file_path: configuration_file)
+
+      expect(subject.registered_linters['FakeLinter']).to be nil
+    end
+
     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)
@@ -209,6 +287,21 @@ RSpec.describe CukeLinter do
                                       { 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')
+
+      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)
+
+      expect(results).to match_array([{ linter: 'FakeLinter', location: 'path_to_file:1', problem: 'FakeLinter problem' }])
+    end
+
   end
 
 end

data/testing/rspec/spec/unit/cuke_linter_unit_spec.rb

@@ -29,11 +29,12 @@ RSpec.describe CukeLinter do
     expect(CukeLinter).to respond_to(:lint)
   end
 
-  it 'lints the (optionally) given model tree using the (optionally) provided set of linters and formats the output with the (optionally) provided formatters' do
+  it 'lints the (optionally) given model trees and (optionally) file paths using the (optionally) provided set of linters and formats the output with the (optionally) provided formatters' do
     expect(CukeLinter.method(:lint).arity).to eq(-1)
-    expect(CukeLinter.method(:lint).parameters).to match_array([[:key, :model_tree],
+    expect(CukeLinter.method(:lint).parameters).to match_array([[:key, :model_trees],
                                                                 [:key, :linters],
-                                                                [:key, :formatters]])
+                                                                [:key, :formatters],
+                                                                [:key, :file_paths]])
   end
 
   it 'can register a linter' do

data/testing/rspec/spec/unit/formatters/pretty_formatter_unit_spec.rb

@@ -50,16 +50,41 @@ RSpec.describe CukeLinter::PrettyFormatter do
                            '3 issues found'].join("\n"))
   end
 
-  it 'orders violations by line number' do
+  it 'orders violations within the same category by file path' do
     linting_data = [{ linter:   'SomeLinter',
                       problem:  'Some problem',
-                      location: 'path/to/the_file:2' },
+                      location: 'path/to/the_file:1' },
                     { linter:   'SomeLinter',
                       problem:  'Some problem',
                       location: 'path/to/the_file:3' },
+                    { linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/a_different_file:2' }]
+
+    results = subject.format(linting_data)
+
+    expect(results).to eq(['SomeLinter',
+                           '  Some problem',
+                           '    path/to/a_different_file:2',
+                           '    path/to/the_file:1',
+                           '    path/to/the_file:3',
+                           '',
+                           '3 issues found'].join("\n"))
+  end
+
+  it 'orders violations in the same file by line number' do
+    linting_data = [{ linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:2' },
                     { linter:   'SomeLinter',
                       problem:  'Some problem',
                       location: 'path/to/the_file:3' },
+                    { linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:11' }, # larger number that is alphabetically lower
+                    { linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:3' }, # duplicate number
                     { linter:   'SomeLinter',
                       problem:  'Some problem',
                       location: 'path/to/the_file:1' }]
@@ -72,8 +97,9 @@ RSpec.describe CukeLinter::PrettyFormatter do
                            '    path/to/the_file:2',
                            '    path/to/the_file:3',
                            '    path/to/the_file:3',
+                           '    path/to/the_file:11',
                            '',
-                           '4 issues found'].join("\n"))
+                           '5 issues found'].join("\n"))
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_linter
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-25 00:00:00.000000000 Z
+date: 2019-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cuke_modeler
@@ -209,6 +209,7 @@ files:
 - testing/formatter_factory.rb
 - testing/linter_factory.rb
 - testing/model_factory.rb
+- testing/rspec/spec/integration/cli_integration_spec.rb
 - testing/rspec/spec/integration/cuke_linter_integration_spec.rb
 - testing/rspec/spec/integration/formatters/formatter_integration_specs.rb
 - testing/rspec/spec/integration/formatters/pretty_formatter_integration_spec.rb