Merge pull request #1 from lucasferreiralimax/i18n

i18n and refactory folders

gitman/commands/__init__.py

@@ -0,0 +1,8 @@
+from .projects_update import projects_update
+from .ncu_update import ncu_update
+from .get_cli_version import get_cli_version
+from .check_outdated import check_outdated
+from .check_status import check_status
+
+# Exportando funções/módulos
+__all__ = ["projects_update", "ncu_update", "get_cli_version", "check_outdated", "check_status"]

src/commands/check_outdated.py → gitman/commands/check_outdated.py

@@ -1,22 +1,23 @@
 import os
 import subprocess
+import i18n
 
 # Função para verificar dependências desatualizadas em todos os projetos
 def check_outdated(base_dir):
     for dir in os.listdir(base_dir):
         full_path = os.path.join(base_dir, dir)
         if os.path.isdir(full_path):
-            print("Entrando no diretório:", full_path)
+            print(i18n.t('check_outdated.entering_directory', fullpath=full_path))
             os.chdir(full_path)
 
             try:
-                print("Rodando 'outdated' em", full_path)
+                print(i18n.t('check_outdated.running_outdated', fullpath=full_path))
                 subprocess.run(['npm', 'outdated'], check=True)
 
             except subprocess.CalledProcessError as e:
-                print(f"Erro ao verificar dependências desatualizadas em {full_path}:")
+                print(i18n.t('check_outdated.error', fullpath=full_path))
                 print(e.stderr)
 
             os.chdir('..')
 
-    print("Verificação concluída.")
+    print(i18n.t('check_status.complete_status'))

src/commands/check_status.py → gitman/commands/check_status.py

@@ -1,22 +1,23 @@
 import os
 import subprocess
+import i18n
 
 # Função para verificar o status do Git em todos os projetos
 def check_status(base_dir):
     for dir in os.listdir(base_dir):
         full_path = os.path.join(base_dir, dir)
         if os.path.isdir(full_path):
-            print("Entrando no diretório:", full_path)
+            print(i18n.t('check_status.entering_directory', fullpath=full_path))
             os.chdir(full_path)
 
             try:
-                print("Verificando o status do Git em", full_path)
+                print(i18n.t('check_status.checking_git_status', fullpath=full_path))
                 subprocess.run(['git', 'status'], check=True)
 
             except subprocess.CalledProcessError as e:
-                print(f"Erro ao verificar o status do Git em {full_path}:")
+                print(i18n.t('check_status.git_error', fullpath=full_path))
                 print(e.stderr)
 
             os.chdir('..')
-    
-    print("Verificação de status do Git concluída.")
+
+    print(i18n.t('check_status.complete_status'))

src/commands/get_cli_version.py → gitman/commands/get_cli_version.py

@@ -1,8 +1,9 @@
 from importlib.metadata import version
+import i18n
 
 # Função para exibir a versão do programa
 def get_cli_version():
     try:
-        return version('gitman')
+        print(i18n.t('comman.version', version=version('gitman')))
     except Exception:
-        return "Versão desconhecida"
+        print(i18n.t('comman.version_not_found'))

src/commands/ncu_update_projects.py → gitman/commands/ncu_update.py

@@ -1,27 +1,28 @@
 import os
 import subprocess
+import i18n
 
-# Função para rodar npx npm-check-updates e atualizar dependências
-def ncu_update_projects(projects, commit_message, base_dir):
+# Função para rodar npx npm-check-updates e atualizar
+def ncu_update(projects, commit_message, base_dir):
     project_list = projects.split(',')
 
     for project_dir in project_list:
         full_path = os.path.join(base_dir, project_dir)
         if not os.path.isdir(full_path):
-            print(f"O diretório {full_path} não existe.")
+            print(i18n.t('ncu_update.ncu_directory_not_exist').format(fullpath=full_path))
             continue
 
+        print(i18n.t('ncu_update.ncu_entering_directory').format(fullpath=full_path))
         os.chdir(full_path)
 
-        print(f"Atualizando todas as dependências em {full_path} com npm-check-updates")
-
         try:
+            print(i18n.t('ncu_update.ncu_running').format(fullpath=full_path))
             # Executa npx npm-check-updates
             ncu_result = subprocess.run(['npx', 'npm-check-updates', '-u'], capture_output=True, text=True)
 
             # Exibir a saída completa para depuração
-            print(f"Saída do npx npm-check-updates:\n{ncu_result.stdout}")
-            print(f"Erros do npx npm-check-updates:\n{ncu_result.stderr}")
+            print(i18n.t('ncu_update.ncu_output').format(output=ncu_result.stdout))
+            print(i18n.t('ncu_update.ncu_errors').format(errors=ncu_result.stderr))
 
             # Se houver atualizações, ncu_result.returncode será 1
             if ncu_result.returncode not in [0, 1]:
@@ -31,8 +32,8 @@ def ncu_update_projects(projects, commit_message, base_dir):
             install_result = subprocess.run(['npm', 'install'], capture_output=True, text=True)
 
             # Exibir a saída completa para depuração
-            print(f"Saída do npm install:\n{install_result.stdout}")
-            print(f"Erros do npm install:\n{install_result.stderr}")
+            print(i18n.t('ncu_update.ncu_npm_install_output').format(output=install_result.stdout))
+            print(i18n.t('ncu_update.ncu_npm_install_errors').format(errors=install_result.stderr))
 
             if install_result.returncode != 0:
                 raise subprocess.CalledProcessError(install_result.returncode, install_result.args, output=install_result.stdout, stderr=install_result.stderr)
@@ -41,12 +42,17 @@ def ncu_update_projects(projects, commit_message, base_dir):
             subprocess.run(['git', 'add', 'package.json', 'package-lock.json'], check=True)
             subprocess.run(['git', 'commit', '-m', commit_message], check=True)
             subprocess.run(['git', 'push'], check=True)
+
+            print(i18n.t('ncu_update.ncu_git_commit_message').format(message=commit_message))
+            print(i18n.t('ncu_update.ncu_git_push'))
 
         except subprocess.CalledProcessError as e:
-            print(f"Erro ao executar npm-check-updates ou npm install em {full_path}:")
-            print(f"Comando: {e.cmd}")
-            print(f"Retorno do comando: {e.returncode}")
-            print(f"Saída: {e.output}")
-            print(f"Erro: {e.stderr}")
+            print(i18n.t('ncu_update.ncu_error').format(fullpath=full_path))
+            print(i18n.t('ncu_update.ncu_command').format(command=e.cmd))
+            print(i18n.t('ncu_update.ncu_return_code').format(returncode=e.returncode))
+            print(i18n.t('ncu_update.ncu_output').format(output=e.output.decode()))
+            print(i18n.t('ncu_update.ncu_error_details').format(errors=e.stderr.decode()))
 
         os.chdir('..')
+
+    print(i18n.t('ncu_update.ncu_complete'))

src/commands/update_projects.py → gitman/commands/projects_update.py

@@ -1,19 +1,20 @@
 import os
 import subprocess
+import i18n
 
 # Função para atualizar dependências de um projeto
-def update_projects(projects, ignored_deps, commit_message, base_dir):
+def projects_update(projects, ignored_deps, commit_message, base_dir):
     project_list = projects.split(',')
 
     for project_dir in project_list:
         full_path = os.path.join(base_dir, project_dir)
         if not os.path.isdir(full_path):
-            print(f"O diretório {full_path} não existe.")
+            print(i18n.t('update.up_directory_not_exist').format(fullpath=full_path))
             continue
 
         os.chdir(full_path)
 
-        print(f"Verificando dependências desatualizadas em {full_path}")
+        print(i18n.t('update.up_checking_outdated').format(fullpath=full_path))
 
         try:
             # Gera uma lista de dependências desatualizadas com nome e versão
@@ -23,8 +24,8 @@ def update_projects(projects, ignored_deps, commit_message, base_dir):
             )
 
             # Exibir a saída completa para depuração
-            print(f"Saída do npm outdated:\n{outdated_result.stdout}")
-            print(f"Erros do npm outdated:\n{outdated_result.stderr}")
+            print(i18n.t('update.up_outdated_output').format(output=outdated_result.stdout))
+            print(i18n.t('update.up_outdated_errors').format(errors=outdated_result.stderr))
 
             # Se houver dependências desatualizadas, outdated_result.returncode será 1
             if outdated_result.returncode not in [0, 1]:
@@ -41,29 +42,32 @@ def update_projects(projects, ignored_deps, commit_message, base_dir):
                     )
 
             if outdated_packages:
-                print("Dependências desatualizadas encontradas. Atualizando dependências:")
+                print(i18n.t('update.up_outdated_found'))
                 for package in outdated_packages.split('\n'):
                     package_name = package.split(':')[1]
                     print(f"  - {package_name}")
 
                 # Atualiza cada pacote individualmente
                 for package in outdated_packages.split('\n'):
                     package_name = package.split(':')[1]
-                    print(f"Atualizando {package_name}")
+                    print(i18n.t('update.up_updating_package').format(package_name=package_name))
                     subprocess.run(['npm', 'install', package_name, '--legacy-peer-deps'], check=True)
 
                 # Adiciona mudanças ao Git, cria um commit e faz push
                 subprocess.run(['git', 'add', 'package.json', 'package-lock.json'], check=True)
                 subprocess.run(['git', 'commit', '-m', commit_message], check=True)
                 subprocess.run(['git', 'push'], check=True)
+
+                print(i18n.t('update.up_git_commit_message').format(message=commit_message))
+                print(i18n.t('update.up_git_push'))
             else:
-                print(f"Todas as dependências estão atualizadas em {full_path}")
+                print(i18n.t('update.up_all_to_date').format(fullpath=full_path))
 
         except subprocess.CalledProcessError as e:
-            print(f"Erro ao verificar/atualizar dependências em {full_path}:")
-            print(f"Comando: {e.cmd}")
-            print(f"Retorno do comando: {e.returncode}")
-            print(f"Saída: {e.output}")
-            print(f"Erro: {e.stderr}")
+            print(i18n.t('update.up_error').format(fullpath=full_path))
+            print(i18n.t('update.up_command').format(command=e.cmd))
+            print(i18n.t('update.up_return_code').format(returncode=e.returncode))
+            print(i18n.t('update.up_output').format(output=e.output.decode()))
+            print(i18n.t('update.up_error_details').format(errors=e.stderr.decode()))
 
         os.chdir('..')

gitman/config.py

@@ -0,0 +1,34 @@
+import i18n
+import platform
+import subprocess
+
+def i18nConfig():
+    # Obter informações do sistema
+    system_info = platform.system()
+
+    if system_info == 'Windows':
+        # Para Windows, usando o módulo winreg para obter o idioma
+        import winreg
+
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Control Panel\\International", 0, winreg.KEY_READ)
+        system_lang, _ = winreg.QueryValueEx(key, "LocaleName")
+        winreg.CloseKey(key)
+
+    elif system_info == 'Darwin':
+        # Para macOS, usando o comando 'defaults' para obter o idioma
+        proc = subprocess.Popen(['defaults', 'read', '-g', 'AppleLocale'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, _ = proc.communicate()
+        system_lang = out.strip().decode('utf-8')
+
+    else:
+        # Para Linux e outros sistemas baseados em Unix, usando 'locale' para obter o idioma
+        proc = subprocess.Popen(['locale'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, _ = proc.communicate()
+        system_lang = out.split()[0].decode('utf-8').split('=')[1]
+
+    if system_lang:
+        system_lang = system_lang[:2]
+
+    i18n.load_path.append('gitman/translations')
+    i18n.set('fallback', 'en')
+    i18n.set('locale', system_lang)

gitman/main.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+import os
+import sys
+import i18n
+from .config import i18nConfig
+from .commands import projects_update
+from .commands import ncu_update
+from .commands import get_cli_version
+from .commands import check_outdated
+from .commands import check_status
+
+gitman = """
+  _______  __  .___________..___  ___.      ___      .__   __. 
+ /  _____||  | |           ||   \/   |     /   \     |  \ |  | 
+|  |  __  |  | `---|  |----`|  \  /  |    /  ^  \    |   \|  | 
+|  | |_ | |  |     |  |     |  |\/|  |   /  /_\  \   |  . `  | 
+|  |__| | |  |     |  |     |  |  |  |  /  _____  \  |  |\   | 
+ \______| |__|     |__|     |__|  |__| /__/     \__\ |__| \__| 
+                                                               
+"""
+
+# Função para exibir o uso correto do script
+def usage():
+    print(gitman)
+    print(i18n.t('main.usage.description'))
+    for i in range(1, 9):
+        new_line = 'line' + str(i)
+        print(i18n.t('main.usage.'+ new_line))
+    sys.exit(1)
+
+# Função principal do programa
+def app():
+    try:
+        i18nConfig()    
+
+        # Verifica os parâmetros do script
+        if len(sys.argv) == 1:
+            usage()
+
+        project_directory = ""
+        ignored_dependencies = ""
+        ncu_flag = False
+        commit_message = "update: deps of project"
+        base_directory = os.path.expanduser("~/Documents")
+
+        # Processa os argumentos de linha de comando
+        args = sys.argv[1:]
+        while args:
+            opt = args.pop(0)
+            if opt == '-b':
+                base_directory = os.path.expanduser(args.pop(0))
+            elif opt == '-u':
+                project_directory = args.pop(0)
+            elif opt == '-i':
+                ignored_dependencies = args.pop(0)
+            elif opt == '-a':
+                check_outdated(base_directory)
+            elif opt == '-g':
+                check_status(base_directory)
+            elif opt == '-n':
+                project_directory = args.pop(0)
+                ncu_flag = True
+            elif opt == '-m':
+                commit_message = args.pop(0)
+            elif opt in ('-v', '--version'):
+                get_cli_version()
+                sys.exit(0)
+            else:
+                usage()
+
+        # Executa o comando apropriado baseado nos parâmetros fornecidos
+        if ncu_flag:
+            ncu_update(project_directory, commit_message, base_directory)
+        elif project_directory:
+            projects_update(project_directory, ignored_dependencies, commit_message, base_directory)
+
+    except KeyboardInterrupt:                            
+        print(gitman)                              
+        print('\nGitman execution interrupted; exiting.')
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"Erro: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    app()

gitman/translations/check_outdated.en.yml

@@ -0,0 +1,5 @@
+en:
+  entering_directory: "Entering directory: %{fullpath}"
+  running_outdated: "Running 'outdated' in %{fullpath}"
+  error: "Error checking outdated dependencies in %{fullpath}:"
+  complete_check: "Check completed."

gitman/translations/check_outdated.pt.yml

@@ -0,0 +1,5 @@
+pt:
+  entering_directory: "Entrando no diretório: %{fullpath}"
+  running_outdated: "Rodando 'outdated' em %{fullpath}"
+  error: "Erro ao verificar dependências desatualizadas em %{fullpath}:"
+  complete_check: "Verificação concluída."

gitman/translations/check_status.en.yml

@@ -0,0 +1,5 @@
+en:
+  entering_directory: "Entering directory: %{fullpath}"
+  checking_git_status: "Checking Git status in %{fullpath}"
+  git_error: "Error checking Git status in %{fullpath}:"
+  complete_status: "Git status check completed."

gitman/translations/check_status.pt.yml

@@ -0,0 +1,5 @@
+pt:
+  entering_directory: "Entrando no diretório: %{fullpath}"
+  checking_git_status: "Verificando o status do Git em %{fullpath}"
+  git_error: "Erro ao verificar o status do Git em %{fullpath}:"
+  complete_status: "Verificação de status do Git concluída."

gitman/translations/comman.en.yml

@@ -0,0 +1,3 @@
+en:
+  version: "Program version: %{version}"
+  version_not_found: "Version not found"

gitman/translations/comman.pt.yml

@@ -0,0 +1,3 @@
+pt:
+  version: "Versão do programa: %{version}"
+  version_not_found: "Versão desconhecida"