konpeito 0.1.0

data/tools/konpeito-asm/src/konpeito/runtime/KCrypto.java

@@ -0,0 +1,151 @@
+package konpeito.runtime;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.SecureRandom;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+/**
+ * KCrypto - Cryptographic operations for Konpeito JVM backend.
+ * Maps to KonpeitoCrypto Ruby module.
+ * Uses java.security.* and javax.crypto.* (no external dependencies).
+ */
+public class KCrypto {
+
+    private static final SecureRandom SECURE_RANDOM = new SecureRandom();
+    private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();
+
+    // ========================================================================
+    // Hash Functions
+    // ========================================================================
+
+    /** KonpeitoCrypto.sha256(data) -> String (hex) */
+    public static String sha256(String data) {
+        return hexDigest("SHA-256", data);
+    }
+
+    /** KonpeitoCrypto.sha512(data) -> String (hex) */
+    public static String sha512(String data) {
+        return hexDigest("SHA-512", data);
+    }
+
+    /** KonpeitoCrypto.sha256_binary(data) -> String (binary via ISO-8859-1) */
+    public static String sha256Binary(String data) {
+        return binaryDigest("SHA-256", data);
+    }
+
+    /** KonpeitoCrypto.sha512_binary(data) -> String (binary via ISO-8859-1) */
+    public static String sha512Binary(String data) {
+        return binaryDigest("SHA-512", data);
+    }
+
+    // ========================================================================
+    // HMAC
+    // ========================================================================
+
+    /** KonpeitoCrypto.hmac_sha256(key, data) -> String (hex) */
+    public static String hmacSha256(String key, String data) {
+        return hexHmac("HmacSHA256", key, data);
+    }
+
+    /** KonpeitoCrypto.hmac_sha512(key, data) -> String (hex) */
+    public static String hmacSha512(String key, String data) {
+        return hexHmac("HmacSHA512", key, data);
+    }
+
+    /** KonpeitoCrypto.hmac_sha256_binary(key, data) -> String (binary) */
+    public static String hmacSha256Binary(String key, String data) {
+        return binaryHmac("HmacSHA256", key, data);
+    }
+
+    // ========================================================================
+    // Random
+    // ========================================================================
+
+    /** KonpeitoCrypto.random_bytes(count) -> String (binary via ISO-8859-1) */
+    public static String randomBytes(long count) {
+        byte[] bytes = new byte[(int) Math.min(count, Integer.MAX_VALUE)];
+        SECURE_RANDOM.nextBytes(bytes);
+        return new String(bytes, StandardCharsets.ISO_8859_1);
+    }
+
+    /** KonpeitoCrypto.random_hex(count) -> String (hex, 2*count chars) */
+    public static String randomHex(long count) {
+        byte[] bytes = new byte[(int) Math.min(count, Integer.MAX_VALUE)];
+        SECURE_RANDOM.nextBytes(bytes);
+        return bytesToHex(bytes);
+    }
+
+    // ========================================================================
+    // Comparison
+    // ========================================================================
+
+    /** KonpeitoCrypto.secure_compare(a, b) -> boolean (constant-time) */
+    public static boolean secureCompare(String a, String b) {
+        byte[] aBytes = a.getBytes(StandardCharsets.UTF_8);
+        byte[] bBytes = b.getBytes(StandardCharsets.UTF_8);
+        if (aBytes.length != bBytes.length) return false;
+        int result = 0;
+        for (int i = 0; i < aBytes.length; i++) {
+            result |= aBytes[i] ^ bBytes[i];
+        }
+        return result == 0;
+    }
+
+    // ========================================================================
+    // Internal Helpers
+    // ========================================================================
+
+    private static String hexDigest(String algorithm, String data) {
+        try {
+            MessageDigest md = MessageDigest.getInstance(algorithm);
+            byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));
+            return bytesToHex(hash);
+        } catch (Exception e) {
+            throw new RuntimeException("Digest failed: " + e.getMessage(), e);
+        }
+    }
+
+    private static String binaryDigest(String algorithm, String data) {
+        try {
+            MessageDigest md = MessageDigest.getInstance(algorithm);
+            byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));
+            return new String(hash, StandardCharsets.ISO_8859_1);
+        } catch (Exception e) {
+            throw new RuntimeException("Digest failed: " + e.getMessage(), e);
+        }
+    }
+
+    private static String hexHmac(String algorithm, String key, String data) {
+        try {
+            Mac mac = Mac.getInstance(algorithm);
+            mac.init(new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm));
+            byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
+            return bytesToHex(hash);
+        } catch (Exception e) {
+            throw new RuntimeException("HMAC failed: " + e.getMessage(), e);
+        }
+    }
+
+    private static String binaryHmac(String algorithm, String key, String data) {
+        try {
+            Mac mac = Mac.getInstance(algorithm);
+            mac.init(new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm));
+            byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
+            return new String(hash, StandardCharsets.ISO_8859_1);
+        } catch (Exception e) {
+            throw new RuntimeException("HMAC failed: " + e.getMessage(), e);
+        }
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        char[] hex = new char[bytes.length * 2];
+        for (int i = 0; i < bytes.length; i++) {
+            int v = bytes[i] & 0xFF;
+            hex[i * 2] = HEX_CHARS[v >>> 4];
+            hex[i * 2 + 1] = HEX_CHARS[v & 0x0F];
+        }
+        return new String(hex);
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KFile.java

@@ -0,0 +1,100 @@
+package konpeito.runtime;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+/**
+ * KFile - File I/O operations for Konpeito JVM backend.
+ * Maps to KonpeitoFile Ruby module (JVM-only).
+ * Uses java.nio.file.* (Java 7+).
+ */
+public class KFile {
+
+    /** KonpeitoFile.read(path) -> String */
+    public static String read(String path) {
+        try {
+            return Files.readString(Path.of(path), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            throw new RuntimeException("File read failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoFile.write(path, content) -> String (content) */
+    public static String write(String path, String content) {
+        try {
+            Files.writeString(Path.of(path), content, StandardCharsets.UTF_8);
+            return content;
+        } catch (IOException e) {
+            throw new RuntimeException("File write failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoFile.exist?(path) -> boolean */
+    public static boolean exists(String path) {
+        return Files.exists(Path.of(path));
+    }
+
+    /** KonpeitoFile.delete(path) -> boolean */
+    public static boolean delete(String path) {
+        try {
+            return Files.deleteIfExists(Path.of(path));
+        } catch (IOException e) {
+            throw new RuntimeException("File delete failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoFile.size(path) -> long */
+    public static long size(String path) {
+        try {
+            return Files.size(Path.of(path));
+        } catch (IOException e) {
+            throw new RuntimeException("File size failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoFile.readlines(path) -> KArray<String> */
+    public static KArray<String> readlines(String path) {
+        try {
+            List<String> lines = Files.readAllLines(Path.of(path), StandardCharsets.UTF_8);
+            KArray<String> result = new KArray<>();
+            for (String line : lines) {
+                result.add(line);
+            }
+            return result;
+        } catch (IOException e) {
+            throw new RuntimeException("File readlines failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoFile.basename(path) -> String */
+    public static String basename(String path) {
+        Path p = Path.of(path).getFileName();
+        return p != null ? p.toString() : "";
+    }
+
+    /** KonpeitoFile.dirname(path) -> String */
+    public static String dirname(String path) {
+        Path p = Path.of(path).getParent();
+        return p != null ? p.toString() : ".";
+    }
+
+    /** KonpeitoFile.extname(path) -> String */
+    public static String extname(String path) {
+        String name = Path.of(path).getFileName().toString();
+        int dot = name.lastIndexOf('.');
+        return dot > 0 ? name.substring(dot) : "";
+    }
+
+    /** KonpeitoFile.mkdir(path) -> boolean */
+    public static boolean mkdir(String path) {
+        try {
+            Files.createDirectories(Path.of(path));
+            return true;
+        } catch (IOException e) {
+            throw new RuntimeException("mkdir failed: " + e.getMessage(), e);
+        }
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KHTTP.java

@@ -0,0 +1,113 @@
+package konpeito.runtime;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.util.Map;
+
+/**
+ * KHTTP - HTTP client for Konpeito JVM backend.
+ * Maps to KonpeitoHTTP Ruby module.
+ * Uses java.net.http.HttpClient (Java 11+).
+ */
+public class KHTTP {
+    private static final HttpClient CLIENT = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .connectTimeout(Duration.ofSeconds(30))
+            .build();
+
+    /** KonpeitoHTTP.get(url) -> String (body) */
+    public static String get(String url) {
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .timeout(Duration.ofSeconds(30))
+                    .GET()
+                    .build();
+            HttpResponse<String> response = CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
+            return response.body();
+        } catch (Exception e) {
+            throw new RuntimeException("HTTP GET failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoHTTP.post(url, body) -> String (body) */
+    public static String post(String url, String body) {
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .timeout(Duration.ofSeconds(30))
+                    .POST(HttpRequest.BodyPublishers.ofString(body != null ? body : ""))
+                    .header("Content-Type", "application/json")
+                    .build();
+            HttpResponse<String> response = CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
+            return response.body();
+        } catch (Exception e) {
+            throw new RuntimeException("HTTP POST failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoHTTP.get_response(url) -> KHash {status, body, headers} */
+    @SuppressWarnings("unchecked")
+    public static KHash<String, Object> getResponse(String url) {
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .timeout(Duration.ofSeconds(30))
+                    .GET()
+                    .build();
+            HttpResponse<String> response = CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
+            return buildResponseHash(response);
+        } catch (Exception e) {
+            throw new RuntimeException("HTTP GET failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoHTTP.request(method, url, body, headers) -> KHash */
+    @SuppressWarnings("unchecked")
+    public static KHash<String, Object> request(String method, String url, String body, KHash<String, String> headers) {
+        try {
+            HttpRequest.Builder builder = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .timeout(Duration.ofSeconds(30));
+
+            // Set method and body
+            if (body != null && !body.isEmpty()) {
+                builder.method(method.toUpperCase(), HttpRequest.BodyPublishers.ofString(body));
+            } else {
+                builder.method(method.toUpperCase(), HttpRequest.BodyPublishers.noBody());
+            }
+
+            // Set custom headers
+            if (headers != null) {
+                for (Map.Entry<String, String> entry : headers.entrySet()) {
+                    builder.header(entry.getKey(), entry.getValue());
+                }
+            }
+
+            HttpResponse<String> response = CLIENT.send(builder.build(), HttpResponse.BodyHandlers.ofString());
+            return buildResponseHash(response);
+        } catch (Exception e) {
+            throw new RuntimeException("HTTP request failed: " + e.getMessage(), e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static KHash<String, Object> buildResponseHash(HttpResponse<String> response) {
+        KHash<String, Object> result = new KHash<>();
+        result.put("status", (long) response.statusCode());
+        result.put("body", response.body());
+
+        // Build headers hash
+        KHash<String, Object> headersHash = new KHash<>();
+        response.headers().map().forEach((key, values) -> {
+            if (!values.isEmpty()) {
+                headersHash.put(key, values.get(0));
+            }
+        });
+        result.put("headers", headersHash);
+        return result;
+    }
+}

data/tools/konpeito-asm/src/konpeito/runtime/KHash.java

@@ -0,0 +1,228 @@
+package konpeito.runtime;
+
+import java.util.*;
+
+/**
+ * KHash - Ruby Hash implementation for JVM backend.
+ *
+ * Implements java.util.Map<K,V> via composition (wrapping LinkedHashMap<K,V>),
+ * providing both Java collection interop and Ruby-specific methods.
+ * LinkedHashMap preserves insertion order, matching Ruby Hash semantics.
+ *
+ * @param <K> Key type
+ * @param <V> Value type
+ */
+public class KHash<K, V> implements Map<K, V> {
+    private final LinkedHashMap<K, V> data;
+
+    // ========================================================================
+    // Constructors
+    // ========================================================================
+
+    public KHash() {
+        this.data = new LinkedHashMap<>();
+    }
+
+    public KHash(Map<? extends K, ? extends V> m) {
+        this.data = new LinkedHashMap<>(m);
+    }
+
+    // ========================================================================
+    // Ruby-specific methods
+    // ========================================================================
+
+    /** Ruby: hash.deconstruct_keys(keys) — returns self (for pattern matching) */
+    @SuppressWarnings("unchecked")
+    public KHash<K, V> deconstruct_keys(Object keys) {
+        // In Ruby, deconstruct_keys returns a hash with only the specified keys.
+        // For simplicity, return self — the pattern matcher will check keys individually.
+        return this;
+    }
+
+    /** Ruby: hash.length / hash.size — returns long (Ruby Integer) */
+    public long length() {
+        return data.size();
+    }
+
+    /** Ruby: hash.has_key?(key) / hash.key?(key) */
+    public boolean hasKey(K key) {
+        return data.containsKey(key);
+    }
+
+    /** Ruby: hash.has_value?(value) / hash.value?(value) */
+    public boolean hasValue(V value) {
+        return data.containsValue(value);
+    }
+
+    /** Ruby: hash.keys — returns KArray */
+    public KArray<K> rubyKeys() {
+        return new KArray<>(data.keySet());
+    }
+
+    /** Ruby: hash.values — returns KArray */
+    public KArray<V> rubyValues() {
+        return new KArray<>(data.values());
+    }
+
+    /** Ruby: hash.empty? */
+    public boolean isEmpty_() {
+        return data.isEmpty();
+    }
+
+    /** Ruby: hash.fetch(key, default) */
+    public V fetch(K key, V defaultValue) {
+        V value = data.get(key);
+        return value != null ? value : defaultValue;
+    }
+
+    /** Ruby: hash.merge(other) — returns new hash */
+    public KHash<K, V> merge(KHash<K, V> other) {
+        KHash<K, V> result = new KHash<>(this.data);
+        result.data.putAll(other.data);
+        return result;
+    }
+
+    /** Ruby: hash.to_a — returns array of [key, value] pairs */
+    public KArray<KArray<Object>> toArray_() {
+        KArray<KArray<Object>> result = new KArray<>();
+        for (Map.Entry<K, V> entry : data.entrySet()) {
+            KArray<Object> pair = new KArray<>(2);
+            pair.add(entry.getKey());
+            pair.add(entry.getValue());
+            result.add(pair);
+        }
+        return result;
+    }
+
+    /** Ruby: hash.count (without block) */
+    public long count() {
+        return data.size();
+    }
+
+    /** Ruby: hash.merge!(other) / hash.update(other) — mutating merge */
+    @SuppressWarnings("unchecked")
+    public KHash<K, V> mergeInPlace(KHash<K, V> other) {
+        this.data.putAll(other.data);
+        return this;
+    }
+
+    /** Ruby: hash.each_key { |k| ... } support — returns keys as KArray */
+    public KArray<K> eachKeys() {
+        return new KArray<>(data.keySet());
+    }
+
+    /** Ruby: hash.each_value { |v| ... } support — returns values as KArray */
+    public KArray<V> eachValues() {
+        return new KArray<>(data.values());
+    }
+
+    // ========================================================================
+    // Map<K,V> interface delegation
+    // ========================================================================
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return data.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return data.containsValue(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return data.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        return data.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        return data.remove(key);
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        data.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return data.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return data.values();
+    }
+
+    @Override
+    public Set<Map.Entry<K, V>> entrySet() {
+        return data.entrySet();
+    }
+
+    // ========================================================================
+    // Ruby-compatible toString: {"a" => 1, "b" => 2}
+    // ========================================================================
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("{");
+        boolean first = true;
+        for (Map.Entry<K, V> entry : data.entrySet()) {
+            if (!first) sb.append(", ");
+            first = false;
+            K key = entry.getKey();
+            V value = entry.getValue();
+            if (key instanceof String) {
+                sb.append("\"").append(key).append("\"");
+            } else {
+                sb.append(key);
+            }
+            sb.append(" => ");
+            if (value instanceof String) {
+                sb.append("\"").append(value).append("\"");
+            } else {
+                sb.append(value);
+            }
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o instanceof KHash) {
+            return data.equals(((KHash<?, ?>) o).data);
+        }
+        if (o instanceof Map) {
+            return data.equals(o);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return data.hashCode();
+    }
+}