Struct Issues 

pub struct Issues { /* private fields */ }

A collection of issues.

Implementations

impl Issues

pub fn new() -> Self

Creates a new Issues collection.

This initializes the collection with a “root” issue.

Examples found in repository

examples/main.rs (line 7)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn add_new_issue(&mut self, i: Issue) -> usize

Adds a new issue to the collection.

Returns the index of the newly added issue.

Examples found in repository

examples/main.rs (line 21)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn get_list(&self) -> &Vec<Issue>

Returns a reference to the list of issues.

Examples found in repository

examples/main.rs (line 8)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn find_from_title<T: AsRef<str>>( &mut self, s: T, ) -> Option<Vec<&mut Issue>>

Finds issues containing the given title string.

Returns Some(Vec<&mut Issue>) if matches are found, otherwise None.

Examples found in repository

examples/main.rs (line 31)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn find_from_updated_time( &mut self, st: DateTime<Local>, ed: DateTime<Local>, ) -> Option<Vec<&mut Issue>>

Finds issues updated within the given time range.

Returns Some(Vec<&mut Issue>) if matches are found, otherwise None.

pub fn find_from_created_time( &mut self, st: DateTime<Local>, ed: DateTime<Local>, ) -> Option<Vec<&mut Issue>>

Finds issues created within the given time range.

Returns Some(Vec<&mut Issue>) if matches are found, otherwise None.

pub fn find_from_comments<T: AsRef<str>>( &mut self, s: T, ) -> Option<Vec<&mut Issue>>

Finds issues containing a comment with the given text.

Returns Some(Vec<&mut Issue>) if matches are found, otherwise None.

pub fn get(&self, index: usize) -> Option<&Issue>

Gets an issue by its index.

Examples found in repository

examples/main.rs (line 41)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn get_mut(&mut self, index: usize) -> Option<&mut Issue>

Gets a mutable reference to an issue by its index.

pub fn fork(&mut self, from: usize) -> Option<usize>

Forks an issue from a given index.

The original issue is marked as CloseAsForked, and a new copy is created with from set to the original index.

Returns Some(usize) which is the index of the new forked issue, or None if the original issue doesn’t exist.

Examples found in repository

examples/main.rs (line 39)

fn main() {
    // 1. Create a new Issues collection
    let mut issues = Issues::new();
    println!("Initial issues count: {}", issues.get_list().len());

    // 2. Create a User
    let user = User::new("Alice", "alice@example.com");

    // 3. Create a new Issue
    let mut new_issue = Issue::new("Add better documentation", user.clone(), vec!["Enhance"]);

    // 4. Add a Comment to the issue
    let comment = Comment::new("I think we should add more examples.", user.clone());
    new_issue.comment(comment);

    // 5. Add the issue to the collection
    let issue_index = issues.add_new_issue(new_issue);
    println!("Added new issue at index: {}", issue_index);

    // 6. Print all issues
    println!("\nAll Issues:");
    for (i, issue) in issues.get_list().iter().enumerate() {
        println!("Issue #{}: {:?}", i, issue);
    }

    // 7. Find an issue by title
    if let Some(found_issues) = issues.find_from_title("documentation") {
        println!(
            "\nFound {} issues matching 'documentation'",
            found_issues.len()
        );
    }

    // 8. Fork an issue
    if let Some(forked_index) = issues.fork(1) {
        println!("\nForked issue #1 to new issue #{}", forked_index);
        let forked_issue = issues.get(forked_index).unwrap();
        println!("Forked issue details: {:?}", forked_issue);

        let original_issue = issues.get(1).unwrap();
        println!("Original issue status after fork: {:?}", original_issue);
    }
}

pub fn get_registered_labels(&self) -> Vec<String>

Returns a list of all registered labels.

Trait Implementations

impl Clone for Issues

fn clone(&self) -> Issues

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Issues

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Issues

fn default() -> Issues

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Issues

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Issues

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Storeable for Issues

fn save<P>( &self, path: P, new_create: bool, format: Format, ) -> Result<(), Error>

where P: AsRef<Path>,

Save to file.

fn save_by_extension<P>(&self, path: P, new_create: bool) -> Result<(), Error>

where P: AsRef<Path>,

save to file by extension of path

fn load<P>(path: P, format: Format) -> Result<Self, Error>

where P: AsRef<Path>,

Load from file.

fn load_by_extension<P>(path: P) -> Result<Self, Error>

where P: AsRef<Path>,

load from file by extension of path