bddgenx 0.1.51 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 887584d64b29e9d2eecbedefa011eb4c3cd2c1e7ee8e3e71b2f2d602b9229f34
-  data.tar.gz: f58a637a706bb935d3bda39078cfcf22773612a9857bbe86a9af395ca0e7f468
+  metadata.gz: 0ee7808e2b0f0cf6e65b1dbc5ea11689a1522dbc06ec2db6ed35494329920913
+  data.tar.gz: f88f37264c7e26caa90f4b25aef60e194cd5b08d7a97819b4aa623a7e99d6b04
 SHA512:
-  metadata.gz: 2c0a0dc0277a314964853a723559ea784d0a660de28d2bba7ea3d94c6cc4833df35b76c8d3f09d81896c801c2bd9baf6668efb3afe0ab8599bf7d45588d5cc48
-  data.tar.gz: 804cefd2b537ca4f9902a1790b702c7d79f457b5b94e6316d6b5c9793c5d6cafd358e36c999c7ed3804820c34138b938bede09687a1eea0486280b356b5168cf
+  metadata.gz: 1bdc7124701b3fd7eba6e60993e75e31fb19613a1ae53cb7549afeae1c0d4a7f167a3e5c19bf6805ee118ffd6a6c7a6b5d29b0d25e34e894dbfb86c0e45f2879
+  data.tar.gz: eec2871ad622cb5c638163854dbb7dabcb5da57e6bb784732c561c50cc1a4fabc81c3647b82c63509a6bd125e72801db2a69a88415d550af44ccf9f944ed7ac7

data/README.md

@@ -5,6 +5,56 @@
 
 Ferramenta Ruby para gerar automaticamente arquivos Gherkin (`.feature`) e definições de passos (`steps.rb`) a partir de histórias em texto. Atende aos padrões ISTQB, suporta parametrização com blocos de exemplos e fornece relatórios de QA (rastreabilidade, backups e PDF).
 
+## Estrutura do projeto
+```
+bdd-generation/
+├── .github/                     # Workflows do GitHub Actions
+│   └── workflows/
+│       └── main.yml
+├── bin/
+│   └── console                  # Execução local (se necessário)
+├── features/                    # Gherkin gerados automaticamente
+│   └── steps/                   # Steps correspondentes
+├── input/                       # Histórias de entrada
+│   ├── historia.txt
+│   ├── historia_en.txt
+│   └── ...
+├── lib/
+│   └── bddgenx/
+│       ├── ia/                  # Módulo de IA
+│       │   ├── chatgpt_cliente.rb
+│       │   └── gemini_cliente.rb
+│       ├── generators/          # Responsável por geração
+│       │   ├── generator.rb
+│       │   ├── steps_generator.rb
+│       │   └── runner.rb
+│       ├── reports/            # Exportadores, backups e rastreabilidade
+│       │   ├── pdf_exporter.rb
+│       │   ├── backup.rb
+│       │   └── tracer.rb
+│       ├── support/            # Utilitários auxiliares
+│       │   ├── gherkin_cleaner.rb
+│       │   ├── remover_steps_duplicados.rb
+│       │   ├── validator.rb
+│       │   └── font_loader.rb
+│       ├── parser.rb           # Parse do .txt
+│       ├── version.rb          # Versão da gem
+│       └── bddgenx.rb          # Arquivo principal (require central)
+├── reports/                     # Saídas: PDF, backup, rastreabilidade
+│   ├── pdf/
+│   ├── backup/
+│   └── rastreabilidade/
+├── .env                         # Variáveis de ambiente
+├── .gitignore
+├── bddgenx.gemspec
+├── bump_version.sh
+├── Gemfile
+├── Gemfile.lock
+├── LICENSE
+├── Rakefile
+├── README.md
+└── VERSION
+```
 ## Instalação
 
 Adicione ao seu `Gemfile`:

data/VERSION

@@ -1 +1 @@
-0.1.51
+2.0.5

data/bin/bddgenx

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-require_relative "../lib/bddgenx/runner"
+require_relative "../lib/bddgenx/generators/runner"
 
 Bddgenx::Runner.execute

data/lib/bddgenx/generators/generator.rb

@@ -0,0 +1,175 @@
+# 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.
+
+module Bddgenx
+  class Generator
+    # 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 de PT → EN
+    GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
+
+    # Mapeamento de 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 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
+    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.
+    #
+    # @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
+    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
+        raw_txt = File.read(input)
+        historia = {
+          idioma: 'pt',
+          quero: File.basename(input, '.txt').tr('_', ' ').capitalize,
+          como: '',
+          para: '',
+          grupos: []
+        }
+
+        texto_gerado = if modo == :gemini
+                         GeminiCliente.gerar_cenarios(raw_txt)
+                       else
+                         ChatGPTCliente.gerar_cenarios(raw_txt)
+                       end
+
+        historia[:grupos] << {
+          tipo: 'gerado',
+          tag: 'ia',
+          passos: GherkinCleaner.limpar(texto_gerado).lines.map(&:strip).reject(&:empty?)
+        }
+      else
+        # Modo estático: utiliza estrutura vinda do Parser ou de um hash diretamente
+        historia = input.is_a?(String) ? Parser.ler_historia(input) : input
+      end
+
+      idioma = historia[:idioma] || 'pt'
+      cont = 1
+
+      # Normaliza o nome base do arquivo
+      nome_base = historia[:quero]
+                    .gsub(/[^a-z0-9]/i, '_')
+                    .downcase
+                    .split('_')
+                    .reject(&:empty?)
+                    .first(5)
+                    .join('_')
+
+      caminho = override_path || "features/#{nome_base}.feature"
+
+      # Define palavras-chave com base no idioma
+      palavras = {
+        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'
+      }
+
+      conteudo = <<~GHK
+        # language: #{idioma}
+        #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
+          # #{historia[:como]}
+          # #{historia[:quero]}
+          # #{historia[:para]}
+      GHK
+
+      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]  || []
+        exemplos = grupo[:exemplos] || []
+        next if passos.empty?
+
+        tag_line = ["@#{grupo[:tipo].downcase}", ("@#{grupo[:tag]}" if grupo[:tag])].compact.join(' ')
+        conteudo << "    #{tag_line}\n"
+
+        if exemplos.any?
+          conteudo << "    #{palavras[:esquema]}: Exemplo #{cont}\n"
+          cont += 1
+        else
+          conteudo << "    #{palavras[:cenario]}: #{grupo[:tipo].capitalize}\n"
+        end
+
+        passos.each do |p|
+          parts = p.strip.split(' ', 2)
+          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
+          linha_step = "      #{out_conn} #{text}"
+
+          next if passos_unicos.include?(linha_step)
+
+          passos_unicos << linha_step
+          conteudo << "#{linha_step}\n"
+        end
+
+        if exemplos.any?
+          conteudo << "\n      #{palavras[:exemplos]}:\n"
+          exemplos.select { |l| l.strip.start_with?('|') }.each do |line|
+            cleaned = line.strip.gsub(/^"|"$/, '')
+            conteudo << "        #{cleaned}\n"
+          end
+        end
+
+        conteudo << "\n"
+      end
+
+      [caminho, conteudo]
+    end
+
+    ##
+    # Gera o caminho padrão de saída para um arquivo `.feature` com base no nome do `.txt`.
+    #
+    # @param arquivo_txt [String] caminho do arquivo .txt de entrada
+    # @return [String] caminho completo do arquivo .feature correspondente
+    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.
+    #
+    # @param caminho [String] caminho completo para salvar o arquivo
+    # @param conteudo [String] conteúdo do arquivo .feature
+    # @return [void]
+    def self.salvar_feature(caminho, conteudo)
+      FileUtils.mkdir_p(File.dirname(caminho))
+      File.write(caminho, conteudo)
+      puts "✅ Arquivo .feature gerado: #{caminho}"
+    end
+  end
+end

data/lib/bddgenx/{runner.rb → generators/runner.rb}

@@ -4,14 +4,7 @@
 # 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.
-
-require 'fileutils'
-require_relative 'utils/parser'
-require_relative 'generator'
-require_relative 'utils/pdf_exporter'
-require_relative 'steps_generator'
-require_relative 'utils/validator'
-require_relative 'utils/backup'
+require_relative '../../bddgenx'
 
 module Bddgenx
   # Ponto de entrada da gem: coordena todo o processo de geração BDD.
@@ -80,6 +73,8 @@ module Bddgenx
     #
     # @return [void]
     def self.execute
+      modo = ENV['BDDGENX_MODE'] || 'static'
+
       input_dir = 'input'
       Dir.mkdir(input_dir) unless Dir.exist?(input_dir)
 
@@ -106,7 +101,27 @@ module Bddgenx
         end
 
         # Geração de feature
-        feature_path, feature_content = Generator.gerar_feature(historia)
+        if modo == 'gemini' || modo == 'chatgpt'
+          puts "🤖 Gerando cenários com IA (#{modo.capitalize})..."
+          idioma = IA::GeminiCliente.detecta_idioma_arquivo(arquivo)
+          feature_text =
+            if modo == 'gemini'
+              IA::GeminiCliente.gerar_cenarios(historia, idioma)
+            else
+              IA::ChatGptCliente.gerar_cenarios(historia, idioma)
+            end
+          if feature_text
+            feature_path = Generator.path_para_feature(arquivo)
+            feature_content = Bddgenx::GherkinCleaner.limpar(feature_text)
+          else
+            ignored += 1
+            puts "❌ Falha ao gerar com IA: #{arquivo}"
+            next
+          end
+        else
+          feature_path, feature_content = Generator.gerar_feature(historia)
+        end
+
         Backup.salvar_versao_antiga(feature_path)
         features += 1 if Generator.salvar_feature(feature_path, feature_content)
 

data/lib/bddgenx/{steps_generator.rb → generators/steps_generator.rb}

@@ -6,82 +6,77 @@
 # Suporta palavras-chave Gherkin em Português e Inglês e parametriza
 # strings e números conforme necessário.
 
-require 'fileutils'
-require 'strscan'  # Para uso de StringScanner
-
 module Bddgenx
-  # Gera arquivos de definições de passos Ruby para Cucumber
-  # com base em arquivos .feature.
   class StepsGenerator
-    # Palavras-chave Gherkin em Português usadas em arquivos de feature
-    # @return [Array<String>]
+    # Palavras-chave Gherkin em Português
     GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
 
-    # Palavras-chave Gherkin em Inglês usadas em arquivos de feature
-    # @return [Array<String>]
+    # Palavras-chave Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
 
-    # Conjunto de todas as palavras-chave suportadas (PT + EN)
-    # @return [Array<String>]
+    # Conjunto de todas as palavras-chave suportadas
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
-    # Converte uma string para camelCase, útil para nomes de argumentos
+    ##
+    # Transforma uma string em estilo camelCase.
+    #
+    # @param str [String] A string a ser transformada.
+    # @return [String] A string convertida para camelCase.
     #
-    # @param [String] str Texto de entrada a ser convertido
-    # @return [String] Versão em camelCase do texto
     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 definições de passos a partir de um arquivo .feature
+    ##
+    # 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.
     #
-    # @param [String] feature_path Caminho para o arquivo .feature
-    # @raise [ArgumentError] Se feature_path não for String
-    # @return [Boolean] Retorna true se passos foram gerados, false se não houver passos
     def self.gerar_passos(feature_path)
-      # Valida tipo de entrada
-      unless feature_path.is_a?(String)
-        raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}"
-      end
+      raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
 
       linhas = File.readlines(feature_path)
 
-      # Detecta idioma no cabeçalho: "# language: pt" ou "# language: en"
+      # Detecta o idioma com base na diretiva "# language:"
       lang = if (m = linhas.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
                m[/^#\s*language:\s*(\w+)/i, 1].downcase
              else
                'pt'
              end
 
-      # Mapas de tradução entre PT e EN
       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 linhas que começam com palavras-chave Gherkin
+      # Seleciona apenas linhas que começam com palavras-chave Gherkin
       linhas_passos = linhas.map(&:strip).select do |linha|
         ALL_KEYS.any? { |chave| linha.start_with?(chave + ' ') }
       end
 
-      # Se não encontrar passos, retorna false
       return false if linhas_passos.empty?
 
-      # Cria diretório e arquivo de saída
       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"
 
+      passos_unicos = Set.new
+
       linhas_passos.each do |linha|
         palavra_original, restante = linha.split(' ', 2)
 
-        # Define palavra-chave no idioma de saída
+        # Tradução de palavras-chave se necessário
         chave = case lang
                 when 'en' then pt_para_en[palavra_original] || palavra_original
-                else         en_para_pt[palavra_original] || palavra_original
+                else           en_para_pt[palavra_original] || palavra_original
                 end
 
         texto_bruto = restante.dup
@@ -89,6 +84,7 @@ module Bddgenx
         padrao = ''
         tokens = []
 
+        # Analisa e parametriza o conteúdo dos passos
         until scanner.eos?
           if scanner.check(/"<([^>]+)>"/)
             scanner.scan(/"<([^>]+)>"/)
@@ -111,11 +107,14 @@ module Bddgenx
           end
         end
 
-        # Escapa aspas no padrão
         padrao_seguro = padrao.gsub('"', '\\"')
-        assinatura = "#{chave}(\"#{padrao_seguro}\")"
 
-        # Adiciona parâmetros se existirem tokens
+        # Impede criação de métodos duplicados
+        next if passos_unicos.include?(padrao_seguro)
+
+        passos_unicos << padrao_seguro
+
+        assinatura = "#{chave}(\"#{padrao_seguro}\")"
         if tokens.any?
           argumentos = tokens.each_index.map { |i| "arg#{i+1}" }.join(', ')
           assinatura << " do |#{argumentos}|"
@@ -128,7 +127,6 @@ module Bddgenx
         conteudo << "end\n\n"
       end
 
-      # Escreve arquivo de saída
       File.write(arquivo_saida, conteudo)
       puts "✅ Steps gerados: #{arquivo_saida}"
       true

data/lib/bddgenx/ia/chatgtp_cliente.rb

@@ -0,0 +1,147 @@
+# lib/bddgenx/ia/chatgpt_cliente.rb
+
+module Bddgenx
+  module IA
+    ##
+    # Cliente para interação com a API do ChatGPT da OpenAI para gerar
+    # cenários BDD no formato Gherkin, com suporte a fallback para Gemini.
+    #
+    class ChatGptCliente
+      CHATGPT_API_URL = 'https://api.openai.com/v1/chat/completions'.freeze
+      MODEL = 'gpt-4o'
+
+      ##
+      # Gera cenários BDD a partir de uma história fornecida,
+      # solicitando à API do ChatGPT a criação dos cenários em formato Gherkin.
+      # Se a API key não estiver configurada ou houver erro na requisição,
+      # utiliza fallback com o GeminiCliente.
+      #
+      # @param historia [String] Texto com a história para basear os cenários.
+      # @param idioma [String] Código do idioma ('pt' ou 'en'), padrão 'pt'.
+      # @return [String] Cenários gerados em formato Gherkin com palavras-chave no idioma indicado.
+      #
+      def self.gerar_cenarios(historia, idioma = 'pt')
+        api_key = ENV['OPENAI_API_KEY']
+
+        unless api_key
+          warn "❌ API Key do ChatGPT não encontrada no .env (OPENAI_API_KEY)"
+          return fallback_com_gemini(historia, idioma)
+        end
+
+        # Palavras-chave Gherkin para português e inglês
+        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"
+        }
+
+        keywords = idioma == 'en' ? keywords_en : keywords_pt
+
+        # Prompt base enviado ao ChatGPT, instruindo a saída no formato correto
+        prompt_base = <<~PROMPT
+          Gere cenários BDD no formato Gherkin, usando as palavras-chave de estrutura 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]}
+
+          Atenção: Os textos e descrições dos cenários e passos devem ser escritos em português, mesmo que as palavras-chave estejam em inglês.
+
+          História:
+          #{historia}
+        PROMPT
+
+        uri = URI(CHATGPT_API_URL)
+        request_body = {
+          model: MODEL,
+          messages: [
+            {
+              role: "user",
+              content: prompt_base
+            }
+          ]
+        }
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}"
+        }
+
+        response = Net::HTTP.post(uri, request_body.to_json, headers)
+
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+          texto_ia = json.dig("choices", 0, "message", "content")
+
+          if texto_ia
+            texto_limpo = Bddgenx::GherkinCleaner.limpar(texto_ia)
+            Utils::StepCleaner.remover_steps_duplicados(texto_ia, idioma)
+
+            # Ajusta a linha de idioma no arquivo gerado
+            texto_limpo.sub!(/^# language: .*/, "# language: #{idioma}")
+            texto_limpo.prepend("# language: #{idioma}\n") unless texto_limpo.start_with?("# language:")
+            return texto_limpo
+          else
+            warn "❌ Resposta da IA sem conteúdo de texto"
+            warn JSON.pretty_generate(json)
+            return fallback_com_gemini(historia, idioma)
+          end
+        else
+          warn "❌ Erro ao chamar ChatGPT: #{response.code} - #{response.body}"
+          return fallback_com_gemini(historia, idioma)
+        end
+      end
+
+      ##
+      # Método de fallback que chama o GeminiCliente para gerar cenários,
+      # usado quando a API do ChatGPT não está disponível ou ocorre erro.
+      #
+      # @param historia [String] Texto da história para basear os cenários.
+      # @param idioma [String] Código do idioma ('pt' ou 'en').
+      # @return [String] Cenários gerados pelo GeminiCliente.
+      #
+      def self.fallback_com_gemini(historia, idioma)
+        warn "🔁 Tentando gerar com Gemini como fallback..."
+        GeminiCliente.gerar_cenarios(historia, idioma)
+      end
+
+      ##
+      # Detecta o idioma de um arquivo de feature pela linha "# language:".
+      #
+      # @param caminho_arquivo [String] Caminho para o arquivo de feature.
+      # @return [String] Código do idioma detectado ('pt' por padrão).
+      #
+      def self.detecta_idioma_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'
+      end
+    end
+  end
+end