cuke_linter 1.3.0 → 1.4.0

data/lib/cuke_linter/linters/feature_without_scenarios_linter.rb

@@ -1,23 +1,23 @@
-module CukeLinter
-
-  # A linter that detects empty features
-  class FeatureWithoutScenariosLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model) # rubocop:disable Metrics/CyclomaticComplexity # It's good enough
-      return false unless model.is_a?(CukeModeler::Feature)
-
-      feature_tests = model.tests && model.tests.any?
-      rule_tests    = model.respond_to?(:rules) && # Earlier versions of CukeModeler did not have Rule models
-                      model.rules && model.rules.any? { |rule| rule.tests && rule.tests.any? }
-
-      !(feature_tests || rule_tests)
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Feature has no scenarios'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects empty features
+  class FeatureWithoutScenariosLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model) # rubocop:disable Metrics/CyclomaticComplexity -- It's good enough
+      return false unless model.is_a?(CukeModeler::Feature)
+
+      feature_tests = model.tests && model.tests.any?
+      rule_tests    = model.respond_to?(:rules) && # Earlier versions of CukeModeler did not have Rule models
+                      model.rules && model.rules.any? { |rule| rule.tests && rule.tests.any? }
+
+      !(feature_tests || rule_tests)
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Feature has no scenarios'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/linter.rb

@@ -1,42 +1,42 @@
-module CukeLinter
-
-  # A generic linter that can be used to make arbitrary linting rules
-  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
-      @message = message || "#{self.name} problem detected"
-      @rule    = rule
-    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)
-
-      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
-    end
-
-  end
-end
+module CukeLinter
+
+  # A generic linter that can be used to make arbitrary linting rules
+  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
+      @message = message || "#{self.name} problem detected"
+      @rule    = rule
+    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)
+
+      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
+    end
+
+  end
+end

data/lib/cuke_linter/linters/outline_with_single_example_row_linter.rb

@@ -1,22 +1,22 @@
-module CukeLinter
-
-  # A linter that detects outlines that don't have multiple example rows
-  class OutlineWithSingleExampleRowLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Outline)
-      return false if model.examples.nil?
-
-      examples_rows = model.examples.collect(&:argument_rows).flatten
-
-      examples_rows.count == 1
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Outline has only one example row'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects outlines that don't have multiple example rows
+  class OutlineWithSingleExampleRowLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Outline)
+      return false if model.examples.nil?
+
+      examples_rows = model.examples.collect(&:argument_rows).flatten
+
+      examples_rows.one?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Outline has only one example row'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/single_test_background_linter.rb

@@ -1,19 +1,19 @@
-module CukeLinter
-
-  # A linter that detects backgrounds that apply to only one test
-  class SingleTestBackgroundLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Background)
-
-      model.parent_model.tests.count == 1
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Background used with only one test'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects backgrounds that apply to only one test
+  class SingleTestBackgroundLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Background)
+
+      model.parent_model.tests.one?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Background used with only one test'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/step_with_end_period_linter.rb

@@ -1,19 +1,19 @@
-module CukeLinter
-
-  # A linter that detects steps that end in a period
-  class StepWithEndPeriodLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Step)
-
-      model.text.end_with?('.')
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Step ends with a period'
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects steps that end in a period
+  class StepWithEndPeriodLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Step)
+
+      model.text.end_with?('.')
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Step ends with a period'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/step_with_too_many_characters_linter.rb

@@ -1,38 +1,38 @@
-module CukeLinter
-
-  # A linter that detects steps that are too long
-  class StepWithTooManyCharactersLinter < Linter
-
-    # The threshold used if not otherwise configured
-    DEFAULT_STEP_LENGTH_THRESHOLD = 80
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @step_length_threshold = options['StepLengthThreshold'] if options['StepLengthThreshold']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Step)
-
-      @linted_step_length = model.text.nil? ? 0 : model.text.length
-
-      @linted_step_length > step_length_threshold
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      "Step is too long. #{@linted_step_length} characters found (max #{step_length_threshold})"
-    end
-
-
-    private
-
-
-    # The maximum length allowable of a step
-    def step_length_threshold
-      @step_length_threshold || DEFAULT_STEP_LENGTH_THRESHOLD
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects steps that are too long
+  class StepWithTooManyCharactersLinter < Linter
+
+    # The threshold used if not otherwise configured
+    DEFAULT_STEP_LENGTH_THRESHOLD = 80
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @step_length_threshold = options['StepLengthThreshold'] if options['StepLengthThreshold']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Step)
+
+      @linted_step_length = model.text.nil? ? 0 : model.text.length
+
+      @linted_step_length > step_length_threshold
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Step is too long. #{@linted_step_length} characters found (max #{step_length_threshold})"
+    end
+
+
+    private
+
+
+    # The maximum length allowable of a step
+    def step_length_threshold
+      @step_length_threshold || DEFAULT_STEP_LENGTH_THRESHOLD
+    end
+
+  end
+end

data/lib/cuke_linter/linters/test_name_with_too_many_characters_linter.rb

@@ -1,38 +1,38 @@
-module CukeLinter
-
-  # A linter that detects test names that are too long
-  class TestNameWithTooManyCharactersLinter < Linter
-
-    # The threshold used if not otherwise configured
-    DEFAULT_TEST_NAME_LENGTH_THRESHOLD = 80
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @test_name_length_threshold = options['TestNameLengthThreshold'] if options['TestNameLengthThreshold']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
-
-      @linted_test_name_length = model.name.nil? ? 0 : model.name.length
-
-      @linted_test_name_length > test_name_length_threshold
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      "Scenario name is too long. #{@linted_test_name_length} characters found (max #{test_name_length_threshold})"
-    end
-
-
-    private
-
-
-    # The maximum length allowable of a scenario name
-    def test_name_length_threshold
-      @test_name_length_threshold || DEFAULT_TEST_NAME_LENGTH_THRESHOLD
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects test names that are too long
+  class TestNameWithTooManyCharactersLinter < Linter
+
+    # The threshold used if not otherwise configured
+    DEFAULT_TEST_NAME_LENGTH_THRESHOLD = 80
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @test_name_length_threshold = options['TestNameLengthThreshold'] if options['TestNameLengthThreshold']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
+
+      @linted_test_name_length = model.name.nil? ? 0 : model.name.length
+
+      @linted_test_name_length > test_name_length_threshold
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Scenario name is too long. #{@linted_test_name_length} characters found (max #{test_name_length_threshold})"
+    end
+
+
+    private
+
+
+    # The maximum length allowable of a scenario name
+    def test_name_length_threshold
+      @test_name_length_threshold || DEFAULT_TEST_NAME_LENGTH_THRESHOLD
+    end
+
+  end
+end

data/lib/cuke_linter/linters/test_should_use_background_linter.rb

@@ -1,80 +1,80 @@
-# TODO: Make a new class that it is from the POV of a Feature model instead
-
-module CukeLinter
-
-  # A linter that detects scenarios and outlines within a feature that all share common beginning steps
-  class TestShouldUseBackgroundLinter < Linter
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
-
-      model_steps          = model.steps || []
-      parent_feature_model = model.get_ancestor(:feature)
-
-      return false unless parent_feature_model.tests.count > 1
-
-      matching_steps     = all_first_steps_match?(parent_feature_model, model_steps)
-      none_parameterized = no_parameterized_steps?(parent_feature_model)
-
-      matching_steps && none_parameterized
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      'Test shares steps with all other tests in feature. Use a background.'
-    end
-
-
-    private
-
-
-    def all_first_steps_match?(feature_model, model_steps)
-      feature_model.tests.all? do |test|
-        test_steps = test.steps || []
-        test_steps.first == model_steps.first
-      end
-    end
-
-    def no_parameterized_steps?(feature_model)
-      feature_model.tests.none? do |test|
-        next false if test.is_a?(CukeModeler::Scenario)
-
-        test_steps          = test.steps || []
-        params_used_by_test = test.examples.map(&:parameters).flatten.uniq
-
-        next false unless test_steps.any?
-
-        parameterized_step?(test_steps.first, parameters: params_used_by_test)
-      end
-    end
-
-    def parameterized_step?(step_model, parameters:)
-      parameters.any? do |parameter|
-        parameter_string = "<#{parameter}>"
-
-        parameterized_text?(step_model, parameter_string) ||
-          parameterized_doc_string?(step_model, parameter_string) ||
-          parameterized_table?(step_model, parameter_string)
-      end
-    end
-
-    def parameterized_text?(step_model, parameter)
-      step_model.text.include?(parameter)
-    end
-
-    def parameterized_doc_string?(step_model, parameter)
-      return false unless step_model.block.is_a?(CukeModeler::DocString)
-
-      step_model.block.content.include?(parameter)
-    end
-
-    def parameterized_table?(step_model, parameter)
-      return false unless step_model.block.is_a?(CukeModeler::Table)
-
-      step_model.block.rows.map(&:cells).flatten.map(&:value).any? { |cell_text| cell_text.include?(parameter) }
-    end
-
-  end
-
-end
+# TODO: Make a new class that it is from the POV of a Feature model instead
+
+module CukeLinter
+
+  # A linter that detects scenarios and outlines within a feature that all share common beginning steps
+  class TestShouldUseBackgroundLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
+
+      model_steps          = model.steps || []
+      parent_feature_model = model.get_ancestor(:feature)
+
+      return false unless parent_feature_model.tests.count > 1
+
+      matching_steps     = all_first_steps_match?(parent_feature_model, model_steps)
+      none_parameterized = no_parameterized_steps?(parent_feature_model)
+
+      matching_steps && none_parameterized
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Test shares steps with all other tests in feature. Use a background.'
+    end
+
+
+    private
+
+
+    def all_first_steps_match?(feature_model, model_steps)
+      feature_model.tests.all? do |test|
+        test_steps = test.steps || []
+        test_steps.first == model_steps.first
+      end
+    end
+
+    def no_parameterized_steps?(feature_model)
+      feature_model.tests.none? do |test|
+        next false if test.is_a?(CukeModeler::Scenario)
+
+        test_steps          = test.steps || []
+        params_used_by_test = test.examples.map(&:parameters).flatten.uniq
+
+        next false unless test_steps.any?
+
+        parameterized_step?(test_steps.first, parameters: params_used_by_test)
+      end
+    end
+
+    def parameterized_step?(step_model, parameters:)
+      parameters.any? do |parameter|
+        parameter_string = "<#{parameter}>"
+
+        parameterized_text?(step_model, parameter_string) ||
+          parameterized_doc_string?(step_model, parameter_string) ||
+          parameterized_table?(step_model, parameter_string)
+      end
+    end
+
+    def parameterized_text?(step_model, parameter)
+      step_model.text.include?(parameter)
+    end
+
+    def parameterized_doc_string?(step_model, parameter)
+      return false unless step_model.block.is_a?(CukeModeler::DocString)
+
+      step_model.block.content.include?(parameter)
+    end
+
+    def parameterized_table?(step_model, parameter)
+      return false unless step_model.block.is_a?(CukeModeler::Table)
+
+      step_model.block.rows.map(&:cells).flatten.map(&:value).any? { |cell_text| cell_text.include?(parameter) }
+    end
+
+  end
+
+end

data/lib/cuke_linter/linters/test_with_action_step_as_final_step_linter.rb

@@ -1,33 +1,33 @@
-module CukeLinter
-
-  # A linter that detects scenarios and outlines that have an action step as their final step
-  class TestWithActionStepAsFinalStepLinter < Linter
-
-    # Changes the linting settings on the linter using the provided configuration
-    def configure(options)
-      @when_keywords = options['When']
-    end
-
-    # The rule used to determine if a model has a problem
-    def rule(model)
-      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
-
-      model_steps = model.steps || []
-      return false unless model_steps.last
-
-      when_keywords.include?(model_steps.last.keyword)
-    end
-
-    # The message used to describe the problem that has been found
-    def message
-      "Test has 'When' as the final step."
-    end
-
-    private
-
-    def when_keywords
-      @when_keywords || [DEFAULT_WHEN_KEYWORD]
-    end
-
-  end
-end
+module CukeLinter
+
+  # A linter that detects scenarios and outlines that have an action step as their final step
+  class TestWithActionStepAsFinalStepLinter < Linter
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @when_keywords = options['When']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Scenario) || model.is_a?(CukeModeler::Outline)
+
+      model_steps = model.steps || []
+      return false unless model_steps.last
+
+      when_keywords.include?(model_steps.last.keyword)
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Test has 'When' as the final step."
+    end
+
+    private
+
+    def when_keywords
+      @when_keywords || [DEFAULT_WHEN_KEYWORD]
+    end
+
+  end
+end