Yoda 0.12.12

Browser for Gemini Protocol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

mod bookmark;
mod database;
mod history;
mod identity;
mod proxy;
mod search;
mod tofu;

use anyhow::Result;
use bookmark::Bookmark;
use database::Database;
use gtk::glib::{DateTime, user_config_dir};
use history::History;
use identity::Identity;
use proxy::Proxy;
use r2d2::Pool;
use r2d2_sqlite::SqliteConnectionManager;
use search::Search;
use sqlite::Transaction;
use std::{fs::create_dir_all, path::PathBuf};
use tofu::Tofu;

const VENDOR: &str = "YGGverse";
const APP_ID: &str = "Yoda";
const BRANCH: &str = "master";

const DB_NAME: &str = "database.sqlite3";

pub struct Profile {
    pub bookmark: Bookmark,
    pub config_path: PathBuf,
    pub database: Database,
    pub history: History,
    pub identity: Identity,
    pub proxy: Proxy,
    pub search: Search,
    pub tofu: Tofu,
}

impl Profile {
    // Constructors

    pub fn init() -> Result<Self> {
        // Init profile path
        let mut config_path = user_config_dir();

        config_path.push(VENDOR);
        config_path.push(APP_ID);
        config_path.push(BRANCH);
        config_path.push(format!(
            "{}.{}",
            env!("CARGO_PKG_VERSION_MAJOR"),
            env!("CARGO_PKG_VERSION_MINOR")
        )); // @TODO remove after auto-migrate feature implementation

        create_dir_all(&config_path)?;

        // Init database path
        let mut database_path = config_path.clone();
        database_path.push(DB_NAME);

        // Init database connection
        let database_pool =
            Pool::new(SqliteConnectionManager::file(database_path.as_path())).unwrap();

        // Init profile components
        {
            // Init writable connection
            let mut connection = database_pool.get()?;

            // Init new transaction
            let tx = connection.transaction()?;

            // Begin migration
            migrate(&tx)?;
            tx.commit()?;
        } // unlock database

        // Init model
        let database = Database::build(&database_pool);

        // Get active profile or create new one
        let profile_id = match database.active()? {
            Some(profile) => profile.id,
            None => database.add(true, DateTime::now_local()?, None)?,
        };

        // Init components
        let bookmark = Bookmark::build(&database_pool, profile_id)?;
        let history = History::build(&database_pool, profile_id)?;
        let identity = Identity::build(&database_pool, profile_id)?;
        let proxy = Proxy::init(&database_pool, profile_id)?;
        let search = Search::build(&database_pool, profile_id)?;
        let tofu = Tofu::init(&database_pool, profile_id)?;

        // Result
        Ok(Self {
            bookmark,
            config_path,
            database,
            history,
            identity,
            proxy,
            search,
            tofu,
        })
    }

    // Actions

    pub fn save(&self) -> Result<()> {
        self.history.save()?;
        self.proxy.save()?;
        self.tofu.save()?;
        Ok(())
    }
}

pub fn migrate(tx: &Transaction) -> Result<()> {
    // Migrate self components
    database::init(tx)?;

    // Delegate migration to children components
    bookmark::migrate(tx)?;
    history::migrate(tx)?;
    identity::migrate(tx)?;
    proxy::migrate(tx)?;
    search::migrate(tx)?;
    tofu::migrate(tx)?;

    // Success
    Ok(())
}