Merge lp:~kalikiana/midori/databaseapi into lp:midori

[Cris Dywan]

Introduce Midori.Database and use for history and tabby

[André Stösel (ivaldi)]

Looks good!

review: Approve

=== added directory 'data/history'
=== added file 'data/history/Create.sql'
--- data/history/Create.sql	1970-01-01 00:00:00 +0000
+++ data/history/Create.sql	2013-09-13 21:27:32 +0000
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS history
+(
+    uri text,
+    title text,
+    date integer,
+    day integer
+);
+CREATE TABLE IF NOT EXISTS search
+(
+    keywords text,
+    uri text,
+    day integer
+);

=== modified file 'extensions/tabby.vala'
--- extensions/tabby.vala	2013-09-09 21:00:43 +0000
+++ extensions/tabby.vala	2013-09-13 21:27:32 +0000
@@ -282,7 +282,8 @@
         }
 
         private class Storage : Base.Storage {
-            protected Sqlite.Database db;
+            private Midori.Database database;
+            private unowned Sqlite.Database db;
 
             public override Katze.Array get_sessions () {
                 Katze.Array sessions = new Katze.Array (typeof (Session));
@@ -323,36 +324,24 @@
             internal Storage (Midori.App app) {
                 GLib.Object (app: app);
 
-                string db_path = Midori.Paths.get_config_filename_for_writing ("tabby.db");
-
-                bool db_exists = GLib.FileUtils.test(db_path, GLib.FileTest.EXISTS);
-
-                if (Sqlite.Database.open_v2 (db_path, out this.db) != Sqlite.OK)
-                    critical (_("Failed to open stored session: %s"), db.errmsg);
-
-                string filename = Midori.Paths.get_res_filename ("tabby/Create.sql");
-                string schema;
                 try {
-                        bool success = FileUtils.get_contents (filename, out schema, null);
-                        if (!success || schema == null)
-                            critical (_("Failed to open database schema file: %s"), filename);
-                        if (success && schema != null)
-                            if (this.db.exec (schema) != Sqlite.OK)
-                                critical (_("Failed to execute database schema: %s"), filename);
-                            else if (db_exists == false) {
-                                string config_file = Midori.Paths.get_config_filename_for_reading ("session.xbel");
-                                try {
-                                    Katze.Array old_session = new Katze.Array (typeof (Katze.Item));
-                                    Midori.array_from_file (old_session, config_file, "xbel-tiny");
-                                    this.import_session (old_session);
-                                } catch (GLib.FileError file_error) {
-                                    /* no old session.xbel -> could be a new profile -> ignore it */
-                                } catch (GLib.Error error) {
-                                    critical (_("Failed to import legacy session: %s"), error.message);
-                                }
-                            }
-                } catch (GLib.FileError schema_error) {
-                    critical (_("Failed to open database schema file: %s"), schema_error.message);
+                    database = new Midori.Database ("tabby.db");
+                } catch (Midori.DatabaseError schema_error) {
+                    error (schema_error.message);
+                }
+                db = database.db;
+
+                if (database.first_use) {
+                    string config_file = Midori.Paths.get_config_filename_for_reading ("session.xbel");
+                    try {
+                        Katze.Array old_session = new Katze.Array (typeof (Katze.Item));
+                        Midori.array_from_file (old_session, config_file, "xbel-tiny");
+                        this.import_session (old_session);
+                    } catch (GLib.FileError file_error) {
+                        /* no old session.xbel -> could be a new profile -> ignore it */
+                    } catch (GLib.Error error) {
+                        critical (_("Failed to import legacy session: %s"), error.message);
+                    }
                 }
             }
         }

=== added file 'midori/midori-database.vala'
--- midori/midori-database.vala	1970-01-01 00:00:00 +0000
+++ midori/midori-database.vala	2013-09-13 21:27:32 +0000
@@ -0,0 +1,76 @@
+/*
+ Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ See the file COPYING for the full license text.
+*/
+
+namespace Midori {
+    public errordomain DatabaseError {
+        OPEN,
+        SCHEMA,
+        EXECUTE,
+    }
+
+    public class Database : GLib.Object, GLib.Initable {
+        public Sqlite.Database? db { get { return _db; } }
+        protected Sqlite.Database? _db = null;
+        public string? path { get; protected set; default = ":memory:"; }
+
+        /*
+         * A new database successfully opened for the first time.
+         * Old or additional data should be opened if this is true.
+         */
+        public bool first_use { get; protected set; default = false; }
+
+        /*
+         * If a filename is passed it's assumed to be in the config folder.
+         * Otherwise the database is in memory only (useful for private browsing).
+         */
+        public Database (string? path) throws DatabaseError {
+            Object (path: path);
+            init ();
+        }
+
+        public virtual bool init (GLib.Cancellable? cancellable = null) throws DatabaseError {
+            if (path == null)
+                path = ":memory:";
+            else if (!Path.is_absolute (path))
+                path = Midori.Paths.get_config_filename_for_writing (path);
+            bool exists = Posix.access (path, Posix.F_OK) == 0;
+
+            if (Sqlite.Database.open_v2 (path, out _db) != Sqlite.OK)
+                throw new DatabaseError.OPEN ("Failed to open database %s".printf (path));
+
+            if (db.exec ("PRAGMA journal_mode = WAL; PRAGMA cache_size = 32100;") != Sqlite.OK)
+                db.exec ("PRAGMA synchronous = NORMAL; PRAGMA temp_store = MEMORY;");
+
+            string basename = Path.get_basename (path);
+            string[] parts = basename.split (".");
+            if (!(parts != null && parts[0] != null && parts[1] != null))
+                throw new DatabaseError.SCHEMA ("Failed to deduce schema filename from %s".printf (path));
+            string schema_filename = Midori.Paths.get_res_filename (parts[0] + "/Create.sql");
+            string schema;
+            try {
+                FileUtils.get_contents (schema_filename, out schema, null);
+            } catch (Error error) {
+                throw new DatabaseError.SCHEMA ("Failed to open schema: %s".printf (schema_filename));
+            }
+            if (db.exec (schema) != Sqlite.OK)
+                throw new DatabaseError.EXECUTE ("Failed to execute schema: %s".printf (schema));
+
+            first_use = !exists;
+            return true;
+        }
+
+        public bool exec (string query) throws DatabaseError {
+            if (db.exec (query) != Sqlite.OK)
+                throw new DatabaseError.EXECUTE (db.errmsg ());
+            return true;
+        }
+    }
+}

=== modified file 'midori/midori-history.c'
--- midori/midori-history.c	2013-05-19 09:33:02 +0000
+++ midori/midori-history.c	2013-09-13 21:27:32 +0000
@@ -30,7 +30,8 @@
 KatzeArray*
 midori_history_new (char** errmsg)
 {
-    gchar* filename;
+    MidoriHistoryDatabase* database;
+    GError* error = NULL;
     sqlite3* db;
     gboolean has_day = FALSE;
     sqlite3_stmt* stmt;
@@ -41,36 +42,16 @@
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
-    filename = midori_paths_get_config_filename_for_writing ("history.db");
-    if (sqlite3_open (filename, &db) != SQLITE_OK)
+    database = midori_history_database_new (NULL, &error);
+    if (error != NULL)
     {
-        *errmsg = g_strdup_printf (_("Failed to open database: %s\n"),
-            db ? sqlite3_errmsg (db) : "(db = NULL)");
-        g_free (filename);
-        sqlite3_close (db);
+        *errmsg = g_strdup (error->message);
+        g_error_free (error);
         return NULL;
     }
-    g_free (filename);
 
-    if (sqlite3_exec (db,
-        "PRAGMA journal_mode = WAL; PRAGMA cache_size = 32100;",
-        NULL, NULL, errmsg) != SQLITE_OK)
-        sqlite3_exec (db, "PRAGMA journal_mode = TRUNCATE;", NULL, NULL, errmsg);
-    sqlite3_exec (db,
-        "PRAGMA synchronous = NORMAL; PRAGMA temp_store = MEMORY;",
-        NULL, NULL, errmsg);
-    if (*errmsg)
-    {
-        g_warning ("Failed to set journal mode: %s", *errmsg);
-        sqlite3_free (*errmsg);
-    }
-    if (sqlite3_exec (db,
-                      "CREATE TABLE IF NOT EXISTS "
-                      "history (uri text, title text, date integer, day integer);"
-                      "CREATE TABLE IF NOT EXISTS "
-                      "search (keywords text, uri text, day integer);",
-                      NULL, NULL, errmsg) != SQLITE_OK)
-        return NULL;
+    db = midori_database_get_db (MIDORI_DATABASE (database));
+    g_return_val_if_fail (db != NULL, NULL);
 
     sqlite3_prepare_v2 (db, "SELECT day FROM history LIMIT 1", -1, &stmt, NULL);
     result = sqlite3_step (stmt);
@@ -93,11 +74,6 @@
                       "COMMIT;",
                       NULL, NULL, errmsg);
 
-    bookmarks_filename = midori_paths_get_config_filename_for_writing ("bookmarks_v2.db");
-    sql = g_strdup_printf ("ATTACH DATABASE '%s' AS bookmarks", bookmarks_filename);
-    g_free (bookmarks_filename);
-    sqlite3_exec (db, sql, NULL, NULL, errmsg);
-    g_free (sql);
     array = katze_array_new (KATZE_TYPE_ARRAY);
     g_object_set_data (G_OBJECT (array), "db", db);
     g_signal_connect (array, "clear",

=== modified file 'midori/midori-historycompletion.vala'
--- midori/midori-historycompletion.vala	2013-07-28 21:20:32 +0000
+++ midori/midori-historycompletion.vala	2013-09-13 21:27:32 +0000
@@ -18,8 +18,12 @@
         }
 
         public override void prepare (GLib.Object app) {
-            database = new HistoryDatabase (app);
-            return_if_fail (database != null);
+            try {
+                database = new HistoryDatabase (app);
+            }
+            catch (Error error) {
+                warning (error.message);
+            }
         }
 
         public override bool can_complete (string text) {

=== modified file 'midori/midori-historydatabase.vala'
--- midori/midori-historydatabase.vala	2013-07-22 23:05:26 +0000
+++ midori/midori-historydatabase.vala	2013-09-13 21:27:32 +0000
@@ -35,15 +35,12 @@
         public int64 date { get; set; }
     }
 
-    public class HistoryDatabase : GLib.Object {
-        unowned Sqlite.Database db = null;
-
-        public HistoryDatabase (GLib.Object app) {
-            GLib.Object history;
-            app.get ("history", out history);
-            return_val_if_fail (history != null, null);
-            db = history.get_data<Sqlite.Database?> ("db");
-            return_val_if_fail (db != null, null);
+    public class HistoryDatabase : Midori.Database {
+        public HistoryDatabase (GLib.Object? app) throws DatabaseError {
+            Object (path: "history.db");
+            init ();
+            string bookmarks_filename = Midori.Paths.get_config_filename_for_writing ("bookmarks_v2.db");
+            exec ("ATTACH DATABASE '%s' AS bookmarks".printf (bookmarks_filename));
         }
 
         public async List<HistoryItem>? query (string sqlcmd, string? filter, int day, int max_items, Cancellable cancellable) {

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2013-09-08 16:00:37 +0000
+++ po/POTFILES.in	2013-09-13 21:27:32 +0000
@@ -6,6 +6,7 @@
 midori/midori-app.c
 midori/midori-array.c
 midori/midori-browser.c
+midori/midori-database.vala
 midori/midori-extension.c
 midori/midori-locationaction.c
 midori/midori-panel.c

=== modified file 'tests/completion.vala'
--- tests/completion.vala	2013-09-08 00:52:09 +0000
+++ tests/completion.vala	2013-09-13 21:27:32 +0000
@@ -107,16 +107,12 @@
 }
 
 void completion_history () {
+    Sqlite.Database db;
+    assert (Sqlite.Database.open_v2 (Midori.Paths.get_config_filename_for_writing ("bookmarks_v2.db"), out db) == Sqlite.OK);
+    assert (db.exec ("CREATE TABLE bookmarks (uri TEXT, title TEXT, last_visit DATE);") == Sqlite.OK);
+
     var completion = new Midori.HistoryCompletion ();
     var app = new Midori.App ();
-    var history = new Katze.Array (typeof (Katze.Item));
-    app.set ("history", history);
-    Sqlite.Database db;
-    Sqlite.Database.open_v2 (":memory:", out db);
-    db.exec ("CREATE TABLE history (uri TEXT, title TEXT, date INTEGER, day INTEGER);");
-    db.exec ("CREATE TABLE search (uri TEXT, keywords TEXT, day INTEGER);");
-    db.exec ("CREATE TABLE bookmarks (uri TEXT, title TEXT, last_visit DATE);");
-    history.set_data<unowned Sqlite.Database?> ("db", db);
     completion.prepare (app);
     foreach (var spec in completions)
         complete_spec.begin (completion, spec);
@@ -152,6 +148,7 @@
 void main (string[] args) {
     Test.init (ref args);
     Midori.App.setup (ref args, null);
+    Midori.Paths.init (Midori.RuntimeMode.NORMAL, null);
     Test.add_func ("/completion/autocompleter", completion_autocompleter);
     Test.add_func ("/completion/history", completion_history);
     Test.add_func ("/completion/location-action", completion_location_action);