Change option to buffer_support & improve readme

Author: timfish

Diff for: README.md

@@ -6,22 +6,26 @@ and enums
 ## Goals
 
 - Generate TypeScript code directly from Rust source
-- Work from `build.rs`
+- TypeScript must compile with [`strict` mode enabled](https://github.com/timfish/bincode-typescript/blob/master/tests/build.rs)
 - Avoid Object Orientated TypeScript for better tree-shaking and optimisation
-- TypeScript for enums/structs should be ergonomic and high performance
+- TypeScript should be ergonomic and high performance
   - Use `const enum` for Unit enums and respect discriminant values!
-  - Use `TypedArray`s for `Vec<{integer,float}>` for greater performance
+  - Use `TypedArray` and copy byte blocks for `Vec<{integer,float}>` for greater performance
 
 ## Status
 
 I'm pretty new to Rust and I've just hacked around until the tests pass 🤷‍♂️
 
 There is much room for improvement and PRs are welcome!
 
-Check out the [Rust
-code](https://github.com/timfish/bincode-typescript/blob/master/tests/test_types.rs)
-used in the tests and the [generated
-TypeScript](https://github.com/timfish/bincode-typescript/blob/master/tests/test_types.ts) code.
+Check the source for [currently supported Rust types and their TypeScript
+equivalents](https://github.com/timfish/bincode-typescript/blob/master/src/types.rs#L30).
+
+You may also like to look at the [Rust
+types](https://github.com/timfish/bincode-typescript/blob/master/tests/test_types.rs)
+used in the tests and the [TypeScript
+generated](https://github.com/timfish/bincode-typescript/blob/master/tests/test_types.ts)
+from these.
 
 ## Current Issues & Limitations
 
@@ -30,7 +34,7 @@ TypeScript](https://github.com/timfish/bincode-typescript/blob/master/tests/test
 - All types must be in a single file
 - Serde attributes are not currently respected
 - `Vec<T>` are always converted to `Uint8Array/Int8Array/etc` whenever possible
-  and this might not be particularly ergonomic from TypeScript.
+  and this might not always be desired.
 - Generated code will not work on node < v11 due to the global usage of `TextEncoder/TextDecoder`
 
 ## Example via `build.rs`
@@ -44,7 +48,7 @@ bincode_typescript::from_file("./src/types.rs", "./ts/types.ts", false);
 
 ## Example via CLI
 
-There is currently a single option (`--support-buffer`) to enable support for node.js
+There is currently a single option (`--buffer-support`) to enable support for node.js
 `Buffer`.
 
 ```shell

Diff for: src/bin.rs

@@ -6,11 +6,11 @@ use std::{
 
 fn main() -> Result<(), Box<dyn Error>> {
     let args: Vec<String> = std::env::args().collect();
-    let support_buffer = args.contains(&"--support-buffer".to_string());
+    let buffer_support = args.contains(&"--buffer-support".to_string());
     let input = args.last().expect("Could not find input file name");
 
     let rust = fs::read_to_string(input)?;
-    println!("{}", from_string(&rust, support_buffer)?);
+    println!("{}", from_string(&rust, buffer_support)?);
 
     Ok(())
 }

Diff for: src/lib.rs

@@ -52,9 +52,9 @@ impl<'ast> Visit<'ast> for CodeVisitor {
     }
 }
 
-pub fn from_string(input: &str, support_buffer: bool) -> Result<String, Box<dyn Error>> {
+pub fn from_string(input: &str, buffer_support: bool) -> Result<String, Box<dyn Error>> {
     let ast = syn::parse_file(input)?;
-    let mut enum_visit = CodeVisitor::new(support_buffer);
+    let mut enum_visit = CodeVisitor::new(buffer_support);
     enum_visit.visit_file(&ast);
 
     Ok(enum_visit.render()?)
@@ -63,11 +63,11 @@ pub fn from_string(input: &str, support_buffer: bool) -> Result<String, Box<dyn
 pub fn from_file<P1: AsRef<Path>, P2: AsRef<Path>>(
     input: P1,
     output: P2,
-    support_buffer: bool,
+    buffer_support: bool,
 ) -> Result<(), Box<dyn Error>> {
     fs::create_dir_all(&output.as_ref().parent().unwrap())?;
     let rust = fs::read_to_string(input)?;
-    let typescript = from_string(&rust, support_buffer)?;
+    let typescript = from_string(&rust, buffer_support)?;
     fs::write(output, typescript)?;
 
     Ok(())

Diff for: src/types.rs

@@ -93,8 +93,8 @@ impl RustType {
             RustType::Vec(t) => format!("writeSeq({})", t.writer()),
             RustType::TypedArray(_) => "writeTypedArray".to_string(),
             RustType::Tuple(t) => format!(
-                "writeTuple<[{}]>({})",
-                t.iter().map(|t| t.ts_type()).collect::<Vec<_>>().join(", "),
+                "writeTuple<{}>({})",
+                self.ts_type(),
                 t.iter().map(|t| t.writer()).collect::<Vec<_>>().join(", ")
             ),
             RustType::HashMap(k, v) => format!("writeMap({}, {})", k.writer(), v.writer()),
@@ -122,10 +122,10 @@ impl RustType {
             RustType::String => "readString".to_string(),
             RustType::Option(t) => format!("readOption({})", t.reader()),
             RustType::Vec(t) => format!("readSeq({})", t.reader()),
-            RustType::TypedArray(_) => format!("readTypedArray({0})", self.ts_type()),
+            RustType::TypedArray(_) => format!("readTypedArray({})", self.ts_type()),
             RustType::Tuple(t) => format!(
-                "readTuple<[{}]>({})",
-                t.iter().map(|t| t.ts_type()).collect::<Vec<_>>().join(", "),
+                "readTuple<{}>({})",
+                self.ts_type(),
                 t.iter().map(|t| t.reader()).collect::<Vec<_>>().join(", ")
             ),
             RustType::HashMap(k, v) => format!("readMap({}, {})", k.reader(), v.reader()),

Diff for: templates/enum_complex.ts.j2

@@ -108,13 +108,13 @@ export function read{{ident}}(sinkOrBuf: SinkOrBuf): {{ident}} {
       {%- for ty in types %}
         {{ ty.reader() }}(sink),
       {%- endfor %} 
-        );
+      );
     {%- when EnumVariantDeclaration::Named with { ident, types } %}
       return {{type_variant}}.{{ident}}({
       {%- for (id, ty) in types %}
         {{ id }}: {{ ty.reader() }}(sink),
       {%- endfor %}
-        });
+      });
   {%- endmatch -%}
 {%- endfor %}
     default:

Diff for: tests/test_types.ts

@@ -208,15 +208,15 @@ export function readSomeEvent(sinkOrBuf: SinkOrBuf): SomeEvent {
     case 1:
       return SomeEvent.UnnamedSingle(
         readF32(sink), 
-        );
+      );
     case 2:
       return SomeEvent.UnnamedOptVec(
         readOption(readTypedArray(Uint8Array))(sink), 
-        );
+      );
     case 3:
       return SomeEvent.UnnamedSingleUnitEnum(
         readOption(readSeq(readUnitEnum))(sink), 
-        );
+      );
     case 4:
       return SomeEvent.UnnamedMultiple(
         readU8(sink),
@@ -232,24 +232,24 @@ export function readSomeEvent(sinkOrBuf: SinkOrBuf): SomeEvent {
         readUSize(sink),
         readISize(sink),
         readBool(sink), 
-        );
+      );
     case 5:
       return SomeEvent.Named({
         length: readUSize(sink),
         interval: readF64(sink),
-        });
+      });
     case 6:
       return SomeEvent.UnnamedWithStruct(
         readNamedStruct(sink), 
-        );
+      );
     case 7:
       return SomeEvent.UnnamedHashMap(
         readOption(readMap(readString, readOption(readUnitEnum)))(sink), 
-        );
+      );
     case 8:
       return SomeEvent.NamedStruct({
         inner: readNamedStruct(sink),
-        });
+      });
     default:
       throw new Error(`'${value}' is invalid value for enum 'SomeEvent'`);
   }

Diff for: tests/tests.rs

@@ -124,7 +124,7 @@ function test(buffer: Buffer): api.Sink {{
     }
 
     #[test]
-    fn named_struct() {
+    fn named_struct_with_tuple() {
         generate_and_run(
             NamedStruct {
                 zero: Some(28),
@@ -256,7 +256,7 @@ function test(buffer: Buffer): api.Sink {{
             SomeEvent::UnnamedHashMap(Some(
                 vec![
                     ("One".to_string(), Some(UnitEnum::One)),
-                    ("Two".to_string(), Some(UnitEnum::Two)),
+                    ("Two".to_string(), None),
                     ("Three".to_string(), Some(UnitEnum::Three)),
                 ]
                 .into_iter()
@@ -267,7 +267,7 @@ function test(buffer: Buffer): api.Sink {{
         let expected = api.SomeEvent.UnnamedHashMap(
             new Map([
                 ['One', api.UnitEnum.One], 
-                ['Two', api.UnitEnum.Two],
+                ['Two', undefined],
                 ['Three', api.UnitEnum.Three],
             ])
         );