dojo/scootaloo
1
0
Fork 0
mirror of https://framagit.org/veretcle/scootaloo.git synced 2025-07-20 17:11:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

style: fmt & clippy processed

Browse Source
This commit is contained in:
VC
2022-08-11 12:29:40 +02:00
parent dab8725f99
commit b11595bfca
10 changed files with 297 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.gitlab-ci.yml
View File

@@ -10,6 +10,11 @@ rust-latest:
- target/release/scootaloo - target/release/scootaloo
image: rust:latest image: rust:latest
script: script:
- rustup component add rustfmt
- rustup component add clippy
- cargo fmt -- --check
- cargo check
- cargo clippy -- -D warnings
- cargo test - cargo test
- cargo build --release --verbose - cargo build --release --verbose
- strip target/release/${CI_PROJECT_NAME} - strip target/release/${CI_PROJECT_NAME}

13
src/config.rs
View File

@@ -1,5 +1,5 @@
use std::fs::read_to_string;
use serde::Deserialize; use serde::Deserialize;
use std::fs::read_to_string;
/// General configuration Struct /// General configuration Struct
#[derive(Debug, Deserialize)] #[derive(Debug, Deserialize)]
@@ -35,14 +35,11 @@ pub struct ScootalooConfig {
/// Parses the TOML file into a Config Struct /// Parses the TOML file into a Config Struct
pub fn parse_toml(toml_file: &str) -> Config { pub fn parse_toml(toml_file: &str) -> Config {
let toml_config = read_to_string(toml_file).unwrap_or_else(|e| let toml_config = read_to_string(toml_file)
panic!("Cannot open config file {}: {}", toml_file, e) .unwrap_or_else(|e| panic!("Cannot open config file {}: {}", toml_file, e));
);
let config: Config = toml::from_str(&toml_config).unwrap_or_else(|e| let config: Config = toml::from_str(&toml_config)
panic!("Cannot parse TOML file {}: {}", toml_file, e) .unwrap_or_else(|e| panic!("Cannot parse TOML file {}: {}", toml_file, e));
);
config config
} }

3
src/error.rs
View File

@@ -1,6 +1,6 @@
use std::{ use std::{
fmt::{Display, Formatter, Result},
error::Error, error::Error,
fmt::{Display, Formatter, Result},
}; };
#[derive(Debug)] #[derive(Debug)]
@@ -23,4 +23,3 @@ impl Display for ScootalooError {
write!(f, "{}", self.details) write!(f, "{}", self.details)
} }
} }

100
src/lib.rs
View File

@@ -2,12 +2,12 @@ mod error;
use error::ScootalooError; use error::ScootalooError;
mod config; mod config;
use config::Config;
pub use config::parse_toml; pub use config::parse_toml;
use config::Config;
mod mastodon; mod mastodon;
use mastodon::{get_mastodon_token, build_basic_status};
pub use mastodon::register; pub use mastodon::register;
use mastodon::{build_basic_status, get_mastodon_token};
mod twitter; mod twitter;
use twitter::*; use twitter::*;
@@ -15,31 +15,28 @@ use twitter::*;
mod util; mod util;
mod state; mod state;
use state::{read_state, write_state, TweetToToot};
pub use state::init_db; pub use state::init_db;
use state::{read_state, write_state, TweetToToot};
use elefren::{prelude::*, status_builder::StatusBuilder};
use log::{debug, error, info, warn};
use rusqlite::Connection;
use std::borrow::Cow; use std::borrow::Cow;
use tokio::fs::remove_file; use tokio::fs::remove_file;
use elefren::{
prelude::*,
status_builder::StatusBuilder,
};
use log::{info, warn, error, debug};
use rusqlite::Connection;
/// This is where the magic happens /// This is where the magic happens
#[tokio::main] #[tokio::main]
pub async fn run(config: Config) { pub async fn run(config: Config) {
// open the SQLite connection // open the SQLite connection
let conn = Connection::open(&config.scootaloo.db_path) let conn = Connection::open(&config.scootaloo.db_path).unwrap_or_else(|e| {
.unwrap_or_else(|e| panic!(
panic!("Something went wrong when opening the DB {}: {}", &config.scootaloo.db_path, e) "Something went wrong when opening the DB {}: {}",
); &config.scootaloo.db_path, e
)
});
// retrieve the last tweet ID for the username // retrieve the last tweet ID for the username
let last_tweet_id = read_state(&conn, None) let last_tweet_id = read_state(&conn, None)
.unwrap_or_else(|e| .unwrap_or_else(|e| panic!("Cannot retrieve last_tweet_id: {}", e))
panic!("Cannot retrieve last_tweet_id: {}", e)
)
.map(|s| s.tweet_id); .map(|s| s.tweet_id);
// get OAuth2 token // get OAuth2 token
@@ -51,9 +48,12 @@ pub async fn run(config: Config) {
// get user timeline feed (Vec<tweet>) // get user timeline feed (Vec<tweet>)
let mut feed = get_user_timeline(&config.twitter, token, last_tweet_id) let mut feed = get_user_timeline(&config.twitter, token, last_tweet_id)
.await .await
.unwrap_or_else(|e| .unwrap_or_else(|e| {
panic!("Something went wrong when trying to retrieve {}’s timeline: {}", &config.twitter.username, e) panic!(
); "Something went wrong when trying to retrieve {}’s timeline: {}",
&config.twitter.username, e
)
});
// empty feed -> exiting // empty feed -> exiting
if feed.is_empty() { if feed.is_empty() {
@@ -69,34 +69,37 @@ pub async fn run(config: Config) {
// initiate the toot_reply_id var // initiate the toot_reply_id var
let mut toot_reply_id: Option<String> = None; let mut toot_reply_id: Option<String> = None;
// determine if the tweet is part of a thread (response to self) or a standard response // determine if the tweet is part of a thread (response to self) or a standard response
if let Some(r) = &tweet.in_reply_to_screen_name { if let Some(r) = &tweet.in_reply_to_screen_name {
if &r.to_lowercase() != &config.twitter.username.to_lowercase() { if r.to_lowercase() != config.twitter.username.to_lowercase() {
// we are responding not threading // we are responding not threading
info!("Tweet is a direct response, skipping"); info!("Tweet is a direct response, skipping");
continue; continue;
} }
info!("Tweet is a thread"); info!("Tweet is a thread");
toot_reply_id = read_state(&conn, tweet.in_reply_to_status_id) toot_reply_id = read_state(&conn, tweet.in_reply_to_status_id)
.unwrap_or(None) .unwrap_or(None)
.map(|s| s.toot_id); .map(|s| s.toot_id);
}; };
// build basic status by just yielding text and dereferencing contained urls // build basic status by just yielding text and dereferencing contained urls
let mut status_text = build_basic_status(tweet); let mut status_text = build_basic_status(tweet);
let mut status_medias: Vec<String> = vec![]; let mut status_medias: Vec<String> = vec![];
// reupload the attachments if any // reupload the attachments if any
if let Some(m) = &tweet.extended_entities { if let Some(m) = &tweet.extended_entities {
for media in &m.media { for media in &m.media {
let local_tweet_media_path = match get_tweet_media(&media, &config.scootaloo.cache_path).await { let local_tweet_media_path =
Ok(m) => m, match get_tweet_media(media, &config.scootaloo.cache_path).await {
Err(e) => { Ok(m) => m,
error!("Cannot get tweet media for {}: {}", &media.url, e); Err(e) => {
continue; error!("Cannot get tweet media for {}: {}", &media.url, e);
}, continue;
}; }
};
let mastodon_media_ids = match mastodon.media(Cow::from(local_tweet_media_path.to_owned())) { let mastodon_media_ids = match mastodon
.media(Cow::from(local_tweet_media_path.to_owned()))
{
Ok(m) => { Ok(m) => {
remove_file(&local_tweet_media_path) remove_file(&local_tweet_media_path)
.await .await
@@ -104,9 +107,12 @@ pub async fn run(config: Config) {
warn!("Attachment for {} has been uploaded, but I’m unable to remove the existing file: {}", &local_tweet_media_path, e) warn!("Attachment for {} has been uploaded, but I’m unable to remove the existing file: {}", &local_tweet_media_path, e)
); );
m.id m.id
}, }
Err(e) => { Err(e) => {
error!("Attachment {} cannot be uploaded to Mastodon Instance: {}", &local_tweet_media_path, e); error!(
"Attachment {} cannot be uploaded to Mastodon Instance: {}",
&local_tweet_media_path, e
);
continue; continue;
} }
}; };
@@ -123,15 +129,15 @@ pub async fn run(config: Config) {
let mut status_builder = StatusBuilder::new(); let mut status_builder = StatusBuilder::new();
status_builder.status(&status_text) status_builder.status(&status_text).media_ids(status_medias);
.media_ids(status_medias);
if let Some(i) = toot_reply_id { if let Some(i) = toot_reply_id {
status_builder.in_reply_to(&i); status_builder.in_reply_to(&i);
} }
let status = status_builder.build() let status = status_builder
.expect(&format!("Cannot build status with text {}", &status_text)); .build()
.unwrap_or_else(|_| panic!("Cannot build status with text {}", &status_text));
// publish status // publish status
// again unwrap is safe here as we are in the main thread // again unwrap is safe here as we are in the main thread
@@ -145,9 +151,7 @@ pub async fn run(config: Config) {
}; };
// write the current state (tweet ID and toot ID) to avoid copying it another time // write the current state (tweet ID and toot ID) to avoid copying it another time
write_state(&conn, ttt_towrite).unwrap_or_else(|e| write_state(&conn, ttt_towrite)
panic!("Can’t write the last tweet retrieved: {}", e) .unwrap_or_else(|e| panic!("Can’t write the last tweet retrieved: {}", e));
);
} }
} }

112
src/main.rs
View File

@@ -1,70 +1,91 @@
use scootaloo::*;
use clap::{App, Arg, SubCommand}; use clap::{App, Arg, SubCommand};
use log::{LevelFilter, error}; use log::{error, LevelFilter};
use scootaloo::*;
use simple_logger::SimpleLogger; use simple_logger::SimpleLogger;
use std::str::FromStr; use std::str::FromStr;
const DEFAULT_CONFIG_PATH: &'static str = "/usr/local/etc/scootaloo.toml"; const DEFAULT_CONFIG_PATH: &str = "/usr/local/etc/scootaloo.toml";
fn main() { fn main() {
let matches = App::new(env!("CARGO_PKG_NAME")) let matches = App::new(env!("CARGO_PKG_NAME"))
.version(env!("CARGO_PKG_VERSION")) .version(env!("CARGO_PKG_VERSION"))
.about("A Twitter to Mastodon bot") .about("A Twitter to Mastodon bot")
.arg(Arg::with_name("config") .arg(
.short("c") Arg::with_name("config")
.long("config") .short("c")
.value_name("CONFIG_FILE") .long("config")
.help(&format!("TOML config file for scootaloo (default {})", DEFAULT_CONFIG_PATH)) .value_name("CONFIG_FILE")
.takes_value(true) .help(&format!(
.display_order(1)) "TOML config file for scootaloo (default {})",
.arg(Arg::with_name("log_level") DEFAULT_CONFIG_PATH
.short("l") ))
.long("loglevel") .takes_value(true)
.value_name("LOGLEVEL") .display_order(1),
.help("Log level. Valid values are: Off, Warn, Error, Info, Debug") )
.takes_value(true) .arg(
.display_order(2)) Arg::with_name("log_level")
.subcommand(SubCommand::with_name("register") .short("l")
.version(env!("CARGO_PKG_VERSION")) .long("loglevel")
.about("Command to register to a Mastodon Instance") .value_name("LOGLEVEL")
.arg(Arg::with_name("host") .help("Log level. Valid values are: Off, Warn, Error, Info, Debug")
.short("H") .takes_value(true)
.long("host") .display_order(2),
.value_name("HOST") )
.help("Base URL of the Mastodon instance to register to (no default)") .subcommand(
.takes_value(true) SubCommand::with_name("register")
.required(true) .version(env!("CARGO_PKG_VERSION"))
.display_order(1))) .about("Command to register to a Mastodon Instance")
.subcommand(SubCommand::with_name("init") .arg(
.version(env!("CARGO_PKG_VERSION")) Arg::with_name("host")
.about("Command to init Scootaloo DB") .short("H")
.arg(Arg::with_name("config") .long("host")
.short("c") .value_name("HOST")
.long("config") .help("Base URL of the Mastodon instance to register to (no default)")
.value_name("CONFIG_FILE") .takes_value(true)
.help(&format!("TOML config file for scootaloo (default {})", DEFAULT_CONFIG_PATH)) .required(true)
.takes_value(true) .display_order(1),
.display_order(1))) ),
.get_matches(); )
.subcommand(
SubCommand::with_name("init")
.version(env!("CARGO_PKG_VERSION"))
.about("Command to init Scootaloo DB")
.arg(
Arg::with_name("config")
.short("c")
.long("config")
.value_name("CONFIG_FILE")
.help(&format!(
"TOML config file for scootaloo (default {})",
DEFAULT_CONFIG_PATH
))
.takes_value(true)
.display_order(1),
),
)
.get_matches();
match matches.subcommand() { match matches.subcommand() {
("register", Some(sub_m)) => { ("register", Some(sub_m)) => {
register(sub_m.value_of("host").unwrap()); register(sub_m.value_of("host").unwrap());
return; return;
}, }
("init", Some(sub_m)) => { ("init", Some(sub_m)) => {
let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH)); let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
init_db(&config.scootaloo.db_path).unwrap(); init_db(&config.scootaloo.db_path).unwrap();
return; return;
}, }
_ => (), _ => (),
} }
if matches.is_present("log_level") { if matches.is_present("log_level") {
match LevelFilter::from_str(matches.value_of("log_level").unwrap()) { match LevelFilter::from_str(matches.value_of("log_level").unwrap()) {
Ok(level) => { SimpleLogger::new().with_level(level).init().unwrap()}, Ok(level) => SimpleLogger::new().with_level(level).init().unwrap(),
Err(e) => { Err(e) => {
SimpleLogger::new().with_level(LevelFilter::Error).init().unwrap(); SimpleLogger::new()
.with_level(LevelFilter::Error)
.init()
.unwrap();
error!("Unknown log level filter: {}", e); error!("Unknown log level filter: {}", e);
} }
}; };
@@ -74,4 +95,3 @@ fn main() {
run(config); run(config);
} }

82
src/mastodon.rs
View File

@@ -1,36 +1,37 @@
use crate::config::MastodonConfig; use crate::config::MastodonConfig;
use std::{
borrow::Cow,
collections::HashMap,
io::stdin,
};
use html_escape::decode_html_entities;
use egg_mode::{ use egg_mode::{
entities::{MentionEntity, UrlEntity},
tweet::Tweet, tweet::Tweet,
entities::{UrlEntity, MentionEntity},
};
use elefren::{
prelude::*,
apps::App,
scopes::Scopes,
}; };
use elefren::{apps::App, prelude::*, scopes::Scopes};
use html_escape::decode_html_entities;
use std::{borrow::Cow, collections::HashMap, io::stdin};
/// Decodes the Twitter mention to something that will make sense once Twitter has joined the /// Decodes the Twitter mention to something that will make sense once Twitter has joined the
/// Fediverse /// Fediverse
fn twitter_mentions(ums: &Vec<MentionEntity>) -> HashMap<String, String> { fn twitter_mentions(ums: &[MentionEntity]) -> HashMap<String, String> {
ums.iter().map(|s| ums.iter()
(format!("@{}", s.screen_name), format!("@{}@twitter.com", s.screen_name)) .map(|s| {
).collect() (
format!("@{}", s.screen_name),
format!("@{}@twitter.com", s.screen_name),
)
})
.collect()
} }
/// Decodes urls from UrlEntities /// Decodes urls from UrlEntities
fn decode_urls(urls: &Vec<UrlEntity>) -> HashMap<String, String> { fn decode_urls(urls: &[UrlEntity]) -> HashMap<String, String> {
urls.iter() urls.iter()
.filter(|s| s.expanded_url.is_some()) .filter(|s| s.expanded_url.is_some())
.map(|s| .map(|s| {
(s.url.to_owned(), s.expanded_url.as_deref().unwrap().to_owned()) (
).collect() s.url.to_owned(),
s.expanded_url.as_deref().unwrap().to_owned(),
)
})
.collect()
} }
/// Gets Mastodon Data /// Gets Mastodon Data
@@ -66,36 +67,50 @@ pub fn build_basic_status(tweet: &Tweet) -> String {
/// Most of this function is a direct copy/paste of the official `elefren` crate /// Most of this function is a direct copy/paste of the official `elefren` crate
pub fn register(host: &str) { pub fn register(host: &str) {
let mut builder = App::builder(); let mut builder = App::builder();
builder.client_name(Cow::from(env!("CARGO_PKG_NAME").to_string())) builder
.client_name(Cow::from(env!("CARGO_PKG_NAME").to_string()))
.redirect_uris(Cow::from("urn:ietf:wg:oauth:2.0:oob".to_string())) .redirect_uris(Cow::from("urn:ietf:wg:oauth:2.0:oob".to_string()))
.scopes(Scopes::write_all()) .scopes(Scopes::write_all())
.website(Cow::from("https://framagit.org/veretcle/scootaloo".to_string())); .website(Cow::from(
"https://framagit.org/veretcle/scootaloo".to_string(),
));
let app = builder.build().expect("Cannot build the app"); let app = builder.build().expect("Cannot build the app");
let registration = Registration::new(host).register(app).expect("Cannot build registration object"); let registration = Registration::new(host)
let url = registration.authorize_url().expect("Cannot generate registration URI!"); .register(app)
.expect("Cannot build registration object");
let url = registration
.authorize_url()
.expect("Cannot generate registration URI!");
println!("Click this link to authorize on Mastodon: {}", url); println!("Click this link to authorize on Mastodon: {}", url);
println!("Paste the returned authorization code: "); println!("Paste the returned authorization code: ");
let mut input = String::new(); let mut input = String::new();
stdin().read_line(&mut input).expect("Unable to read back registration code!"); stdin()
.read_line(&mut input)
.expect("Unable to read back registration code!");
let code = input.trim(); let code = input.trim();
let mastodon = registration.complete(code).expect("Unable to create access token!"); let mastodon = registration
.complete(code)
.expect("Unable to create access token!");
let toml = toml::to_string(&*mastodon).unwrap(); let toml = toml::to_string(&*mastodon).unwrap();
println!("Please insert the following block at the end of your configuration file:\n[mastodon]\n{}", toml); println!(
"Please insert the following block at the end of your configuration file:\n[mastodon]\n{}",
toml
);
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use egg_mode::tweet::TweetEntities;
use chrono::prelude::*; use chrono::prelude::*;
use egg_mode::tweet::TweetEntities;
#[test] #[test]
fn test_twitter_mentions() { fn test_twitter_mentions() {
@@ -109,7 +124,10 @@ mod tests {
let twitter_ums = vec![mention_entity]; let twitter_ums = vec![mention_entity];
let mut expected_mentions = HashMap::new(); let mut expected_mentions = HashMap::new();
expected_mentions.insert("@tamerelol".to_string(), "@tamerelol@twitter.com".to_string()); expected_mentions.insert(
"@tamerelol".to_string(),
"@tamerelol@twitter.com".to_string(),
);
let decoded_mentions = twitter_mentions(&twitter_ums); let decoded_mentions = twitter_mentions(&twitter_ums);
@@ -135,7 +153,10 @@ mod tests {
let twitter_urls = vec![url_entity1, url_entity2]; let twitter_urls = vec![url_entity1, url_entity2];
let mut expected_urls = HashMap::new(); let mut expected_urls = HashMap::new();
expected_urls.insert("https://t.me/tamerelol".to_string(), "https://www.nintendojo.fr/dojobar".to_string()); expected_urls.insert(
"https://t.me/tamerelol".to_string(),
"https://www.nintendojo.fr/dojobar".to_string(),
);
let decoded_urls = decode_urls(&twitter_urls); let decoded_urls = decode_urls(&twitter_urls);
@@ -200,4 +221,3 @@ mod tests {
assert_eq!(&t_out, "Mother 1 & 2 sur le NES/SNES online !\nDispo maintenant. cc @NintendoFrance@twitter.com https://www.youtube.com/watch?v=w5TrSaoYmZ8"); assert_eq!(&t_out, "Mother 1 & 2 sur le NES/SNES online !\nDispo maintenant. cc @NintendoFrance@twitter.com https://www.youtube.com/watch?v=w5TrSaoYmZ8");
} }
} }

65
src/state.rs
View File

@@ -1,6 +1,6 @@
use std::error::Error;
use log::debug; use log::debug;
use rusqlite::{Connection, params, OptionalExtension}; use rusqlite::{params, Connection, OptionalExtension};
use std::error::Error;
/// Struct for each query line /// Struct for each query line
#[derive(Debug)] #[derive(Debug)]
@@ -11,22 +11,26 @@ pub struct TweetToToot {
/// if None is passed, read the last tweet from DB /// if None is passed, read the last tweet from DB
/// if a tweet_id is passed, read this particular tweet from DB /// if a tweet_id is passed, read this particular tweet from DB
pub fn read_state(conn: &Connection, s: Option<u64>) -> Result<Option<TweetToToot>, Box<dyn Error>> { pub fn read_state(
conn: &Connection,
s: Option<u64>,
) -> Result<Option<TweetToToot>, Box<dyn Error>> {
debug!("Reading tweet_id {:?}", s); debug!("Reading tweet_id {:?}", s);
let query: String; let query: String = match s {
match s { Some(i) => format!("SELECT * FROM tweet_to_toot WHERE tweet_id = {}", i),
Some(i) => query = format!("SELECT * FROM tweet_to_toot WHERE tweet_id = {}", i), None => "SELECT * FROM tweet_to_toot ORDER BY tweet_id DESC LIMIT 1".to_string(),
None => query = "SELECT * FROM tweet_to_toot ORDER BY tweet_id DESC LIMIT 1".to_string(),
}; };
let mut stmt = conn.prepare(&query)?; let mut stmt = conn.prepare(&query)?;
let t = stmt.query_row([], |row| { let t = stmt
Ok(TweetToToot { .query_row([], |row| {
tweet_id: row.get(0)?, Ok(TweetToToot {
toot_id: row.get(1)?, tweet_id: row.get(0)?,
toot_id: row.get(1)?,
})
}) })
}).optional()?; .optional()?;
Ok(t) Ok(t)
} }
@@ -37,7 +41,7 @@ pub fn write_state(conn: &Connection, t: TweetToToot) -> Result<(), Box<dyn Erro
conn.execute( conn.execute(
"INSERT INTO tweet_to_toot (tweet_id, toot_id) VALUES (?1, ?2)", "INSERT INTO tweet_to_toot (tweet_id, toot_id) VALUES (?1, ?2)",
params![t.tweet_id, t.toot_id], params![t.tweet_id, t.toot_id],
)?; )?;
Ok(()) Ok(())
} }
@@ -61,10 +65,7 @@ pub fn init_db(d: &str) -> Result<(), Box<dyn Error>> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use std::{ use std::{fs::remove_file, path::Path};
fs::remove_file,
path::Path,
};
#[test] #[test]
fn test_init_db() { fn test_init_db() {
@@ -77,10 +78,7 @@ mod tests {
// open said file // open said file
let conn = Connection::open(d).unwrap(); let conn = Connection::open(d).unwrap();
conn.execute( conn.execute("SELECT * from tweet_to_toot;", []).unwrap();
"SELECT * from tweet_to_toot;",
[],
).unwrap();
remove_file(d).unwrap(); remove_file(d).unwrap();
} }
@@ -99,7 +97,8 @@ mod tests {
VALUES VALUES
(100, 'A');", (100, 'A');",
[], [],
).unwrap(); )
.unwrap();
init_db(d).unwrap(); init_db(d).unwrap();
@@ -123,12 +122,14 @@ mod tests {
let mut stmt = conn.prepare("SELECT * FROM tweet_to_toot;").unwrap(); let mut stmt = conn.prepare("SELECT * FROM tweet_to_toot;").unwrap();
let t_out = stmt.query_row([], |row| { let t_out = stmt
Ok(TweetToToot { .query_row([], |row| {
tweet_id: row.get(0).unwrap(), Ok(TweetToToot {
toot_id: row.get(1).unwrap(), tweet_id: row.get(0).unwrap(),
toot_id: row.get(1).unwrap(),
})
}) })
}).unwrap(); .unwrap();
assert_eq!(t_out.tweet_id, 123456789); assert_eq!(t_out.tweet_id, 123456789);
assert_eq!(t_out.toot_id, "987654321".to_string()); assert_eq!(t_out.toot_id, "987654321".to_string());
@@ -150,7 +151,8 @@ mod tests {
(101, 'A'), (101, 'A'),
(102, 'B');", (102, 'B');",
[], [],
).unwrap(); )
.unwrap();
let t_out = read_state(&conn, None).unwrap().unwrap(); let t_out = read_state(&conn, None).unwrap().unwrap();
@@ -188,7 +190,8 @@ mod tests {
VALUES VALUES
(100, 'A');", (100, 'A');",
[], [],
).unwrap(); )
.unwrap();
let t_out = read_state(&conn, Some(101)).unwrap(); let t_out = read_state(&conn, Some(101)).unwrap();
@@ -210,7 +213,8 @@ mod tests {
VALUES VALUES
(100, 'A');", (100, 'A');",
[], [],
).unwrap(); )
.unwrap();
let t_out = read_state(&conn, Some(100)).unwrap().unwrap(); let t_out = read_state(&conn, Some(100)).unwrap().unwrap();
@@ -220,4 +224,3 @@ mod tests {
assert_eq!(t_out.toot_id, "A"); assert_eq!(t_out.toot_id, "A");
} }
} }

74
src/twitter.rs
View File

@@ -1,23 +1,25 @@
use crate::ScootalooError;
use crate::config::TwitterConfig; use crate::config::TwitterConfig;
use crate::util::cache_media; use crate::util::cache_media;
use crate::ScootalooError;
use std::error::Error;
use egg_mode::{ use egg_mode::{
Token,
KeyPair,
entities::{MediaEntity, MediaType}, entities::{MediaEntity, MediaType},
tweet::{user_timeline, Tweet},
user::UserID, user::UserID,
tweet::{ KeyPair, Token,
Tweet,
user_timeline,
},
}; };
use std::error::Error;
/// Gets Twitter oauth2 token /// Gets Twitter oauth2 token
pub fn get_oauth2_token(config: &TwitterConfig) -> Token { pub fn get_oauth2_token(config: &TwitterConfig) -> Token {
let con_token = KeyPair::new(config.consumer_key.to_owned(),config.consumer_secret.to_owned()); let con_token = KeyPair::new(
let access_token = KeyPair::new(config.access_key.to_owned(), config.access_secret.to_owned()); config.consumer_key.to_owned(),
config.consumer_secret.to_owned(),
);
let access_token = KeyPair::new(
config.access_key.to_owned(),
config.access_secret.to_owned(),
);
Token::Access { Token::Access {
consumer: con_token, consumer: con_token,
@@ -26,12 +28,21 @@ pub fn get_oauth2_token(config: &TwitterConfig) -> Token {
} }
/// Gets Twitter user timeline /// Gets Twitter user timeline
pub async fn get_user_timeline(config: &TwitterConfig, token: Token, lid: Option<u64>) -> Result<Vec<Tweet>, Box<dyn Error>> { pub async fn get_user_timeline(
config: &TwitterConfig,
token: Token,
lid: Option<u64>,
) -> Result<Vec<Tweet>, Box<dyn Error>> {
// fix the page size to 200 as it is the maximum Twitter authorizes // fix the page size to 200 as it is the maximum Twitter authorizes
let (_, feed) = user_timeline(UserID::from(config.username.to_owned()), true, false, &token) let (_, feed) = user_timeline(
.with_page_size(200) UserID::from(config.username.to_owned()),
.older(lid) true,
.await?; false,
&token,
)
.with_page_size(200)
.older(lid)
.await?;
Ok(feed.to_vec()) Ok(feed.to_vec())
} }
@@ -41,22 +52,27 @@ pub async fn get_tweet_media(m: &MediaEntity, t: &str) -> Result<String, Box<dyn
match m.media_type { match m.media_type {
MediaType::Photo => { MediaType::Photo => {
return cache_media(&m.media_url_https, t).await; return cache_media(&m.media_url_https, t).await;
}, }
_ => { _ => match &m.video_info {
match &m.video_info { Some(v) => {
Some(v) => { for variant in &v.variants {
for variant in &v.variants { if variant.content_type == "video/mp4" {
if variant.content_type == "video/mp4" { return cache_media(&variant.url, t).await;
return cache_media(&variant.url, t).await;
}
} }
return Err(ScootalooError::new(&format!("Media Type for {} is video but no mp4 file URL is available", &m.url)).into()); }
}, return Err(ScootalooError::new(&format!(
None => { "Media Type for {} is video but no mp4 file URL is available",
return Err(ScootalooError::new(&format!("Media Type for {} is video but does not contain any video_info", &m.url)).into()); &m.url
}, ))
.into());
}
None => {
return Err(ScootalooError::new(&format!(
"Media Type for {} is video but does not contain any video_info",
&m.url
))
.into());
} }
}, },
}; };
} }

34
src/util.rs
View File

@@ -1,9 +1,9 @@
use std::error::Error;
use crate::ScootalooError; use crate::ScootalooError;
use reqwest::Url; use reqwest::Url;
use std::error::Error;
use tokio::{ use tokio::{
fs::{create_dir_all, File},
io::copy, io::copy,
fs::{File, create_dir_all},
}; };
/// Gets and caches Twitter Media inside the determined temp dir /// Gets and caches Twitter Media inside the determined temp dir
@@ -16,8 +16,21 @@ pub async fn cache_media(u: &str, t: &str) -> Result<String, Box<dyn Error>> {
// create local file // create local file
let url = Url::parse(u)?; let url = Url::parse(u)?;
let dest_filename = url.path_segments().ok_or_else(|| ScootalooError::new(&format!("Cannot determine the destination filename for {}", u)))? let dest_filename = url
.last().ok_or_else(|| ScootalooError::new(&format!("Cannot determine the destination filename for {}", u)))?; .path_segments()
.ok_or_else(|| {
ScootalooError::new(&format!(
"Cannot determine the destination filename for {}",
u
))
})?
.last()
.ok_or_else(|| {
ScootalooError::new(&format!(
"Cannot determine the destination filename for {}",
u
))
})?;
let dest_filepath = format!("{}/{}", t, dest_filename); let dest_filepath = format!("{}/{}", t, dest_filename);
@@ -34,20 +47,21 @@ pub async fn cache_media(u: &str, t: &str) -> Result<String, Box<dyn Error>> {
mod tests { mod tests {
use super::*; use super::*;
use std::{ use std::{fs::remove_dir_all, path::Path};
path::Path,
fs::remove_dir_all,
};
const TMP_DIR: &'static str = "/tmp/scootaloo_test"; const TMP_DIR: &'static str = "/tmp/scootaloo_test";
#[tokio::test] #[tokio::test]
async fn test_cache_media() { async fn test_cache_media() {
let dest = cache_media("https://forum.nintendojo.fr/styles/prosilver/theme/images/ndfr_casual.png", TMP_DIR).await.unwrap(); let dest = cache_media(
"https://forum.nintendojo.fr/styles/prosilver/theme/images/ndfr_casual.png",
TMP_DIR,
)
.await
.unwrap();
assert!(Path::new(&dest).exists()); assert!(Path::new(&dest).exists());
remove_dir_all(TMP_DIR).unwrap(); remove_dir_all(TMP_DIR).unwrap();
} }
} }

18
tests/config.rs
View File

@@ -4,7 +4,10 @@ use scootaloo::parse_toml;
fn test_parse_good_toml() { fn test_parse_good_toml() {
let parse_good_toml = parse_toml("tests/good_test.toml"); let parse_good_toml = parse_toml("tests/good_test.toml");
assert_eq!(parse_good_toml.scootaloo.db_path, "/var/random/scootaloo.sqlite"); assert_eq!(
parse_good_toml.scootaloo.db_path,
"/var/random/scootaloo.sqlite"
);
assert_eq!(parse_good_toml.scootaloo.cache_path, "/tmp/scootaloo"); assert_eq!(parse_good_toml.scootaloo.cache_path, "/tmp/scootaloo");
assert_eq!(parse_good_toml.twitter.username, "tamerelol"); assert_eq!(parse_good_toml.twitter.username, "tamerelol");
@@ -16,18 +19,25 @@ fn test_parse_good_toml() {
assert_eq!(parse_good_toml.mastodon.base, "https://m.nintendojo.fr"); assert_eq!(parse_good_toml.mastodon.base, "https://m.nintendojo.fr");
assert_eq!(parse_good_toml.mastodon.client_id, "rand client id"); assert_eq!(parse_good_toml.mastodon.client_id, "rand client id");
assert_eq!(parse_good_toml.mastodon.client_secret, "secret"); assert_eq!(parse_good_toml.mastodon.client_secret, "secret");
assert_eq!(parse_good_toml.mastodon.redirect, "urn:ietf:wg:oauth:2.0:oob"); assert_eq!(
parse_good_toml.mastodon.redirect,
"urn:ietf:wg:oauth:2.0:oob"
);
assert_eq!(parse_good_toml.mastodon.token, "super secret"); assert_eq!(parse_good_toml.mastodon.token, "super secret");
} }
#[test] #[test]
#[should_panic(expected = "Cannot open config file tests/no_file.toml: No such file or directory (os error 2)")] #[should_panic(
expected = "Cannot open config file tests/no_file.toml: No such file or directory (os error 2)"
)]
fn test_parse_no_toml() { fn test_parse_no_toml() {
let _parse_no_toml = parse_toml("tests/no_file.toml"); let _parse_no_toml = parse_toml("tests/no_file.toml");
} }
#[test] #[test]
#[should_panic(expected = "Cannot parse TOML file tests/bad_test.toml: expected an equals, found a newline at line 1 column 5")] #[should_panic(
expected = "Cannot parse TOML file tests/bad_test.toml: expected an equals, found a newline at line 1 column 5"
)]
fn test_parse_bad_toml() { fn test_parse_bad_toml() {
let _parse_bad_toml = parse_toml("tests/bad_test.toml"); let _parse_bad_toml = parse_toml("tests/bad_test.toml");
} }