cuke_linter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aa45813f720250fdd2aaceab4b69148a6029074418331a2467c65fa544733067
+  data.tar.gz: 89abfd15ecc91f630bc8ab247346d26f8a20ec1f14ce11af197db65725e1fbb6
+SHA512:
+  metadata.gz: 2e986813b8bdb0e86b358058ceac6c62939fce89bf1049599e18e51d5d88d5cbc244c1d172333ed93091e71353a9a859e60caad47aaa08b81e1ca716a9ee72e8
+  data.tar.gz: 3e354fcea0ac508b7bbeb25eeea8ff40bf17e21c2897213dedca3ab76d2c0e9f0c53e2fa030daf0de097b7e3c88a9337647336b17c0e2c0facee0852d8c0c354

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# JetBrains IDE metadata folders
+/.idea
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,14 @@
+os:
+  - linux
+  - osx
+sudo: false
+
+language: ruby
+rvm:
+  - 2.3.3
+  - 2.4.0
+  - 2.5.1
+
+before_install: gem install bundler -v 1.16.2
+
+script: bundle exec rake cuke_linter:ci_build

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+Nothing yet...
+
+
+## [0.1.0] - 2019-02-10
+
+### Added
+- Custom linters, formatters, and command line usability
+
+
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/enkessler/cuke_linter/compare/2bbd3f29f4eb45b6e9ea7d47c5bb47182bf4fde7...HEAD

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cuke_linter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2019 Eric Kessler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+[![Gem Version](https://badge.fury.io/rb/cuke_linter.svg)](https://rubygems.org/gems/cuke_linter)
+[![Build Status](https://travis-ci.org/enkessler/cuke_linter.svg?branch=master)](https://travis-ci.org/enkessler/cuke_linter)
+[![Build Status](https://ci.appveyor.com/api/projects/status/g5o70u747x073evy?svg=true)](https://ci.appveyor.com/project/enkessler/cuke-linter)
+[![Project License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/mit-license.php)
+
+
+# CukeLinter
+
+So you have started to use Cucumber to describe your system in the abstract, natural language style of Gherkin. But wait! All of your feature files are themselves code and that means that they may need the same protection from anti-patterns as the lower level source code of your system. Enter `cuke_linter`.
+
+This gem provides linting functionality for `.feature` files by building upon the modeling capabilities of the `cuke_modeler` gem. By passing models through a set of linters, reports can be generated that will inform you of potential bugs, style violations, or anything else that you can define as a problem  via custom linters! 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cuke_linter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cuke_linter
+
+## Usage
+
+The easiest way to use the gem is to use all of the defaults by invoking it from the command line directly.
+
+```
+$ cuke_linter
+```
+
+The linter can also be used inside of a Ruby script, like so:
+
+```
+require 'cuke_linter'
+
+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
+
+```
+[
+ { problem: 'some linting issue',
+   location: 'path/to/file:line_number' },
+ { problem: 'some linting issue',
+   location: 'path/to/file:line_number' },
+   # etc.
+]
+```
+
+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.
+
+Custom formatters can be any object that responds to `#format` and takes input data in the following format:
+
+```
+[
+ { linter: 'some linter name',
+   problem: 'some linting issue',
+   location: 'path/to/file:line_number' },
+ { linter: 'some linter name',
+   problem: 'some linting issue',
+   location: 'path/to/file:line_number' },
+   # etc.
+]
+```
+
+All formatted data will be output to STDOUT unless a file location is provided as an alternative.
+
+Below is an example of using non-default linting options.
+
+```
+require 'cuke_linter'
+
+class MyCustomLinter
+
+  def name
+    'MyCustomLinter'
+  end
+
+  def lint(model)
+    return [] 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}" }]
+    else
+      []
+    end
+  end
+
+end
+
+class MyCustomFormatter
+
+  def format(linting_data)
+    formatted_data = ''
+
+    linting_data.each do |lint_item|
+      formatted_data << "#{lint_item[:linter]}\n"
+      formatted_data << "  #{lint_item[:problem]}\n"
+      formatted_data << "    #{lint_item[:location]}\n"
+    end
+
+    formatted_data
+  end
+
+end
+
+linter          = MyCustomLinter.new
+formatter       = MyCustomFormatter.new
+output_path     = "#{__dir__}/my_report.txt"
+model_tree_root = CukeModeler::Directory.new(Dir.pwd)
+
+# Providing the formatter twice so that it also is printed to the console
+CukeLinter.lint(linters: [linter], formatters: [[formatter], [formatter, output_path]], model_tree: model_tree_root)
+```
+
+
+For more information, see the documentation [here](https://app.cucumber.pro/projects/cuke_linter/documents/branch/master/).
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake cuke_linter:test_everything` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/enkessler/cuke_linter.
+
+1. Fork it
+2. Create your feature branch (off of the development branch)
+   `git checkout -b my-new-feature`
+3. Commit your changes
+   `git commit -am 'Add some feature'`
+4. Push to the branch
+   `git push origin my-new-feature`
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'racatt'
+
+
+namespace 'racatt' do
+  Racatt.create_tasks
+end
+
+namespace 'cuke_linter' do
+
+  desc 'Run all of the tests'
+  task :test_everything do
+    rspec_args = '--pattern testing/rspec/spec/**/*_spec.rb'
+    cucumber_args = "testing/cucumber/features -r environments/cucumber_env.rb -f progress -t 'not @wip'"
+
+    Rake::Task['racatt:test_everything'].invoke(rspec_args, cucumber_args)
+  end
+
+  task :ci_build => 'cuke_linter:test_everything'
+end
+
+
+task :default => 'cuke_linter:test_everything'

data/appveyor.yml

@@ -0,0 +1,24 @@
+version: '1.0.{build}'
+
+environment:
+  matrix:
+    - RUBY_VERSION: 23
+    - RUBY_VERSION: 23-x64
+    - RUBY_VERSION: 24
+    - RUBY_VERSION: 24-x64
+    - RUBY_VERSION: 25
+    - RUBY_VERSION: 25-x64
+
+install:
+  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
+  - bundle install
+
+build: off
+
+before_test:
+  - ruby -v
+  - gem -v
+  - bundle -v
+
+test_script:
+  - bundle exec rake cuke_linter:ci_build

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cuke_linter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cuke_linter.gemspec

@@ -0,0 +1,34 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cuke_linter/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cuke_linter"
+  spec.version       = CukeLinter::VERSION
+  spec.authors       = ["Eric Kessler"]
+  spec.email         = ["morrow748@gmail.com"]
+
+  spec.summary       = %q{Lints feature files used by Cucumber and other similar frameworks.}
+  spec.homepage      = 'https://github.com/enkessler/cuke_linter'
+  spec.license       = "MIT"
+
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'cuke_modeler', '~> 1.5'
+
+  spec.add_development_dependency "bundler", "< 3.0"
+  spec.add_development_dependency "cucumber", "~> 3.0"
+  spec.add_development_dependency "racatt", "~> 1.0"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "require_all", "~> 2.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/environments/common_env.rb

@@ -0,0 +1,11 @@
+require 'require_all'
+
+require 'cuke_linter'
+
+
+require_relative '../testing/model_factory'
+require_relative '../testing/linter_factory'
+require_relative '../testing/formatter_factory'
+require_relative '../testing/file_helper'
+
+PROJECT_ROOT = "#{__dir__}/.."

data/environments/cucumber_env.rb

@@ -0,0 +1,4 @@
+require_relative 'common_env'
+require 'cucumber'
+
+require_all 'testing/cucumber/step_definitions'

data/environments/rspec_env.rb

@@ -0,0 +1,41 @@
+require_relative 'common_env'
+require 'rspec'
+require 'rubygems/mock_gem_ui'
+
+require_relative '../testing/rspec/spec/unit/formatters/formatter_unit_specs'
+require_relative '../testing/rspec/spec/unit/linters/linter_unit_specs'
+require_relative '../testing/rspec/spec/integration/formatters/formatter_integration_specs'
+require_relative '../testing/rspec/spec/integration/linters/linter_integration_specs'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:suite) do
+    # Using a global variable instead of an instance variable because instance variables are not compatible with :suite hooks
+    $default_linters = Marshal.load(Marshal.dump(CukeLinter.registered_linters))
+  end
+
+  # Restore the original linters after any test that modifies them so that other tests can rely on them being only the default ones
+  config.after(:example, :linter_registration) do
+    CukeLinter.clear_registered_linters
+
+    $default_linters.each_pair do |name, linter|
+      CukeLinter.register_linter(name: name, linter: linter)
+    end
+  end
+
+  config.after(:suite) do
+    CukeLinter::FileHelper.created_directories.each do |dir_path|
+      FileUtils.remove_entry(dir_path, true)
+    end
+  end
+
+end

data/exe/cuke_linter

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "cuke_linter"
+
+CukeLinter.lint
+

data/lib/cuke_linter/formatters/pretty_formatter.rb

@@ -0,0 +1,48 @@
+module CukeLinter
+  class PrettyFormatter
+
+    def format(data)
+      categorized_problems = Hash.new { |linters, linter_name| linters[linter_name] = Hash.new { |problems, problem| problems[problem] = [] } }
+
+      data.each do |lint_item|
+        categorized_problems[lint_item[:linter]][lint_item[:problem]] << lint_item[:location]
+      end
+
+      formatted_data = ''
+
+      categorized_problems.each_pair do |linter, problems|
+        formatted_data << linter + "\n"
+
+        problems.each_pair do |problem, locations|
+          formatted_data << "  #{problem}" + "\n"
+
+          sorted_locations = locations.sort do |a, b|
+            location_1 = a.match(/:(\d+)/)[1].to_i
+            location_2 = b.match(/:(\d+)/)[1].to_i
+
+            case
+              when location_1 < location_2
+                -1
+              when location_1 > location_2
+                1
+              else
+                0
+            end
+          end
+
+          sorted_locations.each do |location|
+            formatted_data << "    #{location}\n"
+          end
+        end
+      end
+
+      total_problems = data.count
+      formatted_data << "\n" unless total_problems.zero?
+
+      formatted_data << "#{total_problems} issues found"
+
+      formatted_data
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_without_scenarios_linter.rb

@@ -0,0 +1,22 @@
+module CukeLinter
+  class FeatureWithoutScenariosLinter
+#     # class FeatureWithoutScenariosLinter < BaseLinter
+#
+# #     targets :features
+
+    def name
+      'FeatureWithoutScenariosLinter'
+    end
+
+    def lint(model)
+      return [] unless model.is_a?(CukeModeler::Feature)
+
+      if model.tests.empty?
+        [{ problem: 'Feature has no scenarios', location: "#{model.parent_model.path}:#{model.source_line}" }]
+      else
+        []
+      end
+    end
+
+  end
+end

data/lib/cuke_linter/version.rb

@@ -0,0 +1,3 @@
+module CukeLinter
+  VERSION = "0.1.0"
+end

data/lib/cuke_linter.rb

@@ -0,0 +1,71 @@
+require 'cuke_modeler'
+
+require "cuke_linter/version"
+require 'cuke_linter/formatters/pretty_formatter'
+require 'cuke_linter/linters/feature_without_scenarios_linter'
+
+
+module CukeLinter
+
+  @registered_linters = { 'FeatureWithoutScenariosLinter' => FeatureWithoutScenariosLinter.new }
+
+  def self.register_linter(linter:, name:)
+    @registered_linters[name] = linter
+  end
+
+  def self.unregister_linter(name)
+    @registered_linters.delete(name)
+  end
+
+  def self.registered_linters
+    @registered_linters
+  end
+
+  def self.clear_registered_linters
+    @registered_linters.clear
+  end
+
+  def self.lint(model_tree: CukeModeler::Directory.new(Dir.pwd), linters: @registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]])
+    # puts "model tree: #{model_tree}"
+    # puts "linters: #{linters}"
+    # puts "formatters: #{formatters}"
+
+    linting_data = []
+
+    model_tree.each_model do |model|
+      linters.each do |linter|
+        # 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)
+      end
+    end
+
+    formatters.each do |formatter_output_pair|
+      formatter = formatter_output_pair[0]
+      location  = formatter_output_pair[1]
+
+      formatted_data = formatter.format(linting_data)
+
+      if location
+        File.write(location, formatted_data)
+      else
+        puts formatted_data
+      end
+    end
+
+    # TODO: keep this or always format data?
+    linting_data
+  end
+
+
+# #   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) }
+# #   end
+# #
+# #   private_class_method(:relevant_model?)
+
+end

data/testing/cucumber/features/command_line.feature

@@ -0,0 +1,12 @@
+Feature: Using cuke_linter on the command line
+
+  Linting functionality can be used directly from the command line.
+
+  Scenario: Linting features
+
+    Given the cuke_linter executable is available
+    When the following command is executed:
+    """
+    cuke_linter
+    """
+    Then a linting report will be made for all features

data/testing/cucumber/features/formatters/pretty_formatter.feature

@@ -0,0 +1,24 @@
+Feature: Pretty formatter
+
+  Scenario: Formatting linter data
+    Given the following linter data:
+      | linter name     | problem             | location             |
+      | SomeLinter      | Some problem        | path/to/the_file:1   |
+      | SomeOtherLinter | Some other problem  | path/to/the_file:33  |
+      | SomeOtherLinter | Some other problem  | path/to/the_file:101 |
+      | SomeOtherLinter | Yet another problem | path/to/the_file:55  |
+    When it is formatted by the "pretty" formatter
+    Then the resulting output is the following:
+      """
+      SomeLinter
+        Some problem
+          path/to/the_file:1
+      SomeOtherLinter
+        Some other problem
+          path/to/the_file:33
+          path/to/the_file:101
+        Yet another problem
+          path/to/the_file:55
+
+      4 issues found
+      """

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

@@ -0,0 +1,7 @@
+Feature: Default Linters
+
+
+  Scenario: Using the default linters
+    Given no other linters have been registered
+    Then the following linters are registered by default
+      | FeatureWithoutScenariosLinter |

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

@@ -0,0 +1,12 @@
+Feature: Feature without scenarios linter
+
+  Scenario: Linting
+    Given a linter for features without scenarios
+    And the following feature:
+      """
+      Feature:
+      """
+    When it is linted
+    Then an error is reported
+      | problem                  | location         |
+      | Feature has no scenarios | <path_to_file>:1 |

data/testing/cucumber/step_definitions/action_steps.rb

@@ -0,0 +1,13 @@
+When(/^the following command is executed:$/) do |command|
+  command = "bundle exec ruby #{@executable_directory}/#{command}"
+
+  @output = `#{command}`
+end
+
+When(/^it is formatted by the "([^"]*)" formatter$/) do |linter_name|
+  @results = CukeLinter.const_get("#{linter_name.capitalize}Formatter").new.format(@linter_data)
+end
+
+When(/^it is linted$/) do
+  @results = @linter.lint(@model)
+end

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -0,0 +1,30 @@
+Given(/^the cuke_linter executable is available$/) do
+  @executable_directory = "#{PROJECT_ROOT}/exe"
+end
+
+Given(/^the following linter data:$/) do |linter_data|
+  @linter_data = [].tap do |data|
+    linter_data.hashes.each do |data_point|
+      data << { linter:   data_point['linter name'],
+                problem:  data_point['problem'],
+                location: data_point['location'] }
+    end
+  end
+end
+
+Given(/^the following feature:$/) do |text|
+  @model = CukeModeler::Feature.new(text)
+
+  fake_file_model      = CukeModeler::FeatureFile.new
+  fake_file_model.path = 'path_to_file'
+
+  @model.parent_model = fake_file_model
+end
+
+Given(/^a linter for features without scenarios$/) do
+  @linter = CukeLinter::FeatureWithoutScenariosLinter.new
+end
+
+Given(/^no other linters have been registered$/) do
+  # There is no way to 'reset' the linters, so just assume that no changes have been made
+end