bddgenx 0.1.17 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eae91a2de34a4ea84503ab6015501479f2a2483dafaa3b2a88d1930fc3271c0f
-  data.tar.gz: d14373f08e54d394f993954acc6fff5c2ef275b942b2e0e381f3f65a02b0d986
+  metadata.gz: 94a0f0c3d58d4244048cc2b01054fbdde3ffaf2c627d36ea531d25bb64fd295d
+  data.tar.gz: fa9590c3a6e81c863ae6ea706e7bd24e0577cf9b31ef851c868f8c5a81c181bf
 SHA512:
-  metadata.gz: 1630a5697a6f519bf92ecfd5f895b088fab0d4305f23efd5ea77204d1b292940c1381f9f282483116edb970890f7e6fd399dabc2a7468748fdb69fc552ba89db
-  data.tar.gz: b2528be1f5c6a3ab8ea4555e168e2fbc7ca9677eb0ba76cc64c72c691d7478c69f12018a7ca8230dd57702dbf2c77e4e3bd00572cec3c6430a3f8b3d2e52fdf7
+  metadata.gz: a6cb0637977eab5b05790e0b0900d9862ebd4a7633b24d2a8d0c1daf0b5ff1259adcc1110f51e89607d07a335cb80f3cd05cca958c24332f93651d120a2eba4a
+  data.tar.gz: df1f2fe658088fb4fa27cea0be63547228d1ac677333191cbc68a59bd59c5b58ae056b75e3c4f7017b43b00879244fa63e81f3da905771f63692322a7397b133

data/lib/bddgenx/generator.rb

@@ -11,141 +11,70 @@ module Bddgenx
       "PERMISSION"  => "Teste de Permissão",
       "EDGE_CASE"   => "Teste de Limite",
       "PERFORMANCE" => "Teste de Desempenho"
-    }
-
-    TIPOS_CENARIO = %w[
-      SUCCESS FAILURE ERROR EXCEPTION
-      VALIDATION PERMISSION EDGE_CASE PERFORMANCE
-    ]
-
+    }.freeze
 
     def self.gerar_feature(historia)
-      idioma = historia[:idioma] || 'pt'
-
-      # Define os conectores de acordo com o idioma
+      idioma = historia[:idioma]
       palavras = {
-        contexto: idioma == 'en' ? 'Background' : 'Contexto',
-        cenario: idioma == 'en' ? 'Scenario' : 'Cenário',
-        esquema: idioma == 'en' ? 'Scenario Outline' : 'Esquema do Cenário',
-        exemplos: idioma == 'en' ? 'Examples' : 'Exemplos',
-        regra: idioma == 'en' ? 'Rule' : 'Regra'
+        contexto:  idioma == 'en' ? 'Background'       : 'Contexto',
+        cenario:   idioma == 'en' ? 'Scenario'         : 'Cenário',
+        esquema:   idioma == 'en' ? 'Scenario Outline' : 'Esquema do Cenário',
+        exemplos:  idioma == 'en' ? 'Examples'         : 'Exemplos',
+        regra:     idioma == 'en' ? 'Rule'             : 'Regra'
       }
 
-      nome_base = historia[:quero].gsub(/[^a-zA-Z0-9]/, '_').downcase
-      caminho = "features/#{nome_base}.feature"
+      nome_base = historia[:quero].gsub(/[^a-z0-9]/i, '_').downcase
+      caminho   = "features/#{nome_base}.feature"
 
-      conteudo = <<~HEADER
+      conteudo = <<~GHERKIN
         # language: #{idioma}
-        Funcionalidade: #{historia[:quero].sub(/^Quero/, '').strip}
-  
+        Funcionalidade: #{historia[:quero].sub(/^Quero\s*/, '')}
+
           #{historia[:como]}
           #{historia[:quero]}
           #{historia[:para]}
-  
-      HEADER
 
-      # Regras
-      if historia[:regras]&.any?
-        conteudo += "    #{palavras[:regra]}: #{historia[:regras].first}\n"
-        historia[:regras][1..].each do |linha|
-          conteudo += "      #{linha}\n"
-        end
-        conteudo += "\n"
-      end
+      GHERKIN
 
+      historia[:grupos].each_with_index do |grupo, idx|
+        tipo     = grupo[:tipo]
+        tag      = grupo[:tag]
+        passos   = grupo[:passos]
+        exemplos = grupo[:exemplos]
 
-      # Contexto
-      if historia[:blocos]["CONTEXT"]&.any?
-        conteudo += "    #{palavras[:contexto]}:\n"
-        historia[:blocos]["CONTEXT"].each { |p| conteudo += "      #{p}\n" }
-        conteudo += "\n"
-      end
-
-      # Cenários
-      TIPOS_CENARIO.each do |tipo|
-        passos = historia[:blocos][tipo]
-        passos = passos&.reject { |l| l.strip.empty? } || []
         next if passos.empty?
 
-        # Ignora geração duplicada se for um SUCCESS parametrizado com EXAMPLES
-        if tipo == "SUCCESS" && historia[:blocos]["EXAMPLES"]&.any?
-          possui_parametros = passos.any? { |p| p.include?('<') }
-          next if possui_parametros
-        end
-
-        nome_teste = TIPOS_ISTQB[tipo] || palavras[:cenario]
-        contexto = passos.first&.gsub(/^(Dado que|Given|Quando|When|Então|Then|E|And)/, '')&.strip || "Condição"
-        resultado = passos.last&.gsub(/^(Então|Then|E|And)/, '')&.strip || "Resultado"
-        nome_cenario = "#{nome_teste} - #{contexto} - #{resultado}"
-
-        conteudo += "    @#{tipo.downcase}\n"
-        conteudo += "    #{palavras[:cenario]}: #{nome_cenario}\n"
-        passos.each { |p| conteudo += "      #{p}\n" }
-        conteudo += "\n"
-      end
-
-      # Esquema do Cenário com Exemplos
-      if historia[:blocos]["EXAMPLES"]&.any?
-        exemplo_bruto = historia[:blocos]["EXAMPLES"]
-        grupos = dividir_examples(exemplo_bruto)
-
-        grupos.each_with_index do |tabela, i|
-          cabecalho = tabela.first.gsub('|', '').split.map(&:strip)
-          linhas = tabela[1..].map { |linha| linha.split('|').reject(&:empty?).map(&:strip) }
-
-          exemplos = { cabecalho: cabecalho, linhas: linhas }
+        linha_tag = ["@#{tipo.downcase}", ("@#{tag}" if tag)].compact.join(' ')
+        possui_parametros = passos.any? { |p| p.include?('<') } && exemplos.any?
 
-          passos_outline = historia[:blocos]["SUCCESS"].select do |linha|
-            cabecalho.any? { |coluna| linha.include?("<#{coluna}>") }
-          end
-
-          next if passos_outline.empty?
-
-          conteudo += "\n"
-          conteudo += idioma == 'en' ? "    Scenario Outline: Example #{i + 1}\n" : "    Esquema do Cenário: Exemplo #{i + 1}\n"
-
-          passos_outline.each do |passo|
-            conteudo += "      #{passo}\n"
-          end
-
-          conteudo += "\n"
-          conteudo += idioma == 'en' ? "      Examples:\n" : "      Exemplos:\n"
-          conteudo += "        #{tabela.first}\n"
-          tabela[1..].each { |linha| conteudo += "        #{linha}\n" }
+        if possui_parametros
+          conteudo << "    #{linha_tag}\n"
+          conteudo << "    #{palavras[:esquema]}: Exemplo #{idx + 1}\n"
+          passos.each { |p| conteudo << "      #{p}\n" }
+          conteudo << "\n      #{palavras[:exemplos]}:\n"
+          exemplos.each { |linha| conteudo << "        #{linha}\n" }
+          conteudo << "\n"
+        else
+          nome_teste = TIPOS_ISTQB[tipo] || palavras[:cenario]
+          contexto   = passos.first.gsub(/^(Dado|Quando|Então|E|Mas)\s+/, '').strip
+          resultado  = passos.last .gsub(/^(Dado|Quando|Então|E|Mas)\s+/, '').strip
+          nome_ceno  = "#{nome_teste} - #{contexto} - #{resultado}"
+
+          conteudo << "    #{linha_tag}\n"
+          conteudo << "    #{palavras[:cenario]}: #{nome_ceno}\n"
+          passos.each { |p| conteudo << "      #{p}\n" }
+          conteudo << "\n"
         end
       end
 
       [caminho, conteudo]
     end
 
-    # Salva o arquivo .feature gerado
-    # Retorna true se o arquivo foi salvo com sucesso, false caso contrário
     def self.salvar_feature(caminho, conteudo)
-      if conteudo.strip.empty?
-        puts "⚠️  Nenhum conteúdo gerado para: #{caminho} (ignorado)"
-        return false
-      end
-
+      FileUtils.mkdir_p(File.dirname(caminho))
       File.write(caminho, conteudo)
       puts "✅ Arquivo .feature gerado: #{caminho}"
       true
     end
-
-    def self.dividir_examples(tabela_bruta)
-      grupos = []
-      grupo_atual = []
-
-      tabela_bruta.each do |linha|
-        if linha.strip =~ /^\|\s*[\w\s]+\|/ && grupo_atual.any? && linha.strip == linha.strip.squeeze(" ")
-          grupos << grupo_atual
-          grupo_atual = [linha]
-        else
-          grupo_atual << linha
-        end
-      end
-
-      grupos << grupo_atual unless grupo_atual.empty?
-      grupos
-    end
   end
 end

data/lib/bddgenx/parser.rb

@@ -4,46 +4,69 @@ module Bddgenx
     VALIDATION PERMISSION EDGE_CASE PERFORMANCE
     EXAMPLES REGRA RULE
   ].freeze
+
   class Parser
     def self.ler_historia(caminho_arquivo)
-      linhas = File.readlines(caminho_arquivo, encoding: 'utf-8').map(&:strip).reject(&:empty?)
+      linhas = File.readlines(caminho_arquivo, encoding: 'utf-8')
+                   .map(&:strip)
+                   .reject(&:empty?)
 
-      # Detecta idioma
+      # idioma
       idioma = linhas.first.downcase.include?('# lang: en') ? 'en' : 'pt'
-      linhas.shift if linhas.first.downcase.start_with?('#')
+      linhas.shift if linhas.first.downcase.start_with?('# lang:')
 
-      # Ignora linhas que sejam blocos ou comentários até encontrar Como/Quero/Para
-      cabecalho = []
+      # cabeçalho Gherkin: Como / Quero / Para
       until linhas.empty?
         linha = linhas.shift
-        break if linha.start_with?("Como", "As")  # início da história em pt ou en
+        break if linha =~ /^(Como |As a )/
       end
-      como = linha
+      como  = linha
       quero = linhas.shift
-      para = linhas.shift
+      para  = linhas.shift
 
       historia = {
-        como: como,
-        quero: quero,
-        para: para,
-        blocos: Hash.new { |h, k| h[k] = [] },
-        regras: [],
-        arquivo_origem: caminho_arquivo,
-        idioma: idioma
+        como:     como,
+        quero:    quero,
+        para:     para,
+        idioma:   idioma,
+        grupos:   []   # cada bloco ([TIPO]@tag) será um grupo
       }
 
-      tipo_atual = nil
+      exemplos_mode = false
+      tipo_atual    = nil
+      tag_atual     = nil
 
       linhas.each do |linha|
-        if linha.match?(/^\[(#{TIPOS_BLOCOS.join('|')})\]$/)
-          tipo_atual = linha.gsub(/[\[\]]/, '')
+        # início de bloco EXAMPLES: modo exemplos para último grupo
+        if linha =~ /^\[EXAMPLES\](?:@(\w+))?$/
+          exemplos_mode = true
+          raise "Formato inválido: EXAMPLES sem bloco anterior" if historia[:grupos].empty?
+          historia[:grupos].last[:exemplos] = []
           next
         end
 
-        if %w[REGRA RULE].include?(tipo_atual)
-          historia[:regras] << linha
+        # início de um novo bloco (exceto EXAMPLES)
+        if linha =~ /^\[(#{TIPOS_BLOCOS.join('|')})\](?:@(\w+))?$/
+          exemplos_mode = false
+          tipo_atual = $1
+          tag_atual  = $2
+          historia[:grupos] << {
+            tipo:     tipo_atual,
+            tag:      tag_atual,
+            passos:   [],
+            exemplos: []
+          }
+          next
+        end
+
+        # atribuir linhas ao bloco atual
+        next if historia[:grupos].empty?
+        atual = historia[:grupos].last
+
+        if exemplos_mode
+          atual[:exemplos] << linha
         else
-          historia[:blocos][tipo_atual] << linha if tipo_atual
+          atual[:passos]   << linha
         end
       end
 

data/lib/bddgenx/pdf_exporter.rb

@@ -13,8 +13,9 @@ module Bddgenx
         if File.exist?(destino)
           puts "⚠️  PDF já existente: #{destino} — pulando geração."
           return
+        else
+          puts "📄 PDF gerado: #{destino}"
         end
-        puts "📄 PDF gerado: #{destino}"
       end
     end
 

data/lib/bddgenx/steps_generator.rb

@@ -4,79 +4,68 @@ require_relative 'utils/verificador'
 module Bddgenx
   class StepsGenerator
     PADROES = {
-      'pt' => %w[Dado Quando Então E Mas Regra Contexto],
-      'en' => %w[Given When Then And But Rule Context]
+      'pt' => %w[Dado Quando Então E Mas],
+      'en' => %w[Given When Then And But]
     }
 
-    TIPOS_BLOCOS = %w[
-      CONTEXT SUCCESS FAILURE ERROR EXCEPTION
-      VALIDATION PERMISSION EDGE_CASE PERFORMANCE
-      EXAMPLES RULE
-    ]
-
+    # Gera step definitions a partir da estrutura historia[:grupos]
     def self.gerar_passos(historia, nome_arquivo_feature)
       idioma = historia[:idioma] || 'pt'
       conectores = PADROES[idioma]
       passos_gerados = []
 
-      grupos_examples = dividir_examples(historia[:blocos]["EXAMPLES"]) if historia[:blocos]["EXAMPLES"]&.any?
-
-      TIPOS_BLOCOS.each do |tipo|
-        blocos = tipo == "RULE" ? historia[:regras] : historia[:blocos][tipo]
-        next unless blocos.is_a?(Array)
+      historia[:grupos].each do |grupo|
+        tipo            = grupo[:tipo]
+        passos          = grupo[:passos]
+        exemplos_brutos = grupo[:exemplos]
+        exemplos        = exemplos_brutos&.any? ? dividir_examples(exemplos_brutos) : nil
 
-        passos = blocos.dup
+        next unless passos.is_a?(Array) && passos.any?
 
         passos.each do |linha|
           conector = conectores.find { |c| linha.strip.start_with?(c) }
           next unless conector
 
-          corpo = linha.strip.sub(/^#{conector}/, '').strip
-
-          # Sanitiza aspas duplas envolvendo parâmetros, ex: "<nome>" -> <nome>
-          corpo_sanitizado = corpo.gsub(/"(<[^>]+>)"/, '\1')
+          corpo             = linha.strip.sub(/^#{conector}\s*/, '')
+          corpo_sanitizado  = corpo.gsub(/"(<[^>]+>)"/, '\1')
 
-          # Verifica se este passo pertence a algum grupo de exemplos
+          # tenta encontrar grupo de exemplos compatível, se existir
           grupo_exemplo_compat = nil
-
-          if tipo == "SUCCESS" && grupos_examples
-            grupos_examples.each do |grupo|
-              cabecalho = grupo.first.gsub('|', '').split.map(&:strip)
+          if exemplos
+            exemplos.each do |tabela|
+              cabecalho = tabela.first.gsub('|', '').split.map(&:strip)
               if cabecalho.any? { |col| corpo.include?("<#{col}>") }
-                grupo_exemplo_compat = {
-                  cabecalho: cabecalho,
-                  linhas: grupo[1..].map { |linha| linha.split('|').reject(&:empty?).map(&:strip) }
-                }
+                linhas = tabela[1..].map { |l| l.gsub('|', '').split.map(&:strip) }
+                grupo_exemplo_compat = { cabecalho: cabecalho, linhas: linhas }
                 break
               end
             end
           end
 
-          if grupo_exemplo_compat
-            # Substitui cada <param> por {tipo} dinamicamente
-            corpo_parametrizado = corpo_sanitizado.gsub(/<([^>]+)>/) do
-              nome = $1.strip
-              tipo_param = detectar_tipo_param(nome, grupo_exemplo_compat)
-              "{#{tipo_param}}"
+          # detecta todos os parametros <...> e gera arg list
+          nomes_param = corpo.scan(/<([^>]+)>/).flatten.map(&:strip)
+          if nomes_param.any?
+            corpo_param = corpo_sanitizado.dup
+            nomes_param.each do |nome|
+              tipo_param = grupo_exemplo_compat ? detectar_tipo_param(nome, grupo_exemplo_compat) : 'string'
+              corpo_param.gsub!(/<\s*#{Regexp.escape(nome)}\s*>/, "{#{tipo_param}}")
             end
-
-            parametros = corpo.scan(/<([^>]+)>/).flatten.map { |p| p.strip.gsub(' ', '_') }
-            param_list = parametros.join(', ')
+            args_list = nomes_param.map { |p| p.gsub(/\s+/, '_') }.join(', ')
+            pending_msg = corpo
           else
-            corpo_parametrizado = corpo
-            parametros = []
-            param_list = ""
+            corpo_param = corpo
+            args_list   = ''
+            pending_msg = corpo
           end
 
           passos_gerados << {
             conector: conector,
-            raw: corpo,
-            param: corpo_parametrizado,
-            args: param_list,
-            tipo: tipo
-          } unless passos_gerados.any? { |p| p[:param] == corpo_parametrizado }
+            raw:      pending_msg,
+            param:    corpo_param,
+            args:     args_list,
+            tipo:     tipo
+          } unless passos_gerados.any? { |p| p[:param] == corpo_param }
         end
-
       end
 
       if passos_gerados.empty?
@@ -85,7 +74,7 @@ module Bddgenx
       end
 
       nome_base = File.basename(nome_arquivo_feature, '.feature')
-      caminho = "steps/#{nome_base}_steps.rb"
+      caminho   = "steps/#{nome_base}_steps.rb"
       FileUtils.mkdir_p(File.dirname(caminho))
 
       comentario = "# Step definitions para #{File.basename(nome_arquivo_feature)}"
@@ -94,14 +83,13 @@ module Bddgenx
 
       passos_gerados.each do |passo|
         conteudo += <<~STEP
-        #{passo[:conector]}('#{passo[:param]}') do#{passo[:args].empty? ? '' : " |#{passo[:args]}|"}
-          pending '#{idioma == 'en' ? 'Implement step' : 'Implementar passo'}: #{passo[:raw]}'
-        end
-  
+          #{passo[:conector]}('#{passo[:param]}') do#{passo[:args].empty? ? '' : " |#{passo[:args]}|"}
+            pending 'Implementar passo: #{passo[:raw]}'
+          end
+
         STEP
       end
 
-      FileUtils.mkdir_p("steps")
       if Bddgenx::Verificador.gerar_arquivo_se_novo(caminho, conteudo)
         puts "✅ Step definitions gerados: #{caminho}"
       else
@@ -110,20 +98,12 @@ module Bddgenx
       true
     end
 
-
-    def self.substituir_parametros(texto, exemplos)
-      texto.gsub(/<([^>]+)>/) do |_match|
-        nome = $1.strip
-        tipo = detectar_tipo_param(nome, exemplos)
-        "{#{tipo}}"
-      end
-    end
-
+    # Detecta tipo do parâmetro baseado em exemplos ou default
     def self.detectar_tipo_param(nome_coluna, exemplos)
-      return 'string' unless exemplos && exemplos[:cabecalho].include?(nome_coluna)
+      return 'string' unless exemplos[:cabecalho].include?(nome_coluna)
 
       idx = exemplos[:cabecalho].index(nome_coluna)
-      valores = exemplos[:linhas].map { |linha| linha[idx].to_s.strip }
+      valores = exemplos[:linhas].map { |l| l[idx].to_s.strip }
 
       return 'boolean' if valores.all? { |v| %w[true false].include?(v.downcase) }
       return 'int'     if valores.all? { |v| v.match?(/^\d+$/) }
@@ -132,34 +112,20 @@ module Bddgenx
       'string'
     end
 
+    # Divide múltiplas tabelas de exemplo em grupos
     def self.dividir_examples(tabela_bruta)
       grupos = []
-      grupo_atual = []
-
+      grupo = []
       tabela_bruta.each do |linha|
-        if linha.strip =~ /^\|\s*[\w\s]+\|/ && grupo_atual.any? && linha.strip == linha.strip.squeeze(" ")
-          grupos << grupo_atual
-          grupo_atual = [linha]
+        if linha.strip =~ /^\|.*\|$/ && grupo.any? && linha.strip == linha.strip.squeeze(' ')
+          grupos << grupo
+          grupo = [linha]
         else
-          grupo_atual << linha
+          grupo << linha
         end
       end
-
-      grupos << grupo_atual unless grupo_atual.empty?
+      grupos << grupo unless grupo.empty?
       grupos
     end
-
-
-    def self.extrair_exemplos(bloco)
-      return nil unless bloco&.any?
-
-      linhas = bloco.map(&:strip)
-      cabecalho = linhas.first.gsub('|', '').split.map(&:strip)
-      dados = linhas[1..].map { |linha| linha.gsub('|', '').split.map(&:strip) }
-
-      { cabecalho: cabecalho, linhas: dados }
-    end
   end
 end
-
-

data/lib/bddgenx/tracer.rb

@@ -3,32 +3,44 @@ require 'fileutils'
 
 module Bddgenx
   class Tracer
-    ARQUIVO = 'output/rastreabilidade.csv'
+    def self.adicionar_entrada(historia, nome_arquivo_feature)
+      FileUtils.mkdir_p('output')
+      arquivo_csv = 'output/rastreabilidade.csv'
 
-    def self.adicionar_entrada(historia, caminho_arquivo)
-      FileUtils.mkdir_p("output")
+      cabecalho = ['Funcionalidade', 'Tipo', 'Tag', 'Cenário', 'Passo', 'Origem']
 
-      CSV.open(ARQUIVO, File.exist?(ARQUIVO) ? 'a' : 'w', col_sep: ';') do |csv|
-        unless File.exist?(ARQUIVO)
-          csv << ["Funcionalidade", "Tipo de Teste", "Nome do Cenário", "Arquivo .feature"]
-        end
+      linhas = []
 
-        historia[:blocos].each do |tipo, passos|
-          next if tipo == "CONTEXT" || tipo == "EXAMPLES" || passos.empty?
+      historia[:grupos].each_with_index do |grupo, idx|
+        tipo = grupo[:tipo]
+        tag  = grupo[:tag]
+        passos = grupo[:passos]
 
-          tipo_istqb = tipo.capitalize.gsub('_', ' ').capitalize
-          contexto = passos.first&.gsub(/^(Dado que|Quando|Então|E)/, '')&.strip || "Condição"
-          resultado = passos.last&.gsub(/^(Então|E)/, '')&.strip || "Resultado"
-          nome_cenario = "#{tipo_istqb} - #{contexto} - #{resultado}"
+        nome_funcionalidade = historia[:quero].gsub(/^Quero\s*/, '').strip
+        nome_cenario = "Cenário #{idx + 1}"
 
-          csv << [
-            historia[:quero].sub(/^Quero/, '').strip,
-            tipo_istqb,
+        passos.each do |passo|
+          linhas << [
+            nome_funcionalidade,
+            tipo,
+            tag || '-',
             nome_cenario,
-            caminho_arquivo
+            passo,
+            File.basename(nome_arquivo_feature)
           ]
         end
       end
+
+      escrever_csv(arquivo_csv, cabecalho, linhas)
+    end
+
+    def self.escrever_csv(caminho, cabecalho, linhas)
+      novo_arquivo = !File.exist?(caminho)
+
+      CSV.open(caminho, 'a+', col_sep: ';', force_quotes: true) do |csv|
+        csv << cabecalho if novo_arquivo
+        linhas.each { |linha| csv << linha }
+      end
     end
   end
 end

data/lib/bddgenx/validator.rb

@@ -1,34 +1,33 @@
 module Bddgenx
   class Validator
-    TIPOS_CENARIO = %w[
-      SUCCESS
-      FAILURE
-      ERROR
-      EXCEPTION
-      VALIDATION
-      PERMISSION
-      EDGE_CASE
-      PERFORMANCE
-    ]
-
     def self.validar(historia)
-      valido = true
+      erros = []
+
+      unless historia[:como] && historia[:quero] && historia[:para]
+        erros << "❌ Cabeçalho incompleto (Como, Quero, Para obrigatórios)"
+      end
+
+      if historia[:grupos].empty?
+        erros << "❌ Nenhum grupo de blocos detectado"
+      else
+        historia[:grupos].each_with_index do |grupo, idx|
+          if grupo[:passos].empty? && grupo[:exemplos].empty?
+            erros << "❌ Grupo #{idx + 1} do tipo [#{grupo[:tipo]}] está vazio"
+          end
 
-      if historia[:como].to_s.strip.empty? ||
-         historia[:quero].to_s.strip.empty? ||
-         historia[:para].to_s.strip.empty?
-        puts "❌ História incompleta: 'Como', 'Quero' ou 'Para' está faltando."
-        valido = false
+          if grupo[:tipo] == "EXAMPLES" && grupo[:exemplos].none? { |l| l.strip.start_with?('|') }
+            erros << "❌ Grupo de EXAMPLES no bloco #{idx + 1} não contém tabela válida"
+          end
+        end
       end
 
-      cenarios_presentes = historia[:blocos].keys & TIPOS_CENARIO
-      valido ||= historia[:blocos]["CONTEXT"]&.any? || historia[:regras]&.any?
-      if cenarios_presentes.empty? && !valido
-        puts "❌ Nenhum conteúdo válido detectado (cenários, contexto ou regras)."
+      if erros.any?
+        puts "⚠️  Erros encontrados no arquivo:"
+        erros.each { |e| puts "   - #{e}" }
         return false
       end
 
-      valido
+      true
     end
   end
 end

data/lib/bddgenx/version.rb

@@ -1,3 +1,3 @@
 module Bddgenx
-  VERSION = "0.1.17"
+  VERSION = "0.1.18"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.18
 platform: ruby
 authors:
 - David Nascimento