Metadata-Version: 2.4
Name: java-magic
Version: 0.1.5
Summary: Magic cell para ejecutar Java de forma interactiva en Jupyter y Colab
Project-URL: Homepage, https://github.com/mgarcesdev/java-magic
Author-email: Manuel <manuegp1994@gmail.com>
Classifier: Framework :: IPython
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Requires-Python: >=3.7
Requires-Dist: ipython>=7.0.0
Requires-Dist: traitlets>=5.0.0
Description-Content-Type: text/markdown

# Java Magic for Google Colab

A lightweight Jupyter Notebook extension to write, compile, and execute Java code directly inside cells. It features automatic Google Colab setup and real-time interactive console input support (Scanner, System.in).

## 🛠️ Installation

```bash
pip install java-magic
```

## 🚀 Quick Start

1. Load the extension
   In your first notebook cell, load the magic:

```python
%load_ext java_magic
```

2. Run standard Java code
   You don't even need a main class wrapper for simple snippets; the extension handles it automatically:

```java
%%java
System.out.println("Hello from Jupyter!");
```

💡 **Tip: Syntax Highlighting**

By default, Jupyter notebooks might not highlight Java code inside custom magic cells. To enable syntax highlighting, simply add `%%js` right next to the magic command like this:

```java
%%java %%js
System.out.println("This code will be colored!");
```

3. Run interactive Java code
   If the extension detects Scanner or System.in, it automatically switches to an interactive terminal loop:
   (Tip: Add `%js` to )

```java
%%java %%js
import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name + "!");
```

4. **Multi-cell Execution**
   You can define a class in one cell and use it in another!

   **Cell 1: Define a class**

```java
%%java %%js
package math;

/**
 * Clase de utilidad para operaciones matemáticas básicas.
 */
public class Calculadora {

    /**
     * Suma dos números enteros.
     * @param a El primer operando.
     * @param b El segundo operando.
     * @return La suma de a y b.
     */
    public static int sumar(int a, int b) {
        return a + b;
    }
}
```

**Cell 2: Use the class**

```java
%%java %%js
import math.Calculadora;

int x = 10;
int y = 25;
int resultado = Calculadora.sumar(x, y);

System.out.println("El resultado de la suma es: " + resultado);
```

## 📚 Generate JavaDoc

You can easily render interactive HTML documentation right inside your notebook using the `%javadoc` magic command.

By default, the extension automatically deletes generated `.java` files after compilation to keep your workspace clean. Only the compiled `.class` files are preserved so you can use them across different cells.

However, if you want to generate documentation using Javadoc, the source code must be present in the directory.

```python
%config JavaMagics.remove_java_file = False
```

Run your cell normally (e.g., the one containing math.Calculadora). Since the configuration was changed, both the `.class` and the `.java` files will now be saved in your environment.

Now you can pass the path of the `.java` file to the `%javadoc` line magic to display the interactive, scrollable HTML documentation directly inside your notebook:

```java
%javadoc math/Calculadora.java
```

## 🧠 Technical Details & Architecture

When you run a cell, the extension creates physical `.java` and `.class` files in your environment's current working directory (e.g., Google Colab's `/content`). You can verify they exist by running:

```
!ls *.java *.class
```

How it differs from IJava
Unlike the IJava kernel, this extension is not a continuous REPL. State is not saved: Variables declared in one cell (e.g., `int x = 5;`) do not persist in memory for the next cell.

📄 License
MIT
