JAVA-Inspector

Classe1.java

@@ -0,0 +1,17 @@
+
+
+public class Classe1 {
+    private String mensagem;
+    
+    public Classe1() {
+        this.mensagem = "Olá da Classe 1!";
+    }
+    
+    public String getMensagem() {
+        return mensagem;
+    }
+    
+    public void setMensagem(String mensagem) {
+        this.mensagem = mensagem;
+    }
+}

Classe2.java

@@ -0,0 +1,16 @@
+public class Classe2 {
+    private int numero;
+    
+    public Classe2() {
+        this.numero = 42;
+    }
+    
+    public int getNumero() {
+        return numero;
+    }
+    
+    public void setNumero(int numero) {
+        this.numero = numero;
+    }
+}
+

Principal.java

@@ -0,0 +1,22 @@
+//nao preciso importar, tudo no mesmo diretorio
+
+public class Principal {
+    public static void main(String[] args) {
+        // Criando instâncias das classes
+        Classe1 obj1 = new Classe1();
+        Classe2 obj2 = new Classe2();
+        
+        // Acessando e mostrando os valores
+        System.out.println(obj1.getMensagem());
+        System.out.println("Número da Classe 2: " + obj2.getNumero());
+        
+        // Modificando os valores
+        obj1.setMensagem("Mensagem modificada!");
+        obj2.setNumero(100);
+        
+        // Mostrando os valores modificados
+        System.out.println("\nApós modificação:");
+        System.out.println(obj1.getMensagem());
+        System.out.println("Número da Classe 2: " + obj2.getNumero());
+    }
+}

README.md

@@ -1,14 +1,54 @@
 ---
-title: Java Inspector
-emoji: 🐠
-colorFrom: yellow
-colorTo: gray
+title: Java Syntax and OO Paradigm Inspector
+emoji: 🔍️☕♨️💻
+colorFrom: blue
+colorTo: purple
 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-Inspector: OO Paradigm and Syntax Inspector for Java Co'
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Java Syntax and OO Paradigm Inspector
+
+This project analyzes Java code to extract insights about syntax elements and Object-Oriented (OO) paradigm usage. The tool identifies primitive types, constants, variable declarations, control structures, and more, helping developers understand and improve their Java code.
+
+## Developer
+
+Developed by Ramon Mayor Martins (2024)
+
+- Email: [email protected]
+- Homepage: https://rmayormartins.github.io/
+- Twitter: @rmayormartins
+- GitHub: https://github.com/rmayormartins
+- Space: https://huggingface.co/rmayormartins
+
+## Key Features
+
+- **Syntax Analysis**:
+  - Detects primitive types and constants.
+  - Identifies control structures like `if/else`, `switch/case`, loops, and operators.
+  - Tracks input/output operations (e.g., `System.out.print`, `Scanner`).
+
+- **OO Analysis**:
+  - Counts classes, objects, and methods.
+  - Examines encapsulation, inheritance, polymorphism, abstraction.
+
+- **User-Friendly Interface**:
+  - Upload multiple Java files for analysis.
+  - Displays results in an easy-to-read table.
+
+## How to Use
+
+1. Open the application interface.
+2. Upload one or more `.java` files.
+3. View detailed syntax and OO paradigm statistics for each file.
+
+## Local Development
+
+To run locally:
+
+```bash
+pip install -r requirements.txt
+python app.py

app.py

@@ -0,0 +1,173 @@
+import gradio as gr
+import javalang
+from collections import Counter
+from typing import Dict, List
+
+class JavaSyntaxAnalyzer:
+    """JAVA-Inspector: OO Paradigm and Syntax Inspector for Java Code """
+
+    def analyze_syntax(self, code: str) -> Dict[str, int]:
+        """Analisa sintaticamente o código em diferentes categorias"""
+        results = Counter()
+
+        try:
+            tree = javalang.parse.parse(code)
+
+            # Declarações
+            results["Tipos Primitivos"] = len([
+                node.type.name for _, node in tree.filter(javalang.tree.LocalVariableDeclaration)
+                if node.type.name in {"int", "double", "boolean", "char", "float", "long", "byte", "short"}
+            ])
+            results["Constantes (final)"] = sum(
+                1 for _, node in tree.filter(javalang.tree.FieldDeclaration) if "final" in node.modifiers
+            )
+            results["Variáveis Declaradas"] = len(list(tree.filter(javalang.tree.LocalVariableDeclaration)))
+
+            # Estruturas de Controle
+            results["If/Else"] = len(list(tree.filter(javalang.tree.IfStatement)))
+            results["Switch/Case"] = len(list(tree.filter(javalang.tree.SwitchStatement)))
+            results["For Loops"] = len(list(tree.filter(javalang.tree.ForStatement)))
+            results["While Loops"] = len(list(tree.filter(javalang.tree.WhileStatement)))
+            results["Do-While Loops"] = len(list(tree.filter(javalang.tree.DoStatement)))
+
+            # Operadores
+            code_snippet = code
+            operators = {
+                "Aritméticos": ["+", "-", "*", "/", "%"],
+                "Comparação": ["==", "!=", ">", "<", ">=", "<="],
+                "Lógicos": ["&&", "||", "!"],
+                "Atribuição": ["+=", "-=", "*=", "/="],
+            }
+            for category, ops in operators.items():
+                results[category] = sum(code_snippet.count(op) for op in ops)
+
+            # Entrada/Saída e Strings
+            results["System.out.print"] = code_snippet.count("System.out.print")
+            results["Scanner"] = code_snippet.count("Scanner")
+            results["Concatenação de Strings"] = code_snippet.count("+")
+            string_methods = ["concat", "substring", "length", "equals", "compareTo"]
+            results["Métodos de String"] = sum(code_snippet.count(f".{method}(") for method in string_methods)
+
+        except Exception as e:
+            results["Erro"] = str(e)
+
+        return dict(results)
+
+    def analyze_oo(self, code: str) -> Dict[str, int]:
+        """Analisa elementos do paradigma OO"""
+        results = Counter()
+
+        try:
+            tree = javalang.parse.parse(code)
+
+            # Classes e Objetos
+            results["Classes"] = len(list(tree.filter(javalang.tree.ClassDeclaration)))
+            results["Objetos"] = len([
+                node for _, node in tree.filter(javalang.tree.VariableDeclarator) 
+                if node.initializer and "new" in str(node.initializer)
+            ])
+
+            # Métodos
+            results["Métodos"] = len(list(tree.filter(javalang.tree.MethodDeclaration)))
+
+            # Atributos e Encapsulamento
+            fields = list(tree.filter(javalang.tree.FieldDeclaration))
+            results["Atributos"] = len(fields)
+            results["Encapsulamento"] = sum(
+                1 for _, field in fields if "private" in field.modifiers
+            )
+
+            # Herança
+            results["Herança"] = len([
+                node for _, node in tree.filter(javalang.tree.ClassDeclaration) if node.extends
+            ])
+
+            # Polimorfismo
+            results["Polimorfismo"] = len([
+                node for _, node in tree.filter(javalang.tree.MethodDeclaration)
+                if "Override" in (node.annotations or [])
+            ])
+
+        except Exception as e:
+            results["Erro"] = str(e)
+
+        return dict(results)
+
+def process_files(files) -> List[Dict]:
+    """Processa múltiplos arquivos e analisa sintaxe e OO"""
+    analyzer = JavaSyntaxAnalyzer()
+    file_results = []
+
+    for file in files:
+        with open(file.name, 'r', encoding='utf-8') as f:
+            code = f.read()
+        syntax_results = analyzer.analyze_syntax(code)
+        oo_results = analyzer.analyze_oo(code)
+        
+        combined_results = {**syntax_results, **oo_results}
+        combined_results["Arquivo"] = file.name
+        file_results.append(combined_results)
+
+    return file_results
+
+# Interface Gradio
+with gr.Blocks(title="JAVA-Inspector") as demo:
+    gr.Markdown("# OO Paradigm and Syntax Inspector for Java Code")
+    gr.Markdown("Suba os arquivos Java para destrinchar as estruturas sintáticas e orientadas a objetos.")
+    
+    with gr.Row():
+        example_file_1 = gr.Button("Exemplo: Principal.java")
+        example_file_2 = gr.Button("Exemplo: Classe1.java")
+        example_file_3 = gr.Button("Exemplo: Classe2.java")
+
+    file_input = gr.File(label="Arquivos Java", file_types=[".java"], file_count="multiple")
+    output_table = gr.Dataframe(
+        label="Resultados", 
+        headers=[
+            "Arquivo", 
+            "Tipos Primitivos", "Constantes", "Variáveis Declaradas", "If/Else", "Switch/Case", 
+            "For Loops", "While Loops", "Do-While Loops", "Aritméticos", "Comparação", 
+            "Lógicos", "Atribuição", "System.out", "Scanner", "Concatenação", "Métodos de String", 
+            "Classes", "Objetos", "Métodos", "Atributos", "Encapsulamento", "Herança", "Polimorfismo"
+        ]
+    )
+
+    def analyze_files(files):
+        results = process_files(files)
+        # Converte os resultados para uma lista de listas para exibição na tabela
+        formatted_results = [
+            [
+                result["Arquivo"],
+                result.get("Tipos Primitivos", 0),
+                result.get("Constantes (final)", 0),
+                result.get("Variáveis Declaradas", 0),
+                result.get("If/Else", 0),
+                result.get("Switch/Case", 0),
+                result.get("For Loops", 0),
+                result.get("While Loops", 0),
+                result.get("Do-While Loops", 0),
+                result.get("Aritméticos", 0),
+                result.get("Comparação", 0),
+                result.get("Lógicos", 0),
+                result.get("Atribuição", 0),
+                result.get("System.out.print", 0),
+                result.get("Scanner", 0),
+                result.get("Concatenação de Strings", 0),
+                result.get("Métodos de String", 0),
+                result.get("Classes", 0),
+                result.get("Objetos", 0),
+                result.get("Métodos", 0),
+                result.get("Atributos", 0),
+                result.get("Encapsulamento", 0),
+                result.get("Herança", 0),
+                result.get("Polimorfismo", 0),
+            ]
+            for result in results
+        ]
+        return formatted_results
+
+    analyze_button = gr.Button("Analisar Arquivos")
+    analyze_button.click(fn=analyze_files, inputs=file_input, outputs=output_table)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

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