bddgenx 2.3.3 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5f895b922c947b8d97296d56a17cfbdc9c31e5bbf6bbfc383c01ebc3e4cfe9d
-  data.tar.gz: 001d68f9b89e12e52e446bc02db6ee249392c864ad1955172dff31203a1a6a6c
+  metadata.gz: 27017e2957f3a9710eb63407c7f6d15e35e756a45890d3dc43b281b357d7d509
+  data.tar.gz: e50c8a8b925a0f941229ea8c79215e7671584b288cc29aab3dda78ad05db9e13
 SHA512:
-  metadata.gz: ce291e292b64946fcc493e9a590ef335fc652d321bee8637fdd7b5c30a7d411f34d7a26baf26c2a8f6ea1208fb2c943c11219b07695aa6e87fd7a932677a25a3
-  data.tar.gz: 52710f0f98ba329340956d8e657c09fd802f7f51a34b6437fd692f1e20924db8354a0ed3adcaa29d297461bf566e31fd9dfff54efa9945bbbd719f3f619c4c57
+  metadata.gz: 73d8b6d056d42b958814229d6d03384338199e6fbbb36da8110923ea955410b0b4de9a36d8f8df71343974178bebfc948a488303fe1e60d9a94bb410968f9e84
+  data.tar.gz: a8da8ca236ae14891de29ba9f22807581348258fb711922cc614dec74453ccb6fa6073b04cf6f74cdff24d304ff958e425d71762daaee59dc15df8bb93b3e163

data/Rakefile

@@ -1,5 +1,5 @@
-require 'rake'
 require 'bddgenx'
+require 'rake'
 
 namespace :bddgenx do
   desc 'Executa geração interativa: escolha entre static, chatgpt, gemini ou deepseek'

data/VERSION

@@ -1 +1 @@
-2.3.3
+2.4.3

data/lib/bddgenx/generators/generator.rb

@@ -1,10 +1,10 @@
 # lib/bddgenx/generator.rb
 # encoding: utf-8
 #
-# Este arquivo define a classe Generator, responsável por gerar arquivos
-# .feature a partir de um hash de história ou de um arquivo de história em texto.
-# Suporta Gherkin em Português e Inglês, inclusão de tags, cenários simples
-# e esquemas de cenário com exemplos.
+# Classe responsável pela geração de arquivos `.feature` no formato Gherkin
+# a partir de arquivos de entrada de histórias ou estruturas hash.
+# Suporta palavras-chave Gherkin em Português e Inglês, além de integração com IA
+# (ChatGPT ou Gemini) para geração automática de cenários.
 
 module Bddgenx
   class Generator
@@ -14,37 +14,39 @@ module Bddgenx
     # Palavras-chave do Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
 
-    # Mapeamento de PT → EN
+    # Mapeamento PT → EN
     GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
 
-    # Mapeamento de EN → PT
+    # Mapeamento EN → PT
     GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
 
-    # Todas as palavras-chave reconhecidas
+    # Todas as palavras-chave reconhecidas pelos parsers
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
     ##
     # Extrai todas as linhas de exemplo de um array de strings.
     #
-    # @param raw [Array<String>] um array contendo linhas de texto
-    # @return [Array<String>] apenas as linhas que começam com '|', ou seja, exemplos
+    # @param raw [Array<String>] Array com linhas do grupo de passos
+    # @return [Array<String>] Somente as linhas que contêm exemplos (começam com '|')
     def self.dividir_examples(raw)
       raw.select { |l| l.strip.start_with?('|') }
     end
 
     ##
-    # Gera o conteúdo de um arquivo `.feature` a partir de uma história.
-    # Pode operar em três modos: estático (hash ou arquivo estruturado),
-    # IA com Gemini, ou IA com ChatGPT.
+    # Gera o conteúdo de um arquivo `.feature` baseado na história fornecida.
+    # Pode operar em três modos:
+    # - :static (sem IA)
+    # - :chatgpt (usando OpenAI)
+    # - :gemini (usando Google Gemini)
     #
-    # @param input [String, Hash] caminho para um arquivo .txt ou um hash estruturado
-    # @param override_path [String, nil] caminho alternativo para salvar o arquivo gerado
-    # @return [Array(String, String)] caminho do arquivo gerado e conteúdo do .feature
+    # @param input [String, Hash] Caminho para um `.txt` ou estrutura de história já processada
+    # @param override_path [String, nil] Caminho alternativo de saída
+    # @return [Array<String, String>] Caminho e conteúdo do `.feature`
     def self.gerar_feature(input, override_path = nil)
       modo = ENV['BDD_MODE']&.to_sym || :static
 
       if input.is_a?(String) && input.end_with?('.txt') && [:gemini, :chatgpt].include?(modo)
-        # Modo com IA: gera cenários automaticamente com base no texto da história
+        # Geração com IA
         raw_txt = File.read(input)
         historia = {
           idioma: 'pt',
@@ -66,14 +68,14 @@ module Bddgenx
           passos: GherkinCleaner.limpar(texto_gerado).lines.map(&:strip).reject(&:empty?)
         }
       else
-        # Modo estático: utiliza estrutura vinda do Parser ou de um hash diretamente
+        # Geração estática
         historia = input.is_a?(String) ? Parser.ler_historia(input) : input
       end
 
       idioma = historia[:idioma] || 'pt'
       cont = 1
 
-      # Normaliza o nome base do arquivo
+      # Cria nome-base do arquivo .feature
       nome_base = historia[:quero]
                     .gsub(/[^a-z0-9]/i, '_')
                     .downcase
@@ -84,7 +86,7 @@ module Bddgenx
 
       caminho = override_path || "features/#{nome_base}.feature"
 
-      # Define palavras-chave com base no idioma
+      # Palavras-chave localizadas
       palavras = {
         feature:  idioma == 'en' ? 'Feature'          : 'Funcionalidade',
         contexto: idioma == 'en' ? 'Background'       : 'Contexto',
@@ -94,6 +96,7 @@ module Bddgenx
         regra:    idioma == 'en' ? 'Rule'             : 'Regra'
       }
 
+      # Cabeçalho do arquivo .feature
       conteudo = <<~GHK
         # language: #{idioma}
         #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
@@ -102,14 +105,14 @@ module Bddgenx
           # #{historia[:para]}
       GHK
 
+      # Controle para não repetir passos
       passos_unicos = Set.new
       pt_map = GHERKIN_MAP_PT_EN
       en_map = GHERKIN_MAP_EN_PT
       detect = ALL_KEYS
-      cont = 1
 
       historia[:grupos].each do |grupo|
-        passos   = grupo[:passos]  || []
+        passos   = grupo[:passos]   || []
         exemplos = grupo[:exemplos] || []
         next if passos.empty?
 
@@ -151,20 +154,21 @@ module Bddgenx
     end
 
     ##
-    # Gera o caminho padrão de saída para um arquivo `.feature` com base no nome do `.txt`.
+    # Retorna o caminho padrão do arquivo `.feature` baseado no nome do `.txt`.
     #
-    # @param arquivo_txt [String] caminho do arquivo .txt de entrada
-    # @return [String] caminho completo do arquivo .feature correspondente
+    # @param arquivo_txt [String] Caminho do arquivo .txt
+    # @return [String] Caminho final da feature gerada
     def self.path_para_feature(arquivo_txt)
       nome = File.basename(arquivo_txt, '.txt')
       File.join('features', "#{nome}.feature")
     end
 
     ##
-    # Salva o conteúdo gerado no disco, criando diretórios se necessário.
+    # Salva o conteúdo do arquivo `.feature` no disco.
+    # Cria diretórios intermediários, se necessário.
     #
-    # @param caminho [String] caminho completo para salvar o arquivo
-    # @param conteudo [String] conteúdo do arquivo .feature
+    # @param caminho [String] Caminho completo do arquivo
+    # @param conteudo [String] Conteúdo da feature a ser salva
     # @return [void]
     def self.salvar_feature(caminho, conteudo)
       FileUtils.mkdir_p(File.dirname(caminho))

data/lib/bddgenx/generators/runner.rb

@@ -2,28 +2,35 @@
 # encoding: utf-8
 #
 # Este arquivo define a classe Runner (CLI) da gem bddgenx,
-# responsável por orquestrar o fluxo de leitura de histórias,
-# validação, geração de features, steps, backups e exportação de PDFs.
+# responsável por orquestrar todo o fluxo de geração BDD:
+# leitura e validação de histórias, geração de features, steps,
+# exportação de PDFs e controle de modo (static / IA).
+
 require_relative '../../bddgenx'
 
 module Bddgenx
-  # Ponto de entrada da gem: coordena todo o processo de geração BDD.
+  # Classe principal de execução da gem.
+  # Atua como ponto de entrada (CLI) para processar arquivos de entrada
+  # e gerar todos os artefatos BDD relacionados.
   class Runner
-    # Seleciona arquivos de entrada para processamento.
-    # Se houver argumentos em ARGV, usa-os como nomes de arquivos .txt;
-    # caso contrário, exibe prompt interativo para escolha.
+
+    ##
+    # Retorna a lista de arquivos de entrada.
+    # Se houver argumentos em ARGV, utiliza-os como nomes de arquivos `.txt`.
+    # Caso contrário, chama prompt interativo.
     #
-    # @param input_dir [String] Diretório onde estão os arquivos .txt de histórias
-    # @return [Array<String>] Lista de caminhos para os arquivos a serem processados
+    # @param input_dir [String] Caminho do diretório de entrada
+    # @return [Array<String>] Lista de arquivos `.txt` a processar
     def self.choose_files(input_dir)
       ARGV.any? ? selecionar_arquivos_txt(input_dir) : choose_input(input_dir)
     end
 
-    # Mapeia ARGV para paths de arquivos .txt em input_dir.
-    # Adiciona extensão '.txt' se necessário e filtra arquivos inexistentes.
+    ##
+    # Processa argumentos ARGV e converte em caminhos válidos de arquivos `.txt`.
+    # Adiciona extensão `.txt` se ausente e remove arquivos inexistentes.
     #
-    # @param input_dir [String] Diretório de entrada
-    # @return [Array<String>] Caminhos válidos para processamento
+    # @param input_dir [String] Diretório onde estão os arquivos
+    # @return [Array<String>] Caminhos válidos para arquivos de entrada
     def self.selecionar_arquivos_txt(input_dir)
       ARGV.map do |arg|
         nome = arg.end_with?('.txt') ? arg : "#{arg}.txt"
@@ -36,12 +43,12 @@ module Bddgenx
       end.compact
     end
 
-    # Exibe prompt interativo para o usuário escolher qual arquivo processar
-    # entre todos os .txt disponíveis em input_dir.
+    ##
+    # Interface interativa para o usuário selecionar arquivos `.txt` a processar.
+    # Exibe uma lista dos arquivos disponíveis e solicita um número ao usuário.
     #
     # @param input_dir [String] Diretório de entrada
-    # @exit [1] Se nenhum arquivo for encontrado ou escolha inválida
-    # @return [Array<String>] Um único arquivo escolhido ou todos se ENTER
+    # @return [Array<String>] Lista com o arquivo escolhido ou todos
     def self.choose_input(input_dir)
       files = Dir.glob(File.join(input_dir, '*.txt'))
       if files.empty?
@@ -61,29 +68,29 @@ module Bddgenx
       [files[idx]]
     end
 
-    # Executa todo o fluxo de geração BDD.
-    # - Cria pasta 'input' se não existir
-    # - Seleciona arquivos de histórias
-    # - Para cada arquivo:
-    #   - Lê e valida a história
-    #   - Gera arquivo .feature e salva backup da versão anterior
-    #   - Gera definitions de steps
-    #   - Exporta PDFs novos via PDFExporter
-    # - Exibe resumo final com estatísticas
+    ##
+    # Executa o fluxo completo de geração BDD:
+    # - Define o modo (static / IA)
+    # - Coleta arquivos de entrada
+    # - Valida as histórias
+    # - Gera arquivos `.feature` e `steps`
+    # - Exporta PDFs e faz backup de versões antigas
+    #
+    # O modo de execução é lido da variável de ambiente `BDDGENX_MODE`.
     #
     # @return [void]
     def self.execute
       modo = ENV['BDDGENX_MODE'] || 'static'
-
       input_dir = 'input'
       Dir.mkdir(input_dir) unless Dir.exist?(input_dir)
 
       arquivos = choose_files(input_dir)
       if arquivos.empty?
-        warn "❌ Nenhum arquivo de história para processar."; exit 1
+        warn I18n.t('messages.no_files')
+        exit 1
       end
 
-      # Inicializa contadores
+      # Contadores de geração
       total = features = steps = ignored = 0
       skipped_steps = []
       generated_pdfs = []
@@ -91,25 +98,28 @@ module Bddgenx
 
       arquivos.each do |arquivo|
         total += 1
-        puts "\n🔍 Processando: #{arquivo}"
+        puts "\n🔍 #{I18n.t('messages.processing')}: #{arquivo}"
 
         historia = Parser.ler_historia(arquivo)
         unless Validator.validar(historia)
           ignored += 1
-          puts "❌ História inválida: #{arquivo}"
+          puts "❌ #{I18n.t('messages.invalid_story')}: #{arquivo}"
           next
         end
 
-        # Geração de feature
-        if %w[gemini chatgpt].include?(modo)
-          puts "🤖 Gerando cenários com IA (#{modo.capitalize})..."
+        # Geração via IA (ChatGPT, Gemini, Deepseek)
+        if %w[gemini chatgpt deepseek].include?(modo)
+          puts I18n.t('messages.start_ia', modo: modo.capitalize)
           idioma = IA::GeminiCliente.detecta_idioma_arquivo(arquivo)
 
-          feature_text = Bddgenx::Support::Loader.run("⏳ Aguardando resposta da IA...") do
-            if modo == 'gemini'
+          feature_text = Support::Loader.run(I18n.t('messages.ia_waiting'), :default) do
+            case modo
+            when 'gemini'
               IA::GeminiCliente.gerar_cenarios(historia, idioma)
-            else
+            when 'chatgpt'
               IA::ChatGptCliente.gerar_cenarios(historia, idioma)
+            when 'deepseek'
+              IA::DeepseekCliente.gerar_cenarios(historia, idioma)
             end
           end
 
@@ -118,11 +128,13 @@ module Bddgenx
             feature_content = Bddgenx::GherkinCleaner.limpar(feature_text)
           else
             ignored += 1
-            puts "❌ Falha ao gerar com IA: #{arquivo}"
+            puts I18n.t('messages.feature_fail', arquivo: arquivo)
             next
           end
         else
-          feature_path, feature_content = Bddgenx::Support::Loader.run("⛏️  Gerando feature estática...", :dots) do
+          # Geração local (modo static)
+          feature_path, feature_content = Support::Loader.run(I18n.t('messages.start_static'), :dots) do
+            sleep(2)
             Generator.gerar_feature(historia)
           end
         end
@@ -130,29 +142,23 @@ module Bddgenx
         Backup.salvar_versao_antiga(feature_path)
         features += 1 if Generator.salvar_feature(feature_path, feature_content)
 
-        # Geração de steps
         if StepsGenerator.gerar_passos(feature_path)
           steps += 1
         else
           skipped_steps << feature_path
         end
 
-        # Exportação de PDF (apenas novos)
         FileUtils.mkdir_p('reports')
         result = PDFExporter.exportar_todos(only_new: true)
         generated_pdfs.concat(result[:generated])
         skipped_pdfs.concat(result[:skipped])
       end
 
-      # Exibe relatório final
-      puts "\n✅ Processamento concluído"
-      puts "- Total de histórias:    #{total}"
-      puts "- Features geradas:      #{features}"
-      puts "- Steps gerados:         #{steps}"
-      puts "- Steps ignorados:       #{skipped_steps.size}"
-      puts "- PDFs gerados:          #{generated_pdfs.size}"
-      puts "- PDFs já existentes:    #{skipped_pdfs.size}"
-      puts "- Histórias ignoradas:   #{ignored}"
+      # Resumo final
+      puts "\n#{I18n.t('messages.processing_done')}"
+      puts "- #{I18n.t('messages.total_histories')}:    #{total}"
+      puts "- #{I18n.t('messages.features_generated')}: #{features}"
+      puts "- #{I18n.t('messages.steps_generated')}:    #{steps}"
     end
   end
 end

data/lib/bddgenx/generators/steps_generator.rb

@@ -1,10 +1,10 @@
 # lib/bddgenx/steps_generator.rb
 # encoding: utf-8
 #
-# Este arquivo define a classe StepsGenerator, responsável por gerar
-# definições de passos do Cucumber a partir de arquivos .feature.
-# Suporta palavras-chave Gherkin em Português e Inglês e parametriza
-# strings e números conforme necessário.
+# Classe responsável por gerar automaticamente os arquivos de definição
+# de passos do Cucumber a partir de arquivos `.feature`.
+# Suporta palavras-chave do Gherkin tanto em Português quanto em Inglês,
+# além de identificar parâmetros dinamicamente (strings e números).
 
 module Bddgenx
   class StepsGenerator
@@ -14,66 +14,67 @@ module Bddgenx
     # Palavras-chave Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
 
-    # Conjunto de todas as palavras-chave suportadas
+    # Conjunto de todas as palavras-chave reconhecidas
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
     ##
-    # Transforma uma string em estilo camelCase.
-    #
-    # @param str [String] A string a ser transformada.
-    # @return [String] A string convertida para camelCase.
+    # Transforma uma string em camelCase (sem alterar acentuação).
     #
+    # @param str [String] A string de entrada
+    # @return [String] A string convertida para estilo camelCase
     def self.camelize(str)
       partes = str.strip.split(/[^a-zA-Z0-9]+/)
       partes.map.with_index { |palavra, i| i.zero? ? palavra.downcase : palavra.capitalize }.join
     end
 
     ##
-    # Gera arquivos de passos do Cucumber a partir de um arquivo .feature.
-    #
-    # O método lê o arquivo, detecta o idioma, extrai os passos,
-    # parametriza as variáveis (números e strings), e escreve os métodos
-    # em um novo arquivo no diretório `steps/`.
-    #
-    # @param feature_path [String] Caminho para o arquivo .feature.
-    # @return [Boolean] Retorna true se os passos forem gerados com sucesso, false se não houver passos.
-    # @raise [ArgumentError] Se o caminho fornecido não for uma String.
+    # Gera um arquivo de definição de passos do Cucumber com base em um `.feature`.
+    # Detecta automaticamente o idioma e converte os passos em métodos com placeholders.
     #
+    # @param feature_path [String] Caminho para o arquivo `.feature`
+    # @return [Boolean] Retorna true se os steps foram gerados, false se nenhum foi encontrado
+    # @raise [ArgumentError] Se o parâmetro não for uma String
     def self.gerar_passos(feature_path)
-      raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
+      raise ArgumentError, I18n.t('errors.invalid_path', path: feature_path.class) unless feature_path.is_a?(String)
 
       linhas = File.readlines(feature_path)
 
-      # Detecta o idioma com base na diretiva "# language:"
+      # Detecta o idioma a partir da linha `# language:`
       lang = if (m = linhas.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
                m[/^#\s*language:\s*(\w+)/i, 1].downcase
              else
                'pt'
              end
 
+      # Define o locale do I18n conforme idioma detectado
+      I18n.locale = lang.to_sym rescue :pt
+
       pt_para_en = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
       en_para_pt = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
 
-      # Seleciona apenas linhas que começam com palavras-chave Gherkin
+      # Seleciona apenas as linhas que representam passos
       linhas_passos = linhas.map(&:strip).select do |linha|
         ALL_KEYS.any? { |chave| linha.start_with?(chave + ' ') }
       end
 
       return false if linhas_passos.empty?
 
+      # Cria diretório `steps` no mesmo nível do `.feature`
       dir_saida = File.join(File.dirname(feature_path), 'steps')
       FileUtils.mkdir_p(dir_saida)
+
       arquivo_saida = File.join(dir_saida, "#{File.basename(feature_path, '.feature')}_steps.rb")
 
+      # Cabeçalho do arquivo gerado
       conteudo = +"# encoding: utf-8\n"
-      conteudo << "# Definições de passos geradas automaticamente para #{File.basename(feature_path)}\n\n"
+      conteudo << "# #{I18n.t('steps.header', file: File.basename(feature_path))}\n\n"
 
       passos_unicos = Set.new
 
       linhas_passos.each do |linha|
         palavra_original, restante = linha.split(' ', 2)
 
-        # Tradução de palavras-chave se necessário
+        # Tradução da palavra-chave inicial
         chave = case lang
                 when 'en' then pt_para_en[palavra_original] || palavra_original
                 else           en_para_pt[palavra_original] || palavra_original
@@ -84,7 +85,7 @@ module Bddgenx
         padrao = ''
         tokens = []
 
-        # Analisa e parametriza o conteúdo dos passos
+        # Analisa e parametriza variáveis
         until scanner.eos?
           if scanner.check(/"<([^>]+)>"/)
             scanner.scan(/"<([^>]+)>"/)
@@ -94,8 +95,8 @@ module Bddgenx
             scanner.scan(/<([^>]+)>/)
             tokens << scanner[1]
             padrao << '{int}'
-          elsif scanner.check(/"([^"<>]+)"/)
-            scanner.scan(/"([^"<>]+)"/)
+          elsif scanner.check(/"([^"]+)"/)
+            scanner.scan(/"([^"]+)"/)
             tokens << scanner[1]
             padrao << '{string}'
           elsif scanner.check(/\d+(?:\.\d+)?/)
@@ -109,11 +110,11 @@ module Bddgenx
 
         padrao_seguro = padrao.gsub('"', '\\"')
 
-        # Impede criação de métodos duplicados
+        # Evita duplicatas de métodos
         next if passos_unicos.include?(padrao_seguro)
-
         passos_unicos << padrao_seguro
 
+        # Monta assinatura do step
         assinatura = "#{chave}(\"#{padrao_seguro}\")"
         if tokens.any?
           argumentos = tokens.each_index.map { |i| "arg#{i+1}" }.join(', ')
@@ -123,12 +124,13 @@ module Bddgenx
         end
 
         conteudo << "#{assinatura}\n"
-        conteudo << "  pending 'Implementar passo: #{texto_bruto}'\n"
+        conteudo << "  pending '#{I18n.t('steps.pending', text: texto_bruto)}'\n"
         conteudo << "end\n\n"
       end
 
+      # Escreve o arquivo final
       File.write(arquivo_saida, conteudo)
-      puts "✅ Steps gerados: #{arquivo_saida}"
+      puts I18n.t('steps.generated', path: arquivo_saida)
       true
     end
   end

data/lib/bddgenx/locales/en.yml

@@ -0,0 +1,28 @@
+en:
+  messages:
+    start_ia: "🤖 Generating scenarios with AI (%{modo})..."
+    start_static: "⛏️  Generating static feature..."
+    ia_waiting: "⏳ Waiting for AI response..."
+    feature_fail: "❌ Failed to generate via AI: %{arquivo}"
+    no_files: "❌ No story file found to process."
+    not_found: "⚠️  File not found: %{arquivo}"
+    processing_done: "✅ Processing complete"
+    total_histories: "Total stories"
+    features_generated: "Generated features"
+    steps_generated: "Generated steps"
+    feature_created: "✅ .feature file generated: %{caminho}"
+  gherkin:
+    feature: "Feature"
+    context: "Background"
+    scenario: "Scenario"
+    scenario_outline: "Scenario Outline"
+    examples: "Examples"
+    rule: "Rule"
+  steps:
+    header: "Step definitions automatically generated for %{file}"
+    pending: "Implement step: %{text}"
+    generated: "✅ Steps generated: %{path}"
+  errors:
+    invalid_path: "Expected path as String, got %{path}"
+  messages2:
+    processing_done: "✅ Processing complete"

data/lib/bddgenx/locales/pt.yml

@@ -0,0 +1,27 @@
+pt:
+  messages:
+    start_ia: "🤖 Gerando cenários com IA (%{modo})..."
+    start_static: "⛏️  Gerando feature estática..."
+    ia_waiting: "⏳ Aguardando resposta da IA..."
+    feature_fail: "❌ Falha ao gerar com IA: %{arquivo}"
+    no_files: "❌ Nenhum arquivo de história para processar."
+    not_found: "⚠️  Arquivo não encontrado: %{arquivo}"
+    processing_done: "✅ Processamento concluído"
+    total_histories: "Total de histórias"
+    features_generated: "Features geradas"
+    steps_generated: "Steps gerados"
+    feature_created: "✅ Arquivo .feature gerado: %{caminho}"
+  gherkin:
+    feature: "Funcionalidade"
+    context: "Contexto"
+    scenario: "Cenário"
+    scenario_outline: "Esquema do Cenário"
+    examples: "Exemplos"
+    rule: "Regra"
+  steps:
+    header: "Definições de passos geradas automaticamente para %{file}"
+    pending: "Implementar passo: %{text}"
+    generated: "✅ Steps gerados: %{path}"
+  errors:
+    invalid_path: "Caminho esperado como String, recebeu %{path}"
+

data/lib/bddgenx.rb

@@ -1,6 +1,3 @@
-#!/usr/bin/env ruby
-# Shebang para permitir execução direta do script no Linux/macOS, usando o interpretador Ruby do PATH
-
 require_relative 'env'
 # Carrega o arquivo 'env.rb' relativo a este script. Geralmente contém configurações e carregamento da gem Bddgenx.
 

data/lib/env.rb

@@ -1,52 +1,109 @@
 # lib/bddgenx/env.rb
+# encoding: utf-8
+#
+# Responsável por carregar todas as dependências da gem bddgenx.
+# Inclui bibliotecas padrão, gems externas e arquivos internos
+# essenciais para o funcionamento da geração BDD, com suporte a I18n,
+# IA (ChatGPT, Gemini), geração de PDF, validações e estrutura de projeto.
 
-# Carregamento de bibliotecas padrão e gems externas usadas no projeto
+# --------------------------------------
+# 📦 Gems padrão da linguagem Ruby
+# --------------------------------------
 
-require 'json'           # Para manipulação de dados JSON
-require 'net/http'       # Para fazer requisições HTTP
-require 'uri'            # Para manipulação de URLs
-require 'fileutils'      # Para manipulação de arquivos e diretórios
-require 'prawn'          # Biblioteca para geração de PDFs
-require 'prawn/table'    # Suporte a tabelas no Prawn PDF
-require 'prawn-svg'      # Para incorporar SVG em PDFs com Prawn
-require 'open3'          # Para executar comandos externos com captura de saída
-require 'faraday'        # Cliente HTTP para Gemini API
-require 'dotenv'         # Para carregar variáveis de ambiente de arquivos .env
-require 'unicode'        # Para manipulação avançada de strings Unicode (ex: remoção de acentos)
-require 'bigdecimal'     # Para operações matemáticas precisas com decimais
+require 'json'           # Manipulação de dados JSON
+require 'net/http'       # Requisições HTTP nativas
+require 'uri'            # Manipulação de URLs
+require 'fileutils'      # Operações com arquivos e diretórios
+require 'open3'          # Execução de comandos externos com captura de saída
+require 'bigdecimal'     # Cálculos matemáticos de alta precisão
+require 'i18n'           # Internacionalização (traduções dinâmicas)
 
-Dotenv.load
+# --------------------------------------
+# 📚 Gems externas
+# --------------------------------------
 
-# Configura o caminho base do projeto e carrega as gems definidas no Gemfile (se existir)
+require 'prawn'          # Geração de documentos PDF
+require 'prawn/table'    # Suporte a tabelas no Prawn
+require 'prawn-svg'      # Suporte a SVG no PDF
+require 'faraday'        # Cliente HTTP para integração com APIs (ex: Gemini)
+require 'dotenv'         # Carrega variáveis de ambiente do arquivo `.env`
+require 'unicode'        # Manipulação e normalização de caracteres Unicode
+
+# --------------------------------------
+# 🌍 Configuração de idioma (I18n)
+# --------------------------------------
+
+Dotenv.load  # Carrega variáveis como BDDGENX_LANG e APIs
+
+# Define o caminho de arquivos de tradução YAML
+locales_path = File.expand_path('bddgenx/locales/*.yml', __dir__)
+I18n.load_path += Dir[locales_path]
+
+# Define o idioma ativo somente se estiver presente e válido
+idioma_env = ENV['BDDGENX_LANG']
+if idioma_env && !idioma_env.strip.empty?
+  I18n.locale = idioma_env.strip.to_sym
+else
+  I18n.locale = :pt
+end
+
+
+# --------------------------------------
+# 🔧 Bundler (para projetos com Gemfile)
+# --------------------------------------
+
+# Carrega as dependências listadas no Gemfile (se houver)
 require 'bundler/setup' if File.exist?(File.expand_path('../../Gemfile', __FILE__))
 
-# Carregamento dos módulos utilitários (helpers)
-require_relative  'bddgenx/support/gherkin_cleaner'          # Limpeza e normalização de textos Gherkin
-require_relative  'bddgenx/support/remover_steps_duplicados' # Remoção de steps duplicados em features
-require_relative  'bddgenx/support/validator'                # Validação de dados e entrada
-require_relative  'bddgenx/support/font_loader'              # Carregamento de fontes para geração PDF
+# --------------------------------------
+# 🧩 Módulos utilitários da gem
+# --------------------------------------
+
+require_relative 'bddgenx/support/gherkin_cleaner'           # Sanitização de Gherkin gerado
+require_relative 'bddgenx/support/remover_steps_duplicados'  # Remove passos duplicados
+require_relative 'bddgenx/support/validator'                 # Valida estrutura de entrada
+require_relative 'bddgenx/support/font_loader'               # Carrega fontes do PDF
+
+# --------------------------------------
+# 🤖 Clientes de IA (ChatGPT, Gemini)
+# --------------------------------------
+
+require_relative 'bddgenx/ia/gemini_cliente'   # Integração com Google Gemini
+require_relative 'bddgenx/ia/chatgtp_cliente'  # Integração com OpenAI (ChatGPT)
+
+# --------------------------------------
+# 🛠 Geradores (features, steps e execução)
+# --------------------------------------
+
+require_relative 'bddgenx/generators/generator'        # Geração do conteúdo `.feature`
+require_relative 'bddgenx/generators/steps_generator'  # Geração de arquivos `*_steps.rb`
+require_relative 'bddgenx/generators/runner'           # Orquestrador da execução CLI
+
+# --------------------------------------
+# 📄 Parser e metadados
+# --------------------------------------
+
+require_relative 'parser'               # Interpreta arquivos `.txt` de entrada
+require_relative 'bddgenx/version'      # Lê versão do arquivo `VERSION`
 
-# Carregamento dos clientes para Integração com Inteligência Artificial
-require_relative  'bddgenx/ia/gemini_cliente'                # Cliente para API Gemini (Google)
-require_relative  'bddgenx/ia/chatgtp_cliente'               # Cliente para API ChatGPT (OpenAI)
+# --------------------------------------
+# 📤 Relatórios e exportação
+# --------------------------------------
 
-# Carregamento dos geradores de BDD (features, steps e runner)
-require_relative  'bddgenx/generators/generator'             # Gerador principal de arquivos .feature
-require_relative  'bddgenx/generators/steps_generator'       # Gerador de arquivos steps.rb
-require_relative  'bddgenx/generators/runner'                 # Classe responsável pela execução do processo de geração
+require_relative 'bddgenx/reports/pdf_exporter'  # Exporta features para PDF
+require_relative 'bddgenx/reports/backup'        # Gera backups de arquivos
+require_relative 'bddgenx/reports/tracer'        # Rastreabilidade de geração
 
-# Parser do arquivo de entrada e versão da gem
-require_relative  'parser'                                    # Parser para interpretar arquivos de entrada
-require_relative 'bddgenx/version'                                   # Informação da versão da gem
+# --------------------------------------
+# ⚙️ Configuração da gem e loaders auxiliares
+# --------------------------------------
 
-# Relatórios e exportação
-require_relative  'bddgenx/reports/pdf_exporter'              # Exporta relatórios em PDF usando Prawn
-require_relative  'bddgenx/reports/backup'                    # Mecanismo de backup dos arquivos gerados
-require_relative  'bddgenx/reports/tracer'                    # Rastreabilidade dos processos
+require_relative 'bddgenx/configuration'  # Variáveis de configuração (modo, APIs, etc.)
+require_relative 'bddgenx/setup'          # Inicializa estrutura do projeto (input/, features/, etc.)
+require_relative 'bddgenx/support/loader' # Exibe loaders/spinners no terminal
 
-require_relative 'bddgenx/configuration'                      # Configuração das variaveis de IA
-require_relative 'bddgenx/setup'                               # Verifica estrutura do projeto, caso nao exista cria a nova.
-require_relative 'bddgenx/support/loader'
+# --------------------------------------
+# 🔁 Define modo de execução (ambiente de dev por padrão)
+# --------------------------------------
 
-# Define variável de ambiente global para indicar que o ambiente BDDGENX está em modo desenvolvimento
 ENV['BDDGENX_ENV'] = 'development'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.4.3
 platform: ruby
 authors:
 - David Nascimento
@@ -132,6 +132,8 @@ files:
 - lib/bddgenx/generators/steps_generator.rb
 - lib/bddgenx/ia/chatgtp_cliente.rb
 - lib/bddgenx/ia/gemini_cliente.rb
+- lib/bddgenx/locales/en.yml
+- lib/bddgenx/locales/pt.yml
 - lib/bddgenx/reports/backup.rb
 - lib/bddgenx/reports/pdf_exporter.rb
 - lib/bddgenx/reports/tracer.rb