cuke_linter 1.0.0 → 1.0.1

data/lib/cuke_linter/configuration.rb

@@ -0,0 +1,45 @@
+module CukeLinter
+
+  # Mix-in module containing methods related to configuring linters
+  module Configuration
+
+    # Configures linters based on the given options
+    def load_configuration(config_file_path: nil, config: nil)
+      # TODO: define what happens if both a configuration file and a configuration are
+      # provided. Merge them or have direct config take precedence? Both?
+
+      unless config || config_file_path
+        config_file_path = "#{Dir.pwd}/.cuke_linter"
+        message          = 'No configuration or configuration file given and no .cuke_linter file found'
+        raise message unless File.exist?(config_file_path)
+      end
+
+      config ||= YAML.load_file(config_file_path)
+      configure_linters(config, registered_linters)
+    end
+
+
+    private
+
+
+    def configure_linters(configuration, linters)
+      common_config = configuration['AllLinters'] || {}
+      to_delete     = []
+
+      linters.each_pair do |name, linter|
+        linter_config = configuration[name] || {}
+        final_config  = common_config.merge(linter_config)
+
+        disabled = (final_config.key?('Enabled') && !final_config['Enabled'])
+
+        # Just save it for afterwards because modifying a collection while iterating through it is not a good idea
+        to_delete << name if disabled
+
+        linter.configure(final_config) if linter.respond_to?(:configure)
+      end
+
+      to_delete.each { |linter_name| unregister_linter(linter_name) }
+    end
+
+  end
+end

data/lib/cuke_linter/default_linters.rb

@@ -0,0 +1,32 @@
+module CukeLinter
+
+  # Long names inherently result in long lines
+  # rubocop:disable Metrics/LineLength
+  @original_linters = { 'BackgroundDoesMoreThanSetupLinter'            => BackgroundDoesMoreThanSetupLinter.new,
+                        'ElementWithCommonTagsLinter'                  => ElementWithCommonTagsLinter.new,
+                        'ElementWithDuplicateTagsLinter'               => ElementWithDuplicateTagsLinter.new,
+                        'ElementWithTooManyTagsLinter'                 => ElementWithTooManyTagsLinter.new,
+                        'ExampleWithoutNameLinter'                     => ExampleWithoutNameLinter.new,
+                        'FeatureFileWithInvalidNameLinter'             => FeatureFileWithInvalidNameLinter.new,
+                        'FeatureFileWithMismatchedNameLinter'          => FeatureFileWithMismatchedNameLinter.new,
+                        'FeatureWithTooManyDifferentTagsLinter'        => FeatureWithTooManyDifferentTagsLinter.new,
+                        'FeatureWithoutDescriptionLinter'              => FeatureWithoutDescriptionLinter.new,
+                        'FeatureWithoutNameLinter'                     => FeatureWithoutNameLinter.new,
+                        'FeatureWithoutScenariosLinter'                => FeatureWithoutScenariosLinter.new,
+                        'OutlineWithSingleExampleRowLinter'            => OutlineWithSingleExampleRowLinter.new,
+                        'SingleTestBackgroundLinter'                   => SingleTestBackgroundLinter.new,
+                        'StepWithEndPeriodLinter'                      => StepWithEndPeriodLinter.new,
+                        'StepWithTooManyCharactersLinter'              => StepWithTooManyCharactersLinter.new,
+                        'TestShouldUseBackgroundLinter'                => TestShouldUseBackgroundLinter.new,
+                        'TestWithActionStepAsFinalStepLinter'          => TestWithActionStepAsFinalStepLinter.new,
+                        'TestWithBadNameLinter'                        => TestWithBadNameLinter.new,
+                        'TestWithNoActionStepLinter'                   => TestWithNoActionStepLinter.new,
+                        'TestWithNoNameLinter'                         => TestWithNoNameLinter.new,
+                        'TestWithNoVerificationStepLinter'             => TestWithNoVerificationStepLinter.new,
+                        'TestWithSetupStepAfterActionStepLinter'       => TestWithSetupStepAfterActionStepLinter.new,
+                        'TestWithSetupStepAfterVerificationStepLinter' => TestWithSetupStepAfterVerificationStepLinter.new,
+                        'TestWithSetupStepAsFinalStepLinter'           => TestWithSetupStepAsFinalStepLinter.new,
+                        'TestWithTooManyStepsLinter'                   => TestWithTooManyStepsLinter.new }
+  # rubocop:enable Metrics/LineLength
+
+end

data/lib/cuke_linter/formatters/pretty_formatter.rb

@@ -1,55 +1,83 @@
 module CukeLinter
 
   # Formats linting data into organized, user readable text
-
   class PrettyFormatter
 
     # Formats the given linting data
     def format(data)
-      categorized_problems = Hash.new { |linters, linter_name| linters[linter_name] = Hash.new { |problems, problem| problems[problem] = [] } }
+      format_data(categorize_problems(data), data.count)
+    end
+
 
-      data.each do |lint_item|
-        categorized_problems[lint_item[:linter]][lint_item[:problem]] << lint_item[:location]
+    private
+
+
+    def categorize_problems(data)
+      {}.tap do |categorized_problems|
+        data.each do |lint_item|
+          categorized_problems[lint_item[:linter]]                      ||= {}
+          categorized_problems[lint_item[:linter]][lint_item[:problem]] ||= []
+          categorized_problems[lint_item[:linter]][lint_item[:problem]] << lint_item[:location]
+        end
       end
+    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|
-            file_name_1   = a.match(/(.*?)(?::\d+)?$/)[1]
-            line_number_1 = a.match(/:(\d+)$/) ? a.match(/:(\d+)$/)[1].to_i : 0
-            file_name_2   = b.match(/(.*?)(?::\d+)?$/)[1]
-            line_number_2 = b.match(/:(\d+)$/) ? b.match(/:(\d+)$/)[1].to_i : 0
-
-            case
-              when (file_name_1 < file_name_2) ||
-                  (file_name_1 == file_name_2) && (line_number_1 < line_number_2)
-                -1
-              when (file_name_1 > file_name_2) ||
-                  (file_name_1 == file_name_2) && (line_number_1 > line_number_2)
-                1
-              else
-                0
-            end
-          end
+    def format_data(problem_data, problem_count)
+      ''.tap do |formatted_data|
+        problem_data.each_pair do |linter, problems|
+          formatted_data << "#{linter}\n"
 
-          sorted_locations.each do |location|
-            formatted_data << "    #{location}\n"
+          problems.each_pair do |problem, locations|
+            formatted_data << "  #{problem}\n"
+
+            sort_locations(locations).each do |location|
+              formatted_data << "    #{location}\n"
+            end
           end
         end
+
+        formatted_data << "\n" unless problem_count.zero?
+        formatted_data << "#{problem_count} issues found"
       end
+    end
+
+    def sort_locations(locations)
+      locations.sort do |a, b|
+        file_name_1   = a.match(/(.*?)(?::\d+)?$/)[1]
+        line_number_1 = a =~ /:\d+$/ ? a.match(/:(\d+)$/)[1].to_i : 0
+        file_name_2   = b.match(/(.*?)(?::\d+)?$/)[1]
+        line_number_2 = b =~ /:\d+$/ ? b.match(/:(\d+)$/)[1].to_i : 0
+
+        compare_locations(file_name_1, file_name_2, line_number_1, line_number_2)
+      end
+    end
+
+    def compare_locations(file_name_1, file_name_2, line_number_1, line_number_2)
+      if earlier_file(file_name_1, file_name_2) ||
+         same_file_earlier_line(file_name_1, file_name_2, line_number_1, line_number_2)
+        -1
+      elsif later_file(file_name_1, file_name_2) ||
+            same_file_later_line(file_name_1, file_name_2, line_number_1, line_number_2)
+        1
+      else
+        0
+      end
+    end
+
+    def earlier_file(file_name_1, file_name_2)
+      (file_name_1 < file_name_2)
+    end
 
-      total_problems = data.count
-      formatted_data << "\n" unless total_problems.zero?
+    def same_file_earlier_line(file_name_1, file_name_2, line_number_1, line_number_2)
+      (file_name_1 == file_name_2) && (line_number_1 < line_number_2)
+    end
 
-      formatted_data << "#{total_problems} issues found"
+    def later_file(file_name_1, file_name_2)
+      (file_name_1 > file_name_2)
+    end
 
-      formatted_data
+    def same_file_later_line(file_name_1, file_name_2, line_number_1, line_number_2)
+      (file_name_1 == file_name_2) && (line_number_1 > line_number_2)
     end
 
   end

data/lib/cuke_linter/gherkin.rb

@@ -0,0 +1,10 @@
+module CukeLinter
+
+  # The default keyword that is considered a 'Given' keyword
+  DEFAULT_GIVEN_KEYWORD = 'Given'.freeze
+  # The default keyword that is considered a 'When' keyword
+  DEFAULT_WHEN_KEYWORD = 'When'.freeze
+  # The default keyword that is considered a 'Then' keyword
+  DEFAULT_THEN_KEYWORD = 'Then'.freeze
+
+end

data/lib/cuke_linter/linter_registration.rb

@@ -0,0 +1,32 @@
+module CukeLinter
+
+  # Mix-in module containing methods related to registering linters
+  module LinterRegistration
+
+    # Returns the registered linters to their default state
+    def reset_linters
+      @registered_linters = nil
+    end
+
+    # Registers for linting use the given linter object, tracked by the given name
+    def register_linter(linter:, name:)
+      registered_linters[name] = linter
+    end
+
+    # Unregisters the linter object tracked by the given name so that it is not used for linting
+    def unregister_linter(name)
+      registered_linters.delete(name)
+    end
+
+    # Lists the names of the currently registered linting objects
+    def registered_linters
+      @registered_linters ||= Marshal.load(Marshal.dump(@original_linters))
+    end
+
+    # Unregisters all currently registered linting objects
+    def clear_registered_linters
+      registered_linters.clear
+    end
+
+  end
+end

data/lib/cuke_linter/linters/background_does_more_than_setup_linter.rb

@@ -14,7 +14,7 @@ module CukeLinter
     def rule(model)
       return false unless model.is_a?(CukeModeler::Background)
 
-      model.steps.collect(&:keyword).any? { |keyword| when_keywords.include?(keyword) || then_keywords.include?(keyword) }
+      model.steps.map(&:keyword).any? { |keyword| when_keywords.include?(keyword) || then_keywords.include?(keyword) }
     end
 
     # The message used to describe the problem that has been found

data/lib/cuke_linter/linters/element_with_common_tags_linter.rb

@@ -6,36 +6,45 @@ module CukeLinter
 
     # The rule used to determine if a model has a problem
     def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature) || model.is_a?(CukeModeler::Outline)
+      return false unless relevant_model?(model)
 
       @linted_model_class = model.class
-
-      child_accessor_method = model.is_a?(CukeModeler::Feature) ? :tests : :examples
-      child_models          = model.send(child_accessor_method) || []
+      child_models        = model.send(child_accessor_method(model)) || []
 
       tag_sets      = child_models.collect { |child_model| child_model.tags || [] }
       tag_name_sets = tag_sets.collect { |tags| tags.map(&:name) }
 
       return false if tag_name_sets.count < 2
 
-      @common_tag = tag_name_sets.reduce(:&).first
-
-      !@common_tag.nil?
+      !find_common_tag(tag_name_sets).nil?
     end
 
     # The message used to describe the problem that has been found
     def message
       class_name = @linted_model_class.name.split('::').last
 
-      case class_name
-        when 'Feature'
-          "All tests in #{class_name} have tag '#{@common_tag}'. Move tag to #{class_name} level."
-        when 'Outline'
-          "All Examples in #{class_name} have tag '#{@common_tag}'. Move tag to #{class_name} level."
-        else
-          raise("Linted an unexpected model type '#{class_name}'!")
+      if class_name == 'Feature'
+        "All tests in Feature have tag '#{@common_tag}'. Move tag to #{class_name} level."
+      else
+        "All Examples in Outline have tag '#{@common_tag}'. Move tag to #{class_name} level."
       end
     end
 
+
+    private
+
+
+    def relevant_model?(model)
+      model.is_a?(CukeModeler::Feature) || model.is_a?(CukeModeler::Outline)
+    end
+
+    def child_accessor_method(model)
+      model.is_a?(CukeModeler::Feature) ? :tests : :examples
+    end
+
+    def find_common_tag(tag_name_sets)
+      @common_tag = tag_name_sets.reduce(:&).first
+    end
+
   end
 end

data/lib/cuke_linter/linters/element_with_duplicate_tags_linter.rb

@@ -11,22 +11,16 @@ module CukeLinter
 
     # The rule used to determine if a model has a problem
     def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature) ||
-          model.is_a?(CukeModeler::Scenario) ||
-          model.is_a?(CukeModeler::Outline) ||
-          model.is_a?(CukeModeler::Example)
-
+      return false unless relevant_model?(model)
 
       @linted_model_class = model.class
 
-      if @tag_inheritance
-        relevant_tags = model.all_tags
-      else
-        relevant_tags = model.tags || []
-      end
-
-
-      tag_names = relevant_tags.map(&:name)
+      relevant_tags = if @tag_inheritance
+                        model.all_tags
+                      else
+                        model.tags || []
+                      end
+      tag_names     = relevant_tags.map(&:name)
 
       @duplicate_tag = tag_names.find { |tag| tag_names.count(tag) > 1 }
 
@@ -40,5 +34,16 @@ module CukeLinter
       "#{class_name} has duplicate tag '#{@duplicate_tag}'."
     end
 
+
+    private
+
+
+    def relevant_model?(model)
+      model.is_a?(CukeModeler::Feature) ||
+        model.is_a?(CukeModeler::Scenario) ||
+        model.is_a?(CukeModeler::Outline) ||
+        model.is_a?(CukeModeler::Example)
+    end
+
   end
 end

data/lib/cuke_linter/linters/element_with_too_many_tags_linter.rb

@@ -12,20 +12,15 @@ module CukeLinter
 
     # The rule used to determine if a model has a problem
     def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature) ||
-          model.is_a?(CukeModeler::Scenario) ||
-          model.is_a?(CukeModeler::Outline) ||
-          model.is_a?(CukeModeler::Example)
-
+      return false unless relevant_model?(model)
 
       @linted_model_class   = model.class
       @linted_tag_threshold = @tag_threshold || 5
-
-      if @tag_inheritance
-        @linted_tag_count = model.all_tags.count
-      else
-        @linted_tag_count = model.tags.nil? ? 0 : model.tags.count
-      end
+      @linted_tag_count     = if @tag_inheritance
+                                model.all_tags.count
+                              else
+                                model.tags.nil? ? 0 : model.tags.count
+                              end
 
       @linted_tag_count > @linted_tag_threshold
     end
@@ -37,5 +32,16 @@ module CukeLinter
       "#{class_name} has too many tags. #{@linted_tag_count} tags found (max #{@linted_tag_threshold})."
     end
 
+
+    private
+
+
+    def relevant_model?(model)
+      model.is_a?(CukeModeler::Feature) ||
+        model.is_a?(CukeModeler::Scenario) ||
+        model.is_a?(CukeModeler::Outline) ||
+        model.is_a?(CukeModeler::Example)
+    end
+
   end
 end

data/lib/cuke_linter/linters/feature_with_too_many_different_tags_linter.rb

@@ -16,9 +16,7 @@ module CukeLinter
       tags = model.tags
 
       model.each_descendant do |descendant_model|
-        if descendant_model.respond_to?(:tags)
-          tags.concat(descendant_model.tags)
-        end
+        tags.concat(descendant_model.tags) if descendant_model.respond_to?(:tags)
       end
 
       tags = tags.collect(&:name).uniq

data/lib/cuke_linter/linters/feature_without_description_linter.rb

@@ -13,7 +13,7 @@ module CukeLinter
 
     # The message used to describe the problem that has been found
     def message
-      "Feature has no description"
+      'Feature has no description'
     end
 
   end

data/lib/cuke_linter/linters/linter.rb

@@ -4,6 +4,9 @@ module CukeLinter
 
   class Linter
 
+    # Returns the name of the linter
+    attr_reader :name
+
     # Creates a new linter object
     def initialize(name: nil, message: nil, rule: nil)
       @name    = name || self.class.name.split('::').last
@@ -11,27 +14,28 @@ module CukeLinter
       @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
+      return nil unless problem_found
+
+      build_problem(model)
+    end
+
+
+    private
+
+
+    def build_problem(model)
+      problem_message = respond_to?(:message) ? message : @message
 
-        if model.is_a?(CukeModeler::FeatureFile)
-          { problem: problem_message, location: "#{model.path}" }
-        else
-          { problem: problem_message, location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
-        end
+      if model.is_a?(CukeModeler::FeatureFile)
+        { problem: problem_message, location: model.path }
       else
-        nil
+        { problem: problem_message, location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
       end
     end