Merge branch 'fix_french_inclusive_writing' into 'master'

feat: allow user to remove some links, replace some links by others

See merge request veretcle/scootaloo!38

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scootaloo"
-version = "0.7.0"
+version = "0.11.0"
 authors = ["VC <veretcle+framagit@mateu.be>"]
 edition = "2021"
 
@@ -8,13 +8,14 @@ edition = "2021"
 
 [dependencies]
 chrono = "^0.4"
+regex = "^1"
 serde = { version = "1.0", features = ["derive"] }
 toml = "^0.5"
-clap = "^2.34"
-futures = "^0.3"
+clap = "^4"
 egg-mode = "^0.16"
 rusqlite = "^0.27"
-tokio = { version = "1", features = ["full"]}
+tokio = { version = "^1", features = ["full"]}
+futures = "^0.3"
 elefren = "^0.22"
 html-escape = "^0.2"
 reqwest = "^0.11"

README.md

@@ -18,9 +18,24 @@ First up, create a configuration file (default path is `/usr/local/etc/scootaloo
 [scootaloo]
 db_path = "/var/lib/scootaloo/scootaloo.sqlite" ## file containing the SQLite Tweet corresponding Toot DB, must be writeable
 cache_path = "/tmp/scootaloo" ## a dir where the temporary files will be download, must be writeable
+rate_limiting = 4 ## optional, default 4, number of accounts handled simultaneously
+## optional, this should be omitted the majority of the time
+## sometimes, twitter try to use french inclusive writting, but instead of using `·` (median point), they’re using `.`
+## this makes twitter interpret it as a URL, which is wrong
+## this parameter allows you to catch such URLs and apply the `display_url` (i.e. `tout.es`) instead of the `expanded_url` (i.e. `http://tout.es`)
+## in those particular cases
+## (!) use with caution, it might have some undesired effects
+show_url_as_display_url_for = "^http(s)://(.+)\\.es$"
+## optional, this allows you to replace the host for popular services such as YouTube of Twitter, or any other
+## with their more freely accessible equivalent
+[scootaloo.alternative_services_for]
+"tamere.lol" = "tonpere.mdr" ## quotes are necessary for both parameters
+"you.pi" = "you.pla"
+"www.you.pi" = "you.pla" ## this is an exact match, so you’ll need to lay out all the possibilities
 
 [twitter]
 ## Consumer/Access key for Twitter (can be generated at https://developer.twitter.com/en/apps)
+page_size = 20 ## optional, default 200, max number of tweet retrieved
 consumer_key = "MYCONSUMERKEY"
 consumer_secret = "MYCONSUMERSECRET"
 access_key = "MYACCESSKEY"
@@ -45,7 +60,8 @@ This will give you the end of the TOML file. It will look like this:
 
 ```toml
 [mastodon.nintendojofr] ## account
-twitter_screen_name="NintendojoFR" ## User Timeline to copy
+twitter_screen_name = "NintendojoFR" ## User Timeline to copy
+mastodon_screen_name = "nintendojofr" ## optional, Mastodon account name used for smart mentions
 base = "https://m.nintendojo.fr"
 client_id = "MYCLIENTID"
 client_secret = "MYCLIENTSECRET"
@@ -55,6 +71,11 @@ token = "MYTOKEN"
 
 You can add other account if you like, after the `[mastodon]` moniker. Scootaloo would theorically support an unlimited number of accounts.
 
+You can also add a custom twitter page size in this section that would override the global (under the `twitter` moniker) and default one (200), like so:
+```
+twitter_page_size = 40
+```
+
 ## Running
 
 You can then run the application via `cron` for example. Here is the generic usage:

src/config.rs

@@ -16,11 +16,14 @@ pub struct TwitterConfig {
     pub consumer_secret: String,
     pub access_key: String,
     pub access_secret: String,
+    pub page_size: Option<i32>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct MastodonConfig {
     pub twitter_screen_name: String,
+    pub mastodon_screen_name: Option<String>,
+    pub twitter_page_size: Option<i32>,
     pub base: String,
     pub client_id: String,
     pub client_secret: String,
@@ -32,6 +35,9 @@ pub struct MastodonConfig {
 pub struct ScootalooConfig {
     pub db_path: String,
     pub cache_path: String,
+    pub rate_limit: Option<usize>,
+    pub show_url_as_display_url_for: Option<String>,
+    pub alternative_services_for: Option<HashMap<String, String>>,
 }
 
 /// Parses the TOML file into a Config Struct

src/error.rs

@@ -1,8 +1,12 @@
 use std::{
+    boxed::Box,
+    convert::From,
     error::Error,
     fmt::{Display, Formatter, Result},
 };
 
+use elefren::Error as elefrenError;
+
 #[derive(Debug)]
 pub struct ScootalooError {
     details: String,
@@ -23,3 +27,15 @@ impl Display for ScootalooError {
         write!(f, "{}", self.details)
     }
 }
+
+impl From<Box<dyn Error>> for ScootalooError {
+    fn from(error: Box<dyn Error>) -> Self {
+        ScootalooError::new(&format!("Error in a subset crate: {}", error))
+    }
+}
+
+impl From<elefrenError> for ScootalooError {
+    fn from(error: elefrenError) -> Self {
+        ScootalooError::new(&format!("Error in elefren crate: {}", error))
+    }
+}

src/lib.rs

@@ -13,152 +13,174 @@ mod twitter;
 use twitter::*;
 
 mod util;
+use crate::util::generate_media_ids;
 
 mod state;
 pub use state::{init_db, migrate_db};
 use state::{read_state, write_state, TweetToToot};
 
-use elefren::{prelude::*, status_builder::StatusBuilder};
-use log::{debug, error, info, warn};
+use elefren::{prelude::*, status_builder::StatusBuilder, Language};
+use futures::StreamExt;
+use log::info;
+use regex::Regex;
 use rusqlite::Connection;
-use std::borrow::Cow;
-use tokio::fs::remove_file;
+use std::{collections::HashMap, sync::Arc};
+use tokio::{spawn, sync::Mutex};
+
+const DEFAULT_RATE_LIMIT: usize = 4;
+const DEFAULT_PAGE_SIZE: i32 = 200;
 
 /// This is where the magic happens
 #[tokio::main]
 pub async fn run(config: Config) {
-    // get OAuth2 token
-    let token = get_oauth2_token(&config.twitter);
-
-    for mastodon_config in config.mastodon.values() {
-        // open the SQLite connection
-        let conn = Connection::open(&config.scootaloo.db_path).unwrap_or_else(|e| {
+    // open the SQLite connection
+    let conn = Arc::new(Mutex::new(
+        Connection::open(&config.scootaloo.db_path).unwrap_or_else(|e| {
             panic!(
                 "Something went wrong when opening the DB {}: {}",
                 &config.scootaloo.db_path, e
             )
-        });
-        // retrieve the last tweet ID for the username
-        let last_tweet_id = read_state(&conn, &mastodon_config.twitter_screen_name, None)
-            .unwrap_or_else(|e| panic!("Cannot retrieve last_tweet_id: {}", e))
-            .map(|s| s.tweet_id);
+        }),
+    ));
 
-        // get Mastodon instance
-        let mastodon = get_mastodon_token(mastodon_config);
+    let scootaloo_mentions: HashMap<String, String> = config
+        .mastodon
+        .values()
+        .filter(|s| s.mastodon_screen_name.is_some())
+        .map(|s| {
+            (
+                format!("@{}", s.twitter_screen_name),
+                format!(
+                    "@{}@{}",
+                    s.mastodon_screen_name.as_ref().unwrap(),
+                    s.base.split('/').last().unwrap()
+                ),
+            )
+        })
+        .collect();
 
-        // get user timeline feed (Vec<tweet>)
-        let mut feed = get_user_timeline(mastodon_config, &token, last_tweet_id)
-            .await
-            .unwrap_or_else(|e| {
-                panic!(
-                    "Something went wrong when trying to retrieve {}’s timeline: {}",
-                    &mastodon_config.twitter_screen_name, e
-                )
-            });
+    let display_url_re = config
+        .scootaloo
+        .show_url_as_display_url_for
+        .as_ref()
+        .map(|r|
+        // we want to panic in case the RE is not valid
+        Regex::new(r).unwrap());
 
-        // empty feed -> exiting
-        if feed.is_empty() {
-            info!("Nothing to retrieve since last time, exiting…");
-            return;
-        }
+    let mut stream = futures::stream::iter(config.mastodon.into_values())
+        .map(|mastodon_config| {
+            // calculate Twitter page size
+            let page_size = mastodon_config
+                .twitter_page_size
+                .unwrap_or_else(|| config.twitter.page_size.unwrap_or(DEFAULT_PAGE_SIZE));
 
-        // order needs to be chronological
-        feed.reverse();
+            // create temporary value for each task
+            let scootaloo_cache_path = config.scootaloo.cache_path.clone();
+            let scootaloo_mentions = scootaloo_mentions.clone();
+            let scootaloo_alt_services = config.scootaloo.alternative_services_for.clone();
+            let display_url_re = display_url_re.clone();
+            let token = get_oauth2_token(&config.twitter);
+            let task_conn = conn.clone();
 
-        for tweet in &feed {
-            debug!("Treating Tweet {} inside feed", tweet.id);
-            // initiate the toot_reply_id var
-            let mut toot_reply_id: Option<String> = None;
-            // 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 r.to_lowercase() != mastodon_config.twitter_screen_name.to_lowercase() {
-                    // we are responding not threadin
-                    info!("Tweet is a direct response, skipping");
-                    continue;
-                }
-                info!("Tweet is a thread");
-                toot_reply_id = read_state(
-                    &conn,
+            spawn(async move {
+                info!("Starting treating {}", &mastodon_config.twitter_screen_name);
+                // retrieve the last tweet ID for the username
+                let lconn = task_conn.lock().await;
+                let last_tweet_id = read_state(&lconn, &mastodon_config.twitter_screen_name, None)?
+                    .map(|r| r.tweet_id);
+                drop(lconn);
+
+                // get reversed, curated user timeline
+                let feed = get_user_timeline(
                     &mastodon_config.twitter_screen_name,
-                    tweet.in_reply_to_status_id,
+                    &token,
+                    last_tweet_id,
+                    page_size,
                 )
-                .unwrap_or(None)
-                .map(|s| s.toot_id);
-            };
+                .await?;
 
-            // build basic status by just yielding text and dereferencing contained urls
-            let mut status_text = build_basic_status(tweet);
+                // get Mastodon instance
+                let mastodon = get_mastodon_token(&mastodon_config);
 
-            let mut status_medias: Vec<String> = vec![];
-            // reupload the attachments if any
-            if let Some(m) = &tweet.extended_entities {
-                for media in &m.media {
-                    let local_tweet_media_path =
-                        match get_tweet_media(media, &config.scootaloo.cache_path).await {
-                            Ok(m) => m,
-                            Err(e) => {
-                                error!("Cannot get tweet media for {}: {}", &media.url, e);
-                                continue;
-                            }
-                        };
+                for tweet in &feed {
+                    info!("Treating Tweet {} inside feed", tweet.id);
 
-                    let mastodon_media_ids = match mastodon
-                        .media(Cow::from(local_tweet_media_path.to_owned()))
-                    {
-                        Ok(m) => {
-                            remove_file(&local_tweet_media_path)
-                            .await
-                            .unwrap_or_else(|e|
-                                warn!("Attachment for {} has been uploaded, but I’m unable to remove the existing file: {}", &local_tweet_media_path, e)
-                            );
-                            m.id
-                        }
-                        Err(e) => {
-                            error!(
-                                "Attachment {} cannot be uploaded to Mastodon Instance: {}",
-                                &local_tweet_media_path, e
-                            );
-                            continue;
+                    let lconn = task_conn.lock().await;
+                    // initiate the toot_reply_id var and retrieve the corresponding toot_id
+                    let toot_reply_id: Option<String> = tweet.in_reply_to_user_id.and_then(|_| {
+                        read_state(
+                            &lconn,
+                            &mastodon_config.twitter_screen_name,
+                            tweet.in_reply_to_status_id,
+                        )
+                        .unwrap_or(None)
+                        .map(|s| s.toot_id)
+                    });
+                    drop(lconn);
+
+                    // build basic status by just yielding text and dereferencing contained urls
+                    let mut status_text = build_basic_status(
+                        tweet,
+                        &scootaloo_mentions,
+                        &display_url_re,
+                        &scootaloo_alt_services,
+                    );
+
+                    // building associative media list
+                    let (media_url, status_medias) =
+                        generate_media_ids(tweet, &scootaloo_cache_path, &mastodon).await;
+
+                    status_text = status_text.replace(&media_url, "");
+
+                    info!("Building corresponding Mastodon status");
+
+                    let mut status_builder = StatusBuilder::new();
+
+                    status_builder.status(&status_text).media_ids(status_medias);
+
+                    // theard if necessary
+                    if let Some(i) = toot_reply_id {
+                        status_builder.in_reply_to(&i);
+                    }
+
+                    // language if any
+                    if let Some(l) = &tweet.lang {
+                        if let Some(r) = Language::from_639_1(l) {
+                            status_builder.language(r);
                         }
+                    }
+
+                    // can be activated for test purposes
+                    // status_builder.visibility(elefren::status_builder::Visibility::Private);
+
+                    let status = status_builder.build()?;
+
+                    let published_status = mastodon.new_status(status)?;
+                    // this will return if it cannot publish the status preventing the last_tweet from
+                    // being written into db
+
+                    let ttt_towrite = TweetToToot {
+                        twitter_screen_name: mastodon_config.twitter_screen_name.clone(),
+                        tweet_id: tweet.id,
+                        toot_id: published_status.id,
                     };
 
-                    status_medias.push(mastodon_media_ids);
-
-                    // last step, removing the reference to the media from with the toot’s text
-                    status_text = status_text.replace(&media.url, "");
+                    // write the current state (tweet ID and toot ID) to avoid copying it another time
+                    let lconn = task_conn.lock().await;
+                    write_state(&lconn, ttt_towrite)?;
+                    drop(lconn);
                 }
-            }
-            // finished reuploading attachments, now let’s do the toot baby!
+                Ok::<(), ScootalooError>(())
+            })
+        })
+        .buffer_unordered(config.scootaloo.rate_limit.unwrap_or(DEFAULT_RATE_LIMIT));
 
-            debug!("Building corresponding Mastodon status");
-
-            let mut status_builder = StatusBuilder::new();
-
-            status_builder.status(&status_text).media_ids(status_medias);
-
-            if let Some(i) = toot_reply_id {
-                status_builder.in_reply_to(&i);
-            }
-
-            let status = status_builder
-                .build()
-                .unwrap_or_else(|_| panic!("Cannot build status with text {}", &status_text));
-
-            // publish status
-            // again unwrap is safe here as we are in the main thread
-            let published_status = mastodon.new_status(status).unwrap();
-            // this will panic if it cannot publish the status, which is a good thing, it allows the
-            // last_tweet gathered not to be written
-
-            let ttt_towrite = TweetToToot {
-                twitter_screen_name: mastodon_config.twitter_screen_name.clone(),
-                tweet_id: tweet.id,
-                toot_id: published_status.id,
-            };
-
-            // write the current state (tweet ID and toot ID) to avoid copying it another time
-            write_state(&conn, ttt_towrite)
-                .unwrap_or_else(|e| panic!("Can’t write the last tweet retrieved: {}", e));
+    // launch and wait for every handle
+    while let Some(result) = stream.next().await {
+        match result {
+            Ok(Err(e)) => eprintln!("Error within thread: {}", e),
+            Err(e) => eprintln!("Error with thread: {}", e),
+            _ => (),
         }
     }
 }

src/main.rs

@@ -1,5 +1,5 @@
-use clap::{App, Arg, SubCommand};
-use log::{error, LevelFilter};
+use clap::{Arg, Command};
+use log::LevelFilter;
 use scootaloo::*;
 use simple_logger::SimpleLogger;
 use std::str::FromStr;
@@ -7,115 +7,118 @@ use std::str::FromStr;
 const DEFAULT_CONFIG_PATH: &str = "/usr/local/etc/scootaloo.toml";
 
 fn main() {
-    let matches = App::new(env!("CARGO_PKG_NAME"))
+    let matches = Command::new(env!("CARGO_PKG_NAME"))
         .version(env!("CARGO_PKG_VERSION"))
         .about("A Twitter to Mastodon bot")
         .arg(
-            Arg::with_name("config")
-                .short("c")
+            Arg::new("config")
+                .short('c')
                 .long("config")
                 .value_name("CONFIG_FILE")
-                .help(&format!(
-                    "TOML config file for scootaloo (default {})",
-                    DEFAULT_CONFIG_PATH
-                ))
-                .takes_value(true)
+                .help("TOML config file for scootaloo")
+                .num_args(1)
+                .default_value(DEFAULT_CONFIG_PATH)
                 .display_order(1),
         )
         .arg(
-            Arg::with_name("log_level")
-                .short("l")
+            Arg::new("log_level")
+                .short('l')
                 .long("loglevel")
                 .value_name("LOGLEVEL")
-                .help("Log level. Valid values are: Off, Warn, Error, Info, Debug")
-                .takes_value(true)
+                .help("Log level")
+                .num_args(1)
+                .value_parser(["Off", "Warn", "Error", "Info", "Debug"])
                 .display_order(2),
         )
         .subcommand(
-            SubCommand::with_name("register")
+            Command::new("register")
                 .version(env!("CARGO_PKG_VERSION"))
                 .about("Command to register to a Mastodon Instance")
                 .arg(
-                    Arg::with_name("host")
-                        .short("H")
+                    Arg::new("host")
+                        .short('H')
                         .long("host")
                         .value_name("HOST")
                         .help("Base URL of the Mastodon instance to register to (no default)")
-                        .takes_value(true)
+                        .num_args(1)
                         .required(true)
                         .display_order(1)
                     )
                 .arg(
-                    Arg::with_name("name")
-                        .short("n")
+                    Arg::new("name")
+                        .short('n')
                         .long("name")
                         .help("Twitter Screen Name (like https://twitter.com/screen_name, no default)")
-                        .takes_value(true)
+                        .num_args(1)
                         .required(true)
                         .display_order(2)
                 ),
         )
         .subcommand(
-            SubCommand::with_name("init")
+            Command::new("init")
                 .version(env!("CARGO_PKG_VERSION"))
                 .about("Command to init Scootaloo DB")
                 .arg(
-                    Arg::with_name("config")
-                        .short("c")
+                    Arg::new("config")
+                        .short('c')
                         .long("config")
                         .value_name("CONFIG_FILE")
                         .help(&format!(
                             "TOML config file for scootaloo (default {})",
                             DEFAULT_CONFIG_PATH
                         ))
-                        .takes_value(true)
+                        .default_value(DEFAULT_CONFIG_PATH)
+                        .num_args(1)
                         .display_order(1),
                 ),
         )
         .subcommand(
-            SubCommand::with_name("migrate")
+            Command::new("migrate")
             .version(env!("CARGO_PKG_VERSION"))
             .about("Command to migrate Scootaloo DB")
             .arg(
-                Arg::with_name("config")
-                    .short("c")
+                Arg::new("config")
+                    .short('c')
                     .long("config")
                     .value_name("CONFIG_FILE")
                     .help(&format!("TOML config file for scootaloo (default {})", DEFAULT_CONFIG_PATH))
-                    .takes_value(true)
+                    .default_value(DEFAULT_CONFIG_PATH)
+                    .num_args(1)
                     .display_order(1),
             )
             .arg(
-                    Arg::with_name("name")
-                        .short("n")
+                    Arg::new("name")
+                        .short('n')
                         .long("name")
                         .help("Twitter Screen Name (like https://twitter.com/screen_name, no default)")
-                        .takes_value(true)
+                        .num_args(1)
                         .display_order(2)
             )
         )
         .get_matches();
 
     match matches.subcommand() {
-        ("register", Some(sub_m)) => {
+        Some(("register", sub_m)) => {
             register(
-                sub_m.value_of("host").unwrap(),
-                sub_m.value_of("name").unwrap(),
+                sub_m.get_one::<String>("host").unwrap(),
+                sub_m.get_one::<String>("name").unwrap(),
             );
             return;
         }
-        ("init", Some(sub_m)) => {
-            let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
+        Some(("init", sub_m)) => {
+            let config = parse_toml(sub_m.get_one::<String>("config").unwrap());
             init_db(&config.scootaloo.db_path).unwrap();
             return;
         }
-        ("migrate", Some(sub_m)) => {
-            let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
+        Some(("migrate", sub_m)) => {
+            let config = parse_toml(sub_m.get_one::<String>("config").unwrap());
             let config_twitter_screen_name =
                 &config.mastodon.values().next().unwrap().twitter_screen_name;
             migrate_db(
                 &config.scootaloo.db_path,
-                sub_m.value_of("name").unwrap_or(config_twitter_screen_name),
+                sub_m
+                    .get_one::<String>("name")
+                    .unwrap_or(config_twitter_screen_name),
             )
             .unwrap();
             return;
@@ -123,20 +126,14 @@ fn main() {
         _ => (),
     }
 
-    if matches.is_present("log_level") {
-        match LevelFilter::from_str(matches.value_of("log_level").unwrap()) {
-            Ok(level) => SimpleLogger::new().with_level(level).init().unwrap(),
-            Err(e) => {
-                SimpleLogger::new()
-                    .with_level(LevelFilter::Error)
-                    .init()
-                    .unwrap();
-                error!("Unknown log level filter: {}", e);
-            }
-        };
+    if let Some(level) = matches.get_one::<String>("log_level") {
+        SimpleLogger::new()
+            .with_level(LevelFilter::from_str(level).unwrap())
+            .init()
+            .unwrap();
     }
 
-    let config = parse_toml(matches.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
+    let config = parse_toml(matches.get_one::<String>("config").unwrap());
 
     run(config);
 }

src/mastodon.rs

@@ -4,8 +4,9 @@ use egg_mode::{
     entities::{MentionEntity, UrlEntity},
     tweet::Tweet,
 };
-use elefren::{apps::App, prelude::*, scopes::Scopes};
+use elefren::{apps::App, prelude::*, scopes::Read, scopes::Scopes, scopes::Write};
 use html_escape::decode_html_entities;
+use regex::Regex;
 use std::{borrow::Cow, collections::HashMap, io::stdin};
 
 /// Decodes the Twitter mention to something that will make sense once Twitter has joined the
@@ -22,14 +23,34 @@ fn twitter_mentions(ums: &[MentionEntity]) -> HashMap<String, String> {
 }
 
 /// Decodes urls from UrlEntities
-fn decode_urls(urls: &[UrlEntity]) -> HashMap<String, String> {
+fn decode_urls(
+    urls: &[UrlEntity],
+    re: &Option<Regex>,
+    alt_urls: &Option<HashMap<String, String>>,
+) -> HashMap<String, String> {
     urls.iter()
         .filter(|s| s.expanded_url.is_some())
         .map(|s| {
-            (
-                s.url.to_owned(),
-                s.expanded_url.as_deref().unwrap().to_owned(),
-            )
+            (s.url.to_owned(), {
+                let mut def = s.expanded_url.as_deref().unwrap().to_owned();
+
+                if let Some(a) = &alt_urls {
+                    for (url_source, url_destination) in a {
+                        def = def.replace(
+                            &format!("https://{}", url_source),
+                            &format!("https://{}", url_destination),
+                        );
+                    }
+                }
+
+                if let Some(r) = &re {
+                    if r.is_match(s.expanded_url.as_deref().unwrap()) {
+                        def = s.display_url.clone();
+                    }
+                }
+
+                def
+            })
         })
         .collect()
 }
@@ -48,14 +69,23 @@ pub fn get_mastodon_token(masto: &MastodonConfig) -> Mastodon {
 }
 
 /// Builds toot text from tweet
-pub fn build_basic_status(tweet: &Tweet) -> String {
+pub fn build_basic_status(
+    tweet: &Tweet,
+    mentions: &HashMap<String, String>,
+    url_regex_filter: &Option<Regex>,
+    url_alt_services: &Option<HashMap<String, String>>,
+) -> String {
     let mut toot = tweet.text.to_owned();
 
-    for decoded_url in decode_urls(&tweet.entities.urls) {
+    for decoded_url in decode_urls(&tweet.entities.urls, url_regex_filter, url_alt_services) {
         toot = toot.replace(&decoded_url.0, &decoded_url.1);
     }
 
-    for decoded_mention in twitter_mentions(&tweet.entities.user_mentions) {
+    for decoded_mention in twitter_mentions(&tweet.entities.user_mentions)
+        .into_iter()
+        .chain(mentions.to_owned())
+        .collect::<HashMap<String, String>>()
+    {
         toot = toot.replace(&decoded_mention.0, &decoded_mention.1);
     }
 
@@ -70,7 +100,12 @@ pub fn register(host: &str, screen_name: &str) {
     builder
         .client_name(Cow::from(env!("CARGO_PKG_NAME").to_string()))
         .redirect_uris(Cow::from("urn:ietf:wg:oauth:2.0:oob".to_string()))
-        .scopes(Scopes::write_all())
+        .scopes(
+            Scopes::write(Write::Accounts)
+                .and(Scopes::write(Write::Media))
+                .and(Scopes::write(Write::Statuses))
+                .and(Scopes::read(Read::Accounts)),
+        )
         .website(Cow::from(
             "https://framagit.org/veretcle/scootaloo".to_string(),
         ));
@@ -99,13 +134,19 @@ pub fn register(host: &str, screen_name: &str) {
 
     let toml = toml::to_string(&*mastodon).unwrap();
 
+    let current_account = mastodon
+        .verify_credentials()
+        .expect("Unable to access account information!");
+
     println!(
         "Please insert the following block at the end of your configuration file:
-        \n[mastodon.{}]
-        \ntwitter_screen_name = \"{}\"
-        \n{}",
+[mastodon.{}]
+twitter_screen_name = \"{}\"
+mastodon_screen_name = \"{}\"
+{}",
         screen_name.to_lowercase(),
         screen_name,
+        current_account.username,
         toml
     );
 }
@@ -155,15 +196,51 @@ mod tests {
             url: "https://t.me/tamerelol".to_string(),
         };
 
-        let twitter_urls = vec![url_entity1, url_entity2];
+        let wrong_url_entity = UrlEntity {
+            display_url: "invité.es".to_string(),
+            expanded_url: Some("http://xn--invit-fsa.es".to_string()),
+            range: (85, 108),
+            url: "https://t.co/WAUgnpHLmo".to_string(),
+        };
 
-        let mut expected_urls = HashMap::new();
-        expected_urls.insert(
-            "https://t.me/tamerelol".to_string(),
-            "https://www.nintendojo.fr/dojobar".to_string(),
-        );
+        let rewritten_url_entity = UrlEntity {
+            display_url: "youtu.be/w5TrSaoYmZ8".to_string(),
+            expanded_url: Some("https://youtu.be/w5TrSaoYmZ8".to_string()),
+            range: (0, 23),
+            url: "https://t.co/fUVYXuF7tg".to_string(),
+        };
 
-        let decoded_urls = decode_urls(&twitter_urls);
+        let re = Regex::new("(.+)\\.es$").ok();
+
+        let alt: HashMap<String, String> = HashMap::from([
+            ("youtube.com".to_string(), "invidio.us".to_string()),
+            ("youtu.be".to_string(), "invidio.us".to_string()),
+            ("www.youtube.com".to_string(), "invidio.us".to_string()),
+        ]);
+
+        let twitter_urls = vec![
+            url_entity1,
+            url_entity2,
+            wrong_url_entity,
+            rewritten_url_entity,
+        ];
+
+        let expected_urls = HashMap::from([
+            (
+                "https://t.me/tamerelol".to_string(),
+                "https://www.nintendojo.fr/dojobar".to_string(),
+            ),
+            (
+                "https://t.co/WAUgnpHLmo".to_string(),
+                "invité.es".to_string(),
+            ),
+            (
+                "https://t.co/fUVYXuF7tg".to_string(),
+                "https://invidio.us/w5TrSaoYmZ8".to_string(),
+            ),
+        ]);
+
+        let decoded_urls = decode_urls(&twitter_urls, &re, &Some(alt));
 
         assert_eq!(expected_urls, decoded_urls);
     }
@@ -192,7 +269,13 @@ mod tests {
                             range: (80, 95),
                             name: "Nintendo France".to_string(),
                             screen_name: "NintendoFrance".to_string(),
-                        }
+                        },
+                        MentionEntity {
+                            id: 999999999,
+                            range: (80, 95),
+                            name: "Willy Wonka".to_string(),
+                            screen_name: "WillyWonka".to_string(),
+                        },
                     ],
                 media: None,
             },
@@ -213,7 +296,7 @@ mod tests {
             retweeted: None,
             retweeted_status: None,
             source: None,
-            text: "Mother 1 &amp; 2 sur le NES/SNES online !\nDispo maintenant. cc @NintendoFrance https://t.co/zXw0FfX2Nt".to_string(),
+            text: "Mother 1 &amp; 2 sur le NES/SNES online !\nDispo maintenant. cc @NintendoFrance @WillyWonka https://t.co/zXw0FfX2Nt".to_string(),
             truncated: false,
             user: None,
             withheld_copyright: false,
@@ -221,8 +304,13 @@ mod tests {
             withheld_scope: None,
         };
 
-        let t_out = build_basic_status(&t);
+        let s: HashMap<String, String> = HashMap::from([(
+            "@WillyWonka".to_string(),
+            "@WillyWonka@chocolatefactory.org".to_string(),
+        )]);
 
-        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");
+        let t_out = build_basic_status(&t, &s, &None, &None);
+
+        assert_eq!(&t_out, "Mother 1 & 2 sur le NES/SNES online !\nDispo maintenant. cc @NintendoFrance@twitter.com @WillyWonka@chocolatefactory.org https://www.youtube.com/watch?v=w5TrSaoYmZ8");
     }
 }

src/state.rs

@@ -87,7 +87,7 @@ pub fn migrate_db(d: &str, s: &str) -> Result<(), Box<dyn Error>> {
     match res {
         Err(e) => match e.to_string().as_str() {
             "duplicate column name: twitter_screen_name" => Ok(()),
-            _ => Err(Box::new(e)),
+            _ => Err(e.into()),
         },
         _ => Ok(()),
     }

src/twitter.rs

@@ -1,4 +1,3 @@
-use crate::config::MastodonConfig;
 use crate::config::TwitterConfig;
 use crate::util::cache_media;
 use crate::ScootalooError;
@@ -28,24 +27,31 @@ pub fn get_oauth2_token(config: &TwitterConfig) -> Token {
     }
 }
 
-/// Gets Twitter user timeline
+/// Gets Twitter user timeline, eliminate responses to others and reverse it
 pub async fn get_user_timeline(
-    config: &MastodonConfig,
+    screen_name: &str,
     token: &Token,
     lid: Option<u64>,
+    page_size: i32,
 ) -> Result<Vec<Tweet>, Box<dyn Error>> {
     // fix the page size to 200 as it is the maximum Twitter authorizes
-    let (_, feed) = user_timeline(
-        UserID::from(config.twitter_screen_name.to_owned()),
-        true,
-        false,
-        token,
-    )
-    .with_page_size(200)
-    .older(lid)
-    .await?;
+    let (_, feed) = user_timeline(UserID::from(screen_name.to_owned()), true, false, token)
+        .with_page_size(page_size)
+        .older(lid)
+        .await?;
 
-    Ok(feed.to_vec())
+    let mut feed: Vec<Tweet> = feed
+        .iter()
+        .cloned()
+        .filter(|t| match &t.in_reply_to_screen_name {
+            Some(r) => r.to_lowercase() == screen_name.to_lowercase(),
+            None => true,
+        })
+        .collect();
+
+    feed.reverse();
+
+    Ok(feed)
 }
 
 /// Retrieves a single media from a tweet and store it in a temporary file

src/util.rs

@@ -1,11 +1,80 @@
-use crate::ScootalooError;
+use crate::{twitter::get_tweet_media, ScootalooError};
+
+use std::{borrow::Cow, error::Error};
+
+use egg_mode::tweet::Tweet;
+
+use elefren::prelude::*;
+
+use log::{error, info, warn};
+
 use reqwest::Url;
-use std::error::Error;
+
 use tokio::{
-    fs::{create_dir_all, File},
+    fs::{create_dir_all, remove_file, File},
     io::copy,
 };
 
+use futures::{stream, stream::StreamExt};
+
+/// Generate associative table between media ids and tweet extended entities
+pub async fn generate_media_ids(
+    tweet: &Tweet,
+    cache_path: &str,
+    mastodon: &Mastodon,
+) -> (String, Vec<String>) {
+    let mut media_url = "".to_string();
+    let mut media_ids: Vec<String> = vec![];
+
+    if let Some(m) = &tweet.extended_entities {
+        info!("{} medias in tweet", m.media.len());
+
+        let medias = m.media.clone();
+
+        let mut stream = stream::iter(medias)
+            .map(|media| {
+                // attribute media url
+                media_url = media.url.clone();
+
+                // clone everything we need
+                let cache_path = String::from(cache_path);
+                let mastodon = mastodon.clone();
+
+                tokio::task::spawn(async move {
+                    info!("Start treating {}", media.media_url_https);
+                    // get the tweet embedded media
+                    let local_tweet_media_path = get_tweet_media(&media, &cache_path).await?;
+
+                    // upload media to Mastodon
+                    let mastodon_media =
+                        mastodon.media(Cow::from(local_tweet_media_path.to_owned()))?;
+                    // at this point, we can safely erase the original file
+                    // it doesn’t matter if we can’t remove, cache_media fn is idempotent
+                    remove_file(&local_tweet_media_path).await.ok();
+
+                    Ok::<String, ScootalooError>(mastodon_media.id)
+                })
+            })
+            .buffered(4); // there are max four medias per tweet and they need to be treated in
+                          // order
+
+        while let Some(result) = stream.next().await {
+            match result {
+                Ok(Ok(v)) => media_ids.push(v),
+                Ok(Err(e)) => warn!("Cannot treat media: {}", e),
+                Err(e) => error!("Something went wrong when joining the main thread: {}", e),
+            }
+        }
+    } else {
+        info!("No media in tweet");
+    }
+
+    // in case some media_ids slot remained empty due to errors, remove them
+    media_ids.retain(|x| !x.is_empty());
+
+    (media_url, media_ids)
+}
+
 /// Gets and caches Twitter Media inside the determined temp dir
 pub async fn cache_media(u: &str, t: &str) -> Result<String, Box<dyn Error>> {
     // create dir

tests/config.rs

@@ -1,4 +1,108 @@
 use scootaloo::parse_toml;
+use std::collections::HashMap;
+
+#[test]
+fn test_alt_services() {
+    let toml = parse_toml("tests/no_test_alt_services.toml");
+    assert_eq!(toml.scootaloo.alternative_services_for, None);
+
+    let toml = parse_toml("tests/test_alt_services.toml");
+    assert_eq!(
+        toml.scootaloo.alternative_services_for,
+        Some(HashMap::from([
+            ("tamere.lol".to_string(), "tonpere.mdr".to_string()),
+            ("you.pi".to_string(), "you.pla".to_string())
+        ]))
+    );
+}
+
+#[test]
+fn test_re_display() {
+    let toml = parse_toml("tests/no_show_url_as_display_url_for.toml");
+    assert_eq!(toml.scootaloo.show_url_as_display_url_for, None);
+
+    let toml = parse_toml("tests/show_url_as_display_url_for.toml");
+
+    assert_eq!(
+        toml.scootaloo.show_url_as_display_url_for,
+        Some("^(.+)\\.es$".to_string())
+    );
+}
+
+#[test]
+fn test_page_size() {
+    const DEFAULT_PAGE_SIZE: i32 = 200;
+    let toml = parse_toml("tests/page_size.toml");
+
+    assert_eq!(toml.twitter.page_size, Some(100));
+
+    assert_eq!(toml.mastodon.get("0").unwrap().twitter_page_size, None);
+
+    assert_eq!(toml.mastodon.get("1").unwrap().twitter_page_size, Some(42));
+
+    // this is the exact line that is used inside fn run() to determine the twitter page size
+    // passed to fn get_user_timeline()
+    let page_size_for_0 = toml
+        .mastodon
+        .get("0")
+        .unwrap()
+        .twitter_page_size
+        .unwrap_or_else(|| toml.twitter.page_size.unwrap_or(DEFAULT_PAGE_SIZE));
+    let page_size_for_1 = toml
+        .mastodon
+        .get("1")
+        .unwrap()
+        .twitter_page_size
+        .unwrap_or_else(|| toml.twitter.page_size.unwrap_or(DEFAULT_PAGE_SIZE));
+
+    assert_eq!(page_size_for_0, 100);
+    assert_eq!(page_size_for_1, 42);
+
+    let toml = parse_toml("tests/no_page_size.toml");
+
+    assert_eq!(toml.twitter.page_size, None);
+    assert_eq!(toml.mastodon.get("0").unwrap().twitter_page_size, None);
+
+    // and same here
+    let page_size_for_0 = toml
+        .mastodon
+        .get("0")
+        .unwrap()
+        .twitter_page_size
+        .unwrap_or_else(|| toml.twitter.page_size.unwrap_or(DEFAULT_PAGE_SIZE));
+
+    assert_eq!(page_size_for_0, 200);
+}
+
+#[test]
+fn test_parse_good_toml_rate_limit() {
+    let parse_good_toml = parse_toml("tests/good_test_rate_limit.toml");
+
+    assert_eq!(parse_good_toml.scootaloo.rate_limit, Some(69 as usize));
+}
+
+#[test]
+fn test_parse_good_toml_mastodon_screen_name() {
+    let parse_good_toml = parse_toml("tests/good_test_mastodon_screen_name.toml");
+
+    assert_eq!(
+        parse_good_toml
+            .mastodon
+            .get("0")
+            .unwrap()
+            .mastodon_screen_name,
+        Some("tarace".to_string())
+    );
+
+    assert_eq!(
+        parse_good_toml
+            .mastodon
+            .get("1")
+            .unwrap()
+            .mastodon_screen_name,
+        None
+    );
+}
 
 #[test]
 fn test_parse_good_toml() {
@@ -9,6 +113,7 @@ fn test_parse_good_toml() {
         "/var/random/scootaloo.sqlite"
     );
     assert_eq!(parse_good_toml.scootaloo.cache_path, "/tmp/scootaloo");
+    assert_eq!(parse_good_toml.scootaloo.rate_limit, None);
 
     assert_eq!(parse_good_toml.twitter.consumer_key, "rand consumer key");
     assert_eq!(parse_good_toml.twitter.consumer_secret, "secret");

tests/good_test_mastodon_screen_name.toml

@@ -0,0 +1,28 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.0]
+twitter_screen_name="tamerelol"
+mastodon_screen_name="tarace"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"
+
+[mastodon.1]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/good_test_rate_limit.toml

@@ -0,0 +1,20 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+rate_limit=69
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.tamerelol]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/no_page_size.toml

@@ -0,0 +1,19 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.0]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/no_show_url_as_display_url_for.toml

@@ -0,0 +1,19 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.tamerelol]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/no_test_alt_services.toml

@@ -0,0 +1,19 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.tamerelol]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/page_size.toml

@@ -0,0 +1,29 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+page_size=100
+
+[mastodon]
+[mastodon.0]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"
+
+[mastodon.1]
+twitter_screen_name="tonperemdr"
+twitter_page_size=42
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/show_url_as_display_url_for.toml

@@ -0,0 +1,20 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+show_url_as_display_url_for = "^(.+)\\.es$"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.tamerelol]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"

tests/test_alt_services.toml

@@ -0,0 +1,22 @@
+[scootaloo]
+
+db_path="/var/random/scootaloo.sqlite"
+cache_path="/tmp/scootaloo"
+[scootaloo.alternative_services_for]
+"tamere.lol" = "tonpere.mdr"
+"you.pi" = "you.pla"
+
+[twitter]
+consumer_key="rand consumer key"
+consumer_secret="secret"
+access_key="rand access key"
+access_secret="super secret"
+
+[mastodon]
+[mastodon.tamerelol]
+twitter_screen_name="tamerelol"
+base = "https://m.nintendojo.fr"
+client_id = "rand client id"
+client_secret = "secret"
+redirect = "urn:ietf:wg:oauth:2.0:oob"
+token = "super secret"