Merge branch master

Cargo.toml

@@ -17,18 +17,18 @@ clap = { version = "4.0.17", features = ["cargo"] }
 colored = "2.0.0"
 flate2 = "1.0"
 infer = "0.15.0"
-ion-rs = {version = "1.0.0-rc.2", features = ["experimental"]}
-memmap = "0.7.0"
+ion-rs = { version = "1.0.0-rc.5", features = ["experimental"] }
 tempfile = "3.2.0"
 ion-schema = "0.10.0"
 serde = { version = "1.0.163", features = ["derive"] }
-serde_json = { version = "1.0.81", features = [ "arbitrary_precision", "preserve_order" ] }
+serde_json = { version = "1.0.81", features = ["arbitrary_precision", "preserve_order"] }
 base64 = "0.21.1"
-tera = {  version = "1.18.1", optional = true }
+tera = { version = "1.18.1", optional = true }
 convert_case = { version = "0.6.0", optional = true }
 matches = "0.1.10"
 thiserror = "1.0.50"
 zstd = "0.13.0"
+termcolor = "1.4.1"
 
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 pager = "0.16.1"

code-gen-projects/README.md

@@ -0,0 +1,134 @@
+# Code generation projects
+
+This directory contains 2 projects that are used in tests for code generation and serve as an example of
+how to use `ion-cli` code generator under the `generate` subcommand with an existing project.
+
+## Table of contents
+
+* [/input](#input)
+* [/schema](#schema)
+* [/java](#java)
+    * [Gradle build process](#gradle-build-process)
+* [/rust](#rust)
+    * [Cargo build process](#cargo-build-process)
+
+## /input
+
+This directory contains some good and bad test Ion files based on corresponding schema in `/schema`.
+
+## /schema
+
+This directory contains all the schema files used in testing code generation with `ion-cli` `generate` subcommand.
+
+## /java
+
+This directory contains a Java project called `code-gen-demo` which is a gradle project which has tests that uses the
+generated code based
+on schema file provided in `/schema` and test Ion file provided in `/input`.
+
+### Gradle build process
+
+To generate code as part of the build process of this project, a gradle build task is defined inside `build.gradle.kts`.
+This task performs following steps:
+
+- Gets the executable path for `ion-cli` through an environment variable `ION_CLI`. If the environment variable is not
+  set then it uses the local executable named `ion`.
+- Sets the schema directory as `/schema` which will be used by `generate` subcommand to generate code for the schema
+  files inside it.
+- Sets the path to output directory where the code will be generated and sets it as source directory.
+- It runs the `ion-cli` `generate` subcommand with the set schema directory and a namespace where the code will be
+  generated.
+
+Following is a sample build task you can add in an existing gradle project to generate code for your schemas,
+
+```
+val ionSchemaSourceCodeDir = "YOUR_SOURCE_SCHEMA_DIRECTORY"
+val generatedIonSchemaModelDir = "${layout.buildDirectory.get()}/generated/java"
+sourceSets {
+    main {
+        java.srcDir(generatedIonSchemaModelDir)
+    }
+}
+
+
+tasks {
+    val ionCodegen = create<Exec>("ionCodegen") {
+        inputs.files(ionSchemaSourceCodeDir)
+        outputs.file(generatedIonSchemaModelDir)
+
+        val ionCli = System.getenv("ION_CLI") ?: "ion"
+
+        commandLine(ionCli)
+            .args(
+                "beta", "generate",
+                "-l", "java",
+                "-n", "NAMESPACE_FOR_GENERATED_CODE",
+                "-d", ionSchemaSourceCodeDir,
+                "-o", generatedIonSchemaModelDir,
+            )
+            .workingDir(rootProject.projectDir)
+    }
+
+    withType<JavaCompile> {
+        options.encoding = "UTF-8"
+        if (JavaVersion.current() != JavaVersion.VERSION_1_8) {
+            options.release.set(8)
+        }
+        dependsOn(ionCodegen)
+    }
+}
+```
+
+## /rust
+
+This directory contains a Rust project called `code-gen-demo` which is a cargo project which has tests that uses the
+generated code based
+on schema file provided in `/schema` and test Ion file provided in `/input`.
+
+### Cargo build process
+
+To generate code as part of the build process of this cargo project, a cargo build script is defined in `build.rs`.
+This task performs following steps:
+
+- Gets the executable path for `ion-cli` through an environment variable `ION_CLI`. If the environment variable is not
+  set then it uses the local executable named `ion`.
+- Sets the schema directory as `/schema` which will be used by `generate` subcommand to generate code for the schema
+  files inside it.
+- Sets the path to output directory where the code will be generated (e.g. `OUT_DIR`).
+- It runs the `ion-cli` `generate` subcommand with the set schema directory and a namespace where the code will be
+  generated.
+
+Following is sample build script you can add in your existing cargo project to generate code using `ion-cli`.
+
+```rust
+fn main() {
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let out_dir = env::var("OUT_DIR").unwrap();
+
+    // Invokes the ion-cli executable using environment variable ION_CLI if present, otherwise uses local executable named `ion`
+    let ion_cli = env::var("ION_CLI").unwrap_or("ion".to_string());
+    println!("cargo:warn=Running command: {}", ion_cli);
+    let mut cmd = std::process::Command::new(ion_cli);
+    cmd.arg("beta")
+        .arg("generate")
+        .arg("-l")
+        .arg("rust")
+        .arg("-d")
+        .arg("YOUR_SOURCE_SCHEMA_DIRECTORY")
+        .arg("-o")
+        .arg(&out_dir);
+
+    println!("cargo:warn=Running: {:?}", cmd);
+
+    let output = cmd.output().expect("failed to execute process");
+
+    println!("status: {}", output.status);
+    io::stdout().write_all(&output.stdout).unwrap();
+    io::stderr().write_all(&output.stderr).unwrap();
+
+    assert!(output.status.success());
+
+    println!("cargo:rerun-if-changed=input/");
+    println!("cargo:rerun-if-changed=schema/");
+}
+```

src/bin/ion/commands/beta/count.rs

@@ -25,29 +25,23 @@ impl IonCliCommand for CountCommand {
             for input_file in input_file_iter {
                 let file = File::open(input_file)
                     .with_context(|| format!("Could not open file '{}'", input_file))?;
-                let mut reader = ReaderBuilder::new().build(file)?;
+                let mut reader = Reader::new(AnyEncoding, file)?;
                 print_top_level_value_count(&mut reader)?;
             }
         } else {
             let input: StdinLock = stdin().lock();
             let buf_reader = BufReader::new(input);
-            let mut reader = ReaderBuilder::new().build(buf_reader)?;
+            let mut reader = Reader::new(AnyEncoding, buf_reader)?;
             print_top_level_value_count(&mut reader)?;
         };
 
         Ok(())
     }
 }
 
-fn print_top_level_value_count(reader: &mut Reader) -> Result<()> {
+fn print_top_level_value_count<I: IonInput>(reader: &mut Reader<AnyEncoding, I>) -> Result<()> {
     let mut count: usize = 0;
-    loop {
-        let item = reader
-            .next()
-            .with_context(|| "could not count values in Ion stream")?;
-        if item == StreamItem::Nothing {
-            break;
-        }
+    while let Some(_) = reader.next()? {
         count += 1;
     }
     println!("{}", count);

src/bin/ion/commands/beta/generate/utils.rs

@@ -5,7 +5,7 @@ use serde::Serialize;
 use std::fmt::{Display, Formatter};
 
 /// Represents a field that will be added to generated data model.
-/// This will be used by the template engine to fill properties of a struct/classs.
+/// This will be used by the template engine to fill properties of a struct/class.
 #[derive(Serialize)]
 pub struct Field {
     pub(crate) name: String,