library_catalogue 0.1.0

A collection of utilities to track the books in your library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

extern crate library_catalogue;
use std::io::{Error, ErrorKind};

use library_catalogue::Book;
use library_catalogue::ISBN;
use library_catalogue::Read;
use library_catalogue::Shelf;

fn main() {

    let rust_book = Book {
        title: String::from("The Rust Programming Language"),
        isbn: ISBN::V10(978, 1, 59327, 828, 1),
        pages: 519,
        read: Read::Started
    };


    let javascript_book = Book {
        title: String::from("Eloquent JavaScript"),
        isbn: ISBN::V13(978, 1, 59327, 564, 6),
        pages: 451,
        ..rust_book
    };

    let mut ruby_book = book_factory(String::from("Beginning Ruby: From Novice to Professional"), 
                                 ISBN::V13(978, 1, 43022, 363, 4),
                                 620);

    ruby_book.finish();


    let mut programming_shelf = Shelf::named(String::from("Programming Languages"));

    programming_shelf.put_book(rust_book);
    programming_shelf.put_book(javascript_book);
    programming_shelf.put_book(ruby_book);

    match list_shelf_contents(Some(&programming_shelf)) {
        Ok(info) => println!("{}", info),
        Err(e)   => println!("ERROR: {:?}", e)
    }

    let empty_shelf = None;

    match list_shelf_contents(empty_shelf) {
        Ok(info) => println!("{}", info),
        Err(e)   => println!("ERROR: {:?}", e)
    }
    

}


/// Creates an instance of a book
/// 
/// # Example
/// 
/// ```
/// let mut ruby_book = book_factory(String::from("Beginning Ruby: From Novice to Professional"), 
///                                 ISBN::V13(978, 1, 43022, 363, 4),
///                                 620);
/// ```                      
fn book_factory(title: String, isbn: ISBN, pages: u32) -> Book {
    Book {
        title,
        isbn,
        pages,
        read: Read::NotStarted
    }
}

/// Shows what's on the shelf
/// 
/// Names the shelf and then all the books on it
fn list_shelf_contents(shelf: Option<&Shelf>) -> Result<String, Error> {

    match shelf {
        None => {
            return Err(Error::new(ErrorKind::Other, "Seems that the shelf is not there (yet?)"));
        },
        Some(shelf) => {
            let mut contents_info = format!("On the `{}` shelf there are following volumes:", shelf.name);

            for book in shelf.books.iter() {
                contents_info = contents_info + &book.summary();
                match book.read {
                    Read::Finished => {
                        contents_info = contents_info + &format!("+ And I have finsihed that one!")
                    },
                    _ => {}
                }
            }
            Ok(contents_info)
        }
    }
}