TIP: To test code one can use the ambitious https://play.rust-lang.org/ . However, a *much faster* and practical solution is to add an extra project (suggestion: call it "playground") in which you develop the code. When everything works, copy it to the project src directory containing the "real" project. This is the solution I ended up using.
TIP: https://www.linuxjournal.com/content/getting-started-rust-working-files-and-doing-file-io
seems to be a good page explaining, as stated in the URL, file i/o!
To stop getting warnings about unused imports and dead code, place #![allow(dead_code)] and
#![allow(unused)] in the absolute beginning of the code, before any 'use' statements. Cleanup when code is finished is a recommendation :0).
Having many modules in a script, getting an error, at least I want to know *what script* failed. To do that one can save the file name of the script running. like:
fn get_exec_name() -> Option<String> {
std::env::current_exe()
.ok()
.and_then(|pb| pb.file_name().map(|s| s.to_os_string()))
.and_then(|s| s.into_string().ok())
}
I've not analyzed the ins and outs of this function so I won't comment on it for now. But if a part of it is used like :
let fname= std::env::current_exe();
println!("{:?}",fname);
you'll get something like this:
Ok("/home/snkdb/rust/projects/ed/target/debug/ed")
The reason is that the result is not just the filename as a string it's an:
enum Result<T, E> {
Ok(T),
Err(E),
}
And the "Ok(/home/....)" is the Ok[T] part. To get the result as a string I have to write:
let fname= std::env::current_exe().unwrap();
println! will then display :
"/home/snkdb/rust/projects/ed/target/debug/ed"
which was the thing I wanted.
One other way is to use 'match' (below, reading from the keyboard):
let mut st3 = String::new(); // a string to stuff my input in
match std::io::stdin().read_line(&mut st3) {
Ok(_) => (st3),
Err(e) => (e.to_string()),
}
The 'st3' will be delivered as the result and the separation of the result from the 'enum' is accomplished.
Those two variants are standard ways to get the result. There are more ways and one of the the things that differentiate them is how and when to display the error message.
If I got this right, an error here would result in a panic, displaying the 'e' message. To avoid panics and let the caller of the function handle the error, other methods must be used. More on that later (I hope).
Let's have a look at what code I currently have:
fn main() {
let input=rdl("Enter something: ".to_string()); // reading from the keyboard
println!("{:?}",input);
}
fn rdl(prompt:String) -> std::string::String {
print!("{}", prompt); // print whatever 'prompt is
io::stdout().flush().unwrap();
let mut st3 = String::new(); // a string to stuff my input in
match std::io::stdin().read_line(&mut st3) {
Ok(_) => (st3), // if OK this is the result, the String
Err(e) => (e.to_string()),
}
}
So; I have a program reading from the keyboard, displaying the input. Not much. Besides, if I enter '[[' it will print "[[\n". After some browsing I came up with a function that removes "\n". Let's add that:
fn main() {
let fname= std::env::current_exe().unwrap(); // not doing much just now
let input=rdl("Enter something: ".to_string()); // reading from the key board
let mut input=input.trim_end_matches('\n');
println!("{:?}",input)
}
I'm thinking about making this into a very basic .ini-file editor. That was the first thing i created programming in Visual Basic 3.0 27 years ago :0)
Let's set up some rules about things I want to be able to create in my .ini file:
if I as the first argument enter "[[" it will be a section header
if I enter "[" it will be a section item
if I enter "/*" it will be a comment
if I enter "*/ it will be the end of the comment
if I enter "h" or "H" some help would appear
if I enter "l" or "L" the file will be listed on the console
At least 6 different choices must be made to activate (probably) as many different functions.
One way to do that is using "if blabla== whatever", sorry, I meant 'if "[[" == input{' but I was defeated in my ongoing war against the compiler. Then I found that using 'match' was a much more compact way of doing the same. After applying that method, winning that round (Yay!), I tested the "if..." variant again and it worked.
This is not an uncommon experience when trying to learn Rust (for me personally, at least). You try what you think will work, you are presented with a lot of exotic hurdles, give up after some wrestling, try something else that mysteriously work and at the end, again testing what didn't work before, finding it mysteriously works. Phew!
A typical 'hurdle' is something along the lines of : 'expected one of `,`, `.`, `?`, `}`, or an operator'.' If you're trying to learn Rust I bet you've met that bastard...
'
Back to the script, the main() function has an 'match' statement added. NOTE: the last line, starting with '&_' must exist. This is where you should end up when none of the other conditions are true! at least the compiler says so. We'll see in the long run.... Also a function to execute, in each case a conditional statement ends up being true, are added last. They just print something encouraging..
fn main() {
let fname= std::env::current_exe().unwrap();
let input=rdl("Enter something: ".to_string());
let input=input.trim_end_matches('\n').to_string();
if "[[" == input{
println!("I didn't expect that to work! {}", input); // :0)
}
match input.as_str() {
"[[" => header(input.to_string()), // function, below, verifying it works
"[" => item(input.to_string()), // etc.
"/*" => comment_start(input.to_string()),
"*/" => comment_end(input.to_string()),
"H" | "h" => help(input.to_string()),
"L" | "l" => help(input.to_string()),
&_ => println!("Input is not acceptable {}",input.to_string()) // must have, == everything else
}
}
// Added needed functions to check it works:
fn header(section_header:String){
println!("Header was: {}",section_header);
}
fn item(section_item:String){
println!("Item was: {}",section_item);
}
fn comment_start(com_strt:String){
println!("Com_strt was: {}",com_strt);
}
fn comment_end(com_end:String){
println!("Com_end was: {}",com_end);
}
fn help(cont_hlp:String){
println!("Help was: {}",cont_hlp);
}
fn list(cont_lst:String){
println!("List was: {}",cont_lst);
}
Now I have six functions that will force me to learn some more Rust, no doubt..
The first one (fn header) will have to do the following:
- Present a new prompt
- accept a string as input
- add "[[" to that input
- add the input to that and
- add the "]]" at the end
- open the file, the .ini-file
- write it to the .ini-file.
Seeing that we need to open a file, the lazy programmer will pick that function from the first example in this series. Let's add it and display what we've got so far (the whole shebang!):
use std::fs::{File,OpenOptions};
use std::io::{self, Write, Error,ErrorKind};
use std::result::Result;
#[allow(dead_code)]
#[allow(unused)]
fn main() {
let fname_own= std::env::current_exe().unwrap(); // changed, doesn't matter for the moment
let fname_ini="/home/snkdb/rust/projects/ed/src/ed.ini"; // this is the file we're working on
let input=rdl("Enter something: ".to_string());
let input=input.trim_end_matches('\n').to_string();
if "[[" == input{
println!("I didn't expect that to work! {}", input);
}
match input.as_str() {
"[[" => header(input.to_string(),fname_ini.to_string()), // this points to the fn 'header'
"[" => item(input.to_string()),
"/*" => comment_start(input.to_string()),
"*/" => comment_end(input.to_string()),
"H" | "h" => help(input.to_string()),
"L" | "l" => help(input.to_string()),
&_ => println!("Input is not acceptable {}",input.to_string())
}
}
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
}
fn item(section_item:String){
println!("Item was: {}",section_item);
}
fn comment_start(com_strt:String){
println!("Com_strt was: {}",com_strt);
}
fn comment_end(com_end:String){
println!("Com_end was: {}",com_end);
}
fn help(cont_hlp:String){
println!("Help was: {}",cont_hlp);
}
fn list(cont_lst:String){
println!("List was: {}",cont_lst);
}
fn rdl(prompt:String) -> std::string::String {
print!("{}", prompt); // print whatever 'prompt is
io::stdout().flush().unwrap();
let mut st3 = String::new(); // a string to stufff my input in
match std::io::stdin().read_line(&mut st3) {
Ok(_) => (st3),
Err(e) => (e.to_string()),
}
}
fn open_file (fname:String) -> std::fs::File{
/* NOTE: Files are automatically closed when they go out of scope.
But: "The most general way for your function to use files is to take an open file handle as parameter, as this allows it to also use file handles that are not part of the filesystem".
Worth noting is that file handles can't be copied or dereferenced */
let f = OpenOptions::new().read(true).append(true).open(&fname);
let f = match f {
Ok(f) => return f,
Err(error) => match error.kind() {
ErrorKind::NotFound => match File::create(&fname){
Ok(f) => return f,
Err(e) => panic!("Failed creating file 'data' {:?}", e),
}, // one more is coming, a comma
other_err => {
panic!("Failed opening file 'data' {:?}", other_err)
}
}
}; // END of "let f = match f {", a semicolon!
}
The first function. Header
OK so good so far. Lets concentrate on the first one (fn header):
It looks like:
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
}
The 'section_header:String' is our input from the first prompt, the '[['. Since the first example,
https://a-zproj.blogspot.com/2021/03/began-to-learn-rust.html
we have a piece of code getting input from the console, let's use it. We also have to supply a filename as a String and this was the reason for renaming 'fname' to fname_own' in the beginning. Let's add a statement opening the file:
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
let mut f = open_file (fname_ini.to_string());
}
Then we'd like to chat with the user, we need some text to enter into the .ini-file header we're writing. We're lucky, the function getting things read from the console already exists. Let's use it for sending a prompt to rdl() and to get the answer:
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
let mut f = open_file (fname_ini.to_string());
let prompt:String = "Header chosen. Please enter the header text: >> ".to_string();
let inp:String =rdl(prompt).to_string();
}
There's one thing I'd like to do here. Eventual white spaces ought to be removed. after battling with the documentation I came up with this:
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
let mut f = open_file (fname_ini.to_string());
let prompt:String = "Header chosen. Please enter the header text: >> ".to_string();
let inp:String =rdl(prompt).trim().to_string(); // several trim_ functions exist. This trims the ends
}
To make header complete, I'd like to add ']]' at the end of it, before writing.
To that end we need to use some simple and user freindly statements (sigh):
Lets add them:
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
let mut f = open_file (fname_ini.to_string()); // is "mut" really needed? Not sure
let prompt:String = "Header chosen. Please enter the header text: >> ".to_string();
let inp:String =rdl(prompt).trim().to_string();
let mut header = String::new(); // because it will change!
header.push_str(section_header.as_str()); // lets add the first piece, "[[". Push_str needs // "as_str" format
let header_postfix="]]".to_string();
header.push_str(inp.as_str()); // let's add the second part, 'inp'
header.push_str(&header_postfix); // lets add the third part. "]]".
let n:String = String::from("\n"); // let's add a NewLine (needing 2 statements!)
header = header + &n;
println!("Complete header is: {}: ", header); // printing this: "Complete header is: [[test]]:"
}
Trying "section_header.push_str(inp.as_str()).push_str(inp.as_str(&header_postfix)))' may seem tempting but it doesn't work. The 'push_str()' does not refer to the 'section_header', the "header" is a new variable used to assemble the text written to disk. Since the header is complete I want to write it to my file 'fname_ini' (with some error checking)
fn header(section_header:String,fname_ini:String){
println!("Header was: {}",section_header);
let mut f = open_file (fname_ini.to_string());
let prompt:String = "Header chosen. Please enter the header text: >> ".to_string();
let inp:String =rdl(prompt).trim().to_string();
let mut header = String::new(); // as in the first Learning Rust-example.
header.push_str(section_header.as_str()); // lets add the first piece, "[["
header.push_str(inp.as_str()); // let's add the second part, 'inp'
let header_postfix="]]".to_string();
header.push_str(&header_postfix); // lets add the third part. "]]".
let n:String = String::from("\n"); // let's add a NewLine (needing 2 statements!)
header = String::from("\n") + &header + &n;
/* solving copy problem of 'n' (see below)
header = n + &header + &n; will produce the error: ----- move occurs because `n` has type `std::string::String`, which does not implement the `Copy` trait */
let res = write_file(header.to_string(), f);
let res = match res {
Ok(res) => res,
Err(error) => error.to_string(),
};
}
OK, we have a header function that is working. My primary goal here is to take the shortest route to working functions. Functionality beyond that will have to wait, for the moment. when the applikation is run, this is the console output:
Enter something: [[
I didn't expect that to work! [[
Header was: [[
Header chosen. Please enter the header text: >> test
Complete header is: [test]
after repeated use the file ed.ini will look like:
