add examples

examples/enum_example.rs

@@ -0,0 +1,20 @@
+use strum::{EnumDiscriminants, EnumIter, EnumMessage};
+
+#[derive(Debug, Clone, EnumDiscriminants, interactive_clap_derive::InteractiveClap)]
+#[strum_discriminants(derive(EnumMessage, EnumIter))]
+#[interactive_clap(context = ())]
+pub enum Mode {
+    #[strum_discriminants(strum(message = "Yes, I keep it simple"))]
+    Network,
+    #[strum_discriminants(strum(
+        message = "No, I want to work in no-network (air-gapped) environment"
+    ))]
+    Offline,
+}
+
+fn main() {
+    let cli_mode = CliMode::Network;
+    println!("cli_mode: {:?}", cli_mode);
+    let variant = Mode::choose_variant(());
+    println!("variant: {:?}", variant)
+}

examples/hello.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello from an example!");
+}

examples/struct_example.rs

@@ -0,0 +1,27 @@
+use clap::Clap;
+
+#[derive(Debug, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = ())]
+struct Args {
+    #[interactive_clap(long = "prepaid-gas")]
+    gas: u64,
+    #[interactive_clap(long)]
+    first_first: String,
+}
+
+impl Args {
+    fn input_gas(_context: &()) -> color_eyre::eyre::Result<u64> {
+        Ok(1_000_000_000)
+    }
+
+    fn input_first_first(_context: &()) -> color_eyre::eyre::Result<String> {
+        Ok("First".to_string())
+    }
+}
+
+fn main() {
+    let cli_args = CliArgs::parse();
+    println!("cli: {:?}", &cli_args);
+    let args = Args::from_cli(Some(cli_args), ());
+    println!("args: {:#?}", args)
+}

examples/struct_with_context.rs

@@ -0,0 +1,50 @@
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(input_context = ())]
+#[interactive_clap(output_context = OfflineArgsContext)]
+pub struct OfflineArgs {
+    #[interactive_clap(named_arg)]
+    ///Specify a sender
+    account: Sender,
+}
+
+pub struct OfflineArgsContext {}
+
+impl OfflineArgsContext {
+    fn from_previous_context(
+        _previous_context: (),
+        _scope: &<OfflineArgs as interactive_clap::ToInteractiveClapContextScope>::InteractiveClapContextScope,
+    ) -> Self {
+        Self {}
+    }
+}
+
+impl From<OfflineArgsContext> for NetworkContext {
+    fn from(_: OfflineArgsContext) -> Self {
+        Self {
+            connection_config: None,
+        }
+    }
+}
+
+pub struct NetworkContext {
+    pub connection_config: Option<crate::common::ConnectionConfig>,
+}
+
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = OfflineArgsContext)]
+pub struct Sender {
+    pub sender_account_id: String,
+}
+
+impl Sender {
+    fn input_sender_account_id(context: &OfflineArgsContext) -> color_eyre::eyre::Result<String> {
+        Ok("Volodymyr".to_string())
+    }
+}
+
+fn main() {
+    let cli_offline_args = CliOfflineArgs::default();
+    println!("cli_offline_args: {:?}", cli_offline_args);
+    let offline_args = OfflineArgs::from_cli(Some(cli_offline_args), ());
+    println!("offline_args: {:?}", offline_args)
+}

examples/struct_with_named_attrs_and_custom_type_example.rs

@@ -0,0 +1,26 @@
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = ())]
+struct OfflineArgs {
+    #[interactive_clap(named_arg)]
+    ///Specify a sender
+    account: Sender,
+}
+
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = ())]
+pub struct Sender {
+    pub sender_account_id: String,
+}
+
+impl Sender {
+    fn input_sender_account_id(context: &()) -> color_eyre::eyre::Result<String> {
+        Ok("Volodymyr".to_string())
+    }
+}
+
+fn main() {
+    let cli_offline_args = CliOfflineArgs::default();
+    println!("cli_offline_args: {:?}", cli_offline_args);
+    let offline_args = OfflineArgs::from_cli(Some(cli_offline_args), ());
+    println!("offline_args: {:?}", offline_args)
+}

examples/struct_with_subcommand_example.rs

@@ -0,0 +1,13 @@
+mod enum_example;
+
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = ())]
+pub struct OperationMode {
+    #[interactive_clap(subcommand)]
+    pub mode: enum_example::Mode,
+}
+
+fn main() {
+    let cli_operation_mode = CliOperationMode::default();
+    println!("cli_operation_mode: {:?}", cli_operation_mode)
+}

examples/to_cli_args.rs

@@ -0,0 +1,64 @@
+use dialoguer::{theme::ColorfulTheme, Select};
+use strum::{EnumDiscriminants, EnumIter, EnumMessage, IntoEnumIterator};
+
+#[derive(Debug, Clone, interactive_clap_derive::InteractiveClap)]
+#[interactive_clap(context = crate::common::ConnectionConfig)]
+struct OnlineArgs {
+    #[interactive_clap(subcommand)]
+    submit: Submit,
+}
+
+#[derive(Debug, EnumDiscriminants, Clone, clap::Clap, interactive_clap_derive::ToCliArgs)]
+#[strum_discriminants(derive(EnumMessage, EnumIter))]
+pub enum Submit {
+    #[strum_discriminants(strum(message = "I want to send the transaction to the network"))]
+    Send,
+    #[strum_discriminants(strum(
+        message = "I only want to print base64-encoded transaction for JSON RPC input and exit"
+    ))]
+    Display,
+}
+
+impl Submit {
+    fn choose_variant(connection_config: crate::common::ConnectionConfig) -> color_eyre::eyre::Result<Self> {
+        let variants = SubmitDiscriminants::iter().collect::<Vec<_>>();
+        let submits = variants
+            .iter()
+            .map(|p| p.get_message().unwrap().to_owned())
+            .collect::<Vec<_>>();
+        let select_submit = Select::with_theme(&ColorfulTheme::default())
+            .with_prompt("How would you like to proceed")
+            .items(&submits)
+            .default(0)
+            .interact()
+            .unwrap();
+        match variants[select_submit] {
+            SubmitDiscriminants::Send => Ok(Submit::Send),
+            SubmitDiscriminants::Display => Ok(Submit::Display),
+        }
+    }
+
+    fn from_cli(
+        optional_clap_variant: Option<<Submit as interactive_clap::ToCli>::CliVariant>,
+        context: crate::common::ConnectionConfig,
+    ) -> color_eyre::eyre::Result<Self> {
+        let submit: Option<Submit> = optional_clap_variant
+            .clone();
+        match submit {
+            Some(_) => Ok(Submit::Send),
+            None => Ok(Submit::Display)
+        }
+            
+    }
+}
+
+impl interactive_clap::ToCli for Submit {
+    type CliVariant = Submit;
+}
+
+fn main() {
+    let cli_online_args = CliOnlineArgs::default();
+    println!("cli_online_args: {:?}", cli_online_args);
+    let online_args = OnlineArgs::from_cli(Some(cli_online_args), crate::common::ConnectionConfig::Testnet);
+    println!("online_args: {:?}", online_args)
+}