bddgenx 2.4.6 → 2.4.9

data/lib/bddgenx/ia/microsoft_copilot_cliente.rb

@@ -0,0 +1,133 @@
+module Bddgenx
+  module IA
+    ##
+    # Cliente para interação com a API Microsoft Copilot para geração
+    # de conteúdo, aqui usado para criar cenários BDD no formato Gherkin.
+    #
+    class MicrosoftCopilotCliente
+      MICROSOFT_COPILOT_API_URL = ENV['MICROSOFT_COPILOT_API_URL']
+
+      ##
+      # Gera cenários BDD baseados em uma história, solicitando à API Microsoft Copilot
+      # o retorno no formato Gherkin com palavras-chave no idioma desejado.
+      #
+      # @param historia [String] Texto base da história para gerar os cenários.
+      # @param idioma [String] Código do idioma, 'pt' por padrão.
+      # @return [String, nil] Cenários no formato Gherkin, ou nil em caso de erro.
+      #
+      def self.gerar_cenarios(historia, idioma = 'pt')
+        api_key = Bddgenx.configuration.microsoft_copilot_api_key  # para Copilot
+
+        # Define as palavras-chave para os cenários BDD
+        keywords_pt = {
+          feature: "Funcionalidade",
+          scenario: "Cenário",
+          scenario_outline: "Esquema do Cenário",
+          examples: "Exemplos",
+          given: "Dado",
+          when: "Quando",
+          then: "Então",
+          and: "E"
+        }
+
+        keywords_en = {
+          feature: "Feature",
+          scenario: "Scenario",
+          scenario_outline: "Scenario Outline",
+          examples: "Examples",
+          given: "Given",
+          when: "When",
+          then: "Then",
+          and: "And"
+        }
+
+        # Escolhe o conjunto de palavras-chave conforme o idioma
+        keywords = idioma == 'en' ? keywords_en : keywords_pt
+
+        # Prompt base que instrui a IA a gerar cenários Gherkin no idioma indicado
+        prompt_base = <<~PROMPT
+                    Gere cenários BDD no formato Gherkin, utilizando as palavras-chave estruturais no idioma "#{idioma}":
+                      Feature: #{keywords[:feature]}
+                      Scenario: #{keywords[:scenario]}
+                      Scenario Outline: #{keywords[:scenario_outline]}
+                      Examples: #{keywords[:examples]}
+                      Given: #{keywords[:given]}
+                      When: #{keywords[:when]}
+                      Then: #{keywords[:then]}
+                      And: #{keywords[:and]}
+                  
+                    Instruções:
+                    - Todos os textos dos passos devem ser escritos em **português**.
+                    - Use as palavras-chave Gherkin no idioma especificado ("#{idioma}").
+                    - Gere **vários cenários**, incluindo positivos e negativos.
+                    - Use `Scenario Outline` e `Examples` sempre que houver valores variáveis.
+                    - Mantenha os parâmetros como `<email>`, `<senha>` e outros entre colchetes angulares, exatamente como aparecem.
+                    - Se a história fornecer contexto (ex: `[CONTEXT]` ou "Dado que..."), utilize-o como base para os cenários.
+                    - Se não houver contexto explícito, **crie um coerente** baseado na história.
+                    - A primeira linha do resultado deve conter obrigatoriamente `# language: #{idioma}`.
+                    - Evite passos vagos ou genéricos. Use ações claras e específicas.
+                    - Gere apenas o conteúdo da feature, sem explicações adicionais.
+                    
+                    História fornecida:
+                    #{historia}
+                  PROMPT
+
+        # Verifica se a chave de API foi configurada corretamente
+        unless api_key
+          warn "❌ API Key do Microsoft Copilot não encontrada no .env (MICROSOFT_COPILOT_API_KEY)"
+          return nil
+        end
+
+        # Define o endpoint da API Microsoft Copilot
+        uri = URI("#{MICROSOFT_COPILOT_API_URL}?key=#{api_key}")
+
+        # Estrutura do corpo da requisição para a API Microsoft Copilot
+        request_body = {
+          contents: [
+            {
+              model: "o4-mini",
+              role: "user",
+              parts: [{ text: prompt_base }]
+            }
+          ]
+        }
+
+        # Executa requisição POST para a API Microsoft Copilot
+        response = Net::HTTP.post(uri, request_body.to_json, { "Content-Type" => "application/json" })
+
+        # Verifica se a resposta foi bem-sucedida
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+
+          unless json["choices"]&.is_a?(Array) && json["choices"].any?
+            warn "❌ Resposta da IA sem candidatos válidos:"
+            warn JSON.pretty_generate(json)
+            return nil
+          end
+
+          # Recupera o conteúdo gerado pela IA
+          texto_ia = json["choices"].first.dig("message", "content")
+
+          if texto_ia
+            # Limpeza e sanitização do texto para manter padrão Gherkin
+            texto_limpo = Utils.limpar(texto_ia)
+            Utils.remover_steps_duplicados(texto_ia, idioma)
+
+            # Ajuste da diretiva de idioma na saída gerada
+            texto_limpo.sub!(/^# language: .*/, "# language: #{idioma}")
+            texto_limpo.prepend("# language: #{idioma}\n") unless texto_limpo.start_with?("# language:")
+
+            return texto_limpo
+          else
+            warn I18n.t('errors.ia_no_content')
+            warn JSON.pretty_generate(json)
+            return nil
+          end
+        else
+          warn I18n.t('errors.microsoft_copilot_error', code: response.code, body: response.body)
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/bddgenx/locales/en.yml

@@ -28,6 +28,7 @@ en:
     ia_no_content: "❌ No content returned from AI"
     gemini_error: "❌ Error calling Gemini: %{code} - %{body}"
     chatgpt_key_missing: "❌ ChatGPT API key not found in .env (OPENAI_API_KEY)"
+    microsoft_copilot_error: "Erro"
     openai_quota: "❌ OpenAI API quota exceeded."
     openai_check_usage: "🔗 Check your usage: https://platform.openai.com/account/usage"
     feature_not_found: "⚠️ Feature not found: %{feature}"

data/lib/bddgenx/locales/pt.yml

@@ -29,6 +29,7 @@ pt:
     gemini_error: "❌ Erro ao chamar Gemini: %{code} - %{body}"
     chatgpt_key_missing: "❌ API Key do ChatGPT não encontrada no .env (OPENAI_API_KEY)"
     openai_quota: "❌ Limite de uso da API OpenAI excedido."
+    microsoft_copilot_error: "Erro"
     openai_check_usage: "🔗 Verifique sua conta: https://platform.openai.com/account/usage"
     feature_not_found: "⚠️ Feature não encontrada: %{feature}"
     pdf_generation_failed: "❌ Erro ao gerar PDF de %{file}: %{error}"

data/lib/bddgenx/reports/tracer.rb

@@ -1,70 +1,141 @@
-# lib/bddgenx/tracer.rb
 # encoding: utf-8
 #
-# Este arquivo define a classe Tracer, responsável por gerar e manter
-# informações de rastreabilidade de cenários e passos em um arquivo CSV.
-# Útil para auditoria e análise de cobertura de cenários gerados.
+# Este arquivo define a classe `Tracer`, responsável por gerar arquivos de rastreabilidade
+# (CSV) a partir das features geradas automaticamente pela gem BDDGenX.
+#
+# Para cada feature processada, o `Tracer` extrai os cenários da própria feature `.feature`
+# e associa cada passo definido na história original com o bloco Gherkin correspondente.
+# O objetivo é fornecer visibilidade e rastreabilidade completa entre requisitos e testes.
+
+require 'csv'
+require 'fileutils'
+
 module Bddgenx
-  # Classe para adicionar registros de rastreabilidade a um relatório CSV.
+  # Classe responsável por rastrear os artefatos gerados pela gem
+  # e exportá-los em arquivos CSV, um por funcionalidade.
+  #
+  # Para cada grupo de passos (do `.txt`), associa os dados com o
+  # cenário equivalente gerado no arquivo `.feature`.
   class Tracer
-    # Adiciona entradas de rastreabilidade para cada passo de cada grupo
-    # da história em um arquivo CSV localizado em 'reports/output/rastreabilidade.csv'.
+    ##
+    # Adiciona entradas de rastreabilidade a um CSV baseado na feature gerada.
+    #
+    # - Cada funcionalidade recebe um arquivo CSV próprio, salvo em:
+    #   `reports/output/funcionalidade_<nome>.csv`
+    #
+    # - A coluna "BDD" contém o cenário completo extraído diretamente do `.feature`,
+    #   preservando a sintaxe original do Gherkin (cenário, steps, tags).
     #
     # @param historia [Hash]
-    #   Objeto de história contendo :quero (título da funcionalidade) e :grupos,
-    #   onde cada grupo possui :tipo, :tag, e :passos (Array<String>)
-    # @param nome_arquivo_feature [String]
-    #   Nome do arquivo .feature de onde os passos foram gerados
+    #   Hash representando a história extraída do `.txt`, contendo:
+    #   - :quero  → nome da funcionalidade
+    #   - :grupos → lista de blocos com :tipo, :tag e :passos
+    #
+    # @param feature_path [String]
+    #   Caminho do arquivo `.feature` já gerado no sistema
+    #
     # @return [void]
-    def self.adicionar_entrada(historia, nome_arquivo_feature)
-      # Garante existência do diretório de saída
+    def self.adicionar_entrada(historia, feature_path)
       FileUtils.mkdir_p('reports/output')
-      arquivo_csv = 'reports/output/rastreabilidade.csv'
 
-      # Cabeçalho padrão do CSV: identifica colunas
-      cabecalho = ['Funcionalidade', 'Tipo', 'Tag', 'Cenário', 'Passo', 'Origem']
+      nome_funcionalidade = historia[:quero].gsub(/^Quero\s*/, '').strip
+      nome_funcionalidade_sanitizado = nome_funcionalidade.downcase.gsub(/[^a-z0-9]+/, '_')
+      arquivo_csv = "reports/output/funcionalidade_#{nome_funcionalidade_sanitizado}.csv"
 
+      cabecalho = ['Funcionalidade', 'Tipo', 'Tag', 'Cenário', 'Passo', 'Origem', 'BDD']
       linhas = []
 
-      # Itera sobre grupos de passos para compor linhas de rastreabilidade
+      # Leitura real da feature gerada
+      blocos_gherkin = extrair_cenarios_gherkin(feature_path)
+
       historia[:grupos].each_with_index do |grupo, idx|
         tipo  = grupo[:tipo]
-        tag   = grupo[:tag]
+        tag   = grupo[:tag] || '-'
         passos = grupo[:passos] || []
-
-        nome_funcionalidade = historia[:quero].gsub(/^Quero\s*/, '').strip
         nome_cenario = "Cenário #{idx + 1}"
 
+        # Bloco Gherkin real do cenário gerado
+        gherkin_bloco = blocos_gherkin[idx] || ''
+
         passos.each do |passo|
           linhas << [
             nome_funcionalidade,
             tipo,
-            tag || '-',
+            tag,
             nome_cenario,
             passo,
-            File.basename(nome_arquivo_feature)
+            File.basename(feature_path),
+            gherkin_bloco
           ]
         end
       end
 
-      # Escreve ou anexa as linhas geradas ao CSV
       escrever_csv(arquivo_csv, cabecalho, linhas)
     end
 
-    # Escreve ou anexa registros em um arquivo CSV, criando cabeçalho se necessário.
+    ##
+    # Escreve ou anexa dados em um arquivo CSV.
+    # - Cria o cabeçalho caso seja a primeira escrita.
+    # - Evita duplicações com base na combinação "Passo + Origem".
+    #
+    # @param caminho [String] Caminho completo do arquivo CSV a ser salvo
+    # @param cabecalho [Array<String>] Títulos das colunas do CSV
+    # @param novas_linhas [Array<Array>] Linhas de conteúdo a serem gravadas
     #
-    # @param caminho [String] Caminho completo para o arquivo CSV de rastreabilidade
-    # @param cabecalho [Array<String>] Array de títulos das colunas a serem escritos
-    # @param linhas [Array<Array<String>>] Dados a serem gravados no CSV (cada sub-array é uma linha)
     # @return [void]
-    def self.escrever_csv(caminho, cabecalho, linhas)
-      # Verifica se é um novo arquivo para incluir o cabeçalho
+    def self.escrever_csv(caminho, cabecalho, novas_linhas)
       novo_arquivo = !File.exist?(caminho)
 
+      existentes = []
+      if File.exist?(caminho)
+        existentes = CSV.read(caminho, col_sep: ';', headers: true).map do |row|
+          [row['Passo'], row['Origem']]
+        end
+      end
+
       CSV.open(caminho, 'a+', col_sep: ';', force_quotes: true) do |csv|
         csv << cabecalho if novo_arquivo
-        linhas.each { |linha| csv << linha }
+
+        novas_linhas.each do |linha|
+          passo, origem = linha[4], linha[5]
+          next if existentes.include?([passo, origem])
+          csv << linha
+        end
       end
     end
+
+    ##
+    # Extrai todos os cenários completos do arquivo `.feature` gerado,
+    # preservando a estrutura Gherkin original (cenários, tags, steps).
+    #
+    # Um novo bloco é iniciado quando uma das palavras-chave de título
+    # de cenário é encontrada.
+    #
+    # @param feature_path [String] Caminho completo do arquivo `.feature`
+    # @return [Array<String>] Lista de blocos Gherkin, um por cenário
+    def self.extrair_cenarios_gherkin(feature_path)
+      return [] unless File.exist?(feature_path)
+
+      content = File.read(feature_path)
+      linhas = content.lines
+
+      blocos = []
+      bloco_atual = []
+      capturando = false
+
+      linhas.each_with_index do |linha, i|
+        if linha.strip =~ /^(Scenario|Scenario Outline|Cenário|Esquema do Cenário):/i
+          # Novo cenário → salva anterior
+          blocos << bloco_atual.join if bloco_atual.any?
+          bloco_atual = [linha]
+          capturando = true
+        elsif capturando
+          bloco_atual << linha
+        end
+      end
+
+      blocos << bloco_atual.join if bloco_atual.any?
+      blocos
+    end
   end
 end

data/lib/bddgenx/support/properties_loader.rb

@@ -0,0 +1,108 @@
+# lib/bddgenx/properties_loader.rb
+#
+# Módulo `Bddgenx::PropertiesLoader` é responsável por carregar e processar os arquivos de configuração
+# `.properties` que contêm variáveis de ambiente, além de também carregar as variáveis do arquivo `.env`.
+# Este módulo lida com a substituição de placeholders nas propriedades, garantindo que as variáveis de ambiente
+# sejam corretamente carregadas e definidas para uso no sistema.
+#
+# O fluxo de trabalho é o seguinte:
+# 1. Carregar variáveis de ambiente a partir do arquivo `.env`.
+# 2. Localizar e ler arquivos `.properties` presentes no diretório raiz do projeto.
+# 3. Substituir placeholders no conteúdo dos arquivos `.properties` com variáveis de ambiente.
+# 4. Mesclar as propriedades carregadas e definir as variáveis de ambiente no Ruby.
+#
+# Este módulo permite a configuração flexível de variáveis de ambiente, com suporte tanto para arquivos `.env`
+# quanto para arquivos `.properties`.
+
+module Bddgenx
+  class PropertiesLoader
+    # Carregar as variáveis do arquivo .env
+    #
+    # Este método utiliza a gem `dotenv` para carregar variáveis de ambiente a partir de um arquivo `.env`.
+    # Ele carrega as variáveis do arquivo `.env` para o ambiente de execução, onde elas ficam disponíveis via
+    # `ENV['VAR_NAME']` em qualquer parte do código.
+    def self.load_env_variables
+      Dotenv.load  # Carrega as variáveis do .env automaticamente
+    end
+
+    # Função para substituir variáveis no conteúdo do arquivo .properties
+    #
+    # Este método recebe o conteúdo de um arquivo `.properties` e substitui os placeholders no formato `{{VAR_NAME}}`
+    # pelas variáveis de ambiente correspondentes, se definidas. Caso a variável de ambiente não esteja definida,
+    # o placeholder original é mantido no conteúdo.
+    #
+    # @param content [String] O conteúdo do arquivo `.properties` a ser processado.
+    # @return [String] O conteúdo com os placeholders substituídos pelas variáveis de ambiente.
+    def self.replace_placeholders(content)
+      content.gsub!(/\{\{(\w+)\}\}/) do |match|
+        ENV[$1] || match  # Substitui pela variável de ambiente ou mantém o placeholder
+      end
+      content
+    end
+
+    # Função para garantir que o arquivo seja lido com a codificação correta
+    #
+    # Este método lê um arquivo especificado com codificação UTF-8. Caso o arquivo contenha caracteres inválidos,
+    # eles são substituídos por um caractere de substituição, garantindo que o conteúdo seja lido corretamente.
+    #
+    # @param file [String] O caminho do arquivo a ser lido.
+    # @return [String] O conteúdo do arquivo lido, com caracteres inválidos substituídos, se necessário.
+    def self.read_file_with_correct_encoding(file)
+      # Lê o arquivo com codificação UTF-8 e ignora caracteres inválidos
+      content = File.read(file, encoding: 'UTF-8')
+      content.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+    end
+
+    # Carregar e substituir propriedades de arquivos .properties
+    #
+    # Este método localiza todos os arquivos `.properties` no diretório raiz do projeto,
+    # lê seu conteúdo, substitui os placeholders pelas variáveis de ambiente, carrega as propriedades
+    # e mescla essas propriedades em um único hash.
+    #
+    # Após carregar as propriedades, ele também define as variáveis de ambiente no Ruby (via `ENV`)
+    # usando as propriedades carregadas, mas não sobrescreve as variáveis de ambiente já definidas.
+    #
+    # @return [Hash] O hash contendo as propriedades carregadas e mescladas dos arquivos `.properties`.
+    def self.load_properties
+      # Carregar variáveis do .env primeiro
+      load_env_variables
+
+      # Localizar arquivos .properties na raiz do projeto
+      properties_files = Dir.glob(File.expand_path('../*.properties', __dir__))
+
+      properties = {}
+
+      properties_files.each do |file|
+        # Forçar a leitura do arquivo com codificação UTF-8 e lidar com caracteres inválidos
+        content = read_file_with_correct_encoding(file)
+
+        # Substituir os placeholders antes de carregar as propriedades
+        content = replace_placeholders(content)
+
+        # Carregar as propriedades do arquivo
+        file_properties = JavaProperties::Properties.load(StringIO.new(content))
+
+        # Mesclar as propriedades carregadas no hash
+        properties.merge!(file_properties.to_h)
+      end
+
+      # Agora, define as variáveis de ambiente a partir das propriedades carregadas
+      set_environment_variables(properties)
+
+      properties
+    end
+
+    # Função para definir variáveis de ambiente a partir das propriedades carregadas
+    #
+    # Este método percorre as propriedades carregadas e as define como variáveis de ambiente (`ENV`) no Ruby.
+    # Se a variável de ambiente já estiver definida (por exemplo, pelo `.env`), ela não será sobrescrita.
+    #
+    # @param properties [Hash] O hash contendo as propriedades carregadas dos arquivos `.properties`.
+    def self.set_environment_variables(properties)
+      properties.each do |key, value|
+        # Se a variável de ambiente já estiver definida, não sobrescreve
+        ENV[key.upcase] ||= value
+      end
+    end
+  end
+end

data/lib/bddgenx/{support/gherkin_cleaner.rb → utils/gherkin_cleaner_helper.rb}

@@ -1,5 +1,5 @@
 module Bddgenx
-  class GherkinCleaner
+  module Utils
     # Método principal para limpar o texto Gherkin recebido.
     # Executa uma sequência de operações para deixar o texto formatado e correto.
     #

data/lib/bddgenx/utils/language_helper.rb

@@ -0,0 +1,45 @@
+module Bddgenx
+  module Utils
+    # Palavras-chave do Gherkin em Português
+    GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
+
+    # Palavras-chave do Gherkin em Inglês
+    GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
+
+    # Mapeamento PT → EN
+    GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
+
+    # Mapeamento EN → PT
+    GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
+
+    # Todas as palavras-chave reconhecidas
+    ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
+
+    ##
+    # Extrai o idioma do arquivo .txt, a partir da linha "# language:".
+    # @param txt_file [String] Caminho do arquivo .txt
+    # @return [String] O idioma extraído ou 'pt' como padrão
+    def self.obter_idioma_do_arquivo(caminho_arquivo)
+      return 'pt' unless File.exist?(caminho_arquivo)
+
+      File.foreach(caminho_arquivo) do |linha|
+        if linha =~ /^#\s*language:\s*(\w{2})/i
+          return $1.downcase
+        end
+      end
+
+      'pt' # idioma padrão caso não encontre
+    end
+
+    ##
+    # Detecta o idioma a partir de um texto (como conteúdo de arquivo ou string).
+    # @param texto [String] O texto onde o idioma será detectado
+    # @return [String] O idioma detectado ('pt' por padrão)
+    def self.detecta_idioma_de_texto(texto)
+      if texto =~ /^#\s*language:\s*(\w{2})/i
+        return $1.downcase
+      end
+      'pt' # Idioma padrão se o idioma não for detectado
+    end
+  end
+end

data/lib/bddgenx/utils/remover_steps_duplicados_helper.rb

@@ -0,0 +1,79 @@
+module Bddgenx
+  module Utils
+    # Remove passos duplicados em um texto de cenários BDD,
+    # levando em conta o idioma para identificar as keywords (Given, When, Then, And / Dado, Quando, Então, E)
+    #
+    # Parâmetros:
+    # - texto: string contendo o texto do cenário BDD
+    # - idioma: 'en' para inglês ou qualquer outro para português
+    #
+    # Retorna o texto com passos duplicados removidos, preservando a ordem original
+    def self.remover_steps_duplicados(texto, idioma)
+      # Define as keywords principais para o idioma
+      keywords = idioma == 'en' ? %w[Given When Then And] : %w[Dado Quando Então E]
+
+      # Conjunto para rastrear passos já vistos (versão canônica)
+      seen = Set.new
+      resultado = []
+
+      # Percorre linha a linha
+      texto.each_line do |linha|
+        # Verifica se a linha começa com uma das keywords
+        if keywords.any? { |kw| linha.strip.start_with?(kw) }
+          # Canonicaliza o passo para comparação sem variações irrelevantes
+          canonical = Utils::canonicalize_step(linha, keywords)
+
+          # Só adiciona se ainda não viu o passo canônico
+          unless seen.include?(canonical)
+            seen.add(canonical)
+            resultado << linha
+          end
+        else
+          # Linhas que não são passos são adicionadas normalmente
+          resultado << linha
+        end
+      end
+
+      # Retorna o texto reconstruído sem duplicatas
+      resultado.join
+    end
+
+    # Gera uma versão canônica (normalizada) do passo para facilitar
+    # a identificação de duplicatas mesmo com variações menores de texto.
+    #
+    # Exemplo: Dado "usuario" fez login  e Dado <usuario> fez login
+    # gerarão o mesmo canonical para evitar repetição.
+    #
+    # Passos:
+    # - Remove a keyword (Given, When, etc) do começo
+    # - Substitui textos entre aspas, placeholders <> e números por <param>
+    # - Remove acentuação e pontuação para normalizar
+    # - Converte para minúsculas e remove espaços extras
+    #
+    # Parâmetros:
+    # - linha: string com o passo completo
+    # - keywords: array com as keywords para remoção
+    #
+    # Retorna uma string normalizada representando o passo
+    def self.canonicalize_step(linha, keywords)
+      texto = linha.dup.strip
+
+      # Remove a keyword do início, se existir
+      keywords.each do |kw|
+        texto.sub!(/^#{kw}\s+/i, '')
+      end
+
+      # Substitui textos entre aspas, placeholders e números por <param>
+      texto.gsub!(/"[^"]*"|<[^>]*>|\b\d+\b/, '<param>')
+
+      # Remove acentos usando Unicode Normalization Form KD (decompõe caracteres)
+      texto = Unicode.normalize_KD(texto).gsub(/\p{Mn}/, '')
+
+      # Remove pontuação, deixando apenas letras, números, espaços e <>
+      texto.gsub!(/[^a-zA-Z0-9\s<>]/, '')
+
+      # Converte para minúsculas, remove espaços extras e retorna
+      texto.downcase.strip.squeeze(" ")
+    end
+  end
+end