rinru 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a738e53fa302793dce1926e5911d2f90281ecf114f12f0a987c477c1c2f47f28
-  data.tar.gz: 9a4b037d240916b2a14226020dcacc4786b2a3bb960ca134a5d79170ebc9eaa9
+  metadata.gz: ac0bc5ee73902ad4542818e6d50b8ba0c7733bd6ee06b5cba09c8dc70dd506e3
+  data.tar.gz: 01eabee27c2d447009b868500803a429477d1d30f32f62bc0b43ed0a7b0a37af
 SHA512:
-  metadata.gz: d211f7e8baa57b11c7583df4e53cb4c4c5520f602b613ed39b80194d30b2c9b04c3394ddce04c182b08009d55e1b4cf55125fed2d0b20ff9b097e50276232ac1
-  data.tar.gz: dd04b42572fa4c6d647f30a3179583ce5a747af6263c08869890b4ee42c697e0ab4e0878e92719f236f0455656178aa7e8eb3293d59641a4737c7a27ab07ced9
+  metadata.gz: 4acd173d7fd1f334d598d67eee162437b7c51631098b8d4b042f924de08bd45194f86a8c2cf6e3d0df77d30611a477ac35c2726e847cf3fc4ed42d6087df1960
+  data.tar.gz: 332c13431fc377ab5ad389c6073d7eae1cb8556f411ff06621816b95a99721628c550659cb415b1eabd2968e29af04904746d457474092bac3276969549f38e8

data/README.md

@@ -0,0 +1,92 @@
+# Rinru
+
+Rinru (Rust-in-Ruby) is a lightning-fast, zero-boilerplate framework distributed as a self-contained Ruby gem. It allows you to write and compile complete Rust code ecosystems natively and inject them directly into your running Ruby scripts as global methods.
+
+## Features
+
+- **Fluent Injection Pipeline:** Link a Cargo configuration and `.rs` source file straight to a global method name out of thin air.
+- **Embedded Toolchain:** Carries its own private copy of the Rust compiler binary. Users do not need rustup or system-wide Rust paths configured to use it.
+- **Dynamic Variable Ingestion:** Accepts numbers, floating points, and text strings from Ruby, coordinating all FFI pointer allocations automatically.
+- **Incremental MD5 Caching:** Skips compiling on subsequent runs if your Rust files have not changed, keeping execution overhead at zero.
+- **Graceful Error Catching:** Intercepts Rust syntax compilation errors (stderr) and formats them into clean Ruby exception logs rather than crashing your terminal runtime.
+
+## Installation
+
+You can install the self-contained framework directly onto your system using:
+
+```bash
+gem install rinru
+```
+
+Or add this line to your application's Gemfile:
+
+```ruby
+gem 'rinru'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### 1. Setup a standard Cargo Project Layout
+
+Create a project manifest folder (`project/Cargo.toml`):
+
+```toml
+[package]
+name = "rinru_math_engine"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+evalexpr = "8.1"
+```
+
+Write your high-performance code inside your target source file (`project/src/main.rs`):
+
+```rust
+fn main(expression_ptr: *const std::os::raw::c_char) -> i32 {
+    if expression_ptr.is_null() { return 0; }
+    
+    let c_str = unsafe { std::ffi::CStr::from_ptr(expression_ptr) };
+    let expr_str = c_str.to_str().unwrap_or("0");
+
+    // Let the evalexpr crate parse and compute the string operations natively
+    match evalexpr::eval_int(expr_str) {
+        Ok(result) => result as i32,
+        Err(_) => 0,
+    }
+}
+```
+
+### 2. Run it in your Ruby Script
+
+Simply chain your configurations together. Once declared, you invoke the variable name as a top-level native Ruby method:
+
+```ruby
+require 'rinru'
+
+# Chain cargo parsing straight into your target method injection
+rinru.cargo("project/Cargo.toml").var("project/src/main.rs").as("main")
+
+# Pass raw math string expressions. Rust calculates the order of operations natively!
+puts main("5 * (10 + 20) - 5")
+# => 145
+```
+
+## How It Works Under the Hood
+
+1. **`rinru.cargo().var()`** maps out the locations of your source script files.
+2. **`.as("main")`** invokes Rinru's internal rustc environment compiler. It reviews an MD5 hash of your code state. If unchanged, it pulls the library straight from cache; otherwise, it silently generates an optimized release binary `.so`/`.dylib`.
+3. **Dynamic FFI Proxying:** It automatically binds the binary function directly into Ruby's root Kernel workspace, letting you invoke the method natively anywhere in your application.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org).

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: rinru
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
-- Developer
+- ''
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -27,11 +27,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/rinru.rb
-homepage: https://github.com
-licenses:
-- MIT
-metadata: {}
+homepage: https://github.com/coder2h2/rinru
+licenses: []
+metadata:
+  homepage_uri: https://github.com/coder2h2/rinru
 rdoc_options: []
 require_paths:
 - lib
@@ -39,7 +40,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.3.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -48,5 +49,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.22
 specification_version: 4
-summary: Rust-in-Ruby runtime variable method injector framework.
+summary: Rinru - Portable self-contained Rust engine.
 test_files: []