aitzol/Plume
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clippy

Browse Source
This commit is contained in:
Kitaiti Makoto 2023-01-03 02:45:13 +09:00
parent 2f53fc78b6
commit 4df2c3e6f6
33 changed files with 297 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
plume-common/src/activity_pub/sign.rs
View File

@ -119,7 +119,7 @@ impl Signable for serde_json::Value {
} }
} }
#[derive(Debug, Copy, Clone, PartialEq)] #[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum SignatureValidity { pub enum SignatureValidity {
Invalid, Invalid,
ValidNoDigest, ValidNoDigest,

2
plume-models/src/api_tokens.rs
View File

@ -103,7 +103,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for ApiToken {
let conn = request let conn = request
.guard::<DbConn>() .guard::<DbConn>()
.map_failure(|_| (Status::InternalServerError, TokenError::DbError))?; .map_failure(|_| (Status::InternalServerError, TokenError::DbError))?;
if let Ok(token) = ApiToken::find_by_value(&*conn, val) { if let Ok(token) = ApiToken::find_by_value(&conn, val) {
return Outcome::Success(token); return Outcome::Success(token);
} }
} }

5
plume-models/src/blocklisted_emails.rs
View File

@ -126,11 +126,10 @@ pub(crate) mod tests {
.id, .id,
various[1].id various[1].id
); );
assert_eq!( assert!(
BlocklistedEmail::matches_blocklist(&conn, no_match) BlocklistedEmail::matches_blocklist(&conn, no_match)
.unwrap() .unwrap()
.is_none(), .is_none()
true
); );
Ok(()) Ok(())
}); });

92
plume-models/src/blogs.rs
View File

@ -660,7 +660,7 @@ pub(crate) mod tests {
.unwrap() .unwrap()
.id, .id,
); );
let _: Blog = blog1.save_changes(&*conn).unwrap(); let _: Blog = blog1.save_changes(conn).unwrap();
(users, vec![blog1, blog2, blog3]) (users, vec![blog1, blog2, blog3])
} }
@ -669,10 +669,10 @@ pub(crate) mod tests {
fn get_instance() { fn get_instance() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
fill_database(&conn); fill_database(conn);
let blog = Blog::insert( let blog = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"SomeName".to_owned(), "SomeName".to_owned(),
"Some name".to_owned(), "Some name".to_owned(),
@ -684,7 +684,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
blog.get_instance(&conn).unwrap().id, blog.get_instance(conn).unwrap().id,
Instance::get_local().unwrap().id Instance::get_local().unwrap().id
); );
// TODO add tests for remote instance // TODO add tests for remote instance
@ -696,10 +696,10 @@ pub(crate) mod tests {
fn authors() { fn authors() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (user, _) = fill_database(&conn); let (user, _) = fill_database(conn);
let b1 = Blog::insert( let b1 = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"SomeName".to_owned(), "SomeName".to_owned(),
"Some name".to_owned(), "Some name".to_owned(),
@ -710,7 +710,7 @@ pub(crate) mod tests {
) )
.unwrap(); .unwrap();
let b2 = Blog::insert( let b2 = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"Blog".to_owned(), "Blog".to_owned(),
"Blog".to_owned(), "Blog".to_owned(),
@ -723,7 +723,7 @@ pub(crate) mod tests {
let blog = vec![b1, b2]; let blog = vec![b1, b2];
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[0].id, blog_id: blog[0].id,
author_id: user[0].id, author_id: user[0].id,
@ -733,7 +733,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[0].id, blog_id: blog[0].id,
author_id: user[1].id, author_id: user[1].id,
@ -743,7 +743,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[1].id, blog_id: blog[1].id,
author_id: user[0].id, author_id: user[0].id,
@ -753,39 +753,39 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
assert!(blog[0] assert!(blog[0]
.list_authors(&conn) .list_authors(conn)
.unwrap() .unwrap()
.iter() .iter()
.any(|a| a.id == user[0].id)); .any(|a| a.id == user[0].id));
assert!(blog[0] assert!(blog[0]
.list_authors(&conn) .list_authors(conn)
.unwrap() .unwrap()
.iter() .iter()
.any(|a| a.id == user[1].id)); .any(|a| a.id == user[1].id));
assert!(blog[1] assert!(blog[1]
.list_authors(&conn) .list_authors(conn)
.unwrap() .unwrap()
.iter() .iter()
.any(|a| a.id == user[0].id)); .any(|a| a.id == user[0].id));
assert!(!blog[1] assert!(!blog[1]
.list_authors(&conn) .list_authors(conn)
.unwrap() .unwrap()
.iter() .iter()
.any(|a| a.id == user[1].id)); .any(|a| a.id == user[1].id));
assert!(Blog::find_for_author(&conn, &user[0]) assert!(Blog::find_for_author(conn, &user[0])
.unwrap() .unwrap()
.iter() .iter()
.any(|b| b.id == blog[0].id)); .any(|b| b.id == blog[0].id));
assert!(Blog::find_for_author(&conn, &user[1]) assert!(Blog::find_for_author(conn, &user[1])
.unwrap() .unwrap()
.iter() .iter()
.any(|b| b.id == blog[0].id)); .any(|b| b.id == blog[0].id));
assert!(Blog::find_for_author(&conn, &user[0]) assert!(Blog::find_for_author(conn, &user[0])
.unwrap() .unwrap()
.iter() .iter()
.any(|b| b.id == blog[1].id)); .any(|b| b.id == blog[1].id));
assert!(!Blog::find_for_author(&conn, &user[1]) assert!(!Blog::find_for_author(conn, &user[1])
.unwrap() .unwrap()
.iter() .iter()
.any(|b| b.id == blog[1].id)); .any(|b| b.id == blog[1].id));
@ -797,10 +797,10 @@ pub(crate) mod tests {
fn find_local() { fn find_local() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
fill_database(&conn); fill_database(conn);
let blog = Blog::insert( let blog = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"SomeName".to_owned(), "SomeName".to_owned(),
"Some name".to_owned(), "Some name".to_owned(),
@ -811,7 +811,7 @@ pub(crate) mod tests {
) )
.unwrap(); .unwrap();
assert_eq!(Blog::find_by_fqn(&conn, "SomeName").unwrap().id, blog.id); assert_eq!(Blog::find_by_fqn(conn, "SomeName").unwrap().id, blog.id);
Ok(()) Ok(())
}) })
} }
@ -820,10 +820,10 @@ pub(crate) mod tests {
fn get_fqn() { fn get_fqn() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
fill_database(&conn); fill_database(conn);
let blog = Blog::insert( let blog = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"SomeName".to_owned(), "SomeName".to_owned(),
"Some name".to_owned(), "Some name".to_owned(),
@ -843,10 +843,10 @@ pub(crate) mod tests {
fn delete() { fn delete() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (_, blogs) = fill_database(&conn); let (_, blogs) = fill_database(conn);
blogs[0].delete(&conn).unwrap(); blogs[0].delete(conn).unwrap();
assert!(Blog::get(&conn, blogs[0].id).is_err()); assert!(Blog::get(conn, blogs[0].id).is_err());
Ok(()) Ok(())
}) })
} }
@ -855,10 +855,10 @@ pub(crate) mod tests {
fn delete_via_user() { fn delete_via_user() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (user, _) = fill_database(&conn); let (user, _) = fill_database(conn);
let b1 = Blog::insert( let b1 = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"SomeName".to_owned(), "SomeName".to_owned(),
"Some name".to_owned(), "Some name".to_owned(),
@ -869,7 +869,7 @@ pub(crate) mod tests {
) )
.unwrap(); .unwrap();
let b2 = Blog::insert( let b2 = Blog::insert(
&conn, conn,
NewBlog::new_local( NewBlog::new_local(
"Blog".to_owned(), "Blog".to_owned(),
"Blog".to_owned(), "Blog".to_owned(),
@ -882,7 +882,7 @@ pub(crate) mod tests {
let blog = vec![b1, b2]; let blog = vec![b1, b2];
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[0].id, blog_id: blog[0].id,
author_id: user[0].id, author_id: user[0].id,
@ -892,7 +892,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[0].id, blog_id: blog[0].id,
author_id: user[1].id, author_id: user[1].id,
@ -902,7 +902,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
BlogAuthor::insert( BlogAuthor::insert(
&conn, conn,
NewBlogAuthor { NewBlogAuthor {
blog_id: blog[1].id, blog_id: blog[1].id,
author_id: user[0].id, author_id: user[0].id,
@ -911,11 +911,11 @@ pub(crate) mod tests {
) )
.unwrap(); .unwrap();
user[0].delete(&conn).unwrap(); user[0].delete(conn).unwrap();
assert!(Blog::get(&conn, blog[0].id).is_ok()); assert!(Blog::get(conn, blog[0].id).is_ok());
assert!(Blog::get(&conn, blog[1].id).is_err()); assert!(Blog::get(conn, blog[1].id).is_err());
user[1].delete(&conn).unwrap(); user[1].delete(conn).unwrap();
assert!(Blog::get(&conn, blog[0].id).is_err()); assert!(Blog::get(conn, blog[0].id).is_err());
Ok(()) Ok(())
}) })
} }
@ -924,10 +924,10 @@ pub(crate) mod tests {
fn self_federation() { fn self_federation() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, mut blogs) = fill_database(&conn); let (users, mut blogs) = fill_database(conn);
blogs[0].icon_id = Some( blogs[0].icon_id = Some(
Media::insert( Media::insert(
&conn, conn,
NewMedia { NewMedia {
file_path: "aaa.png".into(), file_path: "aaa.png".into(),
alt_text: String::new(), alt_text: String::new(),
@ -943,7 +943,7 @@ pub(crate) mod tests {
); );
blogs[0].banner_id = Some( blogs[0].banner_id = Some(
Media::insert( Media::insert(
&conn, conn,
NewMedia { NewMedia {
file_path: "bbb.png".into(), file_path: "bbb.png".into(),
alt_text: String::new(), alt_text: String::new(),
@ -958,9 +958,9 @@ pub(crate) mod tests {
.id, .id,
); );
let _: Blog = blogs[0].save_changes(&**conn).unwrap(); let _: Blog = blogs[0].save_changes(&**conn).unwrap();
let ap_repr = blogs[0].to_activity(&conn).unwrap(); let ap_repr = blogs[0].to_activity(conn).unwrap();
blogs[0].delete(&conn).unwrap(); blogs[0].delete(conn).unwrap();
let blog = Blog::from_activity(&conn, ap_repr).unwrap(); let blog = Blog::from_activity(conn, ap_repr).unwrap();
assert_eq!(blog.actor_id, blogs[0].actor_id); assert_eq!(blog.actor_id, blogs[0].actor_id);
assert_eq!(blog.title, blogs[0].title); assert_eq!(blog.title, blogs[0].title);
@ -972,8 +972,8 @@ pub(crate) mod tests {
assert_eq!(blog.public_key, blogs[0].public_key); assert_eq!(blog.public_key, blogs[0].public_key);
assert_eq!(blog.fqn, blogs[0].fqn); assert_eq!(blog.fqn, blogs[0].fqn);
assert_eq!(blog.summary_html, blogs[0].summary_html); assert_eq!(blog.summary_html, blogs[0].summary_html);
assert_eq!(blog.icon_url(&conn), blogs[0].icon_url(&conn)); assert_eq!(blog.icon_url(conn), blogs[0].icon_url(conn));
assert_eq!(blog.banner_url(&conn), blogs[0].banner_url(&conn)); assert_eq!(blog.banner_url(conn), blogs[0].banner_url(conn));
Ok(()) Ok(())
}) })
@ -983,7 +983,7 @@ pub(crate) mod tests {
fn to_activity() { fn to_activity() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, Error, _>(|| { conn.test_transaction::<_, Error, _>(|| {
let (_users, blogs) = fill_database(&conn); let (_users, blogs) = fill_database(conn);
let blog = &blogs[0]; let blog = &blogs[0];
let act = blog.to_activity(conn)?; let act = blog.to_activity(conn)?;

16
plume-models/src/comments.rs
View File

@ -381,7 +381,7 @@ impl AsObject<User, Delete, &DbConn> for Comment {
} }
for n in Notification::find_for_comment(conn, &self)? { for n in Notification::find_for_comment(conn, &self)? {
n.delete(&**conn)?; n.delete(conn)?;
} }
diesel::update(comments::table) diesel::update(comments::table)
@ -431,7 +431,7 @@ mod tests {
use serde_json::{json, to_value}; use serde_json::{json, to_value};
fn prepare_activity(conn: &DbConn) -> (Comment, Vec<Post>, Vec<User>, Vec<Blog>) { fn prepare_activity(conn: &DbConn) -> (Comment, Vec<Post>, Vec<User>, Vec<Blog>) {
let (posts, users, blogs) = fill_database(&conn); let (posts, users, blogs) = fill_database(conn);
let comment = Comment::insert( let comment = Comment::insert(
conn, conn,
@ -457,8 +457,8 @@ mod tests {
fn self_federation() { fn self_federation() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (original_comm, posts, users, _blogs) = prepare_activity(&conn); let (original_comm, posts, users, _blogs) = prepare_activity(conn);
let act = original_comm.create_activity(&conn).unwrap(); let act = original_comm.create_activity(conn).unwrap();
assert_json_eq!(to_value(&act).unwrap(), json!({ assert_json_eq!(to_value(&act).unwrap(), json!({
"actor": "https://plu.me/@/admin/", "actor": "https://plu.me/@/admin/",
@ -500,7 +500,7 @@ mod tests {
}, },
) )
.unwrap(); .unwrap();
let reply_act = reply.create_activity(&conn).unwrap(); let reply_act = reply.create_activity(conn).unwrap();
assert_json_eq!(to_value(&reply_act).unwrap(), json!({ assert_json_eq!(to_value(&reply_act).unwrap(), json!({
"actor": "https://plu.me/@/user/", "actor": "https://plu.me/@/user/",
@ -522,12 +522,12 @@ mod tests {
})); }));
inbox( inbox(
&conn, conn,
serde_json::to_value(original_comm.build_delete(&conn).unwrap()).unwrap(), serde_json::to_value(original_comm.build_delete(conn).unwrap()).unwrap(),
) )
.unwrap(); .unwrap();
match inbox(&conn, to_value(act).unwrap()).unwrap() { match inbox(conn, to_value(act).unwrap()).unwrap() {
InboxResult::Commented(c) => { InboxResult::Commented(c) => {
// TODO: one is HTML, the other markdown: assert_eq!(c.content, original_comm.content); // TODO: one is HTML, the other markdown: assert_eq!(c.content, original_comm.content);
assert_eq!(c.in_response_to_id, original_comm.in_response_to_id); assert_eq!(c.in_response_to_id, original_comm.in_response_to_id);

3
plume-models/src/db_conn.rs
View File

@ -69,7 +69,8 @@ pub(crate) mod tests {
impl CustomizeConnection<Connection, ConnError> for TestConnectionCustomizer { impl CustomizeConnection<Connection, ConnError> for TestConnectionCustomizer {
fn on_acquire(&self, conn: &mut Connection) -> Result<(), ConnError> { fn on_acquire(&self, conn: &mut Connection) -> Result<(), ConnError> {
PragmaForeignKey.on_acquire(conn)?; PragmaForeignKey.on_acquire(conn)?;
Ok(conn.begin_test_transaction().unwrap()) conn.begin_test_transaction().unwrap();
Ok(())
} }
} }
} }

2
plume-models/src/follows.rs
View File

@ -108,7 +108,7 @@ impl Follow {
let accept = res.build_accept(from, target, follow)?; let accept = res.build_accept(from, target, follow)?;
broadcast( broadcast(
&*target, target,
accept, accept,
vec![from.clone()], vec![from.clone()],
CONFIG.proxy().cloned(), CONFIG.proxy().cloned(),

18
plume-models/src/inbox.rs
View File

@ -82,9 +82,9 @@ pub(crate) mod tests {
use crate::post_authors::*; use crate::post_authors::*;
use crate::posts::*; use crate::posts::*;
let (users, blogs) = blog_fill_db(&conn); let (users, blogs) = blog_fill_db(conn);
let post = Post::insert( let post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "testing".to_owned(), slug: "testing".to_owned(),
@ -102,7 +102,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
PostAuthor::insert( PostAuthor::insert(
&conn, conn,
NewPostAuthor { NewPostAuthor {
post_id: post.id, post_id: post.id,
author_id: users[0].id, author_id: users[0].id,
@ -190,7 +190,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))
@ -221,7 +221,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))
@ -249,7 +249,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))
@ -324,7 +324,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))
@ -362,7 +362,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))
@ -397,7 +397,7 @@ pub(crate) mod tests {
}); });
assert!(matches!( assert!(matches!(
super::inbox(&conn, act.clone()), super::inbox(&conn, act),
Err(super::Error::Inbox( Err(super::Error::Inbox(
box plume_common::activity_pub::inbox::InboxError::InvalidObject(_), box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
)) ))

2
plume-models/src/instance.rs
View File

@ -523,7 +523,7 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
let inst = Instance::get(conn, inst.id).unwrap(); let inst = Instance::get(conn, inst.id).unwrap();
assert_eq!(inst.name, "NewName".to_owned()); assert_eq!(inst.name, "NewName".to_owned());
assert_eq!(inst.open_registrations, false); assert!(!inst.open_registrations);
assert_eq!( assert_eq!(
inst.long_description.get(), inst.long_description.get(),
"[long_description](/with_link)" "[long_description](/with_link)"

2
plume-models/src/lib.rs
View File

@ -354,7 +354,7 @@ mod tests {
}; };
} }
pub fn db<'a>() -> db_conn::DbConn { pub fn db() -> db_conn::DbConn {
db_conn::DbConn((*DB_POOL).get().unwrap()) db_conn::DbConn((*DB_POOL).get().unwrap())
} }

6
plume-models/src/likes.rs
View File

@ -199,7 +199,7 @@ mod tests {
let (posts, _users, _blogs) = fill_database(&conn); let (posts, _users, _blogs) = fill_database(&conn);
let post = &posts[0]; let post = &posts[0];
let user = &post.get_authors(&conn)?[0]; let user = &post.get_authors(&conn)?[0];
let like = Like::insert(&*conn, NewLike::new(post, user))?; let like = Like::insert(&conn, NewLike::new(post, user))?;
let act = like.to_activity(&conn).unwrap(); let act = like.to_activity(&conn).unwrap();
let expected = json!({ let expected = json!({
@ -223,8 +223,8 @@ mod tests {
let (posts, _users, _blogs) = fill_database(&conn); let (posts, _users, _blogs) = fill_database(&conn);
let post = &posts[0]; let post = &posts[0];
let user = &post.get_authors(&conn)?[0]; let user = &post.get_authors(&conn)?[0];
let like = Like::insert(&*conn, NewLike::new(post, user))?; let like = Like::insert(&conn, NewLike::new(post, user))?;
let act = like.build_undo(&*conn)?; let act = like.build_undo(&conn)?;
let expected = json!({ let expected = json!({
"actor": "https://plu.me/@/admin/", "actor": "https://plu.me/@/admin/",

2
plume-models/src/lists.rs
View File

@ -413,7 +413,7 @@ mod tests {
&List::find_for_user_by_name(conn, l1.user_id, &l1.name).unwrap(), &List::find_for_user_by_name(conn, l1.user_id, &l1.name).unwrap(),
); );
l_eq( l_eq(
&&l1u, &l1u,
&List::find_for_user_by_name(conn, l1u.user_id, &l1u.name).unwrap(), &List::find_for_user_by_name(conn, l1u.user_id, &l1u.name).unwrap(),
); );
Ok(()) Ok(())

6
plume-models/src/medias.rs
View File

@ -42,7 +42,7 @@ pub struct NewMedia {
pub owner_id: i32, pub owner_id: i32,
} }
#[derive(PartialEq)] #[derive(PartialEq, Eq)]
pub enum MediaCategory { pub enum MediaCategory {
Image, Image,
Audio, Audio,
@ -343,7 +343,7 @@ pub(crate) mod tests {
use std::path::Path; use std::path::Path;
pub(crate) fn fill_database(conn: &Conn) -> (Vec<User>, Vec<Media>) { pub(crate) fn fill_database(conn: &Conn) -> (Vec<User>, Vec<Media>) {
let mut wd = current_dir().unwrap().to_path_buf(); let mut wd = current_dir().unwrap();
while wd.pop() { while wd.pop() {
if wd.join(".git").exists() { if wd.join(".git").exists() {
set_current_dir(wd).unwrap(); set_current_dir(wd).unwrap();
@ -456,7 +456,7 @@ pub(crate) mod tests {
let media = Media::insert( let media = Media::insert(
conn, conn,
NewMedia { NewMedia {
file_path: path.clone(), file_path: path,
alt_text: "alt message".to_owned(), alt_text: "alt message".to_owned(),
is_remote: false, is_remote: false,
remote_url: None, remote_url: None,

10
plume-models/src/password_reset_requests.rs
View File

@ -89,7 +89,7 @@ mod tests {
let request = PasswordResetRequest::find_by_token(&conn, &token) let request = PasswordResetRequest::find_by_token(&conn, &token)
.expect("couldn't retrieve request"); .expect("couldn't retrieve request");
assert!(&token.len() > &32); assert!(token.len() > 32);
assert_eq!(&request.email, &admin_email); assert_eq!(&request.email, &admin_email);
Ok(()) Ok(())
@ -103,8 +103,8 @@ mod tests {
user_tests::fill_database(&conn); user_tests::fill_database(&conn);
let admin_email = "admin@example.com"; let admin_email = "admin@example.com";
PasswordResetRequest::insert(&conn, &admin_email).expect("couldn't insert new request"); PasswordResetRequest::insert(&conn, admin_email).expect("couldn't insert new request");
PasswordResetRequest::insert(&conn, &admin_email) PasswordResetRequest::insert(&conn, admin_email)
.expect("couldn't insert second request"); .expect("couldn't insert second request");
let count = password_reset_requests::table.count().get_result(&*conn); let count = password_reset_requests::table.count().get_result(&*conn);
@ -132,7 +132,7 @@ mod tests {
.execute(&*conn) .execute(&*conn)
.expect("could not insert request"); .expect("could not insert request");
match PasswordResetRequest::find_by_token(&conn, &token) { match PasswordResetRequest::find_by_token(&conn, token) {
Err(Error::Expired) => (), Err(Error::Expired) => (),
_ => panic!("Received unexpected result finding expired token"), _ => panic!("Received unexpected result finding expired token"),
} }
@ -148,7 +148,7 @@ mod tests {
user_tests::fill_database(&conn); user_tests::fill_database(&conn);
let admin_email = "admin@example.com"; let admin_email = "admin@example.com";
let token = PasswordResetRequest::insert(&conn, &admin_email) let token = PasswordResetRequest::insert(&conn, admin_email)
.expect("couldn't insert new request"); .expect("couldn't insert new request");
PasswordResetRequest::find_and_delete_by_token(&conn, &token) PasswordResetRequest::find_and_delete_by_token(&conn, &token)
.expect("couldn't find and delete request"); .expect("couldn't find and delete request");

29
plume-models/src/posts.rs
View File

@ -133,8 +133,7 @@ impl Post {
.filter(posts::id.eq_any(ids)) .filter(posts::id.eq_any(ids))
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.count() .count()
.load(conn)? .load(conn)?.first()
.get(0)
.cloned() .cloned()
.ok_or(Error::NotFound) .ok_or(Error::NotFound)
} }
@ -465,7 +464,7 @@ impl Post {
.collect::<HashSet<_>>(); .collect::<HashSet<_>>();
for (m, id) in &mentions { for (m, id) in &mentions {
if !old_user_mentioned.contains(id) { if !old_user_mentioned.contains(id) {
Mention::from_activity(&*conn, m, self.id, true, true)?; Mention::from_activity(conn, m, self.id, true, true)?;
} }
} }
@ -488,7 +487,7 @@ impl Post {
.filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string())) .filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string()))
.collect::<HashSet<_>>(); .collect::<HashSet<_>>();
let old_tags = Tag::for_post(&*conn, self.id)?; let old_tags = Tag::for_post(conn, self.id)?;
let old_tags_name = old_tags let old_tags_name = old_tags
.iter() .iter()
.filter_map(|tag| { .filter_map(|tag| {
@ -525,7 +524,7 @@ impl Post {
.filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string())) .filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string()))
.collect::<HashSet<_>>(); .collect::<HashSet<_>>();
let old_tags = Tag::for_post(&*conn, self.id)?; let old_tags = Tag::for_post(conn, self.id)?;
let old_tags_name = old_tags let old_tags_name = old_tags
.iter() .iter()
.filter_map(|tag| { .filter_map(|tag| {
@ -1036,7 +1035,7 @@ mod tests {
let post = &posts[0]; let post = &posts[0];
let mentioned = &users[1]; let mentioned = &users[1];
let mention = Mention::insert( let mention = Mention::insert(
&conn, conn,
NewMention { NewMention {
mentioned_id: mentioned.id, mentioned_id: mentioned.id,
post_id: Some(post.id), post_id: Some(post.id),
@ -1044,7 +1043,7 @@ mod tests {
}, },
) )
.unwrap(); .unwrap();
(post.to_owned(), mention.to_owned(), posts, users, blogs) (post.to_owned(), mention, posts, users, blogs)
} }
// creates a post, get it's Create activity, delete the post, // creates a post, get it's Create activity, delete the post,
@ -1053,9 +1052,9 @@ mod tests {
fn self_federation() { fn self_federation() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (_, users, blogs) = fill_database(&conn); let (_, users, blogs) = fill_database(conn);
let post = Post::insert( let post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "yo".into(), slug: "yo".into(),
@ -1072,19 +1071,19 @@ mod tests {
) )
.unwrap(); .unwrap();
PostAuthor::insert( PostAuthor::insert(
&conn, conn,
NewPostAuthor { NewPostAuthor {
post_id: post.id, post_id: post.id,
author_id: users[0].id, author_id: users[0].id,
}, },
) )
.unwrap(); .unwrap();
let create = post.create_activity(&conn).unwrap(); let create = post.create_activity(conn).unwrap();
post.delete(&conn).unwrap(); post.delete(conn).unwrap();
match inbox(&conn, serde_json::to_value(create).unwrap()).unwrap() { match inbox(conn, serde_json::to_value(create).unwrap()).unwrap() {
InboxResult::Post(p) => { InboxResult::Post(p) => {
assert!(p.is_author(&conn, users[0].id).unwrap()); assert!(p.is_author(conn, users[0].id).unwrap());
assert_eq!(p.source, "Hello".to_owned()); assert_eq!(p.source, "Hello".to_owned());
assert_eq!(p.blog_id, blogs[0].id); assert_eq!(p.blog_id, blogs[0].id);
assert_eq!(p.content, SafeString::new("Hello")); assert_eq!(p.content, SafeString::new("Hello"));
@ -1221,7 +1220,7 @@ mod tests {
let actual = to_value(act)?; let actual = to_value(act)?;
let id = actual["id"].to_string(); let id = actual["id"].to_string();
let (id_pre, id_post) = id.rsplit_once("-").unwrap(); let (id_pre, id_post) = id.rsplit_once('-').unwrap();
assert_eq!(post.ap_url, "https://plu.me/~/BlogName/testing"); assert_eq!(post.ap_url, "https://plu.me/~/BlogName/testing");
assert_eq!( assert_eq!(
id_pre, id_pre,

6
plume-models/src/reshares.rs
View File

@ -229,7 +229,7 @@ mod test {
let (posts, _users, _blogs) = fill_database(&conn); let (posts, _users, _blogs) = fill_database(&conn);
let post = &posts[0]; let post = &posts[0];
let user = &post.get_authors(&conn)?[0]; let user = &post.get_authors(&conn)?[0];
let reshare = Reshare::insert(&*conn, NewReshare::new(post, user))?; let reshare = Reshare::insert(&conn, NewReshare::new(post, user))?;
let act = reshare.to_activity(&conn).unwrap(); let act = reshare.to_activity(&conn).unwrap();
let expected = json!({ let expected = json!({
@ -253,8 +253,8 @@ mod test {
let (posts, _users, _blogs) = fill_database(&conn); let (posts, _users, _blogs) = fill_database(&conn);
let post = &posts[0]; let post = &posts[0];
let user = &post.get_authors(&conn)?[0]; let user = &post.get_authors(&conn)?[0];
let reshare = Reshare::insert(&*conn, NewReshare::new(post, user))?; let reshare = Reshare::insert(&conn, NewReshare::new(post, user))?;
let act = reshare.build_undo(&*conn)?; let act = reshare.build_undo(&conn)?;
let expected = json!({ let expected = json!({
"actor": "https://plu.me/@/admin/", "actor": "https://plu.me/@/admin/",

2
plume-models/src/safe_string.rs
View File

@ -93,7 +93,7 @@ fn url_add_prefix(url: &str) -> Option<Cow<'_, str>> {
} }
} }
#[derive(Debug, Clone, PartialEq, AsExpression, FromSqlRow, Default)] #[derive(Debug, Clone, PartialEq, Eq, AsExpression, FromSqlRow, Default)]
#[sql_type = "Text"] #[sql_type = "Text"]
pub struct SafeString { pub struct SafeString {
value: String, value: String,

34
plume-models/src/search/actor.rs
View File

@ -108,7 +108,7 @@ mod tests {
let searcher = Arc::new(get_searcher(&CONFIG.search_tokenizers)); let searcher = Arc::new(get_searcher(&CONFIG.search_tokenizers));
SearchActor::init(searcher.clone(), db_pool.clone()); SearchActor::init(searcher.clone(), db_pool.clone());
let conn = db_pool.clone().get().unwrap(); let conn = db_pool.get().unwrap();
let title = random_hex()[..8].to_owned(); let title = random_hex()[..8].to_owned();
let (_instance, _user, blog) = fill_database(&conn); let (_instance, _user, blog) = fill_database(&conn);
@ -161,41 +161,43 @@ mod tests {
long_description_html: "<p>Good morning</p>".to_string(), long_description_html: "<p>Good morning</p>".to_string(),
short_description: SafeString::new("Hello"), short_description: SafeString::new("Hello"),
short_description_html: "<p>Hello</p>".to_string(), short_description_html: "<p>Hello</p>".to_string(),
name: random_hex().to_string(), name: random_hex(),
open_registrations: true, open_registrations: true,
public_domain: random_hex().to_string(), public_domain: random_hex(),
}, },
) )
.unwrap(); .unwrap();
let user = User::insert( let user = User::insert(
conn, conn,
NewUser { NewUser {
username: random_hex().to_string(), username: random_hex(),
display_name: random_hex().to_string(), display_name: random_hex(),
outbox_url: random_hex().to_string(), outbox_url: random_hex(),
inbox_url: random_hex().to_string(), inbox_url: random_hex(),
summary: "".to_string(), summary: "".to_string(),
email: None, email: None,
hashed_password: None, hashed_password: None,
instance_id: instance.id, instance_id: instance.id,
ap_url: random_hex().to_string(), ap_url: random_hex(),
private_key: None, private_key: None,
public_key: "".to_string(), public_key: "".to_string(),
shared_inbox_url: None, shared_inbox_url: None,
followers_endpoint: random_hex().to_string(), followers_endpoint: random_hex(),
avatar_id: None, avatar_id: None,
summary_html: SafeString::new(""), summary_html: SafeString::new(""),
role: 0, role: 0,
fqn: random_hex().to_string(), fqn: random_hex(),
}, },
) )
.unwrap(); .unwrap();
let mut blog = NewBlog::default(); let blog = NewBlog {
blog.instance_id = instance.id; instance_id: instance.id,
blog.actor_id = random_hex().to_string(); actor_id: random_hex(),
blog.ap_url = random_hex().to_string(); ap_url: random_hex(),
blog.inbox_url = random_hex().to_string(); inbox_url: random_hex(),
blog.outbox_url = random_hex().to_string(); outbox_url: random_hex(),
..Default::default()
};
let blog = Blog::insert(conn, blog).unwrap(); let blog = Blog::insert(conn, blog).unwrap();
BlogAuthor::insert( BlogAuthor::insert(
conn, conn,

2
plume-models/src/search/mod.rs
View File

@ -154,7 +154,7 @@ pub(crate) mod tests {
}, },
) )
.unwrap(); .unwrap();
searcher.add_document(&conn, &post).unwrap(); searcher.add_document(conn, &post).unwrap();
searcher.commit(); searcher.commit();
assert_eq!( assert_eq!(
searcher.search_document(conn, Query::from_str(&title).unwrap(), (0, 1))[0].id, searcher.search_document(conn, Query::from_str(&title).unwrap(), (0, 1))[0].id,

2
plume-models/src/tags.rs
View File

@ -92,7 +92,7 @@ mod tests {
let (posts, _users, _blogs) = fill_database(conn); let (posts, _users, _blogs) = fill_database(conn);
let post_id = posts[0].id; let post_id = posts[0].id;
let mut ht = Hashtag::new(); let mut ht = Hashtag::new();
ht.set_href(ap_url(&format!("https://plu.me/tag/a_tag")).parse::<IriString>()?); ht.set_href(ap_url("https://plu.me/tag/a_tag").parse::<IriString>()?);
ht.set_name("a_tag".to_string()); ht.set_name("a_tag".to_string());
let tag = Tag::from_activity(conn, &ht, post_id, true)?; let tag = Tag::from_activity(conn, &ht, post_id, true)?;

216
plume-models/src/timeline/mod.rs
View File

@ -14,7 +14,7 @@ pub(crate) mod query;
pub use self::query::Kind; pub use self::query::Kind;
use self::query::{QueryError, TimelineQuery}; use self::query::{QueryError, TimelineQuery};
#[derive(Clone, Debug, PartialEq, Queryable, Identifiable, AsChangeset)] #[derive(Clone, Debug, PartialEq, Eq, Queryable, Identifiable, AsChangeset)]
#[table_name = "timeline_definition"] #[table_name = "timeline_definition"]
pub struct Timeline { pub struct Timeline {
pub id: i32, pub id: i32,
@ -282,73 +282,73 @@ mod tests {
fn test_timeline() { fn test_timeline() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let users = userTests::fill_database(&conn); let users = userTests::fill_database(conn);
let mut tl1_u1 = Timeline::new_for_user( let mut tl1_u1 = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"my timeline".to_owned(), "my timeline".to_owned(),
"all".to_owned(), "all".to_owned(),
) )
.unwrap(); .unwrap();
List::new( List::new(
&conn, conn,
"languages I speak", "languages I speak",
Some(&users[1]), Some(&users[1]),
ListType::Prefix, ListType::Prefix,
) )
.unwrap(); .unwrap();
let tl2_u1 = Timeline::new_for_user( let tl2_u1 = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"another timeline".to_owned(), "another timeline".to_owned(),
"followed".to_owned(), "followed".to_owned(),
) )
.unwrap(); .unwrap();
let tl1_u2 = Timeline::new_for_user( let tl1_u2 = Timeline::new_for_user(
&conn, conn,
users[1].id, users[1].id,
"english posts".to_owned(), "english posts".to_owned(),
"lang in \"languages I speak\"".to_owned(), "lang in \"languages I speak\"".to_owned(),
) )
.unwrap(); .unwrap();
let tl1_instance = Timeline::new_for_instance( let tl1_instance = Timeline::new_for_instance(
&conn, conn,
"english posts".to_owned(), "english posts".to_owned(),
"license in [cc]".to_owned(), "license in [cc]".to_owned(),
) )
.unwrap(); .unwrap();
assert_eq!(tl1_u1, Timeline::get(&conn, tl1_u1.id).unwrap()); assert_eq!(tl1_u1, Timeline::get(conn, tl1_u1.id).unwrap());
assert_eq!( assert_eq!(
tl2_u1, tl2_u1,
Timeline::find_for_user_by_name(&conn, Some(users[0].id), "another timeline") Timeline::find_for_user_by_name(conn, Some(users[0].id), "another timeline")
.unwrap() .unwrap()
); );
assert_eq!( assert_eq!(
tl1_instance, tl1_instance,
Timeline::find_for_user_by_name(&conn, None, "english posts").unwrap() Timeline::find_for_user_by_name(conn, None, "english posts").unwrap()
); );
let tl_u1 = Timeline::list_for_user(&conn, Some(users[0].id)).unwrap(); let tl_u1 = Timeline::list_for_user(conn, Some(users[0].id)).unwrap();
assert_eq!(3, tl_u1.len()); // it is not 2 because there is a "Your feed" tl created for each user automatically assert_eq!(3, tl_u1.len()); // it is not 2 because there is a "Your feed" tl created for each user automatically
assert!(tl_u1.iter().fold(false, |res, tl| { res || *tl == tl1_u1 })); assert!(tl_u1.iter().any(|tl| *tl == tl1_u1));
assert!(tl_u1.iter().fold(false, |res, tl| { res || *tl == tl2_u1 })); assert!(tl_u1.iter().any(|tl| *tl == tl2_u1));
let tl_instance = Timeline::list_for_user(&conn, None).unwrap(); let tl_instance = Timeline::list_for_user(conn, None).unwrap();
assert_eq!(3, tl_instance.len()); // there are also the local and federated feed by default assert_eq!(3, tl_instance.len()); // there are also the local and federated feed by default
assert!(tl_instance assert!(tl_instance
.iter() .iter()
.fold(false, |res, tl| { res || *tl == tl1_instance })); .any(|tl| *tl == tl1_instance));
tl1_u1.name = "My Super TL".to_owned(); tl1_u1.name = "My Super TL".to_owned();
let new_tl1_u2 = tl1_u2.update(&conn).unwrap(); let new_tl1_u2 = tl1_u2.update(conn).unwrap();
let tl_u2 = Timeline::list_for_user(&conn, Some(users[1].id)).unwrap(); let tl_u2 = Timeline::list_for_user(conn, Some(users[1].id)).unwrap();
assert_eq!(2, tl_u2.len()); // same here assert_eq!(2, tl_u2.len()); // same here
assert!(tl_u2 assert!(tl_u2
.iter() .iter()
.fold(false, |res, tl| { res || *tl == new_tl1_u2 })); .any(|tl| *tl == new_tl1_u2));
Ok(()) Ok(())
}); });
@ -358,48 +358,48 @@ mod tests {
fn test_timeline_creation_error() { fn test_timeline_creation_error() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let users = userTests::fill_database(&conn); let users = userTests::fill_database(conn);
assert!(Timeline::new_for_user( assert!(Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"my timeline".to_owned(), "my timeline".to_owned(),
"invalid keyword".to_owned(), "invalid keyword".to_owned(),
) )
.is_err()); .is_err());
assert!(Timeline::new_for_instance( assert!(Timeline::new_for_instance(
&conn, conn,
"my timeline".to_owned(), "my timeline".to_owned(),
"invalid keyword".to_owned(), "invalid keyword".to_owned(),
) )
.is_err()); .is_err());
assert!(Timeline::new_for_user( assert!(Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"my timeline".to_owned(), "my timeline".to_owned(),
"author in non_existant_list".to_owned(), "author in non_existant_list".to_owned(),
) )
.is_err()); .is_err());
assert!(Timeline::new_for_instance( assert!(Timeline::new_for_instance(
&conn, conn,
"my timeline".to_owned(), "my timeline".to_owned(),
"lang in dont-exist".to_owned(), "lang in dont-exist".to_owned(),
) )
.is_err()); .is_err());
List::new(&conn, "friends", Some(&users[0]), ListType::User).unwrap(); List::new(conn, "friends", Some(&users[0]), ListType::User).unwrap();
List::new(&conn, "idk", None, ListType::Blog).unwrap(); List::new(conn, "idk", None, ListType::Blog).unwrap();
assert!(Timeline::new_for_user( assert!(Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"my timeline".to_owned(), "my timeline".to_owned(),
"blog in friends".to_owned(), "blog in friends".to_owned(),
) )
.is_err()); .is_err());
assert!(Timeline::new_for_instance( assert!(Timeline::new_for_instance(
&conn, conn,
"my timeline".to_owned(), "my timeline".to_owned(),
"not author in idk".to_owned(), "not author in idk".to_owned(),
) )
@ -413,10 +413,10 @@ mod tests {
fn test_simple_match() { fn test_simple_match() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, blogs) = blogTests::fill_database(&conn); let (users, blogs) = blogTests::fill_database(conn);
let gnu_tl = Timeline::new_for_user( let gnu_tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"GNU timeline".to_owned(), "GNU timeline".to_owned(),
"license in [AGPL, LGPL, GPL]".to_owned(), "license in [AGPL, LGPL, GPL]".to_owned(),
@ -424,7 +424,7 @@ mod tests {
.unwrap(); .unwrap();
let gnu_post = Post::insert( let gnu_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug".to_string(), slug: "slug".to_string(),
@ -440,10 +440,10 @@ mod tests {
}, },
) )
.unwrap(); .unwrap();
assert!(gnu_tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(gnu_tl.matches(conn, &gnu_post, Kind::Original).unwrap());
let non_free_post = Post::insert( let non_free_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug2".to_string(), slug: "slug2".to_string(),
@ -460,7 +460,7 @@ mod tests {
) )
.unwrap(); .unwrap();
assert!(!gnu_tl assert!(!gnu_tl
.matches(&conn, &non_free_post, Kind::Original) .matches(conn, &non_free_post, Kind::Original)
.unwrap()); .unwrap());
Ok(()) Ok(())
@ -471,9 +471,9 @@ mod tests {
fn test_complex_match() { fn test_complex_match() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, blogs) = blogTests::fill_database(&conn); let (users, blogs) = blogTests::fill_database(conn);
Follow::insert( Follow::insert(
&conn, conn,
NewFollow { NewFollow {
follower_id: users[0].id, follower_id: users[0].id,
following_id: users[1].id, following_id: users[1].id,
@ -483,11 +483,11 @@ mod tests {
.unwrap(); .unwrap();
let fav_blogs_list = let fav_blogs_list =
List::new(&conn, "fav_blogs", Some(&users[0]), ListType::Blog).unwrap(); List::new(conn, "fav_blogs", Some(&users[0]), ListType::Blog).unwrap();
fav_blogs_list.add_blogs(&conn, &[blogs[0].id]).unwrap(); fav_blogs_list.add_blogs(conn, &[blogs[0].id]).unwrap();
let my_tl = Timeline::new_for_user( let my_tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"My timeline".to_owned(), "My timeline".to_owned(),
"blog in fav_blogs and not has_cover or local and followed exclude likes" "blog in fav_blogs and not has_cover or local and followed exclude likes"
@ -496,7 +496,7 @@ mod tests {
.unwrap(); .unwrap();
let post = Post::insert( let post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "about-linux".to_string(), slug: "about-linux".to_string(),
@ -512,10 +512,10 @@ mod tests {
}, },
) )
.unwrap(); .unwrap();
assert!(my_tl.matches(&conn, &post, Kind::Original).unwrap()); // matches because of "blog in fav_blogs" (and there is no cover) assert!(my_tl.matches(conn, &post, Kind::Original).unwrap()); // matches because of "blog in fav_blogs" (and there is no cover)
let post = Post::insert( let post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[1].id, blog_id: blogs[1].id,
slug: "about-linux-2".to_string(), slug: "about-linux-2".to_string(),
@ -533,7 +533,7 @@ mod tests {
}, },
) )
.unwrap(); .unwrap();
assert!(!my_tl.matches(&conn, &post, Kind::Like(&users[1])).unwrap()); assert!(!my_tl.matches(conn, &post, Kind::Like(&users[1])).unwrap());
Ok(()) Ok(())
}); });
@ -543,17 +543,17 @@ mod tests {
fn test_add_to_all_timelines() { fn test_add_to_all_timelines() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, blogs) = blogTests::fill_database(&conn); let (users, blogs) = blogTests::fill_database(conn);
let gnu_tl = Timeline::new_for_user( let gnu_tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"GNU timeline".to_owned(), "GNU timeline".to_owned(),
"license in [AGPL, LGPL, GPL]".to_owned(), "license in [AGPL, LGPL, GPL]".to_owned(),
) )
.unwrap(); .unwrap();
let non_gnu_tl = Timeline::new_for_user( let non_gnu_tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Stallman disapproved timeline".to_owned(), "Stallman disapproved timeline".to_owned(),
"not license in [AGPL, LGPL, GPL]".to_owned(), "not license in [AGPL, LGPL, GPL]".to_owned(),
@ -561,7 +561,7 @@ mod tests {
.unwrap(); .unwrap();
let gnu_post = Post::insert( let gnu_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug".to_string(), slug: "slug".to_string(),
@ -579,7 +579,7 @@ mod tests {
.unwrap(); .unwrap();
let non_free_post = Post::insert( let non_free_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug2".to_string(), slug: "slug2".to_string(),
@ -596,13 +596,13 @@ mod tests {
) )
.unwrap(); .unwrap();
Timeline::add_to_all_timelines(&conn, &gnu_post, Kind::Original).unwrap(); Timeline::add_to_all_timelines(conn, &gnu_post, Kind::Original).unwrap();
Timeline::add_to_all_timelines(&conn, &non_free_post, Kind::Original).unwrap(); Timeline::add_to_all_timelines(conn, &non_free_post, Kind::Original).unwrap();
let res = gnu_tl.get_latest(&conn, 2).unwrap(); let res = gnu_tl.get_latest(conn, 2).unwrap();
assert_eq!(res.len(), 1); assert_eq!(res.len(), 1);
assert_eq!(res[0].id, gnu_post.id); assert_eq!(res[0].id, gnu_post.id);
let res = non_gnu_tl.get_latest(&conn, 2).unwrap(); let res = non_gnu_tl.get_latest(conn, 2).unwrap();
assert_eq!(res.len(), 1); assert_eq!(res.len(), 1);
assert_eq!(res[0].id, non_free_post.id); assert_eq!(res[0].id, non_free_post.id);
@ -614,10 +614,10 @@ mod tests {
fn test_matches_lists_direct() { fn test_matches_lists_direct() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, blogs) = blogTests::fill_database(&conn); let (users, blogs) = blogTests::fill_database(conn);
let gnu_post = Post::insert( let gnu_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug".to_string(), slug: "slug".to_string(),
@ -634,63 +634,63 @@ mod tests {
) )
.unwrap(); .unwrap();
gnu_post gnu_post
.update_tags(&conn, vec![Tag::build_activity("free".to_owned()).unwrap()]) .update_tags(conn, vec![Tag::build_activity("free".to_owned()).unwrap()])
.unwrap(); .unwrap();
PostAuthor::insert( PostAuthor::insert(
&conn, conn,
NewPostAuthor { NewPostAuthor {
post_id: gnu_post.id, post_id: gnu_post.id,
author_id: blogs[0].list_authors(&conn).unwrap()[0].id, author_id: blogs[0].list_authors(conn).unwrap()[0].id,
}, },
) )
.unwrap(); .unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"blog timeline".to_owned(), "blog timeline".to_owned(),
format!("blog in [{}]", blogs[0].fqn), format!("blog in [{}]", blogs[0].fqn),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"blog timeline".to_owned(), "blog timeline".to_owned(),
"blog in [no_one@nowhere]".to_owned(), "blog in [no_one@nowhere]".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"author timeline".to_owned(), "author timeline".to_owned(),
format!( format!(
"author in [{}]", "author in [{}]",
blogs[0].list_authors(&conn).unwrap()[0].fqn blogs[0].list_authors(conn).unwrap()[0].fqn
), ),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"author timeline".to_owned(), "author timeline".to_owned(),
format!("author in [{}]", users[2].fqn), format!("author in [{}]", users[2].fqn),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
assert!(tl assert!(tl
.matches(&conn, &gnu_post, Kind::Reshare(&users[2])) .matches(conn, &gnu_post, Kind::Reshare(&users[2]))
.unwrap()); .unwrap());
assert!(!tl.matches(&conn, &gnu_post, Kind::Like(&users[2])).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Like(&users[2])).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"author timeline".to_owned(), "author timeline".to_owned(),
format!( format!(
@ -699,50 +699,50 @@ mod tests {
), ),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
assert!(!tl assert!(!tl
.matches(&conn, &gnu_post, Kind::Reshare(&users[2])) .matches(conn, &gnu_post, Kind::Reshare(&users[2]))
.unwrap()); .unwrap());
assert!(tl.matches(&conn, &gnu_post, Kind::Like(&users[2])).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Like(&users[2])).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"tag timeline".to_owned(), "tag timeline".to_owned(),
"tags in [free]".to_owned(), "tags in [free]".to_owned(),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"tag timeline".to_owned(), "tag timeline".to_owned(),
"tags in [private]".to_owned(), "tags in [private]".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"english timeline".to_owned(), "english timeline".to_owned(),
"lang in [en]".to_owned(), "lang in [en]".to_owned(),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"franco-italian timeline".to_owned(), "franco-italian timeline".to_owned(),
"lang in [fr, it]".to_owned(), "lang in [fr, it]".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
Ok(()) Ok(())
}); });
@ -786,10 +786,10 @@ mod tests {
fn test_matches_keyword() { fn test_matches_keyword() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let (users, blogs) = blogTests::fill_database(&conn); let (users, blogs) = blogTests::fill_database(conn);
let gnu_post = Post::insert( let gnu_post = Post::insert(
&conn, conn,
NewPost { NewPost {
blog_id: blogs[0].id, blog_id: blogs[0].id,
slug: "slug".to_string(), slug: "slug".to_string(),
@ -807,61 +807,61 @@ mod tests {
.unwrap(); .unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Linux title".to_owned(), "Linux title".to_owned(),
"title contains Linux".to_owned(), "title contains Linux".to_owned(),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Microsoft title".to_owned(), "Microsoft title".to_owned(),
"title contains Microsoft".to_owned(), "title contains Microsoft".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Linux subtitle".to_owned(), "Linux subtitle".to_owned(),
"subtitle contains Stallman".to_owned(), "subtitle contains Stallman".to_owned(),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Microsoft subtitle".to_owned(), "Microsoft subtitle".to_owned(),
"subtitle contains Nadella".to_owned(), "subtitle contains Nadella".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Linux content".to_owned(), "Linux content".to_owned(),
"content contains Linux".to_owned(), "content contains Linux".to_owned(),
) )
.unwrap(); .unwrap();
assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
let tl = Timeline::new_for_user( let tl = Timeline::new_for_user(
&conn, conn,
users[0].id, users[0].id,
"Microsoft content".to_owned(), "Microsoft content".to_owned(),
"subtitle contains Windows".to_owned(), "subtitle contains Windows".to_owned(),
) )
.unwrap(); .unwrap();
assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap()); assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
tl.delete(&conn).unwrap(); tl.delete(conn).unwrap();
Ok(()) Ok(())
}); });

6
plume-models/src/timeline/query.rs
View File

@ -11,7 +11,7 @@ use crate::{
use plume_common::activity_pub::inbox::AsActor; use plume_common::activity_pub::inbox::AsActor;
use whatlang::{self, Lang}; use whatlang::{self, Lang};
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum QueryError { pub enum QueryError {
SyntaxError(usize, usize, String), SyntaxError(usize, usize, String),
UnexpectedEndOfQuery, UnexpectedEndOfQuery,
@ -20,7 +20,7 @@ pub enum QueryError {
pub type QueryResult<T> = std::result::Result<T, QueryError>; pub type QueryResult<T> = std::result::Result<T, QueryError>;
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Kind<'a> { pub enum Kind<'a> {
Original, Original,
Reshare(&'a User), Reshare(&'a User),
@ -292,7 +292,7 @@ impl WithList {
WithList::Author { boosts, likes } => match kind { WithList::Author { boosts, likes } => match kind {
Kind::Original => Ok(list Kind::Original => Ok(list
.iter() .iter()
.filter_map(|a| User::find_by_fqn(&*conn, a).ok()) .filter_map(|a| User::find_by_fqn(conn, a).ok())
.any(|a| post.is_author(conn, a.id).unwrap_or(false))), .any(|a| post.is_author(conn, a.id).unwrap_or(false))),
Kind::Reshare(u) => { Kind::Reshare(u) => {
if *boosts { if *boosts {

50
plume-models/src/users.rs
View File

@ -187,7 +187,7 @@ impl User {
users::table users::table
.filter(users::instance_id.eq(Instance::get_local()?.id)) .filter(users::instance_id.eq(Instance::get_local()?.id))
.count() .count()
.get_result(&*conn) .get_result(conn)
.map_err(Error::from) .map_err(Error::from)
} }
@ -435,7 +435,7 @@ impl User {
} }
// if no user was found, and we were unable to auto-register from ldap // if no user was found, and we were unable to auto-register from ldap
// fake-verify a password, and return an error. // fake-verify a password, and return an error.
let other = User::get(&*conn, 1) let other = User::get(conn, 1)
.expect("No user is registered") .expect("No user is registered")
.hashed_password; .hashed_password;
other.map(|pass| bcrypt::verify(password, &pass)); other.map(|pass| bcrypt::verify(password, &pass));
@ -931,7 +931,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for User {
.cookies() .cookies()
.get_private(AUTH_COOKIE) .get_private(AUTH_COOKIE)
.and_then(|cookie| cookie.value().parse().ok()) .and_then(|cookie| cookie.value().parse().ok())
.and_then(|id| User::get(&*conn, id).ok()) .and_then(|id| User::get(&conn, id).ok())
.or_forward(()) .or_forward(())
} }
} }
@ -1232,7 +1232,7 @@ pub(crate) mod tests {
) )
.unwrap(); .unwrap();
other.avatar_id = Some(avatar.id); other.avatar_id = Some(avatar.id);
let other = other.save_changes::<User>(&*conn).unwrap(); let other = other.save_changes::<User>(conn).unwrap();
vec![admin, user, other] vec![admin, user, other]
} }
@ -1335,11 +1335,11 @@ pub(crate) mod tests {
fn delete() { fn delete() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let inserted = fill_database(&conn); let inserted = fill_database(conn);
assert!(User::get(&conn, inserted[0].id).is_ok()); assert!(User::get(conn, inserted[0].id).is_ok());
inserted[0].delete(&conn).unwrap(); inserted[0].delete(conn).unwrap();
assert!(User::get(&conn, inserted[0].id).is_err()); assert!(User::get(conn, inserted[0].id).is_err());
Ok(()) Ok(())
}); });
} }
@ -1348,20 +1348,20 @@ pub(crate) mod tests {
fn admin() { fn admin() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
let inserted = fill_database(&conn); let inserted = fill_database(conn);
let local_inst = Instance::get_local().unwrap(); let local_inst = Instance::get_local().unwrap();
let mut i = 0; let mut i = 0;
while local_inst.has_admin(&conn).unwrap() { while local_inst.has_admin(conn).unwrap() {
assert!(i < 100); //prevent from looping indefinitelly assert!(i < 100); //prevent from looping indefinitelly
local_inst local_inst
.main_admin(&conn) .main_admin(conn)
.unwrap() .unwrap()
.set_role(&conn, Role::Normal) .set_role(conn, Role::Normal)
.unwrap(); .unwrap();
i += 1; i += 1;
} }
inserted[0].set_role(&conn, Role::Admin).unwrap(); inserted[0].set_role(conn, Role::Admin).unwrap();
assert_eq!(inserted[0].id, local_inst.main_admin(&conn).unwrap().id); assert_eq!(inserted[0].id, local_inst.main_admin(conn).unwrap().id);
Ok(()) Ok(())
}); });
} }
@ -1370,9 +1370,9 @@ pub(crate) mod tests {
fn auth() { fn auth() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
fill_database(&conn); fill_database(conn);
let test_user = NewUser::new_local( let test_user = NewUser::new_local(
&conn, conn,
"test".to_owned(), "test".to_owned(),
"test user".to_owned(), "test user".to_owned(),
Role::Normal, Role::Normal,
@ -1383,10 +1383,10 @@ pub(crate) mod tests {
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
User::login(&conn, "test", "test_password").unwrap().id, User::login(conn, "test", "test_password").unwrap().id,
test_user.id test_user.id
); );
assert!(User::login(&conn, "test", "other_password").is_err()); assert!(User::login(conn, "test", "other_password").is_err());
Ok(()) Ok(())
}); });
} }
@ -1395,26 +1395,26 @@ pub(crate) mod tests {
fn get_local_page() { fn get_local_page() {
let conn = &db(); let conn = &db();
conn.test_transaction::<_, (), _>(|| { conn.test_transaction::<_, (), _>(|| {
fill_database(&conn); fill_database(conn);
let page = User::get_local_page(&conn, (0, 2)).unwrap(); let page = User::get_local_page(conn, (0, 2)).unwrap();
assert_eq!(page.len(), 2); assert_eq!(page.len(), 2);
assert!(page[0].username <= page[1].username); assert!(page[0].username <= page[1].username);
let mut last_username = User::get_local_page(&conn, (0, 1)).unwrap()[0] let mut last_username = User::get_local_page(conn, (0, 1)).unwrap()[0]
.username .username
.clone(); .clone();
for i in 1..User::count_local(&conn).unwrap() as i32 { for i in 1..User::count_local(conn).unwrap() as i32 {
let page = User::get_local_page(&conn, (i, i + 1)).unwrap(); let page = User::get_local_page(conn, (i, i + 1)).unwrap();
assert_eq!(page.len(), 1); assert_eq!(page.len(), 1);
assert!(last_username <= page[0].username); assert!(last_username <= page[0].username);
last_username = page[0].username.clone(); last_username = page[0].username.clone();
} }
assert_eq!( assert_eq!(
User::get_local_page(&conn, (0, User::count_local(&conn).unwrap() as i32 + 10)) User::get_local_page(conn, (0, User::count_local(conn).unwrap() as i32 + 10))
.unwrap() .unwrap()
.len() as i64, .len() as i64,
User::count_local(&conn).unwrap() User::count_local(conn).unwrap()
); );
Ok(()) Ok(())
}); });

2
src/api/apps.rs
View File

@ -10,7 +10,7 @@ pub fn create(conn: DbConn, data: Json<NewAppData>) -> Api<App> {
let client_id = random_hex(); let client_id = random_hex();
let client_secret = random_hex(); let client_secret = random_hex();
let app = App::insert( let app = App::insert(
&*conn, &conn,
NewApp { NewApp {
name: data.name.clone(), name: data.name.clone(),
client_id, client_id,

26
src/routes/blogs.rs
View File

@ -160,7 +160,7 @@ pub fn delete(name: String, conn: DbConn, rockets: PlumeRocket) -> RespondOrRedi
.and_then(|u| u.is_author_in(&conn, &blog).ok()) .and_then(|u| u.is_author_in(&conn, &blog).ok())
.unwrap_or(false) .unwrap_or(false)
{ {
blog.delete(&*conn).expect("blog::expect: deletion error"); blog.delete(&conn).expect("blog::expect: deletion error");
Flash::success( Flash::success(
Redirect::to(uri!(super::instance::index)), Redirect::to(uri!(super::instance::index)),
i18n!(rockets.intl.catalog, "Your blog was deleted."), i18n!(rockets.intl.catalog, "Your blog was deleted."),
@ -364,7 +364,7 @@ pub fn outbox_page(
#[get("/~/<name>/atom.xml")] #[get("/~/<name>/atom.xml")]
pub fn atom_feed(name: String, conn: DbConn) -> Option<Content<String>> { pub fn atom_feed(name: String, conn: DbConn) -> Option<Content<String>> {
let blog = Blog::find_by_fqn(&conn, &name).ok()?; let blog = Blog::find_by_fqn(&conn, &name).ok()?;
let entries = Post::get_recents_for_blog(&*conn, &blog, 15).ok()?; let entries = Post::get_recents_for_blog(&conn, &blog, 15).ok()?;
let uri = Instance::get_local() let uri = Instance::get_local()
.ok()? .ok()?
.compute_box("~", &name, "atom.xml"); .compute_box("~", &name, "atom.xml");
@ -454,9 +454,9 @@ mod tests {
long_description_html: "<p>Good morning</p>".to_string(), long_description_html: "<p>Good morning</p>".to_string(),
short_description: SafeString::new("Hello"), short_description: SafeString::new("Hello"),
short_description_html: "<p>Hello</p>".to_string(), short_description_html: "<p>Hello</p>".to_string(),
name: random_hex().to_string(), name: random_hex(),
open_registrations: true, open_registrations: true,
public_domain: random_hex().to_string(), public_domain: random_hex(),
}, },
) )
.unwrap(); .unwrap();
@ -465,18 +465,18 @@ mod tests {
}); });
let mut user = NewUser::default(); let mut user = NewUser::default();
user.instance_id = instance.id; user.instance_id = instance.id;
user.username = random_hex().to_string(); user.username = random_hex();
user.ap_url = random_hex().to_string(); user.ap_url = random_hex();
user.inbox_url = random_hex().to_string(); user.inbox_url = random_hex();
user.outbox_url = random_hex().to_string(); user.outbox_url = random_hex();
user.followers_endpoint = random_hex().to_string(); user.followers_endpoint = random_hex();
let user = User::insert(conn, user).unwrap(); let user = User::insert(conn, user).unwrap();
let mut blog = NewBlog::default(); let mut blog = NewBlog::default();
blog.instance_id = instance.id; blog.instance_id = instance.id;
blog.actor_id = random_hex().to_string(); blog.actor_id = random_hex();
blog.ap_url = random_hex().to_string(); blog.ap_url = random_hex();
blog.inbox_url = random_hex().to_string(); blog.inbox_url = random_hex();
blog.outbox_url = random_hex().to_string(); blog.outbox_url = random_hex();
let blog = Blog::insert(conn, blog).unwrap(); let blog = Blog::insert(conn, blog).unwrap();
BlogAuthor::insert( BlogAuthor::insert(
conn, conn,

2
src/routes/comments.rs
View File

@ -125,7 +125,7 @@ pub fn create(
user.has_reshared(&conn, &post) user.has_reshared(&conn, &post)
.expect("comments::create: reshared error"), .expect("comments::create: reshared error"),
user.is_following( user.is_following(
&*conn, &conn,
post.get_authors(&conn) post.get_authors(&conn)
.expect("comments::create: authors error")[0] .expect("comments::create: authors error")[0]
.id .id

10
src/routes/instance.rs
View File

@ -105,7 +105,7 @@ pub fn update_settings(
Instance::get_local().expect("instance::update_settings: local instance error"); Instance::get_local().expect("instance::update_settings: local instance error");
instance instance
.update( .update(
&*conn, &conn,
form.name.clone(), form.name.clone(),
form.open_registrations, form.open_registrations,
form.short_description.clone(), form.short_description.clone(),
@ -366,8 +366,8 @@ pub fn edit_users(
} }
fn ban(id: i32, conn: &Connection, worker: &ScheduledThreadPool) -> Result<(), ErrorPage> { fn ban(id: i32, conn: &Connection, worker: &ScheduledThreadPool) -> Result<(), ErrorPage> {
let u = User::get(&*conn, id)?; let u = User::get(conn, id)?;
u.delete(&*conn)?; u.delete(conn)?;
if Instance::get_local() if Instance::get_local()
.map(|i| u.instance_id == i.id) .map(|i| u.instance_id == i.id)
.unwrap_or(false) .unwrap_or(false)
@ -382,8 +382,8 @@ fn ban(id: i32, conn: &Connection, worker: &ScheduledThreadPool) -> Result<(), E
}, },
) )
.unwrap(); .unwrap();
let target = User::one_by_instance(&*conn)?; let target = User::one_by_instance(conn)?;
let delete_act = u.delete_activity(&*conn)?; let delete_act = u.delete_activity(conn)?;
worker.execute(move || broadcast(&u, delete_act, target, CONFIG.proxy().cloned())); worker.execute(move || broadcast(&u, delete_act, target, CONFIG.proxy().cloned()));
} }

10
src/routes/likes.rs
View File

@ -20,14 +20,14 @@ pub fn create(
let b = Blog::find_by_fqn(&conn, &blog)?; let b = Blog::find_by_fqn(&conn, &blog)?;
let post = Post::find_by_slug(&conn, &slug, b.id)?; let post = Post::find_by_slug(&conn, &slug, b.id)?;
if !user.has_liked(&*conn, &post)? { if !user.has_liked(&conn, &post)? {
let like = likes::Like::insert(&*conn, likes::NewLike::new(&post, &user))?; let like = likes::Like::insert(&conn, likes::NewLike::new(&post, &user))?;
like.notify(&*conn)?; like.notify(&conn)?;
Timeline::add_to_all_timelines(&conn, &post, Kind::Like(&user))?; Timeline::add_to_all_timelines(&conn, &post, Kind::Like(&user))?;
let dest = User::one_by_instance(&*conn)?; let dest = User::one_by_instance(&conn)?;
let act = like.to_activity(&*conn)?; let act = like.to_activity(&conn)?;
rockets rockets
.worker .worker
.execute(move || broadcast(&user, act, dest, CONFIG.proxy().cloned())); .execute(move || broadcast(&user, act, dest, CONFIG.proxy().cloned()));

8
src/routes/medias.rs
View File

@ -145,9 +145,9 @@ pub fn details(
#[post("/medias/<id>/delete")] #[post("/medias/<id>/delete")]
pub fn delete(id: i32, user: User, conn: DbConn, intl: I18n) -> Result<Flash<Redirect>, ErrorPage> { pub fn delete(id: i32, user: User, conn: DbConn, intl: I18n) -> Result<Flash<Redirect>, ErrorPage> {
let media = Media::get(&*conn, id)?; let media = Media::get(&conn, id)?;
if media.owner_id == user.id { if media.owner_id == user.id {
media.delete(&*conn)?; media.delete(&conn)?;
Ok(Flash::success( Ok(Flash::success(
Redirect::to(uri!(list: page = _)), Redirect::to(uri!(list: page = _)),
i18n!(intl.catalog, "Your media have been deleted."), i18n!(intl.catalog, "Your media have been deleted."),
@ -167,9 +167,9 @@ pub fn set_avatar(
conn: DbConn, conn: DbConn,
intl: I18n, intl: I18n,
) -> Result<Flash<Redirect>, ErrorPage> { ) -> Result<Flash<Redirect>, ErrorPage> {
let media = Media::get(&*conn, id)?; let media = Media::get(&conn, id)?;
if media.owner_id == user.id { if media.owner_id == user.id {
user.set_avatar(&*conn, media.id)?; user.set_avatar(&conn, media.id)?;
Ok(Flash::success( Ok(Flash::success(
Redirect::to(uri!(details: id = id)), Redirect::to(uri!(details: id = id)),
i18n!(intl.catalog, "Your avatar has been updated."), i18n!(intl.catalog, "Your avatar has been updated."),

2
src/routes/mod.rs
View File

@ -165,7 +165,7 @@ fn post_to_atom(post: Post, conn: &Connection) -> Entry {
.build(), .build(),
) )
.authors( .authors(
post.get_authors(&*conn) post.get_authors(conn)
.expect("Atom feed: author error") .expect("Atom feed: author error")
.into_iter() .into_iter()
.map(|a| { .map(|a| {

12
src/routes/user.rs
View File

@ -48,10 +48,10 @@ pub fn me(user: Option<User>) -> RespondOrRedirect {
#[get("/@/<name>", rank = 2)] #[get("/@/<name>", rank = 2)]
pub fn details(name: String, rockets: PlumeRocket, conn: DbConn) -> Result<Ructe, ErrorPage> { pub fn details(name: String, rockets: PlumeRocket, conn: DbConn) -> Result<Ructe, ErrorPage> {
let user = User::find_by_fqn(&conn, &name)?; let user = User::find_by_fqn(&conn, &name)?;
let recents = Post::get_recents_for_author(&*conn, &user, 6)?; let recents = Post::get_recents_for_author(&conn, &user, 6)?;
let reshares = Reshare::get_recents_for_author(&*conn, &user, 6)?; let reshares = Reshare::get_recents_for_author(&conn, &user, 6)?;
if !user.get_instance(&*conn)?.local { if !user.get_instance(&conn)?.local {
tracing::trace!("remote user found"); tracing::trace!("remote user found");
user.remote_user_found(); // Doesn't block user.remote_user_found(); // Doesn't block
} }
@ -62,14 +62,14 @@ pub fn details(name: String, rockets: PlumeRocket, conn: DbConn) -> Result<Ructe
rockets rockets
.user .user
.clone() .clone()
.and_then(|x| x.is_following(&*conn, user.id).ok()) .and_then(|x| x.is_following(&conn, user.id).ok())
.unwrap_or(false), .unwrap_or(false),
user.instance_id != Instance::get_local()?.id, user.instance_id != Instance::get_local()?.id,
user.get_instance(&*conn)?.public_domain, user.get_instance(&conn)?.public_domain,
recents, recents,
reshares reshares
.into_iter() .into_iter()
.filter_map(|r| r.get_post(&*conn).ok()) .filter_map(|r| r.get_post(&conn).ok())
.collect() .collect()
))) )))
} }

4
src/routes/well_known.rs
View File

@ -50,10 +50,10 @@ impl Resolver<DbConn> for WebfingerResolver {
fn find(prefix: Prefix, acct: String, conn: DbConn) -> Result<Webfinger, ResolverError> { fn find(prefix: Prefix, acct: String, conn: DbConn) -> Result<Webfinger, ResolverError> {
match prefix { match prefix {
Prefix::Acct => User::find_by_fqn(&conn, &acct) Prefix::Acct => User::find_by_fqn(&conn, &acct)
.and_then(|usr| usr.webfinger(&*conn)) .and_then(|usr| usr.webfinger(&conn))
.or(Err(ResolverError::NotFound)), .or(Err(ResolverError::NotFound)),
Prefix::Group => Blog::find_by_fqn(&conn, &acct) Prefix::Group => Blog::find_by_fqn(&conn, &acct)
.and_then(|blog| blog.webfinger(&*conn)) .and_then(|blog| blog.webfinger(&conn))
.or(Err(ResolverError::NotFound)), .or(Err(ResolverError::NotFound)),
Prefix::Custom(_) => Err(ResolverError::NotFound), Prefix::Custom(_) => Err(ResolverError::NotFound),
} }

2
src/template_utils.rs
View File

@ -85,7 +85,7 @@ impl<'r> Responder<'r> for Ructe {
macro_rules! render { macro_rules! render {
($group:tt :: $page:tt ( $( $param:expr ),* ) ) => { ($group:tt :: $page:tt ( $( $param:expr ),* ) ) => {
{ {
use crate::templates; use $crate::templates;
let mut res = vec![]; let mut res = vec![];
templates::$group::$page( templates::$group::$page(