cuke_linter 0.1.0

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -0,0 +1,18 @@
+Then(/^a linting report will be made for all features$/) do
+  expect(@output).to match(/\d+ issues found/)
+end
+
+Then(/^the resulting output is the following:$/) do |text|
+  expect(@results).to eq(text)
+end
+
+Then(/^an error is reported$/) do |table|
+  table.hashes.each do |error_record|
+    expect(@results).to include({ problem:  error_record['problem'],
+                                  location: error_record['location'].sub('<path_to_file>', @model.get_ancestor(:feature_file).path) })
+  end
+end
+
+Then(/^the following linters are registered by default$/) do |linter_names|
+  expect(CukeLinter.registered_linters.keys).to eq(linter_names.raw.flatten)
+end

data/testing/file_helper.rb

@@ -0,0 +1,28 @@
+require 'tmpdir'
+
+
+module CukeLinter
+  module FileHelper
+
+    class << self
+
+      def created_directories
+        @created_directories ||= []
+      end
+
+      def create_directory(options = {})
+        options[:name]      ||= 'test_directory'
+        options[:directory] ||= Dir.mktmpdir
+
+        path = "#{options[:directory]}/#{options[:name]}"
+
+        Dir::mkdir(path)
+        created_directories << options[:directory]
+
+        path
+      end
+
+    end
+
+  end
+end

data/testing/formatter_factory.rb

@@ -0,0 +1,15 @@
+module CukeLinter
+  module FormatterFactory
+
+    def self.generate_fake_formatter(name: 'FakeFormater')
+      formatter = Object.new
+
+      formatter.define_singleton_method('format') do |data|
+        data.reduce("#{name}: ") { |final, lint_error| final << "#{lint_error[:problem]}: #{lint_error[:location]}\n" }
+      end
+
+      formatter
+    end
+
+  end
+end

data/testing/linter_factory.rb

@@ -0,0 +1,22 @@
+module CukeLinter
+  module LinterFactory
+
+    def self.generate_fake_linter(name: 'FakeLinter')
+      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:  "#{name} problem",
+           location: location }]
+      end
+
+      linter.define_singleton_method('name') do
+        name
+      end
+
+      linter
+    end
+
+  end
+end

data/testing/model_factory.rb

@@ -0,0 +1,39 @@
+module CukeLinter
+  class TestModel < CukeModeler::Model
+
+    include CukeModeler::Sourceable
+
+  end
+end
+
+
+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
+
+      model              = CukeModeler::Feature.new(source_text)
+      model.parent_model = fake_file_model
+
+      model
+    end
+
+    def self.generate_lintable_model(parent_file_path: 'path_to_file', source_line: '1', children: [])
+      fake_file_model      = CukeModeler::FeatureFile.new
+      fake_file_model.path = parent_file_path
+
+      model              = CukeLinter::TestModel.new
+      model.parent_model = fake_file_model
+      model.source_line  = source_line
+
+      model.define_singleton_method('children') do
+        children
+      end
+
+      model
+    end
+
+  end
+end

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

@@ -0,0 +1,112 @@
+require_relative '../../../../environments/rspec_env'
+
+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 } }
+
+
+  it 'returns the un-formatted linting data when linting' do
+    results = subject.lint(linting_options)
+
+    expect(results).to eq([{ linter: 'FakeLinter', location: 'path_to_file:1', problem: 'FakeLinter problem' }])
+  end
+
+  it 'uses evey formatter provided' do
+    linting_options[:formatters] = [[CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter1')],
+                                    [CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter2')]]
+
+    expect { subject.lint(linting_options) }.to output("Formatter1: FakeLinter problem: path_to_file:1\nFormatter2: FakeLinter problem: path_to_file:1\n").to_stdout
+  end
+
+  it "uses the 'pretty' formatter if none are provided" do
+    linting_options.delete(:formatters)
+
+    expect { subject.lint(linting_options) }.to output(['FakeLinter',
+                                                        '  FakeLinter problem',
+                                                        '    path_to_file:1',
+                                                        '',
+                                                        '1 issues found',
+                                                        ''].join("\n")).to_stdout
+  end
+
+  it 'outputs formatted linting data to the provided output location' do
+    output_path                  = "#{CukeLinter::FileHelper::create_directory}/output.txt"
+    linting_options[:formatters] = [[CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter1'),
+                                     output_path]]
+
+    expect { subject.lint(linting_options) }.to_not output.to_stdout
+    expect(File.read(output_path)).to eq("Formatter1: FakeLinter problem: path_to_file:1\n")
+  end
+
+  it 'outputs formatted data to STDOUT if not location is provided' do
+    linting_options[:formatters] = [[CukeLinter::FormatterFactory.generate_fake_formatter(name: 'Formatter1')]]
+
+    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
+
+    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' }])
+  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)
+
+    Dir.chdir(test_dir) do
+      @results = subject.lint(linting_options)
+    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
+    linting_options[:linters] = [CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'),
+                                 CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter2')]
+
+    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' }])
+  end
+
+  it 'uses all registered linters if none are provided', :linter_registration do
+    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)
+
+    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' }])
+  end
+
+  it 'includes the name of the linter in the linting data' do
+    linting_options[:linters] = [CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter1'),
+                                 CukeLinter::LinterFactory.generate_fake_linter(name: 'FakeLinter2')]
+
+    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' }])
+  end
+
+  it 'has a default set of registered linters' do
+    expect(subject.registered_linters.keys).to include('FeatureWithoutScenariosLinter')
+    expect(subject.registered_linters['FeatureWithoutScenariosLinter']).to be_a(CukeLinter::FeatureWithoutScenariosLinter)
+  end
+
+end

data/testing/rspec/spec/integration/formatters/formatter_integration_specs.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'a formatter at the integration level' do
+
+  # No defined behavior yet
+
+end

data/testing/rspec/spec/integration/formatters/pretty_formatter_integration_spec.rb

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

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

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

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

@@ -0,0 +1,7 @@
+shared_examples_for 'a linter at the integration level' do
+
+  # it 'inherits from the base linter' do
+  #   expect(subject).to be_a(CukeLinter::BaseLinter)
+  # end
+
+end

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

@@ -0,0 +1,83 @@
+require_relative '../../../../environments/rspec_env'
+
+
+RSpec.describe 'the gem' do
+
+  let(:gemspec) { eval(File.read "#{__dir__}/../../../../cuke_linter.gemspec") }
+
+  it 'has an executable' do
+    expect(gemspec.executables).to include('cuke_linter')
+  end
+
+  it 'validates cleanly' do
+    mock_ui = Gem::MockGemUi.new
+    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
+
+    expect(mock_ui.error).to_not match(/warn/i)
+  end
+
+end
+
+
+RSpec.describe CukeLinter do
+
+  it "has a version number" do
+    expect(CukeLinter::VERSION).not_to be nil
+  end
+
+  it 'can lint' 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
+    expect(CukeLinter.method(:lint).arity).to eq(-1)
+    expect(CukeLinter.method(:lint).parameters).to match_array([[:key, :model_tree],
+                                                                [:key, :linters],
+                                                                [:key, :formatters]])
+  end
+
+  it 'can register a linter' do
+    expect(CukeLinter).to respond_to(:register_linter)
+  end
+
+  it 'can unregister a linter' do
+    expect(CukeLinter).to respond_to(:unregister_linter)
+  end
+
+  it 'registers a linter by name' do
+    expect(CukeLinter.method(:register_linter).arity).to eq(1)
+    expect(CukeLinter.method(:register_linter).parameters).to match_array([[:keyreq, :linter],
+                                                                           [:keyreq, :name]])
+  end
+
+  it 'unregisters a linter by name' do
+    expect(CukeLinter.method(:unregister_linter).arity).to eq(1)
+    expect(CukeLinter.method(:unregister_linter).parameters).to match_array([[:req, :name]])
+  end
+
+  it 'knows its currently registered linters' do
+    expect(CukeLinter).to respond_to(:registered_linters)
+  end
+
+  it 'correctly registers, unregisters, and tracks linters', :linter_registration do
+    CukeLinter.clear_registered_linters
+    CukeLinter.register_linter(name: 'foo', linter: :linter_1)
+    CukeLinter.register_linter(name: 'bar', linter: :linter_2)
+    CukeLinter.register_linter(name: 'baz', linter: :linter_3)
+
+    CukeLinter.unregister_linter('bar')
+
+    expect(CukeLinter.registered_linters).to eq({ 'foo' => :linter_1,
+                                                  'baz' => :linter_3, })
+  end
+
+  it 'can clear all of its currently registered linters', :linter_registration do
+    expect(CukeLinter).to respond_to(:clear_registered_linters)
+
+    CukeLinter.register_linter(name: 'some_linter', linter: :the_linter)
+    CukeLinter.clear_registered_linters
+
+    expect(CukeLinter.registered_linters).to eq({})
+  end
+
+end

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

@@ -0,0 +1,11 @@
+shared_examples_for 'a formatter at the unit level' do
+
+  it 'can format' do
+    expect(subject).to respond_to(:format)
+  end
+
+  it 'formats linting data' do
+    expect(subject.method(:format).arity).to eq(1)
+  end
+
+end

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

@@ -0,0 +1,75 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::PrettyFormatter do
+
+  it_should_behave_like 'a formatter at the unit level'
+
+
+  it 'formats linting data as pretty text' do
+    linting_data = [{ linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:1' },
+                    { linter:   'SomeOtherLinter',
+                      problem:  'Some other problem',
+                      location: 'path/to/the_file:1' }]
+
+    results = subject.format(linting_data)
+
+    expect(results).to eq(['SomeLinter',
+                           '  Some problem',
+                           '    path/to/the_file:1',
+                           'SomeOtherLinter',
+                           '  Some other problem',
+                           '    path/to/the_file:1',
+                           '',
+                           '2 issues found'].join("\n"))
+  end
+
+  it 'groups data by linter and problem' do
+    linting_data = [{ linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:1' },
+                    { linter:   'SomeOtherLinter',
+                      problem:  'Some other problem',
+                      location: 'path/to/the_file:1' },
+                    { linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:11' }]
+
+    results = subject.format(linting_data)
+
+    expect(results).to eq(['SomeLinter',
+                           '  Some problem',
+                           '    path/to/the_file:1',
+                           '    path/to/the_file:11',
+                           'SomeOtherLinter',
+                           '  Some other problem',
+                           '    path/to/the_file:1',
+                           '',
+                           '3 issues found'].join("\n"))
+  end
+
+  it 'orders violations 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:1' }]
+
+    results = subject.format(linting_data)
+
+    expect(results).to eq(['SomeLinter',
+                           '  Some problem',
+                           '    path/to/the_file:1',
+                           '    path/to/the_file:2',
+                           '    path/to/the_file:3',
+                           '',
+                           '3 issues found'].join("\n"))
+  end
+
+end

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

@@ -0,0 +1,72 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
+
+  let(:good_data) do
+    model       = CukeLinter::ModelFactory.generate_feature_model
+    model.tests = ['totally_a_test']
+
+    model
+  end
+
+  let(:bad_data) do
+    model       = CukeLinter::ModelFactory.generate_feature_model
+    model.tests = []
+
+    model
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('FeatureWithoutScenariosLinter')
+  end
+
+  describe 'linting' do
+
+    context 'a feature with no scenarios' do
+
+      let(:test_model) do
+        model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+        model.tests = []
+
+        model
+      end
+
+      it 'records a problem' do
+        results = subject.lint(test_model)
+
+        expect(results.first[:problem]).to eq('Feature has no scenarios')
+      end
+
+      it 'records the location of the problem' do
+        model_1             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+        model_1.tests       = []
+        model_1.source_line = 1
+        model_2             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+        model_2.tests       = []
+        model_2.source_line = 3
+
+        results = subject.lint(model_1)
+        expect(results.first[:location]).to eq('path_to_file:1')
+
+        results = subject.lint(model_2)
+        expect(results.first[:location]).to eq('path_to_file:3')
+      end
+
+    end
+
+    context 'a non-feature model' do
+
+      it 'returns an empty set of results' do
+        results = subject.lint(CukeModeler::Model.new)
+
+        expect(results).to eq([])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+shared_examples_for 'a linter at the unit level' do
+
+  it 'is named' do
+    expect(subject).to respond_to(:name)
+    expect(subject.name).to be_a_kind_of(String)
+    expect(subject.name).to_not be_empty
+  end
+
+  it 'can lint' do
+    expect(subject).to respond_to(:lint)
+  end
+
+  it 'lints a model' do
+    expect(subject.method(:lint).arity).to eq(1)
+  end
+
+  context 'with good data' do
+
+    it 'returns an empty set of results' do
+      expect(subject.lint(good_data)).to eq([])
+    end
+
+  end
+
+  context 'with bad data' do
+
+    it 'returns a set of detected problems' do
+      expect(subject.lint(bad_data)).to_not be_empty
+    end
+
+    it 'includes the problems and their locations in its results' do
+      results = subject.lint(bad_data)
+
+      results.each { |result| expect(result.keys).to match_array([:problem, :location]) }
+    end
+
+  end
+end