gherkin_checker 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187d4e241a76c4044dc0f41c640c4b3b5022508614482d6c6369dd72b4c9888a
-  data.tar.gz: 3e679ba099d82061788ae12270bb0d73f15673289e089ca35436a2d0418934d3
+  metadata.gz: 842d35c08788f9b36bab530ea6278e57ab3e3b073a1685bcfab5aeec07de3079
+  data.tar.gz: 38b86c8550dc83042c76d3903d8a51e25f23ee65749fb3b54da62b2e6658b6d7
 SHA512:
-  metadata.gz: 9184c1441b70cd8f8f8f6db7a1499b3f6cf476556e762a5f3b1318235e9a0ed1bf3dfbc7417aa6b1ff42f78ec4d1ca9ee278bd4edaec7bbfd57821063cea99fe
-  data.tar.gz: 3ba183a3a7af38e70823945f7228ac21311f3462b7d4f5be8c18047263b0f8f8e6d977ae560b61113c02148f0acb7a9dbc29b7b0b84cc87d22c6bc49b1846d25
+  metadata.gz: b80cfb47d90b9e6e48b1789661862c8246a03738a14e4d2cf68cc13e430d178bb4380588a675f469a12fb3dbf2ed20310c9d87e211c1be1dfe86ca2a48159cc2
+  data.tar.gz: c166eff07a845109578d9561546cf7d016a0d25a47dff9e40cd2693ecd1d4ab0bb249cd42ee11ec09a3fa0e6feb21a382a3fc2a3029dd0cad772a7b85fc72580

data/exe/gherkin_checker

@@ -8,4 +8,3 @@ checker = GherkinChecker::Checker.new("gherkin_checker.yml")
 
 # Run the check and print the results
 checker.check_feature_files
-

data/lib/gherkin_checker/config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module GherkinChecker
+  # Config class to handle configuration loading
+  class Config
+    attr_reader :feature_files_path, :one_of_tags, :must_be_tags
+
+    def initialize(config_file = "gherkin_checker.yml")
+      @config = load_config(config_file)
+      @feature_files_path = @config.fetch("feature_files_path", "./features")
+      @one_of_tags = @config.dig("mandatory_tags", "one_of")
+      @must_be_tags = @config.dig("mandatory_tags", "must_be")
+    end
+
+    private
+
+    def load_config(file)
+      return {} unless File.exist?(file)
+
+      YAML.load_file(file) || {}
+    end
+  end
+end

data/lib/gherkin_checker/parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "gherkin/parser"
+require "gherkin/errors"
+
+module GherkinChecker
+  # Parser class to handle Gherkin file parsing
+  class Parser
+    def initialize
+      @parser = Gherkin::Parser.new
+    end
+
+    def parse(file_path)
+      content = File.read(file_path)
+      document = @parser.parse(content)
+      feature = document.feature
+
+      return [] unless feature
+
+      feature_name = feature.name
+      feature_tags = feature.tags.map(&:name).map { |tag| tag.delete_prefix("@") }
+
+      feature.children.map do |child|
+        process_child(child, feature_name, feature_tags)
+      end.compact
+    rescue Gherkin::CompositeParserException => e
+      e.errors.map do |error|
+        { error: error.message, type: :syntax_error }
+      end
+    rescue Gherkin::ParserError => e
+      [{ error: e.message, type: :syntax_error }]
+    rescue StandardError => e
+      [{ error: e.message, type: :unknown_error }]
+    end
+
+    private
+
+    def process_child(child, feature_name, feature_tags)
+      return unless child.respond_to?(:scenario) && child.scenario
+
+      scenario = child.scenario
+      {
+        feature_name: feature_name,
+        feature_tags: feature_tags,
+        line: scenario.location.line,
+        column: scenario.location.column,
+        name: scenario.name,
+        tags: scenario.tags.map(&:name).map { |tag| tag.delete_prefix("@") }
+      }
+    end
+  end
+end

data/lib/gherkin_checker/validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module GherkinChecker
+  # Validator class to check tags against rules
+  class Validator
+    def initialize(config)
+      @config = config
+    end
+
+    def validate(scenario_data)
+      errors = []
+      return errors if scenario_data[:error]
+
+      errors << check_one_of_tags(scenario_data)
+      errors << check_must_be_tags(scenario_data)
+      errors.compact
+    end
+
+    private
+
+    def check_one_of_tags(data)
+      return nil unless @config.one_of_tags
+      return nil if @config.one_of_tags.any? { |tag| data[:tags].include?(tag) }
+
+      format_error(:one_of_tags, @config.one_of_tags, data)
+    end
+
+    def check_must_be_tags(data)
+      return nil unless @config.must_be_tags
+      return nil if @config.must_be_tags.all? { |tag| data[:tags].include?(tag) }
+
+      format_error(:must_be_tags, @config.must_be_tags, data)
+    end
+
+    def format_error(type, expected, data)
+      {
+        check: type,
+        file_line: data[:line], # We will need to prepend file path in runner
+        scenario_name: data[:name],
+        scenario_tags: data[:tags],
+        expected: expected
+      }
+    end
+  end
+end

data/lib/gherkin_checker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GherkinChecker
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/gherkin_checker.rb

@@ -1,44 +1,38 @@
 # frozen_string_literal: true
 
 require "find"
-require "yaml"
-require "gherkin/parser"
-
 require_relative "gherkin_checker/version"
+require_relative "gherkin_checker/config"
+require_relative "gherkin_checker/parser"
+require_relative "gherkin_checker/validator"
 
 module GherkinChecker
-  # Checker class
+  # Checker class - The main runner
   class Checker
     def initialize(config_file = "gherkin_checker.yml")
-      unless File.exist?(config_file)
-        log_message("Error: Configuration file #{config_file} not found.", level: :error)
-        exit(1) # Exit with a status of 1 to indicate an error
-      end
-
-      @config = YAML.load_file(config_file)
-      if @config
-        @skip_check = false
-      else
-        log_message("Warning: The gherkin_checker.yml not define", level: :warn)
-        @skip_check = true
-      end
-
-      @feature_files_path = @config&.key?("feature_files_path") ? @config.fetch("feature_files_path") : "./features"
-      @one_of_tags = @config.dig("mandatory_tags", "one_of") if @config
-      @must_be_tags = @config.dig("mandatory_tags", "must_be") if @config
-
-      # Flags to ensure warnings are only printed once
-      @one_of_tags_warning_shown = false
-      @must_be_tags_warning_shown = false
+      @config = Config.new(config_file)
+      @parser = Parser.new
+      @validator = Validator.new(@config)
     end
 
     def check_feature_files
+      return log_skip_message if skip_check?
+
       errors = []
-      Find.find(@feature_files_path) do |file|
+      Find.find(@config.feature_files_path) do |file|
         next unless File.extname(file) == ".feature"
 
-        errors += check_one_of_tags(file)
-        errors += check_must_be_tags(file)
+        scenarios = @parser.parse(file)
+        scenarios.each do |scenario|
+          if scenario[:error]
+            errors << scenario
+          else
+            validation_errors = @validator.validate(scenario)
+            # Prepend file path to the error
+            validation_errors.each { |err| err[:file_line] = "#{file}:#{err[:file_line]}:#{scenario[:column]}" }
+            errors += validation_errors
+          end
+        end
       end
 
       report_errors(errors)
@@ -46,188 +40,62 @@ module GherkinChecker
 
     private
 
-    def check_one_of_tags(file)
-      return log_one_of_tags_warning if @one_of_tags.nil?
-
-      errors = []
-      extract_scenario_data(file).each do |data|
-        is_tags_nil = data[:scenario_tags].nil?
-        tags = data[:scenario_tags]
-        file_line = data[:file_line]
-        scenario = data[:scenario_name]
-        error = data[:error]
-
-        if is_tags_nil
-          errors << {
-            check: :one_of_tags,
-            file_line: file_line,
-            scenario_name: scenario,
-            scenario_tags: tags,
-            error: error
-          }
-        end
-
-        next if is_tags_nil
-
-        next if @one_of_tags.any? { |tag| tags.include?(tag) }
-
-        errors << {
-          check: :one_of_tags,
-          file_line: file_line,
-          scenario_name: scenario,
-          scenario_tags: tags,
-          error: error
-        }
-      end
-
-      errors
-    end
-
-    def check_must_be_tags(file)
-      return log_must_be_tags_warning if @must_be_tags.nil?
-
-      errors = []
-      extract_scenario_data(file).each do |data|
-        is_tags_nil = data[:scenario_tags].nil?
-        tags = data[:scenario_tags]
-        file_line = data[:file_line]
-        scenario = data[:scenario_name]
-        error = data[:error]
-
-        if is_tags_nil
-          errors << {
-            check: :must_be_tags,
-            file_line: file_line,
-            scenario_name: scenario,
-            scenario_tags: tags,
-            error: error
-          }
-        end
-
-        next if is_tags_nil
-
-        next if @must_be_tags.all? { |item| tags.include?(item) }
-
-        errors << {
-          check: :must_be_tags,
-          file_line: file_line,
-          scenario_name: scenario,
-          scenario_tags: tags,
-          error: error
-        }
-      end
-
-      errors
-    end
-
-    def log_one_of_tags_warning
-      return [] if @one_of_tags_warning_shown
-
-      log_message("Warning: Optional tags not set in 'gherkin_checker.yml'.", level: :warn) unless @skip_check
-      @one_of_tags_warning_shown = true
-      [] # Return an empty array to maintain consistency
+    def skip_check?
+      # If no config was loaded (meaning no file found or empty), we might want to warn
+      # But based on original logic, if config is missing, we warn and skip.
+      # Config class handles loading. If attributes are nil, it means load failed or empty.
+      # Let's check if critical config is present.
+      @config.one_of_tags.nil? && @config.must_be_tags.nil?
     end
 
-    def log_must_be_tags_warning
-      return [] if @must_be_tags_warning_shown
-
-      log_message("Warning: Mandatory tags not set in 'gherkin_checker.yml'.", level: :warn) unless @skip_check
-      @must_be_tags_warning_shown = true
-      [] # Return an empty array to maintain consistency
+    def log_skip_message
+      log_message("Warning: The gherkin_checker.yml not define or no tags configured", level: :warn)
+      log_message("Skip gherkin checking", level: :warn)
     end
 
     def report_errors(errors)
       if errors.empty?
-        if @skip_check
-          log_message("Skip gherkin checking", level: :warn)
-        else
-          log_message("All scenarios have the required tags.")
-        end
+        log_message("All scenarios have the required tags.")
       else
         log_message("Gherkin Checker found Error:", level: :error)
         errors.each do |error|
-          error_message = error[:error]
-          if error_message.nil?
-            scenario_tags = error[:scenario_tags]
-            tags = scenario_tags
-            tags = scenario_tags.nil? ? "Tagging not set" : "Just found '#{tags}'"
-
-            message = case error[:check]
-                      when :one_of_tags
-                        "one_of_tags '#{@one_of_tags}' not found!, #{tags}"
-                      when :must_be_tags
-                        "must_be_tags '#{@must_be_tags}' not found!, #{tags}"
-                      else
-                        "error undefined"
-                      end
-
-            log_message("#{error[:file_line]}: #{error[:scenario_name]} - #{message}", level: :error)
+          if error[:error]
+            log_syntax_error(error)
           else
-            log_message("Error: #{error_message}", level: :error)
+            log_validation_error(error)
           end
         end
       end
     end
 
-    # Define a method to log messages with different levels
+    def log_syntax_error(error)
+      type = error[:type] == :syntax_error ? "Syntax Error" : "Error"
+      log_message("#{type}: #{error[:error]}", level: :error)
+    end
+
+    def log_validation_error(error)
+      tags_str = if error[:scenario_tags].nil? || error[:scenario_tags].empty?
+                   "Tagging not set"
+                 else
+                   "Just found '#{error[:scenario_tags]}'"
+                 end
+      check_type = error[:check] == :one_of_tags ? "one_of_tags" : "must_be_tags"
+
+      message = "#{check_type} '#{error[:expected]}' not found!, #{tags_str}"
+      log_message("#{error[:file_line]}: #{error[:scenario_name]} - #{message}", level: :error)
+    end
+
     def log_message(message, level: :info)
-      # Define color codes
       colors = {
-        debug: "\e[36m", # Cyan
-        info: "\e[32m", # Green
-        warn: "\e[33m", # Yellow
-        error: "\e[31m", # Red
-        fatal: "\e[35m", # Magenta
-        reset: "\e[0m" # Reset to default color
+        debug: "\e[36m",
+        info: "\e[32m",
+        warn: "\e[33m",
+        error: "\e[31m",
+        fatal: "\e[35m",
+        reset: "\e[0m"
       }
-
       color = colors[level] || colors[:reset]
-
       puts "#{color}#{message}#{colors[:reset]}"
     end
-
-    def extract_scenario_data(file)
-      gherkin_parser = Gherkin::Parser.new
-      scenario_data = []
-
-      begin
-        content = File.read(file)
-        document = gherkin_parser.parse(content)
-        feature = document.feature
-        feature_name = feature.name
-        feature_tags = feature.tags.map(&:name)
-
-        feature.children.each do |child|
-          raise "Error: read scenario data" unless child.respond_to?(:scenario) && child.scenario
-
-          scenario = child.scenario
-          scenario_name = scenario.name
-          scenario_tags = scenario.tags.map(&:name)
-          scenario_tags = scenario_tags.map { |tag| tag.delete_prefix("@") }
-          location_line = scenario.location.line
-          location_column = scenario.location.column
-
-          scenario_data << {
-            feature_name: feature_name,
-            feature_tags: feature_tags,
-            file_line: "#{file}:#{location_line}:#{location_column}",
-            scenario_name: scenario_name,
-            scenario_tags: scenario_tags,
-            error: nil
-          }
-        end
-      rescue StandardError => e
-        scenario_data << {
-          feature_name: nil,
-          feature_tags: nil,
-          file_line: nil,
-          scenario_name: nil,
-          scenario_tags: nil,
-          error: e.message
-        }
-      end
-
-      scenario_data
-    end
   end
 end

metadata

@@ -1,14 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: gherkin_checker
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Dikakoko
 bindir: exe
 cert_chain: []
-date: 2025-07-25 00:00:00.000000000 Z
-dependencies: []
+date: 2026-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber-gherkin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '33.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '33.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
 description: Checking .feature files
 email:
 - dikakoko@icloud.com
@@ -20,6 +76,9 @@ files:
 - README.md
 - exe/gherkin_checker
 - lib/gherkin_checker.rb
+- lib/gherkin_checker/config.rb
+- lib/gherkin_checker/parser.rb
+- lib/gherkin_checker/validator.rb
 - lib/gherkin_checker/version.rb
 homepage: https://github.com/dikako/gherkin_checker
 licenses: