0.0.1

Author: oovm

.gitignore

@@ -17,6 +17,7 @@ Cargo.lock
 node_modules/
 cache/
 dist/
+pnpm-lock.yaml
 
 # Logs
 *.txt

Cargo.toml

@@ -1,29 +1,23 @@
 [workspace]
 resolver = "3"
 members = [
-    "compilers/ruby",
-    "compilers/ruby-macros",
-    "compilers/ruby-tools",
-    "compilers/ruby-types",
+    "compilers/*",
 ]
 default-members = [
-    "compilers/ruby",
-    "compilers/ruby-macros",
-    "compilers/ruby-tools",
-    "compilers/ruby-types",
+    "compilers/*",
 ]
 
 
 [workspace.package]
-version = "0.0.0"
+version = "0.0.1"
 edition = "2024"
 authors = ["RBQ Team"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/nyar-vm/rusty-ruby"
 
 [workspace.dependencies]
 async-stream = "0.3"
-tokio = { version = "1.36", features = ["rt-multi-thread", "macros", "net", "time", "sync", "io-util"] }
+tokio = { version = "1.36", features = ["rt-multi-thread", "macros", "net", "time", "sync", "io-util", "io-std"] }
 async-trait = { version = "0.1" }
 serde = { version = "1.0.227", features = ["derive"] }
 serde_json = "1.0"
@@ -41,20 +35,32 @@ chrono = { version = "0.4", features = ["serde"] }
 dashmap = "6.1.0"
 bytes = "1.5"
 byteorder = "1.5"
+libloading = "0.8.1"
+cranelift = "0.103.0"
+cranelift-codegen = "0.103.0"
+cranelift-frontend = "0.103.0"
+cranelift-module = "0.103.0"
+cranelift-jit = "0.103.0"
 
 # Oak parsers
-oak-lsp = { path = "../oaks/projects/oak-lsp", version = "0.0.9" }
-oak-core = { path = "../oaks/projects/oak-core", version = "0.0.9" }
-oak-vfs = { path = "../oaks/projects/oak-vfs", version = "0.0.9" }
-oak-mcp = { path = "../oaks/projects/oak-mcp", version = "0.0.9" }
-oak-json = { path = "../oaks/examples/oak-json", version = "0.0.9" }
-oak-toml = { path = "../oaks/examples/oak-toml", version = "0.0.9" }
-oak-ruby = { path = "../oaks/examples/oak-ruby", version = "0.0.9" }
+oak-lsp = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-core = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-vfs = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-mcp = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-json = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-toml = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
+oak-ruby = { git = "https://github.com/ygg-lang/oaks.git", branch = "dev", version = "0.0.10" }
 
 # Rusty Ruby crates
-ruby-types = { path = "compilers/ruby-types" }
+ruby-types = { path = "compilers/ruby-types" , version = "0.0.1" }
+ruby-ir = { path = "compilers/ruby-ir" , version = "0.0.1" }
+ruby = { path = "compilers/ruby" , version = "0.0.1" }
 
 # Macro dependencies
 syn = { version = "2.0", features = ["full", "extra-traits"] }
 quote = "1.0"
 proc-macro2 = "1.0"
+
+# WASM dependencies
+wasm-bindgen = "0.2.92"
+wasm-bindgen-futures = "0.4.42"

Readme.md

@@ -1,15 +1,66 @@
-Rust Template Project
-=====================
+# Rusty Ruby
 
-Rust template project for monorepo
+A modern, high-performance Ruby implementation written in Rust, designed for speed, safety, and reliability.
 
-## Change the initial commit
+## 🎯 Project Overview
 
-```shell
-git commit --amend --message "🎂 Project initialized!" --date "2012-12-12"
+Rusty Ruby is a comprehensive Ruby implementation that combines the elegance of Ruby with the performance and safety of Rust. It features a multi-tier compilation architecture, advanced garbage collection, and a rich ecosystem of tools and libraries.
+
+## 🌟 Key Features
+
+- **Multi-tier Compilation**: Interpreter, baseline compiler, and optimizing compiler for balanced performance
+- **Advanced Garbage Collection**: Generational, incremental, and concurrent GC strategies
+- **JIT Compilation**: Just-In-Time compilation for hot code paths
+- **WebAssembly Support**: Run Ruby code in the browser with WASI
+- **Language Server Protocol**: Modern IDE integration
+- **Comprehensive Tooling**: Pure Rust implementations of ruby, irb, gem, rake, rdoc, ri, and testrb
+- **Type Safety**: Core type definitions for seamless Rust-Ruby integration
+- **Macros**: Procedural macros for easy Ruby class and method definition in Rust
+
+## 🚀 Quick Start
+
+```bash
+# Build the project
+cargo build
+
+# Run Ruby scripts
+cargo run --bin ruby script.rb
+
+# Start interactive Ruby shell
+cargo run --bin irb
+```
+
+## 📁 Project Structure
+
+The Rusty Ruby project is organized into multiple crates:
+
+- **compilers/ruby**: Main Ruby compiler and runtime
+- **compilers/ruby-ir**: Intermediate Representation for Ruby code
+- **compilers/ruby-lsp**: Language Server Protocol implementation
+- **compilers/ruby-macros**: Procedural macros for Ruby integration
+- **compilers/ruby-tools**: Ruby language tools (ruby, irb, gem, etc.)
+- **compilers/ruby-types**: Core type definitions
+- **compilers/ruby-wasi**: WebAssembly support
+- **frontends/ruby-ts**: TypeScript frontend for WASM integration
+
+## 🔧 Development
+
+```bash
+# Run tests
+cargo test
+
+# Build in release mode
+cargo build --release
+
+# Run benchmarks
+cargo bench
 ```
 
-## Emoji Comment
+## 🤝 Contributing
+
+Contributions are welcome! Feel free to open issues or submit pull requests to help improve Rusty Ruby.
+
+## 📄 Emoji Guide
 
 | Emoji  | Meaning                      |  
 |--------|------------------------------|  

biome.json

@@ -0,0 +1,32 @@
+{
+    "$schema": "https://biomejs.dev/schemas/1.8.0/schema.json",
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineWidth": 100
+    },
+    "javascript": {
+        "formatter": {
+            "arrowParentheses": "always",
+            "bracketSameLine": false,
+            "bracketSpacing": true,
+            "jsxQuoteStyle": "double",
+            "quoteProperties": "asNeeded",
+            "semicolons": "always",
+            "trailingCommas": "all"
+        }
+    },
+    "json": {
+        "formatter": {
+            "enabled": true,
+            "indentWidth": 4
+        },
+        "parser": {
+            "allowComments": true
+        }
+    },
+    "files": {
+        "ignore": ["**/node_modules", "**/target", "**/dist", "**/.git", "**/public"]
+    }
+}

compilers/ruby-ir/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "ruby-ir"
+version.workspace = true
+description = "Intermediate Representation for Ruby code"
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+
+[dependencies]
+ruby-types = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }

compilers/ruby-ir/readme.md

@@ -0,0 +1,123 @@
+# Ruby IR
+
+Intermediate Representation for Ruby code in Rusty Ruby, providing a foundation for optimization and code generation.
+
+## 🎯 Project Overview
+
+Ruby-IR is a crate that provides the intermediate representation (IR) for Ruby code compilation in the Rusty Ruby project. It defines the data structures and traversal utilities for representing Ruby code in a form suitable for optimization and code generation.
+
+## 🌟 Key Features
+
+- **Abstract Syntax Tree (AST) Representation**: Structured representation of Ruby code
+- **Traversal Utilities**: Tools for navigating and manipulating IR nodes
+- **Serialization Support**: Convert IR objects to and from serialized formats
+- **Optimization Framework**: Foundation for code optimization passes
+- **Integration**: Seamlessly works with other Rusty Ruby components
+
+## 🚀 Quick Start
+
+```rust
+use ruby_ir::*;
+
+// Create IR nodes
+let expression = Expression::Constant(Constant::Integer(42));
+
+// Traverse and manipulate IR
+struct MyVisitor;
+
+impl Visitor for MyVisitor {
+    fn visit_expression(&mut self, expr: &Expression) {
+        match expr {
+            Expression::Constant(constant) => println!("Found constant: {:?}", constant),
+            _ => {}
+        }
+    }
+}
+
+let mut visitor = MyVisitor;
+visitor.visit_expression(&expression);
+```
+
+## 🏗️ Architecture
+
+### Core Components
+
+- **Expressions**: Represent Ruby expressions like constants, variables, method calls, etc.
+- **Statements**: Represent Ruby statements like assignments, conditionals, loops, etc.
+- **Symbols**: Represent Ruby symbols and identifiers
+- **Types**: Represent Ruby types and type information
+- **Traversal**: Utilities for visiting and manipulating IR nodes
+
+### Optimization Passes
+
+- **Constant Folding**: Evaluate constant expressions at compile time
+- **Dead Code Elimination**: Remove unreachable code
+- **Inline Expansion**: Inline method calls for better performance
+- **Type Inference**: Infer types for variables and expressions
+
+## 🛠️ Development
+
+```bash
+# Build the project
+cargo build
+
+# Run tests
+cargo test
+
+# Build in release mode
+cargo build --release
+```
+
+## 📚 Usage Examples
+
+### Basic IR Creation
+
+```rust
+use ruby_ir::*;
+
+// Create a binary expression: 1 + 2
+let left = Expression::Constant(Constant::Integer(1));
+let right = Expression::Constant(Constant::Integer(2));
+let add_expr = Expression::BinaryOp(
+    BinaryOp::Add,
+    Box::new(left),
+    Box::new(right)
+);
+
+// Create an assignment statement
+let variable = Expression::Variable("result".to_string());
+let assignment = Statement::Assignment(
+    Box::new(variable),
+    Box::new(add_expr)
+);
+
+// Create a program
+let program = Program {
+    statements: vec![assignment]
+};
+```
+
+### IR Traversal
+
+```rust
+use ruby_ir::*;
+
+struct ConstantCollector {
+    constants: Vec<Constant>
+}
+
+impl Visitor for ConstantCollector {
+    fn visit_constant(&mut self, constant: &Constant) {
+        self.constants.push(constant.clone());
+    }
+}
+
+let mut collector = ConstantCollector { constants: vec![] };
+collector.visit_program(&program);
+
+println!("Found constants: {:?}", collector.constants);
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Feel free to open issues or submit pull requests to help improve Ruby-IR.