bddgenx 0.1.32 → 0.1.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fda31f4771f3fc150f52a9a6242c1e0fac890009c3cf66281640c9f58152f53c
-  data.tar.gz: 60ec20719d98e9f32151f5f4cebeff5123d237d158a8495ce389d7ec65f201bc
+  metadata.gz: 9bf7bc9f9f2860f8e305530e4e445ecdc67a9f45bfc4d6dca751f954bea45931
+  data.tar.gz: cdff8e55fea97da8d77fce3fde6d01d53de653a2bbaa15ce5af84bb27d58f700
 SHA512:
-  metadata.gz: c1f92ae05c89f892f8f206535cf3928be7037ca95f71787f01e74a8ecd401cdf7fa7b852f22b2e0d45de5a757b7ae385dd705bfbb53e28b5c3694d2a398608cd
-  data.tar.gz: 99964cbae7ef80abb75792c6629932efd9a66d4b9000d0e839c7b8ec94f57b793065a04c17722ec72f508df76185ff3d8a13c69008805c040042b3232316fee1
+  metadata.gz: 830ff28e5997763916c6ff02cd51d5c2eb20cdb8933c2f6a695391f39a327a6c1ad330e578855e8048afc00eb5d96006d4435f56e36459ce32d41624a6fa2301
+  data.tar.gz: e365e0c9f7edbb717538b26bbee7dce27b9621f2fb54b26db8fde1d3996636ec4c408f9b0f50f1b2d5d81b3c8c59b494454d75516b8a0def0f6b198c7b065cba

data/README.md

@@ -18,8 +18,6 @@ bddgenx/
 │   └── pdf/                 # relatórios camelCase  
 ├── lib/  
 │   ├── bddgenx/  
-│   │   ├── integrations
-│   │   │   └── jira.rb
 │   │   ├── parser.rb  
 │   │   ├── validator.rb  
 │   │   ├── generator.rb  
@@ -59,11 +57,11 @@ Como um usuario do sistema
 Quero fazer login com sucesso
 Para acessar minha conta
 
-[SUCCESS]@mobile
+[FAILURE]
 Quando preencho email e senha válidos
 Então vejo a tela inicial
 
-[SUCCESS]@regressivo
+[SUCCESS]
 Quando tento logar com "<email>" e "<senha>"
 Então recebo "<resultado>"
 
@@ -179,7 +177,6 @@ namespace :bddgenx do
     puts "✅ Geração BDD concluída com sucesso!"
   end
 end
-
 ```
 
 👨‍💻 Autor

data/VERSION

@@ -1 +1 @@
-0.1.32
+0.1.34

data/lib/bddgenx/generator.rb

@@ -1,73 +1,97 @@
 require 'fileutils'
+require_relative 'utils/tipo_param'
 
 module Bddgenx
   class 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"
-    }.freeze
+    GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
+    GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
+    GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
+    GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
+    ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
+
+    # Divide raw example blocks into a single table
+    def self.dividir_examples(raw)
+      raw.select { |l| l.strip.start_with?('|') }
+    end
+
+    # Gera .feature a partir de hash ou arquivo de história
+    # Respeita idioma em historia[:idioma]
+    def self.gerar_feature(input, override_path = nil)
+      historia = input.is_a?(String) ? Parser.ler_historia(input) : input
+      idioma = historia[:idioma] || 'pt'
+      nome_base = historia[:quero].gsub(/[^a-z0-9]/i, '_')
+                                  .downcase.split('_',3)[0,3].join('_')
+      caminho = override_path.is_a?(String) ? override_path : "features/#{nome_base}.feature"
 
-    def self.gerar_feature(historia)
-      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'
+        feature:   idioma=='en' ? 'Feature'           : 'Funcionalidade',
+        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'
       }
 
-      frase_quero = historia[:quero].sub(/^\s*quero\s*/i, '')
-      partes     = frase_quero.split(/\s+/)[0,3]    # pega só as 3 primeiras palavras
-      slug       = partes.join('_')
-                         .gsub(/[^a-z0-9_]/i, '')                    # remove caracteres especiais
-                         .downcase
-      nome_base  = slug
-      caminho   = "features/#{nome_base}.feature"
-
-      conteudo = <<~GHERKIN
+      conteudo = <<~GHK
         # language: #{idioma}
-        Funcionalidade: #{historia[:quero].sub(/^Quero\s*/, '')}
+        #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
+          # #{historia[:como]}
+          # #{historia[:quero]}
+          # #{historia[:para]}
 
-          #{historia[:como]}
-          #{historia[:quero]}
-          #{historia[:para]}
+      GHK
 
-      GHERKIN
+      pt_map = GHERKIN_MAP_PT_EN
+      en_map = GHERKIN_MAP_EN_PT
+      detect = ALL_KEYS
 
       historia[:grupos].each_with_index do |grupo, idx|
-        tipo     = grupo[:tipo]
-        tag      = grupo[:tag]
-        passos   = grupo[:passos]
-        exemplos = grupo[:exemplos]
-
+        passos = grupo[:passos] || []
+        exemplos = grupo[:exemplos] || []
         next if passos.empty?
 
-        linha_tag = ["@#{tipo.downcase}", ("@#{tag}" if tag)].compact.join(' ')
-        possui_parametros = passos.any? { |p| p.include?('<') } && exemplos.any?
+        tag_line = ["@#{grupo[:tipo].downcase}", ("@#{grupo[:tag]}" if grupo[:tag])].compact.join(' ')
+
+        if exemplos.any?
+          # Scenario Outline
+          conteudo << "    #{tag_line}\n"
+          conteudo << "    #{palavras[:esquema]}: Exemplo #{idx+1}\n"
 
-        if possui_parametros
-          conteudo << "    #{linha_tag}\n"
-          conteudo << "    #{palavras[:esquema]}: Exemplo #{idx + 1}\n"
-          passos.each { |p| conteudo << "      #{p}\n" }
+          # Renderiza cada passo, mapeando connector mesmo se não for Gherkin padrão
+          passos.each do |p|
+            line = p.strip
+            parts = line.split(' ', 2)
+            # match connector case-insensitive
+            con_in = detect.find { |k| k.casecmp(parts[0]) == 0 } || parts[0]
+            text = parts[1] || ''
+            out_conn = idioma=='en' ? pt_map[con_in] || con_in : en_map[con_in] || con_in
+            conteudo << "      #{out_conn} #{text}
+"
+          end
+
+          # Monta tabela de exemplos completa
+          # Renderiza o bloco de Examples exatamente como veio no TXT
           conteudo << "\n      #{palavras[:exemplos]}:\n"
-          exemplos.each { |linha| conteudo << "        #{linha}\n" }
+          exemplos.select { |l| l.strip.start_with?('|') }.each do |line|
+            # Remove aspas apenas das células, mantendo todas as colunas e valores originais
+            cleaned = line.strip.gsub(/^"|"$/, '')
+            conteudo << "        #{cleaned}\n"
+          end
           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" }
+          # Scenario simples
+          conteudo << "    #{tag_line}\n"
+          conteudo << "    #{palavras[:cenario]}: #{grupo[:tipo].capitalize}\n"
+          passos.each do |p|
+            line = p.strip
+            parts = line.split(' ', 2)
+            # match connector case-insensitive
+            con_in = detect.find { |k| k.casecmp(parts[0]) == 0 } || parts[0]
+            text = parts[1] || ''
+            out_conn = idioma=='en' ? pt_map[con_in] || con_in : en_map[con_in] || con_in
+            conteudo << "      #{out_conn} #{text}
+"
+          end
           conteudo << "\n"
         end
       end
@@ -79,7 +103,6 @@ module Bddgenx
       FileUtils.mkdir_p(File.dirname(caminho))
       File.write(caminho, conteudo)
       puts "✅ Arquivo .feature gerado: #{caminho}"
-      true
     end
   end
-end
+end

data/lib/bddgenx/parser.rb

@@ -1,47 +1,38 @@
 module Bddgenx
+  # Tipos de blocos GUARDADOS, incluindo português EXEMPLO/EXEMPLOS
   TIPOS_BLOCOS = %w[
     CONTEXT SUCCESS FAILURE ERROR EXCEPTION
     VALIDATION PERMISSION EDGE_CASE PERFORMANCE
-    EXAMPLES REGRA RULE
+    EXEMPLO EXEMPLOS RULE
   ].freeze
 
   class Parser
+    # Lê arquivo de história (.txt) e retorna hash com atributos e grupos
     def self.ler_historia(caminho_arquivo)
-      linhas = File.readlines(caminho_arquivo, encoding: 'utf-8')
-                   .map(&:strip)
-                   .reject(&:empty?)
+      # Lê todas as linhas, mantendo vazias
+      linhas = File.readlines(caminho_arquivo, encoding: 'utf-8').map(&:rstrip)
 
-      # Detecta idioma (padrão pt, usa en se encontrar '# lang: en')
-      idioma = linhas.first.downcase.include?('# lang: en') ? 'en' : 'pt'
-      linhas.shift if linhas.first.downcase.start_with?('# lang:')
-
-      # Cabeçalho Gherkin (case-insensitive): Como, Eu Como ou As a
-      como = nil
-      linhas.each_with_index do |l, i|
-        if l =~ /^\s*(?:como|eu como|as a)\b/i || l =~ /^\s*(?:COMO|EU COMO|AS A)\b/i
-          como = l
-          linhas = linhas[(i+1)..]
-          break
-        end
+      # Detecta idioma: aceita "# lang: en" ou "# language: en"
+      idioma = 'pt'
+      if linhas.first =~ /^#\s*lang(?:uage)?\s*:\s*(\w+)/i
+        idioma = Regexp.last_match(1).downcase
+        linhas.shift
       end
 
-      # 'Quero' ou 'Eu Quero'
-      quero = nil
-      linhas.each_with_index do |l, i|
-        if l =~ /^\s*(?:quero|eu quero|quero que)\b/i || l =~ /^\s*(?:QUERO|EU QUERO|QUERO QUE)\b/i
+      # Extrai Cabeçalho Como/Quero/Para
+      como, quero, para = nil, nil, nil
+      linhas.reject! do |l|
+        if l =~ /^\s*(?:como|eu como|as a)/i && como.nil?
+          como = l
+          true
+        elsif l =~ /^\s*(?:quero|eu quero|quero que)/i && quero.nil?
           quero = l
-          linhas = linhas[(i+1)..]
-          break
-        end
-      end
-
-      # 'Para', 'Para Eu' ou 'Para Que'
-      para = nil
-      linhas.each_with_index do |l, i|
-        if l =~ /^\s*(?:para|para eu|para que)\b/i || l =~ /^\s*(?:PRA|PARA EU|PARA QUE)\b/i
+          true
+        elsif l =~ /^\s*(?:para|para eu|para que)/i && para.nil?
           para = l
-          linhas = linhas[(i+1)..]
-          break
+          true
+        else
+          false
         end
       end
 
@@ -49,30 +40,30 @@ module Bddgenx
       exemplos_mode = false
 
       linhas.each do |linha|
-        # Início de bloco de exemplos
-        if linha =~ /^\[EXAMPLES\](?:@(\w+))?$/i
+        # Início de bloco de exemplos: [EXEMPLO] ou [EXEMPLOS] ou [EXAMPLES]
+        if linha =~ /^\[(?:EXEMPLO|EXEMPLOS|EXAMPLES)\](?:@(\w+))?$/i
           exemplos_mode = true
+          # inicia array se for o primeiro exemplo
           historia[:grupos].last[:exemplos] = []
           next
         end
 
-        # Início de bloco de tipo (SUCCESS, FAILURE etc.)
+        # Início de bloco de tipo (SUCCESS, FAILURE, REGRA etc.)
         if linha =~ /^\[(#{TIPOS_BLOCOS.join('|')})\](?:@(\w+))?$/i
           exemplos_mode = false
-          tipo = $1.upcase
-          tag  = $2
+          tipo = Regexp.last_match(1).upcase
+          tag  = Regexp.last_match(2)
           historia[:grupos] << { tipo: tipo, tag: tag, passos: [], exemplos: [] }
           next
         end
 
-        # Atribui linhas ao último grupo existente
+        # Atribui linhas ao último grupo
         next if historia[:grupos].empty?
-        atual = historia[:grupos].last
-
+        bloco = historia[:grupos].last
         if exemplos_mode
-          atual[:exemplos] << linha
+          bloco[:exemplos] << linha
         else
-          atual[:passos]   << linha
+          bloco[:passos]   << linha
         end
       end
 

data/lib/bddgenx/runner.rb

@@ -0,0 +1,115 @@
+# lib/bddgenx/cli.rb
+require 'fileutils'
+require_relative 'parser'
+require_relative 'generator'
+require_relative 'steps_generator'
+require_relative 'validator'
+require_relative 'backup'
+require_relative 'pdf_exporter'
+
+module Bddgenx
+  class Runner
+    # Retorna lista de arquivos .txt em input/ ou só aqueles baseados em ARGV
+    def self.selecionar_arquivos_txt(input_dir)
+      ARGV.map do |arg|
+        nome = arg.end_with?('.txt') ? arg : "#{arg}.txt"
+        path = File.join(input_dir, nome)
+        unless File.exist?(path)
+          warn "⚠️  Arquivo não encontrado: #{path}"
+          next
+        end
+        path
+      end.compact
+    end
+
+    # Interativo: permite ao usuário escolher entre os .txt em input/
+    def self.choose_input(input_dir)
+      files = Dir.glob(File.join(input_dir, '*.txt'))
+      if files.empty?
+        warn "❌ Não há arquivos .txt no diretório #{input_dir}"
+        exit 1
+      end
+
+      puts "Selecione o arquivo de história para processar:"
+      files.each_with_index do |f, i|
+        puts "#{i+1}. #{File.basename(f)}"
+      end
+      print "Digite o número correspondente (ou ENTER para todos): "
+      choice = STDIN.gets.chomp
+
+      return files if choice.empty?
+
+      idx = choice.to_i - 1
+      unless idx.between?(0, files.size - 1)
+        warn "❌ Escolha inválida."
+        exit 1
+      end
+      [files[idx]]
+    end
+
+    def self.execute
+      history_dir = 'input'
+      Dir.mkdir(history_dir) unless Dir.exist?(history_dir)
+
+      # Determina quais arquivos processar
+      arquivos = if ARGV.any?
+                   selecionar_arquivos_txt(history_dir)
+                 else
+                   choose_input(history_dir)
+                 end
+
+      if arquivos.empty?
+        warn "❌ Nenhum arquivo de história para processar."
+        exit 1
+      end
+
+      # Contadores e coleções
+      total = features = steps = ignored = 0
+      skipped_steps = []
+      generated_pdfs = []
+      skipped_pdfs = []
+
+      arquivos.each do |arquivo|
+        total += 1
+        puts "\n🔍 Processando: #{arquivo}"
+
+        historia = Parser.ler_historia(arquivo)
+        unless Validator.validar(historia)
+          ignored += 1
+          puts "❌ Arquivo inválido: #{arquivo}"
+          next
+        end
+
+        # Geração de feature
+        feature_path, feature_content = Bddgenx::Generator.gerar_feature(historia)
+        Backup.salvar_versao_antiga(feature_path)
+        if Bddgenx::Generator.salvar_feature(feature_path, feature_content)
+          features += 1
+        end
+
+        # Geração de steps
+        if StepsGenerator.gerar_passos(feature_path)
+          steps += 1
+        else
+          skipped_steps << feature_path
+        end
+
+        # Exportação de PDFs
+        FileUtils.mkdir_p('reports')
+        results = PDFExporter.exportar_todos(only_new: true)
+        generated_pdfs.concat(results[:generated])
+        skipped_pdfs.concat(results[:skipped])
+      end
+
+      # Resumo 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 "- Arquivos ignorados:    #{ignored}"
+    end
+  end
+end

data/lib/bddgenx/steps_generator.rb

@@ -1,138 +1,108 @@
 require 'fileutils'
-require_relative 'utils/verificador'
+require_relative 'utils/tipo_param'
+require 'strscan'  # para usar ::StringScanner
+
+# lib/bddgenx/steps_generator.rb
 
 module Bddgenx
   class StepsGenerator
-    PADROES = {
-      'pt' => %w[Dado Quando Então E Mas],
-      'en' => %w[Given When Then And But]
-    }
-
-    # 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 = []
-
-      historia[:grupos].each do |grupo|
-        tipo            = grupo[:tipo]
-        passos          = grupo[:passos]
-        exemplos_brutos = grupo[:exemplos]
-        exemplos        = exemplos_brutos&.any? ? dividir_examples(exemplos_brutos) : nil
-
-        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}\s*/, '')
-          corpo_sanitizado = corpo.gsub(/"(<[^>]+>)"/, '\1')
-
-          # Identifica grupo de exemplo compatível
-          grupo_exemplo_compat = nil
-          if exemplos
-            exemplos.each do |tabela|
-              cabecalho = tabela.first.gsub('|', '').split.map(&:strip)
-              if cabecalho.any? { |col| corpo.include?("<#{col}>") }
-                linhas = tabela[1..].map { |l| l.gsub('|', '').split.map(&:strip) }
-                grupo_exemplo_compat = { cabecalho: cabecalho, linhas: linhas }
-                break
-              end
-            end
-          end
+    GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
+    GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
+    ALL_KEYS        = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
+
+    # Converte texto para camelCase (para nomes de argumentos)
+    def self.camelize(str)
+      parts = str.strip.split(/[^a-zA-Z0-9]+/)
+      parts.map.with_index { |w, i| i.zero? ? w.downcase : w.capitalize }.join
+    end
 
-          # Detecta parâmetros e gera corpo parametrizado
-          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
-            args_list = nomes_param.map { |p| p.gsub(/\s+/, '_') }.join(', ')
-            pending_msg = corpo
+    # Gera step definitions a partir de um arquivo .feature
+    # - "<nome>" => {string}
+    # - <nome>   => {int}
+    # - "texto" => {string}
+    # - numeros inteiros ou floats soltos => {int}
+    # Respeita idioma de entrada (pt/en) para keywords geradas
+    def self.gerar_passos(feature_path)
+      raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
+
+      lines = File.readlines(feature_path)
+      # Detecta idioma no cabeçalho: "# language: pt" ou "# language: en"
+      lang = if (m = lines.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
+               m[/^#\s*language:\s*(\w+)/i, 1].downcase
+             else
+               'pt'
+             end
+
+      pt_to_en = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
+      en_to_pt = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
+
+      # Seleciona apenas linhas de passo
+      step_lines = lines.map(&:strip).select do |l|
+        ALL_KEYS.any? { |k| l.start_with?(k + ' ') }
+      end
+      return false if step_lines.empty?
+
+      dir = File.join(File.dirname(feature_path), 'steps')
+      FileUtils.mkdir_p(dir)
+      file = File.join(dir, "#{File.basename(feature_path, '.feature')}_steps.rb")
+
+      content = +"# encoding: utf-8\n# Auto-generated step definitions for #{File.basename(feature_path)}\n\n"
+
+      step_lines.each do |line|
+        # Extrai keyword original e resto do passo
+        orig_kw, rest = line.split(' ', 2)
+        # Converte keyword conforme idioma de entrada
+        kw = case lang
+             when 'en' then pt_to_en[orig_kw] || orig_kw
+             else         en_to_pt[orig_kw] || orig_kw
+             end
+        raw = rest.dup
+
+        scanner = ::StringScanner.new(rest)
+        pattern = ''
+        tokens  = []
+
+        until scanner.eos?
+          if scanner.check(/"<([^>]+)>"/)
+            scanner.scan(/"<([^>]+)>"/)
+            tokens << scanner[1]
+            pattern << '{string}'
+          elsif scanner.check(/<([^>]+)>/)
+            scanner.scan(/<([^>]+)>/)
+            tokens << scanner[1]
+            pattern << '{int}'
+          elsif scanner.check(/"([^"<>]+)"/)
+            scanner.scan(/"([^"<>]+)"/)
+            tokens << scanner[1]
+            pattern << '{string}'
+          elsif scanner.check(/\d+(?:\.\d+)?/)
+            num = scanner.scan(/\d+(?:\.\d+)?/)
+            tokens << num
+            pattern << '{int}'
           else
-            corpo_param = corpo
-            args_list   = ''
-            pending_msg = corpo
+            pattern << scanner.getch
           end
-
-          passos_gerados << {
-            conector: conector,
-            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?
-        puts "⚠️  Nenhum passo detectado em: #{nome_arquivo_feature} (arquivo não gerado)"
-        return false
-      end
-
-      nome_base = File.basename(nome_arquivo_feature, '.feature')
-
-      # Define caminho de saída: prioriza pasta steps dentro de features/<nome>
-      feature_dir       = File.dirname(nome_arquivo_feature)
-      feature_steps_dir = File.join(feature_dir, 'steps')
-      if Dir.exist?(feature_steps_dir)
-        FileUtils.mkdir_p(feature_steps_dir)
-        caminho = File.join(feature_steps_dir, "#{nome_base}_steps.rb")
-      else
-        FileUtils.mkdir_p('steps')
-        caminho = "steps/#{nome_base}_steps.rb"
-      end
+        # Escapa aspas no padrão final
+        safe_pattern = pattern.gsub('"', '\\"')
+        signature = "#{kw}(\"#{safe_pattern}\")"
 
-      comentario = "# Step definitions para #{File.basename(nome_arquivo_feature)}"
-      comentario += idioma == 'en' ? " (English)" : " (Português)"
-      conteudo = "#{comentario}\n\n"
-
-      passos_gerados.each do |passo|
-        conteudo += <<~STEP
-          #{passo[:conector]}('#{passo[:param]}') do#{passo[:args].empty? ? '' : " |#{passo[:args]}|"}
-            pending 'Implementar passo: #{passo[:raw]}'
-          end
+        if tokens.any?
+          args = tokens.each_index.map { |i| "args#{i+1}" }.join(', ')
+          signature += " do |#{args}|"
+        else
+          signature += ' do'
+        end
 
-        STEP
+        content << signature << "\n"
+        content << "  pending 'Implementar passo: #{raw}'\n"
+        content << "end\n\n"
       end
 
-      if Bddgenx::Verificador.gerar_arquivo_se_novo(caminho, conteudo)
-        puts "✅ Step definitions gerados: #{caminho}"
-      else
-        puts "⏭️  Steps mantidos: #{caminho}"
-      end
+      File.write(file, content)
+      puts "✅ Steps gerados: #{file}"
       true
     end
-
-    def self.detectar_tipo_param(nome_coluna, exemplos)
-      return 'string' unless exemplos[:cabecalho].include?(nome_coluna)
-
-      idx = exemplos[:cabecalho].index(nome_coluna)
-      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+$/) }
-      return 'float'   if valores.all? { |v| v.match?(/^\d+\.\d+$/) }
-
-      'string'
-    end
-
-    def self.dividir_examples(tabela_bruta)
-      grupos = []
-      grupo = []
-      tabela_bruta.each do |linha|
-        if linha.strip =~ /^\|.*\|$/ && grupo.any? && linha.strip == linha.strip.squeeze(' ')
-          grupos << grupo
-          grupo = [linha]
-        else
-          grupo << linha
-        end
-      end
-      grupos << grupo unless grupo.empty?
-      grupos
-    end
   end
-end
+end

data/lib/bddgenx/utils/tipo_param.rb

@@ -0,0 +1,16 @@
+
+module Bddgenx
+  # Módulo para inferir o tipo de parâmetro a partir de exemplos
+  class TipoParam
+    # Retorna 'string', 'int', 'float' ou 'boolean'
+    def self.determine_type(nome, estrutura)
+      return 'string' unless estrutura[:cabecalho].include?(nome)
+      idx = estrutura[:cabecalho].index(nome)
+      vals = estrutura[:linhas].map { |l| l[idx] }
+      return 'boolean' if vals.all? { |v| %w[true false].include?(v.downcase) }
+      return 'int'     if vals.all? { |v| v.match?(/^\d+$/) }
+      return 'float'   if vals.all? { |v| v.match?(/^\d+\.\d+$/) }
+      'string'
+    end
+  end
+end

data/lib/bddgenx.rb

@@ -1,59 +1,3 @@
-require_relative 'bddgenx/parser'
-require_relative 'bddgenx/validator'
-require_relative 'bddgenx/generator'
-require_relative 'bddgenx/steps_generator'
-require_relative 'bddgenx/tracer'
-require_relative 'bddgenx/backup'
-require_relative 'bddgenx/cli'
-require_relative 'bddgenx/pdf_exporter'
-require_relative 'bddgenx/utils/verificador'
+require_relative 'bddgenx/runner'
 
-cont_total     = 0
-cont_features  = 0
-cont_steps     = 0
-cont_ignorados = 0
-
-# Seleciona arquivos .txt
-arquivos = Bddgenx::Cli.selecionar_arquivos_txt('input')
-# Antes do loop
-skipped_steps = []
-skipped_pdfs  = []
-generated_pdfs = []
-arquivos.each do |arquivo_path|
-  cont_total += 1
-  puts "\n🔍 Processando: #{arquivo_path}"
-
-  historia = Bddgenx::Parser.ler_historia(arquivo_path)
-  unless Bddgenx::Validator.validar(historia)
-    cont_ignorados += 1
-    puts "❌ Arquivo inválido: #{arquivo_path}"
-    next
-  end
-
-  # Gera feature e steps
-  nome_feature, conteudo_feature = Bddgenx::Generator.gerar_feature(historia)
-  Bddgenx::Backup.salvar_versao_antiga(nome_feature)
-  cont_features += 1 if Bddgenx::Generator.salvar_feature(nome_feature, conteudo_feature)
-  cont_steps    += 1 if Bddgenx::StepsGenerator.gerar_passos(historia, nome_feature)
-
-  # Rastreabilidade, PDF
-  FileUtils.mkdir_p('reports')
-  # steps
-  if Bddgenx::StepsGenerator.gerar_passos(historia, nome_feature)
-    cont_steps += 1
-  else
-    skipped_steps << nome_feature
-  end
-  # substituir chamada direta por:
-  results = Bddgenx::PDFExporter.exportar_todos(only_new: true)
-  # exportar_todos agora fornece [:generated, :skipped]
-  generated_pdfs.concat(results[:generated])
-  skipped_pdfs.concat(results[:skipped])
-end
-
-puts "\n✅ Processamento finalizado."
-puts "- Features geradas:     #{cont_features}"
-puts "- Steps gerados:        #{cont_steps}"
-puts "- Steps mantidos:       #{skipped_steps.size}"
-puts "- PDFs gerados:         #{generated_pdfs.size}"
-puts "- PDFs já existentes:   #{skipped_pdfs.size}"
+Bddgenx::Runner.execute

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 0.1.32
+  version: 0.1.34
 platform: ruby
 authors:
 - David Nascimento
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-14 00:00:00.000000000 Z
+date: 2025-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prawn
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: jira-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
 description: Transforma arquivos .txt com histórias em arquivos .feature, com steps,
   rastreabilidade e integração com CI/CD.
 email:
@@ -50,6 +36,10 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- assets/fonts/DejaVuSansMono-Bold.ttf
+- assets/fonts/DejaVuSansMono-BoldOblique.ttf
+- assets/fonts/DejaVuSansMono-Oblique.ttf
+- assets/fonts/DejaVuSansMono.ttf
 - bin/bddgenx
 - lib/bddgenx.rb
 - lib/bddgenx/assets/fonts/DejaVuSansMono-Bold.ttf
@@ -57,13 +47,13 @@ files:
 - lib/bddgenx/assets/fonts/DejaVuSansMono-Oblique.ttf
 - lib/bddgenx/assets/fonts/DejaVuSansMono.ttf
 - lib/bddgenx/backup.rb
-- lib/bddgenx/cli.rb
 - lib/bddgenx/generator.rb
 - lib/bddgenx/parser.rb
 - lib/bddgenx/pdf_exporter.rb
+- lib/bddgenx/runner.rb
 - lib/bddgenx/steps_generator.rb
 - lib/bddgenx/tracer.rb
-- lib/bddgenx/utils/verificador.rb
+- lib/bddgenx/utils/tipo_param.rb
 - lib/bddgenx/validator.rb
 - lib/bddgenx/version.rb
 homepage: https://github.com/David-Nascimento/bdd-generation

data/lib/bddgenx/cli.rb

@@ -1,48 +0,0 @@
-module Bddgenx
-  class Cli
-    def self.confirm(message)
-      print "#{message} "
-      answer = $stdin.gets.to_s.strip.downcase
-      %w[s sim y yes].include?(answer)
-    end
-
-    # Exibe uma mensagem de pergunta e retorna a string digitada pelo usuário
-    def self.ask(message)
-      print "#{message} "
-      $stdin.gets.to_s.strip
-    end
-
-    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
-end

data/lib/bddgenx/utils/verificador.rb

@@ -1,20 +0,0 @@
-require 'fileutils'
-
-module Bddgenx
-  module Verificador
-    # Impede sobrescrita de arquivos existentes
-    def self.gerar_arquivo_se_novo(caminho, novo_conteudo)
-      if File.exist?(caminho)
-        conteudo_atual = File.read(caminho, encoding: 'utf-8').strip
-        return false if conteudo_atual == novo_conteudo.strip
-
-        puts "⚠️  Arquivo já existe: #{caminho} — não será sobrescrito."
-        return false
-      end
-
-      FileUtils.mkdir_p(File.dirname(caminho))
-      File.write(caminho, novo_conteudo)
-      true
-    end
-  end
-end