orca 0.7.0

A Reddit API client for Rust
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::collections::VecDeque;
use std::default::Default;

use json;
use json::Value;

use data::{Comment, Thing};
use App;

use errors::ParseError;
use failure::Error;

/// A listing of Things. Has special implementations, currently just for Comments.
#[derive(Debug, Clone)]
pub struct Listing<T> {
	/// The contents of the Listing
	pub children: VecDeque<T>,
}

impl<T> Listing<T> {
	/// Creates a new empty listing
	pub fn new() -> Listing<T> {
		Listing { children: VecDeque::new() }
	}
}

impl<T> Default for Listing<T> {
	fn default() -> Self {
		Self::new()
	}
}

impl<T> Iterator for Listing<T> {
	type Item = T;

	fn next(&mut self) -> Option<Self::Item> {
		self.children.pop_front()
	}
}

impl Listing<Comment> {
	/// Flatten this listing of comments (consumes the listing)
	pub fn traverse(self) -> Vec<Comment> {
		let mut comments = Vec::new();

		for comment in self.children {
			comments.push(comment.clone());
			{
				comments.append(&mut comment.replies.traverse());
			}
		}

		comments
	}

	fn insert_comment_recursive(&mut self, comment: &Comment) -> bool {
		// For each comment in this listing
		for c in &mut self.children {
			// Check if it's the parent of the comment to be inserted, and if so, insert the comment into the parent's replies
			if c.id == comment.parent_id[3..comment.parent_id.len()] {
				c.replies.children.push_back(comment.clone());
				return true;
			// If not, try to insert it into the replies of the current comment (recursive)
			} else if c.replies.insert_comment_recursive(comment) {
				return true;
			}
		}

		// The comment was not in this listing
		false
	}

	/// Inserts a comment into a listing in it's correct place in the tree.
	pub fn insert_comment(&mut self, comment: Comment) {
		if !self.insert_comment_recursive(&comment) {
			self.children.push_back(comment);
		}
	}

	/// Parses the listing from json, fetching more comments as necessary.
	pub fn from_value(listing_data: &Value, post_id: &str, app: &App) -> Result<Listing<Comment>, Error> {
		let mut listing: Listing<Comment> = Listing::new();

		if let Some(array) = listing_data.as_array() {
			for item in array {
				let kind = item["kind"].as_str().unwrap();
				if kind == "t1" {
					listing.children.push_back(if let Ok(c) = Comment::from_value(item, app) {
						c
					} else {
						return Err(Error::from(ParseError {
							thing_type: "Listing<Comment>".to_string(),
							json: json::to_string_pretty(listing_data).unwrap(),
						}));
					});
				} else if kind == "more" {
					let more = item["data"]["children"].as_array().unwrap();
					let more_id = item["data"]["id"].as_str().unwrap();
					if !more.is_empty() {
						debug!("Need some children {}", json::to_string_pretty(more).unwrap());
						let more = more.iter().map(|i| i.as_str().unwrap()).collect::<Vec<&str>>();
						for child in app.more_children(post_id, more_id, &more)? {
							listing.children.push_back(child);
						}
						trace!("Successfully got children");
					}
				}
			}

			Ok(listing)
		} else {
			Err(Error::from(ParseError {
				thing_type: "Listing<Comment>".to_string(),
				json: json::to_string_pretty(listing_data).unwrap(),
			}))
		}
	}
}