cuke_linter 1.3.0 → 1.4.0

data/lib/cuke_linter/linters/background_does_more_than_setup_linter.rb

@@ -1,35 +1,35 @@
-module CukeLinter
-
-  # A linter that detects backgrounds that have non-setup steps
-  class BackgroundDoesMoreThanSetupLinter < Linter
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @when_keywords = options['When']
-      @then_keywords = options['Then']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Background)
-
-      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
-    def message
-      'Background has non-setup steps'
-    end
-
-    private
-
-    def when_keywords
-      @when_keywords || [DEFAULT_WHEN_KEYWORD]
-    end
-
-    def then_keywords
-      @then_keywords || [DEFAULT_THEN_KEYWORD]
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects backgrounds that have non-setup steps
+  class BackgroundDoesMoreThanSetupLinter < Linter
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @when_keywords = options['When']
+      @then_keywords = options['Then']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Background)
+
+      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
+    def message
+      'Background has non-setup steps'
+    end
+
+    private
+
+    def when_keywords
+      @when_keywords || [DEFAULT_WHEN_KEYWORD]
+    end
+
+    def then_keywords
+      @then_keywords || [DEFAULT_THEN_KEYWORD]
+    end
+
+  end
+end

data/lib/cuke_linter/linters/element_with_common_tags_linter.rb

@@ -1,49 +1,49 @@
-module CukeLinter
-
-  # A linter that detects Gherkin elements that have the same tag on all of their taggable child elements
-  class ElementWithCommonTagsLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless relevant_model?(model)
-
-      @linted_model_class = model.class
-      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
-
-      !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
-
-      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
+module CukeLinter
+
+  # A linter that detects Gherkin elements that have the same tag on all of their taggable child elements
+  class ElementWithCommonTagsLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model) # rubocop:disable Metrics/CyclomaticComplexity -- Rules can be tightened up later
+      return false unless relevant_model?(model)
+
+      @linted_model_class = model.class
+      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
+
+      !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
+
+      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

@@ -1,48 +1,48 @@
-module CukeLinter
-
-  # A linter that detects taggable Gherkin elements that have duplicate tags
-  class ElementWithDuplicateTagsLinter < Linter
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @tag_inheritance = options['IncludeInheritedTags']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless relevant_model?(model)
-
-      @linted_model_class = model.class
-
-      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 }
-
-      !@duplicate_tag.nil?
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      class_name = @linted_model_class.name.split('::').last
-
-      "#{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
+module CukeLinter
+
+  # A linter that detects taggable Gherkin elements that have duplicate tags
+  class ElementWithDuplicateTagsLinter < Linter
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @tag_inheritance = options['IncludeInheritedTags']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless relevant_model?(model)
+
+      @linted_model_class = model.class
+
+      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 }
+
+      !@duplicate_tag.nil?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      class_name = @linted_model_class.name.split('::').last
+
+      "#{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

@@ -1,46 +1,46 @@
-module CukeLinter
-
-  # A linter that detects taggable Gherkin elements that have too many tags
-  class ElementWithTooManyTagsLinter < Linter
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @tag_threshold   = options['TagCountThreshold']
-      @tag_inheritance = options['CountInheritedTags']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless relevant_model?(model)
-
-      @linted_model_class   = model.class
-      @linted_tag_threshold = @tag_threshold || 5
-      @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
-
-    # The message used to describe the problem that has been found
-    def message
-      class_name = @linted_model_class.name.split('::').last
-
-      "#{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
+module CukeLinter
+
+  # A linter that detects taggable Gherkin elements that have too many tags
+  class ElementWithTooManyTagsLinter < Linter
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @tag_threshold   = options['TagCountThreshold']
+      @tag_inheritance = options['CountInheritedTags']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless relevant_model?(model)
+
+      @linted_model_class   = model.class
+      @linted_tag_threshold = @tag_threshold || 5
+      @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
+
+    # The message used to describe the problem that has been found
+    def message
+      class_name = @linted_model_class.name.split('::').last
+
+      "#{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/example_without_name_linter.rb

@@ -1,19 +1,19 @@
-module CukeLinter
-
-  # A linter that detects unnamed example groups
-  class ExampleWithoutNameLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Example)
-
-      model.name.nil? || model.name.empty?
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Example grouping has no name'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects unnamed example groups
+  class ExampleWithoutNameLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Example)
+
+      model.name.nil? || model.name.empty?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Example grouping has no name'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_file_with_invalid_name_linter.rb

@@ -1,20 +1,20 @@
-module CukeLinter
-
-  # A linter that detects invalid feature file names
-  class FeatureFileWithInvalidNameLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::FeatureFile)
-
-      base = File.basename model.path
-      base =~ /[A-Z -]/
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Feature files should be snake_cased.'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects invalid feature file names
+  class FeatureFileWithInvalidNameLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::FeatureFile)
+
+      base = File.basename model.path
+      base =~ /[A-Z -]/
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Feature files should be snake_cased.'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_file_with_mismatched_name_linter.rb

@@ -1,25 +1,25 @@
-module CukeLinter
-
-  # A linter that detects mismatched feature file names
-  class FeatureFileWithMismatchedNameLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::FeatureFile)
-
-      file_name    = File.basename(model.path, '.feature')
-      feature_name = model.feature.name
-
-      normalized_file_name    = file_name.downcase.delete('_ -')
-      normalized_feature_name = feature_name.downcase.delete('_ -')
-
-      normalized_file_name != normalized_feature_name
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Feature file name does not match feature name.'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects mismatched feature file names
+  class FeatureFileWithMismatchedNameLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::FeatureFile)
+
+      file_name    = File.basename(model.path, '.feature')
+      feature_name = model.feature.name
+
+      normalized_file_name    = file_name.downcase.delete('_ -')
+      normalized_feature_name = feature_name.downcase.delete('_ -')
+
+      normalized_file_name != normalized_feature_name
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Feature file name does not match feature name.'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_with_too_many_different_tags_linter.rb

@@ -1,35 +1,35 @@
-module CukeLinter
-
-  # A linter that detects features that contain too many different tags
-  class FeatureWithTooManyDifferentTagsLinter < Linter
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @tag_threshold = options['TagCountThreshold']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature)
-
-      tags = model.tags
-
-      model.each_descendant do |descendant_model|
-        tags.concat(descendant_model.tags) if descendant_model.respond_to?(:tags)
-      end
-
-      tags = tags.collect(&:name).uniq
-
-      @linted_tag_threshold = @tag_threshold || 10
-      @linted_tag_count     = tags.count
-
-      @linted_tag_count > @linted_tag_threshold
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      "Feature contains too many different tags. #{@linted_tag_count} tags found (max #{@linted_tag_threshold})."
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects features that contain too many different tags
+  class FeatureWithTooManyDifferentTagsLinter < Linter
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @tag_threshold = options['TagCountThreshold']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Feature)
+
+      tags = model.tags
+
+      model.each_descendant do |descendant_model|
+        tags.concat(descendant_model.tags) if descendant_model.respond_to?(:tags)
+      end
+
+      tags = tags.collect(&:name).uniq
+
+      @linted_tag_threshold = @tag_threshold || 10
+      @linted_tag_count     = tags.count
+
+      @linted_tag_count > @linted_tag_threshold
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Feature contains too many different tags. #{@linted_tag_count} tags found (max #{@linted_tag_threshold})."
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_without_description_linter.rb

@@ -1,19 +1,19 @@
-module CukeLinter
-
-  # A linter that detects features that don't have a description
-  class FeatureWithoutDescriptionLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature)
-
-      model.description.nil? || model.description.empty?
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Feature has no description'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects features that don't have a description
+  class FeatureWithoutDescriptionLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Feature)
+
+      model.description.nil? || model.description.empty?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Feature has no description'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_without_name_linter.rb

@@ -1,19 +1,19 @@
-module CukeLinter
-
-  # A linter that detects features that don't have a name
-  class FeatureWithoutNameLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Feature)
-
-      model.name.nil? || model.name.empty?
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Feature does not have a name.'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects features that don't have a name
+  class FeatureWithoutNameLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Feature)
+
+      model.name.nil? || model.name.empty?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Feature does not have a name.'
+    end
+
+  end
+end