bddgenx 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef4f9af959d68062c22da0b3cb716f9ac06ad41f10118cca1be47421d1bf7418
+  data.tar.gz: ad9885cb9a2baa14598a0278d3b7ff809bda5759058ef4828161e12c31485848
+SHA512:
+  metadata.gz: 91fbab9be46cabe7a27f15f8c47635c81d33801958373bceb40bf6ce0d925322f7889a5e79de9fc0dd7bb347971636639d99be7377afd05c15ef1d21cd8780cc
+  data.tar.gz: 71cb4f733fcf27a7d5c1fb8f0c1690f0322178a6b9e8c6813ecd91ebf302afe63eed0fc5f7bd4a4eb55d2b77b6d3e73df71b91c8e96e6b03f05c5719a4a7772f

data/README.md

@@ -0,0 +1,161 @@
+# 🧪 Gerador de BDD Automático em Ruby
+
+Este projeto gera arquivos `.feature` (Gherkin) e `steps.rb` automaticamente a partir de arquivos `.txt` com histórias de usuário, seguindo padrões ISTQB, parametrização com `Examples` e integração com pipelines.
+
+---
+
+## 📂 Estrutura do Projeto
+```txt
+bdd_generator/
+├── input/ # Arquivos .txt com histórias de usuário
+├── features/ # Arquivos .feature gerados
+├── steps/ # Arquivos com step definitions
+├── output/
+│ └── rastreabilidade.csv
+├── backup/ # Versões antigas de features sobrescritas
+├── lib/
+│ ├── parser.rb
+│ ├── generator.rb
+│ ├── validator.rb
+│ ├── steps_generator.rb
+│ ├── tracer.rb
+│ ├── backup.rb
+├── main.rb
+├── Rakefile
+└── README.md
+```
+## ▶️ Como Executar
+
+### 🔧 Requisitos
+- Ruby 3.x
+- `bundle install` (caso use gems como `prawn` ou `jira-ruby`)
+
+### 🏁 Comando direto:
+
+```bash
+ruby main.rb
+```
+
+🧱 Com Rake:
+```bash
+rake bddgen:gerar
+```
+
+📥 Como Escrever um .txt de Entrada
+```txt
+# language: pt
+Como um cliente do e-commerce
+Quero adicionar produtos ao carrinho
+Para finalizar minha compra com praticidade
+
+[CONTEXT]
+Dado que estou logado na plataforma
+E tenho produtos disponíveis
+
+[REGRA]
+O carrinho não deve permitir produtos fora de estoque
+E o valor total deve refletir o desconto promocional
+
+[SUCCESS]
+Quando adiciono um produto ao carrinho
+Então ele aparece na listagem do carrinho
+
+[FAILURE]
+Quando tento adicionar um produto esgotado
+Então recebo uma mensagem de "produto indisponível"
+
+[EXAMPLES]
+| produto        | quantidade | total esperado |
+| Camiseta Azul  | 2          | 100            |
+| Tênis Branco   | 1          | 250            |
+
+[SUCCESS]
+Quando adiciono "<produto>" com quantidade <quantidade>
+Então vejo o total <total esperado>
+```
+✅ Blocos Suportados
+[CONTEXT] – contexto comum
+
+[SUCCESS] – cenário positivo
+
+[FAILURE] – cenário negativo
+
+[ERROR], [EXCEPTION], [PERFORMANCE], etc.
+
+[REGRA] ou [RULE] – regras de negócio
+
+[EXAMPLES] – tabela de dados para Scenario Outline
+
+🧠 Saída esperada (feature)
+```gherkin
+# language: pt
+Funcionalidade: adicionar produtos ao carrinho
+
+  Como um cliente do e-commerce
+  Quero adicionar produtos ao carrinho
+  Para finalizar minha compra com praticidade
+
+  Regra: O carrinho não deve permitir produtos fora de estoque
+    E o valor total deve refletir o desconto promocional
+
+  Contexto:
+    Dado que estou logado na plataforma
+    E tenho produtos disponíveis
+
+  @success
+  Cenário: Teste Positivo - adiciono um produto ao carrinho - ele aparece na listagem do carrinho
+    Quando adiciono um produto ao carrinho
+    Então ele aparece na listagem do carrinho
+
+  Esquema do Cenário: Gerado a partir de dados de exemplo
+    Quando adiciono "<produto>" com quantidade <quantidade>
+    Então vejo o total <total esperado>
+
+    Exemplos:
+      | produto        | quantidade | total esperado |
+      | Camiseta Azul  | 2          | 100            |
+      | Tênis Branco   | 1          | 250            |
+```
+
+🧩 Step Definitions geradas
+```ruby
+Quando('adiciono "<produto>" com quantidade <quantidade>') do |produto, quantidade|
+  pending 'Implementar passo: adiciono "<produto>" com quantidade <quantidade>'
+end
+
+Então('vejo o total <total esperado>') do |total_esperado|
+  pending 'Implementar passo: vejo o total <total esperado>'
+end
+```
+🧾 Rastreabilidade
+- Gera automaticamente um CSV em output/rastreabilidade.csv com:
+- Nome do cenário
+- Tipo (SUCCESS, FAILURE, etc.)
+- Caminho do .feature
+- Origem do .txt
+
+🔄 Backup
+Toda vez que um .feature existente for sobrescrito, a versão anterior é salva em:
+```
+backup/
+```
+✅ Execução em CI/CD (GitHub Actions)
+```yaml
+jobs:
+  gerar_bdd:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+      - run: ruby main.rb
+```
+
+👨‍💻 Autor
+David Nascimento – Projeto de automação BDD com Ruby – 2025
+```yaml
+---
+
+Pronto para copiar, colar ou subir no GitHub como `README.md`. Deseja que eu prepare um `.zip` com tudo funcionando como entrega final?
+```

data/bin/bddgenx

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../lib/bddgen/cli"
+
+Bddgenx::CLI.start

data/lib/bddgenx/backup.rb

@@ -0,0 +1,16 @@
+require 'fileutils'
+require 'time'
+
+module Backup
+  def self.salvar_versao_antiga(caminho)
+    return unless File.exist?(caminho)
+
+    FileUtils.mkdir_p("backup")
+    base = File.basename(caminho, ".feature")
+    timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+    destino = "backup/#{base}_#{timestamp}.feature"
+
+    FileUtils.cp(caminho, destino)
+    puts "📦 Backup criado: #{destino}"
+  end
+end

data/lib/bddgenx/cli.rb

@@ -0,0 +1,34 @@
+module CLI
+  def self.selecionar_arquivos_txt(diretorio)
+    arquivos = Dir.glob("#{diretorio}/*.txt")
+
+    if arquivos.empty?
+      puts "❌ Nenhum arquivo .txt encontrado no diretório '#{diretorio}'"
+      exit
+    end
+  
+    arquivos
+
+    puts "📂 Arquivos disponíveis em '#{diretorio}':"
+    arquivos.each_with_index do |arquivo, i|
+      puts "  #{i + 1}. #{File.basename(arquivo)}"
+    end
+
+    print "\nDigite os números dos arquivos que deseja processar (ex: 1,2,3 ou 'todos'): "
+    entrada = gets.chomp
+
+    selecionados = if entrada.downcase == 'todos'
+                     arquivos
+                   else
+                     indices = entrada.split(',').map { |n| n.strip.to_i - 1 }
+                     indices.map { |i| arquivos[i] }.compact
+                   end
+
+    if selecionados.empty?
+      puts "❌ Nenhum arquivo válido selecionado."
+      exit
+    end
+
+    selecionados
+  end
+end

data/lib/bddgenx/generator.rb

@@ -0,0 +1,123 @@
+require 'fileutils'
+
+module Generator
+  TIPOS_ISTQB = {
+    "SUCCESS"     => "Teste Positivo",
+    "FAILURE"     => "Teste Negativo",
+    "ERROR"       => "Teste de Erro",
+    "EXCEPTION"   => "Teste de Exceção",
+    "VALIDATION"  => "Teste de Validação",
+    "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
+  ]
+
+
+  def self.gerar_feature(historia)
+    idioma = historia[:idioma] || 'pt'
+
+    # Define os conectores de acordo com o 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'
+    }
+
+    nome_base = historia[:quero].gsub(/[^a-zA-Z0-9]/, '_').downcase
+    caminho = "features/#{nome_base}.feature"
+
+    conteudo = <<~HEADER
+      # language: #{idioma}
+      Funcionalidade: #{historia[:quero].sub(/^Quero/, '').strip}
+
+        #{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
+
+
+    # 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]
+      next unless passos&.any?
+
+      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?
+      exemplos_bruto = historia[:blocos]["EXAMPLES"]
+      cabecalho = exemplos_bruto.first.gsub('|', '').split.map(&:strip)
+      linhas = exemplos_bruto[1..]
+
+      # Procura qualquer cenário que use parâmetros
+      tipo_cenario = historia[:blocos].keys.find { |k| historia[:blocos][k].any? { |l| l.include?('<') } }
+      passos_exemplo = tipo_cenario ? historia[:blocos][tipo_cenario].select { |l| l.include?('<') } : []
+
+      if idioma == 'en'
+        conteudo += "    Scenario Outline: Generated scenario with data\n"
+      else
+        conteudo += "    Esquema do Cenário: Gerado a partir de dados de exemplo\n"
+      end
+
+      passos_exemplo.each do |passo|
+        conteudo += "      #{passo}\n"
+      end
+
+      conteudo += "\n"
+      conteudo += idioma == 'en' ? "      Examples:\n" : "      Exemplos:\n"
+      conteudo += "        #{exemplos_bruto.first}\n"
+      linhas.each { |linha| conteudo += "        #{linha}\n" }
+    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
+
+    File.write(caminho, conteudo)
+    puts "✅ Arquivo .feature gerado: #{caminho}"
+    true
+  end
+end

data/lib/bddgenx/integrations/jira.rb

@@ -0,0 +1,32 @@
+require 'jira-ruby'
+
+module Bddgen
+  module Integrations
+    class Jira
+      def initialize(options = {})
+        @client = JIRA::Client.new(
+          username: options[:username],
+          password: options[:api_token],
+          site: options[:site],
+          context_path: '',
+          auth_type: :basic
+        )
+        @project_key = options[:project_key]
+      end
+
+      def enviar_cenario(titulo, descricao)
+        issue = {
+          fields: {
+            project: { key: @project_key },
+            summary: titulo,
+            description: descricao,
+            issuetype: { name: "Task" }
+          }
+        }
+
+        @client.Issue.build.save(issue)
+        puts "✅ Cenário enviado para Jira: #{titulo}"
+      end
+    end
+  end
+end

data/lib/bddgenx/integrations/testlink.rb

@@ -0,0 +1,37 @@
+require 'xmlrpc/client'
+
+module Bddgen
+  module Integrations
+    class TestLink
+      def initialize(api_key, url)
+        @server = XMLRPC::Client.new2(url)
+        @key = api_key
+      end
+
+      def criar_caso_teste(plan_id, titulo, passos)
+        steps_formated = passos.map.with_index(1) do |step, i|
+          {
+            step_number: i,
+            actions: step,
+            expected_results: '',
+            execution_type: 1
+          }
+        end
+
+        params = {
+          devKey: @key,
+          testprojectid: 1,
+          testsuiteid: plan_id,
+          testcasename: titulo,
+          steps: steps_formated
+        }
+
+        response = @server.call('tl.createTestCase', params)
+        puts "✅ Teste enviado ao TestLink: #{titulo}"
+        response
+      rescue => e
+        puts "❌ Erro ao criar caso no TestLink: #{e.message}"
+      end
+    end
+  end
+end

data/lib/bddgenx/parser.rb

@@ -0,0 +1,52 @@
+module Parser
+  TIPOS_BLOCOS = %w[
+    CONTEXT SUCCESS FAILURE ERROR EXCEPTION
+    VALIDATION PERMISSION EDGE_CASE PERFORMANCE
+    EXAMPLES REGRA RULE
+  ].freeze
+
+  def self.ler_historia(caminho_arquivo)
+    linhas = File.readlines(caminho_arquivo, encoding: 'utf-8').map(&:strip).reject(&:empty?)
+
+    # Detecta idioma
+    idioma = linhas.first.downcase.include?('# lang: en') ? 'en' : 'pt'
+    linhas.shift if linhas.first.downcase.start_with?('#')
+
+    # Ignora linhas que sejam blocos ou comentários até encontrar Como/Quero/Para
+    cabecalho = []
+    until linhas.empty?
+      linha = linhas.shift
+      break if linha.start_with?("Como", "As")  # início da história em pt ou en
+    end
+    como = linha
+    quero = 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
+    }
+
+    tipo_atual = nil
+
+    linhas.each do |linha|
+      if linha.match?(/^\[(#{TIPOS_BLOCOS.join('|')})\]$/)
+        tipo_atual = linha.gsub(/[\[\]]/, '')
+        next
+      end
+
+      if %w[REGRA RULE].include?(tipo_atual)
+        historia[:regras] << linha
+      else
+        historia[:blocos][tipo_atual] << linha if tipo_atual
+      end
+    end
+
+    historia
+  end
+end

data/lib/bddgenx/pdf_exporter.rb

@@ -0,0 +1,29 @@
+require 'prawn'
+require 'fileutils'
+
+module Bddgen
+  class PDFExporter
+    def self.exportar_todos
+      FileUtils.mkdir_p('pdf')
+
+      Dir.glob('features/*.feature').each do |feature_file|
+        nome = File.basename(feature_file, '.feature')
+        destino = "pdf/#{nome}.pdf"
+
+        exportar_arquivo(feature_file, destino)
+        puts "📄 PDF gerado: #{destino}"
+      end
+    end
+
+    def self.exportar_arquivo(origem, destino)
+      conteudo = File.read(origem, encoding: 'utf-8')
+
+      Prawn::Document.generate(destino) do |pdf|
+        pdf.font_size 10
+        pdf.text "Arquivo: #{File.basename(origem)}", style: :bold, size: 14
+        pdf.move_down 10
+        pdf.text conteudo, size: 10
+      end
+    end
+  end
+end

data/lib/bddgenx/steps_generator.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+
+module StepsGenerator
+  PADROES = {
+    'pt' => %w[Dado Quando Então E],
+    'en' => %w[Given When Then And]
+  }
+
+  TIPOS_BLOCOS = %w[
+    CONTEXT SUCCESS FAILURE ERROR EXCEPTION
+    VALIDATION PERMISSION EDGE_CASE PERFORMANCE
+    EXAMPLES REGRA RULE
+  ]
+
+  def self.gerar_passos(historia, nome_arquivo_feature)
+    idioma = historia[:idioma] || 'pt'
+    conectores = PADROES[idioma]
+    passos_gerados = []
+
+    # Detectar parâmetros e tipos a partir do bloco EXAMPLES
+    exemplos = extrair_exemplos(historia[:blocos]["EXAMPLES"])
+
+    TIPOS_BLOCOS.each do |tipo|
+      blocos = tipo == "REGRA" || tipo == "RULE" ? historia[:regras] : historia[:blocos][tipo]
+      next unless blocos.is_a?(Array)
+
+      blocos.each do |linha|
+        next if tipo == "EXAMPLES" && linha.strip.start_with?("|") # ignora linhas de tabela
+
+        conector = conectores.find { |c| linha.strip.start_with?(c) }
+        next unless conector
+
+        corpo = linha.strip.sub(/^#{conector}/, '').strip
+        corpo_parametrizado = substituir_parametros(corpo, exemplos)
+
+        chave = { conector: conector, raw: corpo, param: corpo_parametrizado }
+        passos_gerados << chave unless passos_gerados.any? { |p| p[:param] == corpo_parametrizado }
+      end
+    end
+
+    if passos_gerados.empty?
+      puts "⚠️  Nenhum passo detectado em: #{nome_arquivo_feature} (arquivo não gerado)"
+      return false
+    end
+
+    nome_base = File.basename(nome_arquivo_feature, '.feature')
+    caminho = "steps/#{nome_base}_steps.rb"
+    FileUtils.mkdir_p(File.dirname(caminho))
+
+    comentario = "# Step definitions para #{File.basename(nome_arquivo_feature)}"
+    comentario += idioma == 'en' ? " (English)" : " (Português)"
+    conteudo = "#{comentario}\n\n"
+
+    passos_gerados.each do |passo|
+    # Extrai nomes dos parâmetros entre < >
+    parametros = passo[:raw].scan(/<([^>]+)>/).flatten.map(&:strip)
+    param_list = parametros.map { |p| p.gsub(' ', '_') }.join(', ')
+
+    conteudo += <<~STEP
+      #{passo[:conector]}('#{passo[:param]}') do#{param_list.empty? ? '' : " |#{param_list}|" }
+        pending '#{idioma == 'en' ? 'Implement step' : 'Implementar passo'}: #{passo[:raw]}'
+      end
+
+    STEP
+    end
+
+    FileUtils.mkdir_p("steps")
+    File.write(caminho, conteudo)
+    puts "✅ Step definitions gerados: #{caminho}"
+    true
+  end
+
+  def self.substituir_parametros(texto, exemplos)
+    texto.gsub(/<([^>]+)>/) do |_match|
+      nome = $1.strip
+      tipo = detectar_tipo_param(nome, exemplos)
+      "{#{tipo}}"
+    end
+  end
+
+  def self.detectar_tipo_param(nome_coluna, exemplos)
+    return 'string' unless exemplos && exemplos[:cabecalho].include?(nome_coluna)
+
+    idx = exemplos[:cabecalho].index(nome_coluna)
+    valores = exemplos[:linhas].map { |l| l[idx] }
+
+    if valores.all? { |v| v.match?(/^\d+$/) }
+      'int'
+    elsif valores.all? { |v| v.match?(/^\d+\.\d+$/) }
+      'float'
+    else
+      'string'
+    end
+  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
+
+

data/lib/bddgenx/tracer.rb

@@ -0,0 +1,32 @@
+require 'csv'
+require 'fileutils'
+
+module Tracer
+  ARQUIVO = 'output/rastreabilidade.csv'
+
+  def self.adicionar_entrada(historia, caminho_arquivo)
+    FileUtils.mkdir_p("output")
+
+    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
+
+      historia[:blocos].each do |tipo, passos|
+        next if tipo == "CONTEXT" || tipo == "EXAMPLES" || passos.empty?
+
+        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}"
+
+        csv << [
+          historia[:quero].sub(/^Quero/, '').strip,
+          tipo_istqb,
+          nome_cenario,
+          caminho_arquivo
+        ]
+      end
+    end
+  end
+end

data/lib/bddgenx/validator.rb

@@ -0,0 +1,32 @@
+module Validator
+  TIPOS_CENARIO = %w[
+    SUCCESS
+    FAILURE
+    ERROR
+    EXCEPTION
+    VALIDATION
+    PERMISSION
+    EDGE_CASE
+    PERFORMANCE
+  ]
+
+  def self.validar(historia)
+    valido = true
+
+    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
+    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)."
+      return false
+    end
+
+    valido
+  end
+end

data/lib/bddgenx/version.rb

@@ -0,0 +1,3 @@
+module Bddgenx
+  VERSION = "0.1.0"
+end

data/lib/bddgenx.rb

@@ -0,0 +1,47 @@
+require_relative "bddgen/version"
+require_relative "bddgen/cli"
+require_relative "bddgen/parser"
+require_relative "bddgen/validator"
+require_relative "bddgen/generator"
+require_relative "bddgen/steps_generator"
+require_relative "bddgen/tracer"
+require_relative "bddgen/backup"
+require_relative 'bddgen/pdf_exporter'
+
+cont_total = 0
+cont_features = 0
+cont_steps = 0
+cont_ignorados = 0
+
+# Exibe menu inicial e pergunta quais arquivos processar
+arquivos = CLI.selecionar_arquivos_txt('input')
+
+arquivos.each do |arquivo_path|
+ puts "\n🔍 Processando: #{arquivo_path}"
+
+  historia = Parser.ler_historia(arquivo_path)
+
+  unless Validator.validar(historia)
+    cont_ignorados += 1
+    puts "❌ Arquivo inválido: #{arquivo_path}"
+    next
+  end
+
+  nome_feature, conteudo_feature = Generator.gerar_feature(historia)
+
+  Backup.salvar_versao_antiga(nome_feature)
+  cont_features += 1 if Generator.salvar_feature(nome_feature, conteudo_feature)
+  cont_steps += 1 if StepsGenerator.gerar_passos(historia, nome_feature)
+
+
+  Tracer.adicionar_entrada(historia, nome_feature)
+end
+
+puts "\n✅ Processamento finalizado. Arquivos gerados em: features/, steps/, output/"
+puts "🔄 Versões antigas salvas em: backup/"
+
+puts "\n✅ Processamento finalizado:"
+puts "- Arquivos processados: #{cont_total}"
+puts "- Features geradas:     #{cont_features}"
+puts "- Steps gerados:        #{cont_steps}"
+puts "- Ignorados:            #{cont_ignorados}"

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: bddgenx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Nascimento
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-10 00:00:00.000000000 Z
+dependencies: []
+description: Transforma arquivos .txt com histórias em arquivos .feature, com steps,
+  rastreabilidade e integração com CI/CD.
+email:
+- halison700@gmail.com
+executables:
+- bddgenx
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/bddgenx
+- lib/bddgenx.rb
+- lib/bddgenx/backup.rb
+- lib/bddgenx/cli.rb
+- lib/bddgenx/generator.rb
+- lib/bddgenx/integrations/jira.rb
+- lib/bddgenx/integrations/testlink.rb
+- lib/bddgenx/parser.rb
+- lib/bddgenx/pdf_exporter.rb
+- lib/bddgenx/steps_generator.rb
+- lib/bddgenx/tracer.rb
+- lib/bddgenx/validator.rb
+- lib/bddgenx/version.rb
+homepage: https://github.com/David-Nascimento/bdd-generation
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.x
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key:
+specification_version: 4
+summary: Geração automática de BDD a partir de histórias de usuário
+test_files: []