cuke_linter 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d4a41e4f1d37dde72387b44003228f891855230312e1da57ffe227fa7f1f853
-  data.tar.gz: ec0842ceccb4025aad332923ae0df4d921250f58f5f2a97f82818b0d7d0717c4
+  metadata.gz: 7b5619ded0f8f0a4db213f7c2505b8868865ea4f5a40991515bf8324c474d5b4
+  data.tar.gz: 93c3214e99988dcfd03d6ce2eb15d291b8a1bbbc04a9af0f5c6f280a6fdccd6d
 SHA512:
-  metadata.gz: c8c38a81b0d6fe47db0f46eaefbc61a8c00305f90273d752fc81e7eb364278f2dc36cc7bf09b487bb183543a27b3380fe219eb7049d934e54fb2f117bc1a31a9
-  data.tar.gz: 8f8a924840f5ce979fe6037e85dca647eb70f91b1f7b2a1a3ee9e31716af04475a9b54095769d703cb796b41c6089366e1dd6d0a61652fd4cc430330fb774df7
+  metadata.gz: 325b5aadbcf822a5e00ffd1ca7db7c26c4e7c6d63673c509247c49364cd09a365b6c5bcb9e42d4a01ebfe12f8bd85378bc639bb41356bca5766c96334a934046
+  data.tar.gz: 6ba5e64086bc5f79716408d6383b281ef468e63dc405423f216c05d6b3a342c0fedf3d2fee9bc4ba8b896a6db8004a40852fb0ed245c8b89328ba4df52bf7402

data/CHANGELOG.md

@@ -8,6 +8,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [0.6.0] - 2019-06-25
+
+### Added
+ - File paths can now be provided for linting without the user first having to turn them into models themselves.
+ - Option flags have been added to the command line interface. This will allow more flexibility when running from the command line and thereby reduce the need for writing a Ruby script for even basic usages of the gem.
+ 
+### Changed
+ - Linting is now done using a collection of model trees instead of taking only a single model tree. 
+
+### Fixed
+ - Fixed a bug in the 'pretty' formatter that was causing problems to be ordered by line number instead of being ordered by file (and then by line number within those files).
+ - Added a missing `require` statement that is needed if no other code in the runtime environment has loaded the needed library already.
+ - Fixed a bug where enabling/disabling a linter would trigger additional configuration of the linter, even for linters that could not be configured.
+ 
 ## [0.5.0] - 2019-05-25
 
 ### Added
@@ -51,7 +65,8 @@ Nothing yet...
 - Custom linters, formatters, and command line usability
 
 
-[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/enkessler/cuke_linter/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/enkessler/cuke_linter/compare/v0.4.0...v0.5.0
 [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

data/README.md

@@ -9,7 +9,7 @@ User stuff:
 
 Developer stuff:
 [![Build Status](https://travis-ci.org/enkessler/cuke_linter.svg?branch=dev)](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)
+[![Build Status](https://ci.appveyor.com/api/projects/status/g5o70u747x073evy/branch/dev?svg=true)](https://ci.appveyor.com/project/enkessler/cuke-linter/branch/dev)
 [![Coverage Status](https://coveralls.io/repos/github/enkessler/cuke_linter/badge.svg?branch=dev)](https://coveralls.io/github/enkessler/cuke_linter?branch=dev)
 [![Maintainability](https://api.codeclimate.com/v1/badges/d1b86760e59a457c8e73/maintainability)](https://codeclimate.com/github/enkessler/cuke_linter/maintainability)
 [![Inline docs](http://inch-ci.org/github/enkessler/cuke_linter.svg?branch=dev)](https://inch-ci.org/github/enkessler/cuke_linter?branch=dev)
@@ -40,12 +40,18 @@ Or install it yourself as:
 
 ## Usage
 
+#### From the command line
+
 The easiest way to use the gem is to use all of the defaults by invoking it from the command line directly.
 
 ```
 $ cuke_linter
 ```
 
+Additional command line options can be provided that can adjust the default behavior. See [documentation](#documentation) for specifics.
+
+#### From a Ruby script
+
 The linter can also be used inside of a Ruby script, like so:
 
 ```
@@ -54,20 +60,20 @@ 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.
+The linting will happen against a tree of `CukeModeler` models that is generated based on the current directory. You can generate your own model trees and use them instead, if desired, or even provide specific file paths that will be modeled and linted.
 
-Custom linters can be any object that responds to `#lint` and returns a detected issue (or `nil`) in the format of
+`cuke_linter` comes with a set of pre-made linters and will use them by default but custom linters can be used instead. 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' }
 ```
 
-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.
+Note that a linter will receive, in turn, *every model* in a 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:
+`cuke_linter` comes with a set of pre-made formatters and will use them by default but custom formatters can be used instead. Custom formatters can be any object that responds to `#format` and takes input data in the following format:
 
 ```
 [
@@ -122,13 +128,14 @@ class MyCustomFormatter
 
 end
 
-linter          = MyCustomLinter.new
-formatter       = MyCustomFormatter.new
-output_path     = "#{__dir__}/my_report.txt"
-model_tree_root = CukeModeler::Directory.new(Dir.pwd)
+linter               = MyCustomLinter.new
+formatter            = MyCustomFormatter.new
+output_path          = "#{__dir__}/my_report.txt"
+model_tree_root      = CukeModeler::Directory.new(Dir.pwd)
+additional_file_path = 'path/to/some.feature'
 
 # 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)
+CukeLinter.lint(linters: [linter], formatters: [[formatter], [formatter, output_path]], model_trees: [model_tree_root], file_paths: [additional_file_path])
 ```
 
 ### Configuration

data/exe/cuke_linter

@@ -1,6 +1,108 @@
 #!/usr/bin/env ruby
 
 require "cuke_linter"
+require 'optparse'
 
-CukeLinter.lint
+params              = {}
+params[:paths]      = []
+params[:formatters] = []
+params[:outs]       = []
+params[:requires]   = []
 
+parser = OptionParser.new do |options|
+
+  options.set_summary_width(30)
+
+  options.on('-p', '--path PATH', String,
+             'The file path that should be linted. Can be a file or directory.',
+             'This option can be specified multiple times in order to lint',
+             'multiple, unconnected locations.') do |path|
+    params[:paths] << path
+  end
+
+  options.on('-f', '--formatter FORMATTER', String,
+             'The formatter used for generating linting output. This option',
+             'can be specified multiple times in order to use more than one',
+             'formatter. Formatters must be specified using their fully',
+             'qualified class name (e.g CukeLinter::PrettyFormatter). Uses',
+             'the default formatter if none are specified.') do |format|
+    params[:formatters] << format
+  end
+
+  options.on('-o', '--out OUT', String,
+             'The file path to which linting results are output. Can be specified',
+             'multiple times. Specified files are matched to formatters in the',
+             'same order that the formatters are specified. Any formatter without',
+             'a corresponding file path will output to STDOUT instead.') do |out|
+    params[:outs] << out
+  end
+
+  options.on('-r', '--require FILEPATH', String,
+             'A file that will be required before further processing. Likely',
+             'needed when using custom linters or formatters in order to ensure',
+             'that the specified classes have been read into memory. This option',
+             'can be specified multiple times in order to load more than one file.') do |file_path|
+    params[:requires] << file_path
+  end
+
+  options.on('-c', '--config FILEPATH', String,
+             'The configuration file that will be used. Will use the default',
+             'configuration file (if present) if this option is not specified.') do |file_path|
+
+    if params[:config]
+      puts 'Cannot specify more than one configuration file!'
+      exit(1)
+    end
+
+    params[:config] = file_path
+  end
+
+  options.on('-h', '--help', 'Display the help that you are reading now.') do
+    puts options.help
+    exit
+  end
+
+  options.on('-v', '--version', 'Display the version of the gem being used.') do
+    puts CukeLinter::VERSION
+    exit
+  end
+
+end
+
+begin
+  parser.parse!
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+  puts e.message
+  puts parser.help
+
+  exit(1)
+end
+
+
+require_files = params[:requires]
+
+require_files.each do |file|
+  require file
+end
+
+file_paths   = params[:paths]
+formatters   = params[:formatters].map { |formatter| Kernel.const_get(formatter).new }
+output_paths = params[:outs]
+
+bundled_formatters = [].tap do |formatter_output_pairs|
+  [formatters.count, output_paths.count].max.times do |count|
+    formatter_output_pairs << [formatters[count] || CukeLinter::PrettyFormatter.new, output_paths[count]]
+  end
+end
+
+options              = {}
+options[:formatters] = bundled_formatters unless bundled_formatters.empty?
+options[:file_paths] = file_paths
+
+if params[:config]
+  CukeLinter.load_configuration(config_file_path: params[:config])
+elsif File.exist?("#{Dir.pwd}/.cuke_linter")
+  CukeLinter.load_configuration
+end
+
+CukeLinter.lint(options)

data/lib/cuke_linter.rb

@@ -1,3 +1,4 @@
+require 'yaml'
 require 'cuke_modeler'
 
 require "cuke_linter/version"
@@ -27,7 +28,7 @@ module CukeLinter
                         'StepWithEndPeriodLinter'           => StepWithEndPeriodLinter.new,
                         'StepWithTooManyCharactersLinter'   => StepWithTooManyCharactersLinter.new,
                         'TestWithTooManyStepsLinter'        => TestWithTooManyStepsLinter.new }
-                        
+
 
   # Configures linters based on the given options
   def self.load_configuration(config_file_path: nil, config: nil)
@@ -39,11 +40,11 @@ module CukeLinter
     end
 
     config = config || YAML.load_file(config_file_path)
-    
+
     config.each_pair do |linter_name, options|
       unregister_linter(linter_name) if options.key?('Enabled') && !options['Enabled']
 
-      registered_linters[linter_name].configure(options) if registered_linters[linter_name]
+      registered_linters[linter_name].configure(options) if registered_linters[linter_name] && registered_linters[linter_name].respond_to?(:configure)
     end
   end
 
@@ -72,24 +73,37 @@ module CukeLinter
     self.registered_linters.clear
   end
 
-  # Lints the tree of model objects rooted at the given model using the given linting objects and formatting the results with the given formatters and their respective output locations
-  def self.lint(model_tree: CukeModeler::Directory.new(Dir.pwd), linters: self.registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]])
-    # puts "model tree: #{model_tree}"
-    # puts "linters: #{linters}"
-    # puts "formatters: #{formatters}"
+  # Lints the given model trees and file paths using the given linting objects and formatting the results with the given formatters and their respective output locations
+  def self.lint(file_paths: [], model_trees: [], linters: self.registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]])
+
+    model_trees      = [CukeModeler::Directory.new(Dir.pwd)] if model_trees.empty? && file_paths.empty?
+    file_path_models = file_paths.collect do |file_path|
+      # TODO: raise exception unless path exists
+      case
+        when File.directory?(file_path)
+          CukeModeler::Directory.new(file_path)
+        when File.file?(file_path) && File.extname(file_path) == '.feature'
+          CukeModeler::FeatureFile.new(file_path)
+        else
+          # Non-feature files are not modeled
+      end
+    end.compact # Compacting in order to get rid of any `nil` values left over from non-feature files
 
     linting_data = []
+    model_sets   = model_trees + file_path_models
 
-    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)
+    model_sets.each do |model_tree|
+      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)
 
-        result = linter.lint(model)
+          result = linter.lint(model)
 
-        if result
-          result[:linter] = linter.name
-          linting_data << result
+          if result
+            result[:linter] = linter.name
+            linting_data << result
+          end
         end
       end
     end

data/lib/cuke_linter/formatters/pretty_formatter.rb

@@ -21,13 +21,17 @@ module CukeLinter
           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
+            file_name_1   = a.match(/(.*):\d+$/)[1]
+            line_number_1 = a.match(/:(\d+)$/)[1].to_i
+            file_name_2   = b.match(/(.*):\d+$/)[1]
+            line_number_2 = b.match(/:(\d+)$/)[1].to_i
 
             case
-              when location_1 < location_2
+              when (file_name_1 < file_name_2) ||
+                  (file_name_1 == file_name_2) && (line_number_1 < line_number_2)
                 -1
-              when location_1 > location_2
+              when (file_name_1 > file_name_2) ||
+                  (file_name_1 == file_name_2) && (line_number_1 > line_number_2)
                 1
               else
                 0

data/lib/cuke_linter/version.rb

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

data/testing/cucumber/features/command_line.feature

@@ -2,11 +2,188 @@ Feature: Using cuke_linter on the command line
 
   Linting functionality can be used directly from the command line.
 
+
   Scenario: Linting features
 
+  Note: By default, linting will be done in the current directory using all linters and 'pretty' formatter.
+
     Given the cuke_linter executable is available
     When the following command is executed:
-    """
-    cuke_linter
-    """
+      """
+      cuke_linter
+      """
     Then a linting report will be made for all features
+
+  Scenario: Accessing command line help
+    Given the cuke_linter executable is available
+    When the following command is executed:
+      """
+      cuke_linter -h
+      """
+    Then the following help is displayed:
+      """
+      Usage: cuke_linter [options]
+          -p, --path PATH                The file path that should be linted. Can be a file or directory.
+                                         This option can be specified multiple times in order to lint
+                                         multiple, unconnected locations.
+          -f, --formatter FORMATTER      The formatter used for generating linting output. This option
+                                         can be specified multiple times in order to use more than one
+                                         formatter. Formatters must be specified using their fully
+                                         qualified class name (e.g CukeLinter::PrettyFormatter). Uses
+                                         the default formatter if none are specified.
+          -o, --out OUT                  The file path to which linting results are output. Can be specified
+                                         multiple times. Specified files are matched to formatters in the
+                                         same order that the formatters are specified. Any formatter without
+                                         a corresponding file path will output to STDOUT instead.
+          -r, --require FILEPATH         A file that will be required before further processing. Likely
+                                         needed when using custom linters or formatters in order to ensure
+                                         that the specified classes have been read into memory. This option
+                                         can be specified multiple times in order to load more than one file.
+          -c, --config FILEPATH          The configuration file that will be used. Will use the default
+                                         configuration file (if present) if this option is not specified.
+          -h, --help                     Display the help that you are reading now.
+          -v, --version                  Display the version of the gem being used.
+      """
+
+  Scenario: Checking the version of CukeLinter
+    Given the cuke_linter executable is available
+    When the following command is executed:
+      """
+      cuke_linter -v
+      """
+    Then the version of the tool is displayed:
+      """
+      <major>.<minor>.<patch>
+      """
+
+  Scenario: Specifying directories and files to lint
+    Given the following feature file "some.feature":
+      """
+      Feature:
+        Scenario: A scenario
+          * a step
+      """
+    And the following feature file "a_directory/with_a.feature":
+      """
+      Feature:
+        Scenario: A scenario
+          * a step
+      """
+    When the following command is executed:
+      """
+      cuke_linter -p <path_to>/some.feature -p <path_to>/a_directory
+      """
+    Then the resulting output is the following:
+      """
+      FeatureWithoutDescriptionLinter
+        Feature has no description
+          <path_to>/a_directory/with_a.feature:1
+          <path_to>/some.feature:1
+
+      2 issues found
+      """
+
+  Scenario: Loading additional files
+    Given the following file "some_important_file.rb":
+      """
+      puts 'I got loaded!'
+      """
+    When the following command is executed:
+      """
+      cuke_linter -r <path_to>/some_important_file.rb
+      """
+    Then the resulting output will include the following:
+      """
+      I got loaded!
+      """
+
+  Scenario: Specifying a formatter to use
+
+  Note: The file containing the formatter class will have to be explicitly loaded if not using one of the built in formatters
+
+    Given the following feature file "some.feature":
+      """
+      Feature: This feature will have linted problems
+      """
+    And the following file "my_custom_formatter.rb":
+      """
+      class MyCustomFormatter
+        def format(data)
+          puts "Formatting done by #{self.class}"
+        end
+      end
+      """
+    When the following command is executed:
+      """
+      cuke_linter -p <path_to>/some.feature -f MyCustomFormatter -r <path_to>/my_custom_formatter.rb
+      """
+    Then the resulting output is the following:
+      """
+      Formatting done by MyCustomFormatter
+      """
+
+  Scenario: Redirecting output
+    Given the cuke_linter executable is available
+    When the following command is executed:
+      """
+      cuke_linter -o <path_to>/my_report.txt
+      """
+    Then the linting report will be output to "<path_to>/my_report.txt"
+
+  Scenario: Redirecting output for specific formatters
+
+  Note: Formatters match to output locations in the same order that they are specified. Formatters that do not have their output location specified will output to STDOUT. Output locations that are not matched to a formatter will use the default formatter.
+
+    Given the following feature file "some.feature":
+      """
+      Feature: This feature will have linted problems
+      """
+    And the following file "my_custom_formatters.rb":
+      """
+      class MyCustomFormatter
+        def format(data)
+          "Formatting done by #{self.class}"
+        end
+      end
+
+      class MyOtherCustomFormatter
+        def format(data)
+          "Formatting done by #{self.class}"
+        end
+      end
+      """
+    When the following command is executed:
+      """
+      cuke_linter -p <path_to>/some.feature -f MyCustomFormatter -f MyOtherCustomFormatter -o <path_to>/my_report.txt  -r <path_to>/my_custom_formatters.rb
+      """
+    Then the resulting output is the following:
+      """
+      Formatting done by MyOtherCustomFormatter
+      """
+    And the file "<path_to>/my_report.txt" contains:
+      """
+      Formatting done by MyCustomFormatter
+      """
+
+  Scenario: Specifying a configuration file
+
+  Note: If not specified, the default configuration file, if present, will be used
+
+    Given the following feature file "has_no_scenarios.feature":
+      """
+      Feature: This feature
+        has no scenarios
+     """
+    And the following configuration file "my_config.file":
+      """
+      FeatureWithoutScenariosLinter:
+        Enabled: false
+      """
+    When the following command is executed:
+      """
+      cuke_linter -p <path_to>/has_no_scenarios.feature -c <path_to>/my_config.file
+      """
+    Then the resulting output is the following:
+      """
+      0 issues found
+      """