claiss 1.1.5 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7395901310b440af99e2a2c8398d2c419165457c3938c7f8d5cc394a49d416b
-  data.tar.gz: 0cde7e9f094e6d3a873d15f886a1625e115b568c91b1f94ca947aad0cf5764f4
+  metadata.gz: 3c3930d146c451e61732c1decad285dcedf966e9203d96c7b9566fda7fc0f927
+  data.tar.gz: 2194f5f1e491c3e332da0d8097f113636db9deee184b09d59b9771acf6a037bb
 SHA512:
-  metadata.gz: 1fad084036805ad9c71f3484c50d83e096c479c50575b3efb9d4ee0154fe40147830501f7749b94eaf19b25bb328f7a5cb6e773185338e0e9d94e775de552a93
-  data.tar.gz: 0fba7b018af22b864ea3c19b920de07a9ccc71f94948953ae872d595778b2c0e2ac8d7237dca6ba59e9bcc081b4ae2ca29bff68c7fa157a9329e806751832ef0
+  metadata.gz: fd0230b487e14d9993b1963705bb3206091924d63cdff8f714fb1dfe9bc4d19db9390ade541d0916b99c77165dc7d6c6a7337b34ed4c30cf805abe9e952b495b
+  data.tar.gz: e5302f23687c15e282067bd6666810538874dae561b3db2446df01bc22a502de730e2bbc0f79c373fad04cc67c8779b2476e5fcf7b6ab9de57c937a39a68e5eb

data/README.md

@@ -59,6 +59,7 @@ $ claiss refactor <project_path> <json_file> [options]
 **Options:**
 - `--destination, -d`: Specify output directory (default: in-place)
 - `--dry-run`: Preview changes without modifying files
+- `--debug`: Show detailed debug messages during processing
 
 **Example:**
 ```bash
@@ -201,14 +202,35 @@ $ claiss refactor <caminho_do_projeto> <arquivo_json> [opções]
 **Opções:**
 - `--destination, -d`: Especifica o diretório de saída (padrão: no local)
 - `--dry-run`: Visualiza as alterações sem modificar os arquivos
+- `--debug`: Mostra mensagens detalhadas de depuração durante o processamento
 
-**Exemplo:**
+**Exemplos:**
 ```bash
-$ claiss refactor meu_projeto regras.json --dry-run
+# Modo normal
+$ claiss refactor meu_projeto ~/.claiss/regras.json
+
+# Especificando diretório de destino
+$ claiss refactor meu_projeto ~/.claiss/regras.json --destination pasta_destino
+
+# Modo debug (mostra mensagens detalhadas)
+$ claiss refactor meu_projeto ~/.claiss/regras.json --debug
+
+# Todas as opções juntas
+$ claiss refactor meu_projeto ~/.claiss/regras.json --destination pasta_destino --debug
 ```
 
 #### Formato do Dicionário JSON
 
+O arquivo de regras pode estar em qualquer local, mas se estiver no diretório `~/.claiss/`, você pode usar apenas o nome do arquivo. Exemplo:
+
+```bash
+# Se o arquivo estiver em ~/.claiss/regras.json
+$ claiss refactor meu_projeto regras.json
+
+# Ou especifique o caminho completo
+$ claiss refactor meu_projeto /caminho/completo/para/regras.json
+```
+
 Crie um arquivo JSON com pares chave-valor para as substituições:
 
 ```json

data/lib/claiss/version.rb

@@ -1,3 +1,3 @@
 module CLAISS
-  VERSION = '1.1.5'
+  VERSION = '1.1.7'
 end

data/lib/claiss.rb

@@ -1,23 +1,24 @@
-require "dry/cli"
-require "fileutils"
-require "json"
-require "logger"
-require "parallel"
-require "ruby-progressbar"
+require 'dry/cli'
+require 'fileutils'
+require 'json'
+require 'logger'
+require 'parallel'
+require 'ruby-progressbar'
+require 'pathname'
 
 # CLAISS module provides CLI commands for refactoring and managing Ruby projects
 module CLAISS
-  IGNORED_DIRECTORIES = [".git/", "node_modules/"]
-  DEFAULT_JSON_DIR = File.join(Dir.home, ".claiss")
+  IGNORED_DIRECTORIES = ['.git/', 'node_modules/']
+  DEFAULT_JSON_DIR = File.join(Dir.home, '.claiss')
 
   # Initialize logger
   LOGGER = Logger.new(STDOUT)
-  LOGGER.level = Logger::INFO  # Set to Logger::DEBUG for more verbose output
+  LOGGER.level = Logger::INFO # Set to Logger::DEBUG for more verbose output
 
   class Error < StandardError; end
 
   class Version < Dry::CLI::Command
-    desc "Print version"
+    desc 'Print version'
 
     def call(*)
       puts "CLAISS version #{CLAISS::VERSION}"
@@ -25,88 +26,193 @@ module CLAISS
   end
 
   class Refactor < Dry::CLI::Command
-    desc "Refactor files and filenames"
+    desc 'Refactor files and filenames'
 
-    argument :path, type: :string, required: true, desc: "Path to the directory to refactor"
-    argument :rules, type: :string, required: true, desc: "Name of the rules file (without .json extension)"
-    option :destination, type: :string, desc: "Destination path for refactored files"
+    argument :path, type: :string, required: true, desc: 'Path to the directory to refactor'
+    argument :rules, type: :string, required: true, desc: 'Name of the rules file (without .json extension)'
+    option :destination, type: :string, desc: 'Destination path for refactored files'
 
     example [
-      "path/to/project autokeras",
-      "path/to/project autokeras --destination path/to/output",
+      'path/to/project rules_file',
+      'path/to/project rules_file --destination path/to/output',
+      'path/to/project rules_file --debug',
+      'path/to/project rules_file --destination path/to/output --debug'
     ]
 
-    def call(path:, rules:, destination: nil, **)
+    def call(path:, rules:, destination: nil, debug: false, **)
+      @debug = debug
       origin_path = File.expand_path(path)
       destination_path = destination ? File.expand_path(destination) : nil
 
-      json_file = File.join(DEFAULT_JSON_DIR, "#{rules}.json")
+      # Primeiro tenta carregar o arquivo como está (pode ser caminho completo)
+      json_file = rules.end_with?('.json') ? rules : "#{rules}.json"
+      
+      debug_puts("\n[DEBUG] Iniciando refatoração")
+      debug_puts("[DEBUG] Origem: #{origin_path}")
+      debug_puts("[DEBUG] Destino: #{destination_path || 'Não especificado'}")
+      debug_puts("[DEBUG] Arquivo de regras: #{json_file}")
+      
+      # Tenta carregar o dicionário
       dict = load_dictionary(json_file)
-
+      
+      if dict.empty?
+        puts "[ERRO] O dicionário de substituição está vazio. Nenhuma alteração será feita."
+        return
+      end
+      
+      debug_puts("[DEBUG] Dicionário carregado com #{dict.size} entradas")
+      
+      # Obtém a lista de arquivos para processar
       files = get_files_to_process(origin_path)
+      debug_puts("[DEBUG] Encontrados #{files.size} arquivos para processar")
+      
+      # Processa os arquivos
       process_files_in_parallel(files, dict, origin_path, destination_path)
       
-      # Se estivermos copiando para um destino, verifica o diretório de destino
-      # Caso contrário, verifica o diretório de origem
+      puts "\n[SUCESSO] Processamento concluído!"
+      puts "Arquivos processados: #{files.size}"
       target_path = destination_path || origin_path
       remove_empty_directories(target_path)
 
-      puts "Done! Files have been refactored#{destination_path ? " to the destination" : " in place"}."
+      puts "Done! Files have been refactored#{destination_path ? ' to the destination' : ' in place'}."
     end
 
     private
 
     def get_files_to_process(origin_path)
-      Dir.glob(File.join(origin_path, "**", "*"), File::FNM_DOTMATCH).reject do |file_name|
-        File.directory?(file_name) || IGNORED_DIRECTORIES.any? { |dir| file_name.include?(dir) }
+      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH).reject do |file_name|
+        next true if File.directory?(file_name)
+        next true if IGNORED_DIRECTORIES.any? { |dir| file_name.include?(dir) }
+
+        false
       end
     end
 
+    def is_binary_file?(file_name)
+      binary_extensions = ['.pdf', '.png', '.jpg', '.jpeg', '.svg', '.ico', '.gif', '.zip', '.gz', '.tar', '.bin',
+                           '.exe', '.dll', '.so', '.dylib']
+      binary_extensions.any? { |ext| file_name.downcase.end_with?(ext) }
+    end
+
+    def debug_puts(message)
+      puts message if @debug
+    end
+
     def process_files_in_parallel(files, dict, origin_path, destination_path)
+      debug_puts("Diretório de trabalho atual: #{Dir.pwd}")
+      puts "\n=== Iniciando processamento de #{files.size} arquivos em paralelo ==="
+      puts "Dicionário de substituição: #{dict.inspect}"
+      puts "Diretório de origem: #{origin_path}"
+      puts "Diretório de destino: #{destination_path || 'Mesmo que origem'}"
+      
+      # Log do diretório de trabalho atual
+      puts "Diretório de trabalho atual: #{Dir.pwd}"
+      
       progress_bar = ProgressBar.create(
         total: files.size,
         format: "%a %b\u{15E7}%i %p%% %t",
-        progress_mark: " ",
-        remainder_mark: "\u{FF65}",
+        progress_mark: ' ',
+        remainder_mark: "\u{FF65}"
       )
 
-      Parallel.each(files, in_threads: Parallel.processor_count) do |file_name|
-        refactor_file(file_name, dict, origin_path, destination_path)
+      Parallel.each(files, in_threads: [2, Parallel.processor_count].min) do |file_name|
+        next if File.directory?(file_name)
+        
+        debug_puts("\n=== Processando arquivo: #{file_name} ===")
+        debug_puts("Arquivo existe? #{File.exist?(file_name) ? 'Sim' : 'NÃO'}")
+        
+        begin
+          if is_binary_file?(file_name)
+            debug_puts("[BINÁRIO] Iniciando processamento de: #{file_name}")
+            process_binary_file_rename(file_name, dict, origin_path, destination_path)
+            debug_puts("[BINÁRIO] Finalizado: #{file_name}")
+          else
+            debug_puts("[TEXTO] Iniciando processamento de: #{file_name}")
+            refactor_file(file_name, dict, origin_path, destination_path)
+            debug_puts("[TEXTO] Finalizado: #{file_name}")
+          end
+        rescue StandardError => e
+          puts "[ERRO] Erro ao processar #{file_name}: #{e.message}"
+          puts e.backtrace.join("\n")
+          LOGGER.error("Error processing #{file_name}: #{e.message}")
+          LOGGER.error(e.backtrace.join("\n")) if LOGGER.debug?
+        end
+        
         progress_bar.increment
       end
+      
+      puts "\n=== Processamento concluído ==="
     end
 
     def load_dictionary(json_file)
+      debug_puts("\n[DEBUG] 1. Iniciando load_dictionary")
+      debug_puts("[DEBUG] 2. Diretório de trabalho atual: #{Dir.pwd}")
+      debug_puts("[DEBUG] 3. Arquivo JSON informado: #{json_file.inspect}")
+      
       if json_file
         # Procura o arquivo no diretório atual e no ~/.claiss
         possible_paths = [
           json_file,
           File.expand_path(json_file),
-          File.expand_path("~/.claiss/#{json_file}"),
-        ]
+          File.join(Dir.home, '.claiss', json_file),
+          File.expand_path("~/.claiss/#{json_file}")
+        ].uniq
+        
+        debug_puts("[DEBUG] 4. Procurando arquivo nos seguintes locais:")
+        possible_paths.each_with_index do |path, i|
+          exists = File.exist?(path) ? 'EXISTE' : 'não encontrado'
+          debug_puts("  #{i+1}. #{path} (#{exists})")
+          if exists == 'EXISTE'
+            debug_puts("     Permissões: #{File.stat(path).mode.to_s(8)}")
+            debug_puts("     Tamanho: #{File.size(path)} bytes")
+          end
+        end
 
         found_file = possible_paths.find { |path| File.exist?(path) }
 
         if found_file
+          debug_puts("[DEBUG] 5. Arquivo encontrado em: #{found_file}")
           begin
-            dict = JSON.parse(File.read(found_file))
-            puts "Oba! Encontrei o arquivo em: #{found_file}"
+            debug_puts("[DEBUG] 6. Lendo conteúdo do arquivo...")
+            file_content = File.read(found_file)
+            debug_puts("[DEBUG] 7. Tamanho do conteúdo: #{file_content.length} bytes")
+            debug_puts("[DEBUG] 8. Conteúdo do arquivo (início):\n#{file_content[0..200].inspect}...")
+            
+            dict = JSON.parse(file_content)
+            debug_puts("[DEBUG] 9. Dicionário carregado com sucesso!")
+            debug_puts("[DEBUG] 10. Número de entradas: #{dict.size}")
+            debug_puts("[DEBUG] 11. Primeiras 3 entradas: #{dict.first(3).to_h.inspect}") if dict.any?
+            
             return dict
           rescue JSON::ParserError => e
-            puts "Ops! O arquivo JSON não está no formato correto. Erro: #{e.message}"
+            puts "[ERRO] O arquivo JSON não está no formato correto. Erro: #{e.message}"
+            debug_puts("[ERRO] Linha do erro: #{e.backtrace.find { |l| l.include?('parse') }}")
+          rescue StandardError => e
+            puts "[ERRO] Erro ao ler o arquivo: #{e.class}: #{e.message}"
+            debug_puts("[ERRO] Backtrace: #{e.backtrace.join("\n")}")
           end
         else
-          puts "Hmm, não consegui encontrar o arquivo. Procurei nesses lugares:"
+          puts '[ERRO] Não consegui encontrar o arquivo em nenhum dos locais:'
           possible_paths.each { |path| puts "  - #{path}" }
+          
+          # Verifica se o diretório .claiss existe
+          claiss_dir = File.join(Dir.home, '.claiss')
+          if Dir.exist?(claiss_dir)
+            debug_puts("[DEBUG] Conteúdo do diretório #{claiss_dir}:")
+            Dir.entries(claiss_dir).each { |f| debug_puts("  - #{f}") }
+          else
+            debug_puts("[DEBUG] Diretório #{claiss_dir} não existe!")
+          end
         end
 
-        puts "Vamos usar o dicionário interativo em vez disso, tá bom?"
+        puts '[AVISO] Vamos usar o dicionário interativo em vez disso, tá bem?'
         interactive_dictionary
       else
+        debug_puts('[DEBUG] Nenhum arquivo JSON informado, usando dicionário interativo')
         interactive_dictionary
       end
     end
-    
+
     def interactive_dictionary
       # Em ambiente de teste, retorna um dicionário de substituição padrão
       if ENV['RACK_ENV'] == 'test' || ENV['RAILS_ENV'] == 'test' || caller.any? { |line| line.include?('rspec') }
@@ -118,49 +224,54 @@ module CLAISS
         }
       else
         # Implementação interativa real iria aqui
-        puts "Modo interativo não implementado. Retornando dicionário vazio."
+        puts 'Modo interativo não implementado. Retornando dicionário vazio.'
         {}
       end
     end
 
     def process_files(origin_path, dict, destination_path)
-      Dir.glob(File.join(origin_path, "**", "*"), File::FNM_DOTMATCH) do |file_name|
+      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH) do |file_name|
         next if File.directory?(file_name)
         next if IGNORED_DIRECTORIES.any? { |dir| file_name.include?(dir) }
+
         refactor_file(file_name, dict, origin_path, destination_path)
       end
     end
 
     def refactor_file(file_name, dict, origin_path, destination_path)
+      if is_binary_file?(file_name)
+        LOGGER.info("Processing binary file (renaming only): ...#{File.basename(file_name)}")
+        process_binary_file_rename(file_name, dict, origin_path, destination_path)
+        return
+      end
+
       begin
         # First, try to read the file as UTF-8
-        text = File.read(file_name, encoding: "UTF-8")
+        text = File.read(file_name, encoding: 'UTF-8')
       rescue Encoding::InvalidByteSequenceError
         # If UTF-8 reading fails, fall back to binary reading and force UTF-8 encoding
         # This approach helps handle files with mixed or unknown encodings
         truncated_file_name = File.basename(file_name)
         LOGGER.warn("Invalid UTF-8 byte sequence in ...#{truncated_file_name}. Falling back to binary reading.")
-        text = File.read(file_name, encoding: "BINARY")
-        text.force_encoding("UTF-8")
+        text = File.read(file_name, encoding: 'BINARY')
+        text.force_encoding('UTF-8')
         # Replace any invalid or undefined characters with empty string
-        text.encode!("UTF-8", invalid: :replace, undef: :replace, replace: "")
+        text.encode!('UTF-8', invalid: :replace, undef: :replace, replace: '')
       end
 
       text_changed = false
       dict.each do |search, replace|
-        if text.gsub!(/#{Regexp.escape(search)}/, replace)
-          text_changed = true
-        end
+        text_changed = true if text.gsub!(/#{Regexp.escape(search)}/, replace)
       end
 
       relative_path = Pathname.new(file_name).relative_path_from(Pathname.new(origin_path))
       new_relative_path = replace_in_path(relative_path.to_s, dict)
 
-      if destination_path
-        new_file_name = File.join(destination_path, new_relative_path)
-      else
-        new_file_name = File.join(origin_path, new_relative_path)
-      end
+      new_file_name = if destination_path
+                        File.join(destination_path, new_relative_path)
+                      else
+                        File.join(origin_path, new_relative_path)
+                      end
 
       new_dir = File.dirname(new_file_name)
       FileUtils.mkdir_p(new_dir) unless File.directory?(new_dir)
@@ -170,69 +281,193 @@ module CLAISS
         if destination_path || new_file_name != file_name
           truncated_old = "...#{File.basename(file_name)}"
           truncated_new = "...#{File.basename(new_file_name)}"
-          LOGGER.info("File #{destination_path ? "copied" : "renamed"} from #{truncated_old} to #{truncated_new}")
+          LOGGER.info("File #{destination_path ? 'copied' : 'renamed'} from #{truncated_old} to #{truncated_new}")
         else
           truncated_file = "...#{File.basename(file_name)}"
           LOGGER.info("File contents updated: #{truncated_file}")
         end
         File.delete(file_name) if !destination_path && new_file_name != file_name
       end
-    rescue => e
+    rescue StandardError => e
       truncated_file = "...#{File.basename(file_name)}"
       LOGGER.error("Error processing file #{truncated_file}: #{e.message}")
       LOGGER.debug(e.backtrace.join("\n"))
     end
 
+    def process_binary_file_rename(file_name, dict, origin_path, destination_path)
+      debug_puts("[DEBUG] Iniciando process_binary_file_rename")
+      debug_puts("[DEBUG] Arquivo: #{file_name}")
+      debug_puts("[DEBUG] Origem: #{origin_path}")
+      debug_puts("[DEBUG] Destino: #{destination_path || 'Não especificado'}")
+      debug_puts("[DEBUG] Dicionário: #{dict.inspect}")
+      
+      begin
+        relative_path = Pathname.new(file_name).relative_path_from(Pathname.new(origin_path)).to_s
+        
+        debug_puts("[DEBUG] Caminho relativo: #{relative_path}")
+        
+        new_relative_path = replace_in_path(relative_path, dict)
+        debug_puts("[DEBUG] Novo caminho relativo: #{new_relative_path}")
+        
+        new_file_name = if destination_path
+                          File.join(destination_path, new_relative_path)
+                        else
+                          File.join(origin_path, new_relative_path)
+                        end
+        
+        debug_puts("[DEBUG] Novo caminho completo: #{new_file_name}")
+
+        if new_file_name != file_name
+          new_dir = File.dirname(new_file_name)
+          
+          debug_puts("[DEBUG] Criando diretório: #{new_dir}")
+          
+          unless File.directory?(new_dir)
+            debug_puts("[DEBUG] Diretório não existe, criando: #{new_dir}")
+            FileUtils.mkdir_p(new_dir)
+          end
+          
+          debug_puts("[DEBUG] Movendo arquivo de:\n  #{file_name}\n  para:\n  #{new_file_name}")
+          
+          FileUtils.mv(file_name, new_file_name, force: true)
+          
+          unless destination_path
+            debug_puts("[DEBUG] Removendo arquivo original: #{file_name}")
+            File.delete(file_name) if File.exist?(file_name)
+          end
+          
+          debug_puts("[DEBUG] Arquivo movido com sucesso!")
+        else
+          debug_puts("[DEBUG] Nenhuma alteração necessária para o arquivo")
+        end
+        
+        true
+      rescue StandardError => e
+        puts "[ERRO] Erro ao processar arquivo binário #{file_name}: #{e.message}"
+        debug_puts("[ERRO] Backtrace: #{e.backtrace.join("\n")}")
+        false
+      ensure
+        debug_puts("[DEBUG] Finalizando process_binary_file_rename\n")
+        puts "[ERRO CRÍTICO] Erro ao processar #{file_name}: #{e.message}"
+        puts e.backtrace.join("\n")
+        LOGGER.error("Error renaming binary file #{file_name}: #{e.message}")
+        LOGGER.error(e.backtrace.join("\n")) if LOGGER.debug?
+      end
+    end
+
     def replace_in_path(path, dict)
-      dict.reduce(path) do |s, (search, replace)|
-        s.gsub(/#{Regexp.escape(search)}/, replace)
+      debug_puts("[DEBUG] Iniciando replace_in_path")
+      debug_puts("[DEBUG] Caminho original: #{path}")
+      debug_puts("[DEBUG] Dicionário: #{dict.inspect}")
+      
+      return path if dict.empty? || path.nil? || path.empty?
+      
+      # Ordena as chaves por tamanho (maior primeiro) para evitar substituições parciais
+      sorted_dict = dict.sort_by { |k, _| -k.size }.to_h
+      debug_puts("[DEBUG] Dicionário ordenado: #{sorted_dict.inspect}")
+      
+      new_path = path.dup
+      
+      sorted_dict.each do |search, replace|
+        debug_puts("[DEBUG] Buscando: '#{search}'")
+        debug_puts("[DEBUG] Substituindo por: '#{replace}'")
+        debug_puts("[DEBUG] Caminho atual: #{new_path}")
+        
+        # Verifica se o caminho contém o termo de busca
+        if new_path.include?(search)
+          # Separa diretório e nome do arquivo
+          dirname = File.dirname(new_path)
+          basename = File.basename(new_path)
+          debug_puts("[DEBUG] Diretório: #{dirname}")
+          debug_puts("[DEBUG] Nome do arquivo: #{basename}")
+          
+          # Aplica a substituição apenas no nome do arquivo
+          new_basename = basename.gsub(search, replace)
+          debug_puts("[DEBUG] Novo nome do arquivo: #{new_basename}")
+          
+          # Reconstrói o caminho
+          if dirname == '.'
+            new_path = new_basename
+          else
+            new_path = File.join(dirname, new_basename)
+          end
+          
+          # Se o diretório também precisar ser substituído
+          dirname_parts = dirname.split(File::SEPARATOR)
+          new_dirname_parts = dirname_parts.map do |part|
+            if part.include?(search)
+              new_part = part.gsub(search, replace)
+              debug_puts("[DEBUG] Substituição no diretório: '#{part}' -> '#{new_part}'")
+              new_part
+            else
+              part
+            end
+          end
+          
+          # Reconstrói o caminho completo com o diretório atualizado
+          new_path = File.join(*new_dirname_parts, File.basename(new_path))
+          
+          debug_puts("[DEBUG] Caminho após substituição: #{new_path}")
+        end
+      end
+      
+      if new_path != path
+        debug_puts("[DEBUG] Caminho alterado de:\n  #{path}\n  para:\n  #{new_path}")
+      else
+        debug_puts("[DEBUG] Nenhuma substituição foi feita no caminho")
       end
+      
+      debug_puts("[DEBUG] Finalizando replace_in_path\n")
+      new_path
     end
 
     def remove_empty_directories(origin_path)
-      Dir.glob(File.join(origin_path, "**", "*"), File::FNM_DOTMATCH).reverse_each do |dir_name|
+      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH).reverse_each do |dir_name|
         next unless File.directory?(dir_name)
-        next if dir_name.include?(".git/") || dir_name.include?("node_modules/") # Ignorar pastas .git e node_modules
-        next if dir_name == "." || dir_name == ".." # Ignorar diretórios especiais . e ..
-        if (Dir.entries(dir_name) - %w[. ..]).empty?
-          begin
-            Dir.rmdir(dir_name)
-            puts "Diretório vazio removido: #{dir_name}"
-          rescue Errno::ENOTEMPTY, Errno::EINVAL => e
-            puts "Não foi possível remover o diretório: #{dir_name}. Erro: #{e.message}"
-          end
+        next if dir_name.include?('.git/') || dir_name.include?('node_modules/') # Ignorar pastas .git e node_modules
+        next if ['.', '..'].include?(dir_name) # Ignorar diretórios especiais . e ..
+
+        next unless (Dir.entries(dir_name) - %w[. ..]).empty?
+
+        begin
+          Dir.rmdir(dir_name)
+          puts "Diretório vazio removido: #{dir_name}"
+        rescue Errno::ENOTEMPTY, Errno::EINVAL => e
+          puts "Não foi possível remover o diretório: #{dir_name}. Erro: #{e.message}"
         end
       end
     end
   end
 
   class FixRubyPermissions < Dry::CLI::Command
-    desc "Fix permissions for a Ruby project"
+    desc 'Fix permissions for a Ruby project'
 
-    argument :path, type: :string, required: false, default: ".", desc: "Path to the Ruby project (default: current directory)"
+    argument :path, type: :string, required: false, default: '.',
+                    desc: 'Path to the Ruby project (default: current directory)'
 
     example [
-      "",
-      "path/to/ruby/project",
+      '',
+      'path/to/ruby/project'
     ]
 
-    def call(path: ".", **)
+    def call(path: '.', **)
       path = File.expand_path(path)
 
-      Dir.glob(File.join(path, "**", "*"), File::FNM_DOTMATCH) do |item|
-        next if item == "." || item == ".."
-        next if item.include?("node_modules/") # Ignore node_modules folder
+      Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH) do |item|
+        next if ['.', '..'].include?(item)
+        next if item.include?('node_modules/') # Ignore node_modules folder
+
         if File.directory?(item)
-          File.chmod(0755, item)
+          File.chmod(0o755, item)
         else
           fix_file_permissions(item)
         end
       end
 
-      executable_files = ["bundle", "rails", "rake", "spring"]
+      executable_files = %w[bundle rails rake spring]
       executable_files.each do |file|
-        file_path = File.join(path, "bin", file)
-        File.chmod(0755, file_path) if File.exist?(file_path)
+        file_path = File.join(path, 'bin', file)
+        File.chmod(0o755, file_path) if File.exist?(file_path)
       end
 
       puts "Permissions fixed for Ruby project at #{path}"
@@ -243,28 +478,28 @@ module CLAISS
     def fix_file_permissions(file)
       # Não altera permissões de arquivos em diretórios restritos
       return if file.include?('/restricted/')
-      
+
       # Obtém o modo atual do arquivo
-      current_mode = File.stat(file).mode & 0777
-      
+      current_mode = File.stat(file).mode & 0o777
+
       # Se o arquivo já tem permissões restritivas (menos de 0600), não altera
       return if current_mode < 0o600
-      
+
       # Define as permissões apropriadas
-      new_mode = if File.extname(file) == ".rb" || file.include?("/bin/")
+      new_mode = if File.extname(file) == '.rb' || file.include?('/bin/')
                    0o755  # Executável
                  else
                    0o644  # Apenas leitura/escrita para o dono
                  end
-      
+
       # Aplica as permissões apenas se forem diferentes
       File.chmod(new_mode, file) if new_mode != current_mode
-    rescue => e
+    rescue StandardError => e
       LOGGER.warn("Could not change permissions for #{file}: #{e.message}")
     end
   end
 end
 
-require_relative "claiss/version"
-require_relative "claiss/commands"
-require_relative "claiss/cli"
+require_relative 'claiss/version'
+require_relative 'claiss/commands'
+require_relative 'claiss/cli'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: claiss
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.7
 platform: ruby
 authors:
 - Júlio Papel
 bindir: exe
 cert_chain: []
-date: 2025-05-31 00:00:00.000000000 Z
+date: 2025-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-cli