Roll back to 0.9.60 and scaffold monorepo

Author: only-cliches

.gitignore

@@ -1,8 +1,21 @@
-no_proto_rs/target
+.DS_Store
+**/.DS_Store
 **/*.rs.bk
-no_proto_rs/Cargo.lock
 test.json
 
-bench/target/**/*
-no_proto_js/target/**/*
-target/**/*
+# Rust
+target/
+**/target/
+no_proto_rs/Cargo.lock
+
+# JavaScript / TypeScript
+node_modules/
+dist/
+coverage/
+
+# PHP
+vendor/
+composer.lock
+
+# Go
+bin/

Cargo.toml

@@ -0,0 +1,7 @@
+[workspace]
+members = [
+    "bench",
+    "no_proto_js",
+    "no_proto_rs",
+]
+resolver = "1"

README.md

@@ -8,6 +8,20 @@
 [![crates.io](https://img.shields.io/crates/v/no_proto.svg)](https://crates.io/crates/no_proto)
 [![docs.rs](https://docs.rs/no_proto/badge.svg)](https://docs.rs/no_proto/latest/no_proto/)
 [![GitHub stars](https://img.shields.io/github/stars/only-cliches/NoProto.svg?style=social&label=Star&maxAge=2592000)](https://GitHub.com/only-cliches/NoProto/stargazers/)
+
+### Monorepo Status
+
+The stable Rust implementation is pinned to `no_proto` `0.9.60`. The experimental `0.10.0` refactor has been abandoned so future work can focus on a language-neutral NoProto specification and compatible implementations.
+
+Repository layout:
+
+- `no_proto_rs/` - stable Rust crate and current reference implementation.
+- `no_proto_js/` - existing Rust/WASM JavaScript package.
+- `packages/` - home for native language implementations such as JavaScript, PHP, and Go.
+- `spec/` - shared NoProto format and schema specification.
+- `conformance/` - cross-language compatibility test plan and fixtures.
+- `bench/` - Rust benchmark suite.
+
 ### Features  
 
 **Lightweight**<br/>
@@ -315,4 +329,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE. 
+SOFTWARE.

bench/src/run_bench_no_proto.rs

@@ -75,7 +75,7 @@ impl NoProtoBench {
     }
 
     #[inline(always)]
-    fn get_factory() -> Result<NP_Factory, NP_Error> {
+    fn get_factory<'get>() -> Result<NP_Factory<'get>, NP_Error> {
 
 //         NP_Factory::new_bytes(&SCHEMA)
         NP_Factory::new(r#"

conformance/README.md

@@ -0,0 +1,26 @@
+# NoProto Conformance
+
+This directory is for shared compatibility fixtures used by every language implementation.
+
+The conformance suite should prove that each implementation can parse the same schemas, encode the same values, decode the same buffers, and export the same JSON-compatible data as `no_proto_rs` `0.9.60`.
+
+## Fixture Shape
+
+Use one directory per case:
+
+```text
+conformance/cases/<case-name>/
+  schema.json
+  schema.idl
+  input.json
+  buffer.hex
+  output.json
+```
+
+- `schema.json` is the canonical schema when JSON schema syntax is available.
+- `schema.idl` is the IDL form when the case covers IDL parsing.
+- `input.json` is the value to encode.
+- `buffer.hex` is the canonical encoded buffer as lowercase hexadecimal.
+- `output.json` is the expected exported value after decoding.
+
+Language packages should load these fixtures directly instead of duplicating them.

docs/monorepo.md

@@ -0,0 +1,26 @@
+# NoProto Monorepo
+
+NoProto is moving from a single Rust crate repository toward a language implementation monorepo. The Rust crate remains the reference implementation at version `0.9.60` while the shared specification and conformance suite are extracted.
+
+## Layout
+
+- `no_proto_rs/` contains the Rust crate published as `no_proto`.
+- `no_proto_js/` contains the existing Rust/WASM JavaScript package.
+- `packages/javascript/` is reserved for a native JavaScript or TypeScript implementation.
+- `packages/php/` is reserved for a native PHP implementation.
+- `packages/go/` is reserved for a native Go implementation.
+- `spec/` contains the language-neutral format and schema specification.
+- `conformance/` contains shared test vectors and compatibility requirements.
+- `bench/` contains the existing Rust benchmark suite.
+
+## Implementation Rules
+
+Every language package should implement the behavior described by `spec/` and validate against `conformance/` before release.
+
+The Rust crate is the compatibility anchor until the specification is complete. If a behavior is not yet documented in `spec/`, match `no_proto_rs` version `0.9.60`.
+
+Language packages should not introduce incompatible buffer, schema, or JSON conversion behavior without first updating the specification and adding conformance coverage.
+
+## Versioning
+
+Package versions should track the NoProto compatibility level they implement. A package that targets the stable Rust crate behavior should start from the `0.9.60` compatibility line, even if its own package ecosystem requires a different release format.

idl.graphql

@@ -0,0 +1,51 @@
+// WIP IDL ideas...
+
+// this is a comment
+struct({fiels: {
+    name: string({default: "default value here", size: 20}),
+    tags: list({of: string()}),
+    tuple: tuple({sorted: true, values: [string(), string(), string()]}),
+    map: map({values: string()}),
+    // another comment
+    enum: option({default: "red", choices: ["red", "blue", "orange"]}),
+    p: portal({to: "map"}),
+    nested: struct({fiels: {
+        name: string(),
+        value: u32({default: 20}),
+        geo: geo({size: 4, default: {lat: 20, lng: 20.28}}),
+    }})
+}});
+
+
+
+rpc_spec({
+    name: "Test API",
+    author: "hello",
+    version: "1.0.0",
+    spec: (self, mod) => {
+        msg("send_name", struct());
+        rpc("your_face", fn(self.send_name), option(self.send_name));
+        rpc("your_face", fn(self.argument), result(self.send_name, self.error));
+        rpc("your_face", fn(self.argument), empty());
+        mod("mod_name", (self) => {
+
+        });
+    }
+});
+
+struct({
+    name: string(),
+    age:  u16({default: 0}),
+    tags: list({of: string()})
+});
+
+//! let user_factory = NP_Factory::new(r#"{
+//!     "type": "struct",
+//!     "fields": [
+//!         ["name",   {"type": "string"}],
+//!         ["age",    {"type": "u16", "default": 0}],
+//!         ["tags",   {"type": "list", "of": {
+//!             "type": "string"
+//!         }}]
+//!     ]
+//! }"#)?;

idl.js

@@ -16,4 +16,6 @@ keywords = ["protocol-buffers", "grpc", "avro", "database", "json"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
+np_rpc = []
+default = ["np_rpc"]
 

no_proto_rs/Cargo.toml

@@ -5,47 +5,47 @@ use crate::error::NP_Error;
 
 pub static SEED: u32 = 2181155409;
 
-#[derive(Debug, Clone)]
-pub struct NP_HashMap<V> {
-    data: Vec<Vec<(u32, V)>>
+#[derive(Debug)]
+pub struct NP_HashMap {
+    data: Vec<Vec<(String, usize)>>
 }
 
-const HASH_SIZE: usize = 4096;
+const HASH_SIZE: usize = 2048;
 
-impl<V> NP_HashMap<V> {
+impl NP_HashMap {
 
     pub fn empty() -> Self {
         Self { data: Vec::with_capacity(1) }
     }
 
     pub fn new() -> Self {
         let mut vector = Vec::with_capacity(HASH_SIZE);
-        vector.extend((0..HASH_SIZE).map(|_| Vec::with_capacity(4)));
+        vector.extend((0..HASH_SIZE).map(|_| Vec::new()));
         Self { data: vector }
     }
 
-    pub fn insert(&mut self, key: &str, value: V) -> Result<(), NP_Error> {
+    pub fn insert(&mut self, key: &str, value: usize) -> Result<(), NP_Error> {
 
         let hash = murmurhash3_x86_32(key.as_bytes(), SEED);
 
         let bucket = hash as usize % HASH_SIZE;
 
         if self.data[bucket].len() == 0 {
-            self.data[bucket].push((hash, value));
+            self.data[bucket].push((String::from(key), value));
         } else {
             for (k, v) in self.data[bucket].iter_mut() {
-                if *k == hash {
+                if k == key {
                     *v = value;
                     return Ok(())
                 }
             }
-            self.data[bucket].push((hash, value));
+            self.data[bucket].push((String::from(key), value));
         }
 
         Ok(())
     }
 
-    pub fn get(&self, key: &str) -> Option<&V> {
+    pub fn get(&self, key: &str) -> Option<&usize> {
         let hash = murmurhash3_x86_32(key.as_bytes(), SEED);
         let bucket = hash as usize % HASH_SIZE;
 
@@ -56,14 +56,10 @@ impl<V> NP_HashMap<V> {
                     return None;
                 }
                 if len == 1 {
-                    if x[0].0 == hash {
-                        return Some(&x[0].1);
-                    } else {
-                        return None;
-                    }
+                    return Some(&x[0].1);
                 }
                 for (k, v) in x.iter() {
-                    if *k == hash {
+                    if k == key {
                         return Some(v)
                     }
                 }
@@ -78,7 +74,7 @@ impl<V> NP_HashMap<V> {
         let bucket = hash as usize % HASH_SIZE;
         match self.data.get_mut(bucket) {
             Some(bucket) => {
-                bucket.retain(|(k, _v)| *k != hash);
+                bucket.retain(|(k, _v)| *k != key);
             },
             _ => { }
         }