JAVA-judge33

README.md

@@ -1,14 +1,78 @@
 ---
-title: Java Judge Syntax Competencies
-emoji: 🏢
-colorFrom: pink
-colorTo: blue
+title: Java-Judge-Syntax-Competencies
+emoji: ⚖️✏️☕♨️🖥️
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.9.1
+sdk_version: 4.7.1
 app_file: app.py
 pinned: false
-license: ecl-2.0
-short_description: 'Java Judge: Syntax & Competencies'
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Avaliador de POO em Java
+
+Este projeto avalia códigos Java com base nos conceitos da Programação Orientada a Objetos (POO), fornecendo feedback detalhado e pontuações de acordo com duas rubricas bem definidas: **Estrutural** e **Competências**.
+
+## Desenvolvedor
+
+Desenvolvido por Ramon Mayor Martins (2024)
+
+- **Email**: rmayormartins@gmail.com
+- **Homepage**: [rmayormartins.github.io](https://rmayormartins.github.io/)
+- **Twitter**: [@rmayormartins](https://twitter.com/rmayormartins)
+- **GitHub**: [github.com/rmayormartins](https://github.com/rmayormartins)
+- **Space**: [Hugging Face Space](https://huggingface.co/rmayormartins)
+
+## Funcionalidades Principais
+
+### **Avaliação Estrutural**
+- Detecta tipos primitivos, constantes e variáveis.
+- Identifica estruturas de controle como `if/else`, `switch/case`, laços e operadores.
+- Analisa operações de entrada e saída (e.g., `System.out.print`, `Scanner`).
+
+### **Avaliação por Competências**
+- Examina a corretude sintática de estruturas básicas e elementos essenciais.
+- Avalia competências como organização, clareza e resolução de problemas.
+- Fornece feedback detalhado com base no uso de estruturas adequadas.
+
+### **Interface Amigável**
+- Permite upload de múltiplos arquivos Java.
+- Exibe resultados detalhados em abas separadas para cada tipo de avaliação.
+
+## Rubricas de Avaliação
+
+### Avaliação Estrutural
+
+| Categoria              | Pontos |
+|------------------------|--------|
+| Declarações e Tipos    | 25     |
+| Estruturas de Controle | 25     |
+| Operadores e Expressões| 25     |
+| Entrada e Saída        | 25     |
+
+### Avaliação por Competências
+
+| Categoria                 | Pontos |
+|---------------------------|--------|
+| Corretude Sintática       | 50     |
+| Competências Demonstradas | 50     |
+
+> Para mais detalhes, visualize a rubrica completa no arquivo [rubric.pdf](rubric.pdf) ou confira a tabela resumida abaixo.
+
+![Tabela da Rubrica](rubric_table.png)
+
+## Como Usar
+
+1. Abra a interface do aplicativo.
+2. Escolha entre **Avaliação Estrutural** ou **Avaliação por Competências**.
+3. Envie um ou mais arquivos `.java`.
+4. Veja a pontuação e o feedback detalhado para cada arquivo.
+
+## Desenvolvimento Local
+
+Para rodar localmente:
+
+```bash
+pip install -r requirements.txt
+python app.py

app.py

@@ -0,0 +1,513 @@
+# Instalação das dependências
+!pip install -q javalang gradio
+
+import gradio as gr
+import javalang
+from typing import Dict, List, Tuple
+import re
+
+class JavaStructuralEvaluator:
+    """Avaliador baseado em estruturas usadas"""
+    def __init__(self):
+        self.rubric = {
+            "declaracoes": 25,  # Declarações e tipos
+            "estruturas_controle": 25,  # if, switch, loops
+            "operadores": 25,  # Operadores e expressões
+            "io_strings": 25  # System.out, concatenação, etc
+        }
+    
+    def analyze_declarations(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa declarações e tipos"""
+        score = 0
+        feedback = []
+        
+        try:
+            tree = javalang.parse.parse(code)
+            
+            # Verificar tipos primitivos
+            primitives = {
+                'int': 'números inteiros',
+                'double': 'números decimais',
+                'boolean': 'valores lógicos',
+                'char': 'caracteres',
+                'float': 'números decimais (float)',
+                'long': 'números longos',
+                'byte': 'valores byte',
+                'short': 'números curtos'
+            }
+            
+            used_types = set()
+            for _, node in tree.filter(javalang.tree.LocalVariableDeclaration):
+                type_name = node.type.name
+                used_types.add(type_name)
+                
+            for type_name, description in primitives.items():
+                if type_name in used_types:
+                    score += 3
+                    feedback.append(f"✓ Uso correto de {type_name} para {description}")
+            
+            # Verificar declarações de variáveis
+            total_vars = len(list(tree.filter(javalang.tree.LocalVariableDeclaration)))
+            if total_vars > 0:
+                score += 5
+                feedback.append(f"✓ {total_vars} variáveis declaradas corretamente")
+            
+            # Verificar constantes
+            constants = list(tree.filter(javalang.tree.FieldDeclaration))
+            if any('final' in node.modifiers for _, node in tree.filter(javalang.tree.FieldDeclaration)):
+                score += 4
+                feedback.append("✓ Uso adequado de constantes (final)")
+            
+        except Exception as e:
+            feedback.append("⚠ Erro na análise de declarações")
+            
+        return score, feedback
+
+    def analyze_control_structures(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa estruturas de controle"""
+        score = 0
+        feedback = []
+        
+        try:
+            tree = javalang.parse.parse(code)
+            
+            # If/Else
+            if_count = len(list(tree.filter(javalang.tree.IfStatement)))
+            if if_count > 0:
+                score += 5
+                feedback.append(f"✓ Uso correto de {if_count} estrutura(s) if/else")
+            
+            # Switch
+            switch_count = len(list(tree.filter(javalang.tree.SwitchStatement)))
+            if switch_count > 0:
+                score += 5
+                feedback.append(f"✓ Uso correto de {switch_count} switch/case")
+            
+            # For loops
+            for_count = len(list(tree.filter(javalang.tree.ForStatement)))
+            if for_count > 0:
+                score += 5
+                feedback.append(f"✓ Uso correto de {for_count} loop(s) for")
+            
+            # While loops
+            while_count = len(list(tree.filter(javalang.tree.WhileStatement)))
+            if while_count > 0:
+                score += 5
+                feedback.append(f"✓ Uso correto de {while_count} loop(s) while")
+            
+            # Do-While loops
+            do_while_count = len(list(tree.filter(javalang.tree.DoStatement)))
+            if do_while_count > 0:
+                score += 5
+                feedback.append(f"✓ Uso correto de {do_while_count} loop(s) do-while")
+            
+        except Exception as e:
+            feedback.append("⚠ Erro na análise de estruturas de controle")
+            
+        return score, feedback
+
+    def analyze_operators(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa operadores e expressões"""
+        score = 0
+        feedback = []
+        
+        try:
+            # Operadores aritméticos
+            arithmetic = ['+', '-', '*', '/', '%']
+            for op in arithmetic:
+                if op in code:
+                    score += 2
+                    feedback.append(f"✓ Uso do operador aritmético {op}")
+            
+            # Operadores de comparação
+            comparison = ['==', '!=', '>', '<', '>=', '<=']
+            for op in comparison:
+                if op in code:
+                    score += 2
+                    feedback.append(f"✓ Uso do operador de comparação {op}")
+            
+            # Operadores lógicos
+            logical = ['&&', '||', '!']
+            for op in logical:
+                if op in code:
+                    score += 2
+                    feedback.append(f"✓ Uso do operador lógico {op}")
+            
+            # Operadores de atribuição
+            assignment = ['+=', '-=', '*=', '/=']
+            for op in assignment:
+                if op in code:
+                    score += 2
+                    feedback.append(f"✓ Uso do operador de atribuição {op}")
+            
+        except Exception as e:
+            feedback.append("⚠ Erro na análise de operadores")
+            
+        return score, feedback
+
+    def analyze_io_strings(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa entrada/saída e manipulação de strings"""
+        score = 0
+        feedback = []
+        
+        try:
+            # System.out
+            if 'System.out.print' in code:
+                score += 5
+                feedback.append("✓ Uso correto de System.out.print")
+            
+            # Scanner
+            if 'Scanner' in code:
+                score += 5
+                feedback.append("✓ Uso correto da classe Scanner para entrada")
+            
+            # Concatenação de strings
+            if '+' in code and '"' in code:
+                score += 5
+                feedback.append("✓ Concatenação de strings com operador +")
+            
+            # Métodos de String
+            string_methods = ['concat', 'substring', 'length', 'equals', 'compareTo']
+            for method in string_methods:
+                if f'.{method}(' in code:
+                    score += 2
+                    feedback.append(f"✓ Uso do método String.{method}")
+            
+        except Exception as e:
+            feedback.append("⚠ Erro na análise de I/O e strings")
+            
+        return score, feedback
+
+    def evaluate_code(self, code: str) -> Dict:
+        """Avalia o código Java"""
+        # Análises individuais
+        decl_score, decl_feedback = self.analyze_declarations(code)
+        ctrl_score, ctrl_feedback = self.analyze_control_structures(code)
+        op_score, op_feedback = self.analyze_operators(code)
+        io_score, io_feedback = self.analyze_io_strings(code)
+        
+        # Calcular pontuação total
+        total_score = sum([
+            decl_score,
+            ctrl_score,
+            op_score,
+            io_score
+        ])
+        
+        # Normalizar para 100
+        total_score = min(100, total_score)
+        
+        # Determinar nível
+        proficiency = "Necessita Melhorias"
+        if total_score >= 90:
+            proficiency = "Excelente"
+        elif total_score >= 75:
+            proficiency = "Bom"
+        elif total_score >= 60:
+            proficiency = "Satisfatório"
+            
+        return {
+            "total_score": total_score,
+            "proficiency": proficiency,
+            "feedback": {
+                "declaracoes": decl_feedback,
+                "estruturas_controle": ctrl_feedback,
+                "operadores": op_feedback,
+                "io_strings": io_feedback
+            }
+        }
+
+class CompetencyEvaluator:
+    """Avaliador baseado em competências"""
+    def __init__(self):
+        self.rubric = {
+            "syntax_correctness": 50,  # Corretude sintática
+            "competencies": 50         # Competências demonstradas
+        }
+    
+    def analyze_syntax_correctness(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa corretude sintática (50 pontos)"""
+        score = 0
+        feedback = []
+        
+        try:
+            tree = javalang.parse.parse(code)
+            
+            # 1. Estrutura básica do programa (10 pontos)
+            if 'class' in code:
+                score += 5
+                feedback.append("✓ Estrutura de classe correta")
+            if 'public static void main' in code:
+                score += 5
+                feedback.append("✓ Método main corretamente declarado")
+
+            # 2. Declarações e Tipos (10 pontos)
+            declarations = list(tree.filter(javalang.tree.LocalVariableDeclaration))
+            if declarations:
+                score += 5
+                feedback.append("✓ Declarações de variáveis sintáticamente corretas")
+                if any(d.type.name in ['int', 'double', 'String', 'boolean'] for d in declarations):
+                    score += 5
+                    feedback.append("✓ Tipos de dados usados corretamente")
+
+            # 3. Expressões e Operadores (10 pontos)
+            if list(tree.filter(javalang.tree.BinaryOperation)):
+                score += 10
+                feedback.append("✓ Expressões e operadores usados corretamente")
+
+            # 4. Blocos e Estruturas (10 pontos)
+            open_braces = code.count('{')
+            close_braces = code.count('}')
+            if open_braces == close_braces and open_braces > 0:
+                score += 5
+                feedback.append("✓ Blocos corretamente delimitados")
+            
+            semicolons = len(re.findall(';[^;]*$', code, re.MULTILINE))
+            if semicolons > 0:
+                score += 5
+                feedback.append("✓ Instruções corretamente terminadas")
+
+            # 5. Entrada/Saída (10 pontos)
+            if 'System.out' in code:
+                score += 5
+                feedback.append("✓ Sintaxe de saída correta")
+            if 'Scanner' in code:
+                score += 5
+                feedback.append("✓ Sintaxe de entrada correta")
+
+        except Exception as e:
+            feedback.append(f"⚠ Erro de sintaxe: {str(e)}")
+            
+        return score, feedback
+
+    def analyze_competencies(self, code: str) -> Tuple[float, List[str]]:
+        """Analisa competências demonstradas (50 pontos)"""
+        score = 0
+        feedback = []
+        
+        try:
+            tree = javalang.parse.parse(code)
+            
+            # 1. Seleção de Estruturas (15 pontos)
+            structures = {
+                'if': list(tree.filter(javalang.tree.IfStatement)),
+                'for': list(tree.filter(javalang.tree.ForStatement)),
+                'while': list(tree.filter(javalang.tree.WhileStatement))
+            }
+            
+            appropriate_use = True
+            for struct_type, instances in structures.items():
+                if instances:
+                    if struct_type == 'for' and any('length' in str(inst) for inst in instances):
+                        score += 5
+                        feedback.append("✓ Uso adequado de for para iteração em arrays")
+                    elif struct_type == 'while' and any('hasNext' in str(inst) for inst in instances):
+                        score += 5
+                        feedback.append("✓ Uso adequado de while para leitura de dados")
+                    else:
+                        score += 5
+                        feedback.append(f"✓ Uso apropriado de {struct_type}")
+
+            # 2. Manipulação de Dados (15 pontos)
+            operations = list(tree.filter(javalang.tree.BinaryOperation))
+            if operations:
+                if any(op.operator in ['*', '/', '+', '-'] for op in operations):
+                    score += 5
+                    feedback.append("✓ Cálculos implementados corretamente")
+                if any(op.operator in ['>', '<', '>=', '<=', '=='] for op in operations):
+                    score += 5
+                    feedback.append("✓ Comparações implementadas corretamente")
+                if any('=' in str(op) for op in operations):
+                    score += 5
+                    feedback.append("✓ Atribuições implementadas corretamente")
+
+            # 3. Clareza e Organização (10 pontos)
+            # Verificar nomes significativos
+            if all(len(decl.declarators[0].name) > 1 for _, decl in tree.filter(javalang.tree.LocalVariableDeclaration)):
+                score += 5
+                feedback.append("✓ Nomes de variáveis significativos")
+            
+            # Verificar indentação e comentários
+            lines = code.split('\n')
+            if any('//' in line or '/*' in line for line in lines):
+                score += 5
+                feedback.append("✓ Código bem documentado")
+
+            # 4. Resolução do Problema (10 pontos)
+            # Verificar se tem entrada, processamento e saída
+            has_input = 'Scanner' in code
+            has_processing = bool(operations)
+            has_output = 'System.out' in code
+            
+            if has_input and has_output:
+                score += 5
+                feedback.append("✓ Programa com entrada e saída")
+            if has_processing:
+                score += 5
+                feedback.append("✓ Lógica de processamento implementada")
+
+        except Exception as e:
+            feedback.append(f"⚠ Erro na análise de competências: {str(e)}")
+            
+        return score, feedback
+
+    def evaluate_code(self, code: str) -> Dict:
+        # Análises individuais
+        syntax_score, syntax_feedback = self.analyze_syntax_correctness(code)
+        comp_score, comp_feedback = self.analyze_competencies(code)
+        
+        # Calcular pontuação total
+        total_score = syntax_score + comp_score
+        
+        # Determinar nível
+        proficiency = "Necessita Melhorias"
+        if total_score >= 90:
+            proficiency = "Excelente"
+        elif total_score >= 75:
+            proficiency = "Bom"
+        elif total_score >= 60:
+            proficiency = "Satisfatório"
+            
+        return {
+            "total_score": total_score,
+            "proficiency": proficiency,
+            "feedback": {
+                "corretude_sintatica": syntax_feedback,
+                "competencias": comp_feedback
+            }
+        }
+
+def process_java_files(files) -> str:
+    """Avalia código usando a rubrica estrutural"""
+    evaluator = JavaStructuralEvaluator()
+    return evaluate_files(files, evaluator, "Estrutural")
+
+def evaluate_competency(files) -> str:
+    """Avalia código usando a rubrica de competências"""
+    evaluator = CompetencyEvaluator()
+    return evaluate_files(files, evaluator, "Competências")
+
+def evaluate_files(files, evaluator, evaluation_type: str) -> str:
+    """Função auxiliar para avaliar arquivos com qualquer avaliador"""
+    results = []
+    project_files = {}
+    
+    try:
+        if not isinstance(files, list):
+            files = [files]
+        
+        # Primeiro, vamos ler todos os arquivos
+        for file in files:
+            with open(file.name, 'r', encoding='utf-8') as f:
+                content = f.read()
+                project_files[file.name] = content
+        
+        # Identificar arquivo principal
+        main_file = None
+        other_files = {}
+        for filename, content in project_files.items():
+            if "public static void main" in content:
+                main_file = (filename, content)
+            else:
+                other_files[filename] = content
+        
+        # Resumo do projeto
+        results.append(f"""
+{'='*50}
+AVALIAÇÃO {evaluation_type.upper()}
+{'='*50}
+Total de arquivos: {len(project_files)}
+Arquivo principal: {main_file[0] if main_file else 'Não encontrado'}
+Arquivos complementares: {len(other_files)}
+{'='*50}
+""")
+        
+        # Avaliar arquivo principal
+        if main_file:
+            result = f"\nARQUIVO PRINCIPAL: {main_file[0]}\n{'-'*30}\n"
+            evaluation = evaluator.evaluate_code(main_file[1])
+            
+            result += f"Pontuação Total: {evaluation['total_score']:.1f}/100\n"
+            result += f"Nível: {evaluation['proficiency']}\n\n"
+            
+            result += "Feedback Detalhado:\n"
+            for category, comments in evaluation['feedback'].items():
+                if comments:
+                    result += f"\n{category.title()}:\n"
+                    for comment in comments:
+                        result += f"  {comment}\n"
+            
+            results.append(result)
+        
+        # Avaliar outros arquivos
+        if other_files:
+            results.append(f"\nARQUIVOS COMPLEMENTARES\n{'-'*30}")
+            
+            for filename, content in other_files.items():
+                result = f"\nAvaliando: {filename}\n"
+                evaluation = evaluator.evaluate_code(content)
+                
+                result += f"Pontuação: {evaluation['total_score']:.1f}/100\n"
+                result += f"Nível: {evaluation['proficiency']}\n\n"
+                
+                result += "Feedback:\n"
+                for category, comments in evaluation['feedback'].items():
+                    if comments:
+                        result += f"\n{category.title()}:\n"
+                        for comment in comments:
+                            result += f"  {comment}\n"
+                
+                results.append(result)
+        
+        return "\n".join(results)
+        
+    except Exception as e:
+        return f"Erro ao processar arquivos: {str(e)}\nTipo do erro: {type(e)}"
+
+# Interface Gradio com abas
+with gr.Blocks(title="Java-Judge-Syntax-Competencies") as demo:
+    gr.Markdown("""
+    # Java-Judge-Syntax-Competencies
+    
+    ### [Visualizar Rubrica em PDF](rubric.pdf)
+    ### [Visualizar Rubrica em PNG](rubric_table.png)
+    Este avaliador analisa código Java usando duas rubricas diferentes:
+    1. **Avaliação Estrutural**: Foca no uso correto de elementos da linguagem
+    2. **Avaliação por Competências**: Analisa qualidade e eficiência do código
+    """)
+    
+    with gr.Tabs():
+        with gr.Tab("Avaliação Estrutural"):
+            upload_structural = gr.File(
+                file_count="multiple",
+                label="Upload dos arquivos Java"
+            )
+            evaluate_btn_structural = gr.Button("Avaliar Estruturas")
+            output_structural = gr.Textbox(
+                label="Resultado da Avaliação",
+                lines=25
+            )
+            evaluate_btn_structural.click(
+                fn=process_java_files,
+                inputs=upload_structural,
+                outputs=output_structural
+            )
+            
+        with gr.Tab("Avaliação por Competências"):
+            upload_competency = gr.File(
+                file_count="multiple",
+                label="Upload dos arquivos Java"
+            )
+            evaluate_btn_competency = gr.Button("Avaliar Competências")
+            output_competency = gr.Textbox(
+                label="Resultado da Avaliação",
+                lines=25
+            )
+            evaluate_btn_competency.click(
+                fn=evaluate_competency,
+                inputs=upload_competency,
+                outputs=output_competency
+            )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+javalang==0.13.0
+