Add patch creation an apply on load logic

@@ -8,7 +8,7 @@ PROFILE =
 endif
 
 start:
-	systemfd --no-pid -s http::3000 -- \
+	systemfd --no-pid -s 0.0.0.0:3000 -- \
 		cargo watch -i static/ -s "make run"
 
 wasm:

@@ -6,71 +6,20 @@ mod models;
 mod routes;
 mod schema;
 
-use std::io::Write;
-use crate::routes::markdown::get_markdowns;
+use crate::routes::markdown::{get_markdowns, update_markdown};
 use crate::routes::other::*;
 use crate::routes::user::*;
 
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
 use diesel::r2d2::{self, ConnectionManager};
 use diesel::SqliteConnection;
-use diffy::create_patch;
-use flate2::Compression;
-use flate2::write::{DeflateEncoder, DeflateDecoder};
 use listenfd::ListenFd;
+use routes::markdown::get_markdown;
 
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 
-const ORIGINAL :&str = r"This is a long Multiline text to
-see if we can create a small patch set from
-a longer text.
-
-This paragraph will be kept without modification. The reason I
-try this is to see if the diff becomes smaller than storing a
-compressed new version of this text...
-
-So this whole paragraph is obsolete. It will be removed in the
-modified text.
-
-There is probably a threshold up to what amount of text is needed
-to make the diff smaller.
-";
-
-const MODIFIED :&str = r"This is a long multiline text to
-see if we can create a small patch set from
-a longer text.
-
-This paragraph will be kept without modification. The reason I
-try this is to see if the diff becomes smaller than storing a
-compressed new version of this text...
-
-This is the replacement for the previous paragraph.
-
-There is probably a threshold up to what amount of text is needed
-to make the diff smaller.
-";
-
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
-    /* just some playing with diffy */
-    let patch = format!("{}", create_patch(ORIGINAL, MODIFIED));
-    println!("{} - {}", patch.len(), patch);
-
-    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::best());
-    encoder.write_all(patch.as_bytes()).unwrap();
-    let compressed = encoder.finish().unwrap();
-    println!("{} - {:?}", compressed.len(), compressed);
-
-    let mut decoder = DeflateDecoder::new(Vec::new());
-    decoder.write_all(compressed.as_ref()).unwrap();
-    let decompressed = decoder.finish().unwrap();
-    let decompressed = match std::str::from_utf8(decompressed.as_ref()) {
-        Ok(v) => v,
-        Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
-    };
-    println!("{} - {}", decompressed.len(), decompressed);
-    /* ======= */
-
     let mut listenfd = ListenFd::from_env();
 
     dotenv::dotenv().ok();
@@ -87,6 +36,10 @@ async fn main() -> std::io::Result<()> {
                             . service( web::resource("/markdowns")
                                      . route(web::get().to(get_markdowns))
                                      )
+                            . service( web::resource("/markdowns/{id}")
+                                     . route(web::get().to(get_markdown))
+                                     . route(web::put().to(update_markdown))
+                                     )
                             . service( web::resource("/users")
                                      . route(web::get().to(get_users))
                                      . route(web::put().to(create_user))

@@ -8,6 +8,10 @@ use diesel::{
     RunQueryDsl
 };
 use serde::{Deserialize, Serialize};
+use std::io::Write;
+use diffy::{apply, create_patch, Patch};
+use flate2::Compression;
+use flate2::write::{DeflateEncoder, DeflateDecoder};
 
 
 #[derive(Debug, Serialize, Deserialize, Queryable, Identifiable)]
@@ -20,6 +24,16 @@ pub struct Markdown {
     pub date_updated: String,
 }
 
+#[derive(Debug, Serialize, Deserialize, Queryable, Identifiable)]
+#[table_name = "markdown_diffs"]
+#[primary_key(markdown_id, diff_id)]
+pub struct MarkdownDiff {
+    pub markdown_id: i32,
+    pub diff_id: i32,
+    pub diff: Vec<u8>,
+    pub date_created: String,
+}
+
 #[derive(Debug, Insertable)]
 #[table_name = "markdowns"]
 pub struct MarkdownNew<'a> {
@@ -30,12 +44,23 @@ pub struct MarkdownNew<'a> {
     pub date_updated: &'a str,
 }
 
+#[derive(Debug, Insertable)]
+#[table_name = "markdown_diffs"]
+pub struct MarkdownDiffNew<'a> {
+    pub markdown_id: i32,
+    pub diff_id: i32,
+    pub diff: &'a [u8],
+    pub date_created: &'a str,
+}
+
 #[derive(Debug, Serialize, Deserialize, AsChangeset)]
 #[table_name="markdowns"]
 pub struct MarkdownJson {
     pub name: String,
     pub content: String,
     pub number_of_versions: i32,
+    pub date_created: String,
+    pub date_updated: String,
 }
 
 pub(crate) enum Action {
@@ -82,11 +107,34 @@ pub(crate) fn get_markdowns(pool: Arc<Pool>) -> Result<Vec<Markdown>, Error>
 }
 
 pub(crate) fn get_markdown( pool:  Arc<Pool>
-                          , ident: i32 ) -> Result<Markdown, Error>
+                          , ident: &str
+                          , patch: Option<i32> ) -> Result<Markdown, Error>
 {
     use crate::schema::markdowns::dsl::*;
+    use crate::schema::markdown_diffs::dsl::*;
     let db_connection = pool.get()?;
-    Ok(markdowns.find(ident).first::<Markdown>(&db_connection)?)
+
+    let mut markdown = markdowns
+                     . filter(name.eq(ident))
+                     . first::<Markdown>(&db_connection)?;
+
+    if let Some(patch) = patch {
+        let result = markdown_diffs . filter(markdown_id.eq(markdown.id))
+            . filter(diff_id.ge(patch))
+            . order(diff_id.desc())
+            . load::<MarkdownDiff>(&db_connection)?;
+
+        let mut decoder = DeflateDecoder::new(Vec::new());
+        for patch in result {
+            decoder.write_all(patch.diff.as_ref()).unwrap();
+            let decomp = decoder.reset(Vec::new()).unwrap();
+            let decomp = Patch::from_str(
+                std::str::from_utf8(decomp.as_ref()).unwrap()).unwrap();
+            markdown.content = apply(&mut markdown.content, &decomp).unwrap();
+        }
+    };
+
+    Ok(markdown)
 }
 
 pub(crate) fn delete_markdown( pool: Arc<Pool>
@@ -98,19 +146,54 @@ pub(crate) fn delete_markdown( pool: Arc<Pool>
 }
 
 pub(crate) fn update_markdown( pool: Arc<Pool>
-                             , ident: i32
-                             , item: MarkdownJson ) -> Result<Markdown, Error>
+                             , ident: String
+                             , mut item: MarkdownJson ) -> Result<Markdown, Error>
 {
     use crate::schema::markdowns::dsl::*;
+    use crate::schema::markdown_diffs::dsl::*;
     let db_connection = pool.get()?;
-    let mut markdown = markdowns.find(ident).first::<Markdown>(&db_connection)?;
+    let mut markdown = markdowns
+                     . filter(name.eq(ident))
+                     . first::<Markdown>(&db_connection)?;
+
+    let patch = format!( "{}", create_patch( item.content.as_str()
+                                           , markdown.content.as_str() ));
+    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::best());
+    encoder.write_all(patch.as_bytes()).unwrap();
+    let compressed = encoder.finish().unwrap();
+
+    let last_diff = match markdown_diffs . filter(markdown_id.eq(markdown.id))
+                                         . order(diff_id.desc())
+                                         . first::<MarkdownDiff>(&db_connection)
+    {
+        Ok(result) => (result.diff_id, Some(result)),
+        Err(_)     => (0, None),
+    };
+
     let now = chrono::Local::now().naive_local();
+    let new_markdown_diff = MarkdownDiffNew {
+        markdown_id:        markdown.id,
+        diff_id:            last_diff.0 + 1,
+        diff:               compressed.as_ref(),
+        date_created:       markdown.date_updated.as_str(),
+    };
+
+    item.date_updated       = format!("{}", now);
+    item.number_of_versions = item.number_of_versions + 1;
+
+    db_connection.transaction::<_, Error, _>(|| {
+        insert_into(markdown_diffs) . values(&new_markdown_diff)
+                                    . execute(&db_connection)?;
+
+        update(&markdown).set(&item).execute(&db_connection)?;
+
+        Ok(())
+    }).unwrap();
 
-    update(markdowns.find(ident)).set(&item).execute(&db_connection)?;
     markdown.name               = item.name;
     markdown.content            = item.content;
     markdown.number_of_versions = item.number_of_versions;
-    markdown.date_updated       = format!("{}", now);
+    markdown.date_updated       = item.date_updated;
 
     Ok(markdown)
 }

@@ -3,12 +3,50 @@ use crate::Pool;
 
 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Patchset {
+    patch: Option<i32>,
+}
 
 pub async fn get_markdowns(pool: web::Data<Pool>)
     -> Result<HttpResponse, Error>
 {
-    Ok(web::block(move || markdown::get_markdowns(pool.into_inner()))
+    Ok( web::block(move || markdown::get_markdowns(pool.into_inner()))
+      . await
+      . map(|markdowns| HttpResponse::Ok().json(markdowns))
+      . map_err(|_| HttpResponse::InternalServerError())?
+      )
+}
+
+pub async fn get_markdown( pool: web::Data<Pool>
+                         , name: web::Path<String>
+                         , patch: web::Query<Patchset>
+                         ) -> Result<HttpResponse, Error>
+{
+    let pool = pool.into_inner();
+    let name = name.into_inner();
+    let patch = patch.into_inner();
+
+    Ok( web::block(move || markdown::get_markdown(pool, name.as_str(), patch.patch))
+      . await
+      . map(|markdowns| HttpResponse::Ok().json(markdowns))
+      . map_err(|_| HttpResponse::InternalServerError())?
+      )
+}
+
+pub async fn update_markdown( pool: web::Data<Pool>
+                            , name: web::Path<String>
+                            , item: web::Json<markdown::MarkdownJson> )
+    -> Result<HttpResponse, Error>
+{
+    let pool = pool.into_inner();
+    let name = name.into_inner();
+    let item = item.into_inner();
+
+    Ok(web::block(move || markdown::update_markdown(pool, name, item))
        . await
-       . map(|markdowns| HttpResponse::Ok().json(markdowns))
+       . map(|markdown| HttpResponse::Ok().json(markdown))
        . map_err(|_| HttpResponse::InternalServerError())?)
 }

@@ -12,6 +12,7 @@ crate-type = ["cdylib", "rlib"]
 default = ["console_error_panic_hook"]
 
 [dependencies]
+katex = { version = "0.4", default-features = false, features = ["wasm-js"] }
 pulldown-cmark = "0.9"
 console_log = "^0.1"
 log = "^0.4"
@@ -39,6 +40,7 @@ features = [
   "Headers",
   "HtmlElement",
   "HtmlInputElement",
+  "MouseEvent",
   "Node",
   "Request",
   "RequestInit",

@@ -3,7 +3,7 @@ mod data;
 use js_sys::JsString;
 use log::Level;
 use mogwai::prelude::*;
-use web_sys::{RequestInit, RequestMode, Request, Response};
+use web_sys::{RequestInit, RequestMode, Request, Response, MouseEvent};
 use serde::{Deserialize, Serialize};
 use std::panic;
 use wasm_bindgen::prelude::*;
@@ -12,6 +12,7 @@ use wasm_bindgen::prelude::*;
 enum AppLogic {
     Update,
     Toggle,
+    Store,
 }
 
 fn md_to_html(source: &str) -> String {
@@ -24,21 +25,23 @@ fn md_to_html(source: &str) -> String {
     html_output
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MarkdownJson {
     pub name: String,
     pub content: String,
     pub number_of_versions: i32,
+    pub date_created: String,
+    pub date_updated: String,
 }
 
-pub type MarkdownsJson = Vec<MarkdownJson>;
-
-async fn md_from_db() -> String {
+async fn md_from_db() -> MarkdownJson {
     let window = web_sys::window().unwrap();
     let mut opts = RequestInit::new();
     opts.method("GET").mode(RequestMode::Cors);
 
-    let request = Request::new_with_str_and_init("/api/v0/markdowns", &opts).unwrap();
+    let request = Request::new_with_str_and_init(
+          "/api/v0/markdowns/md-example?patch=3"
+        , &opts ).unwrap();
     request.headers().set("Accept", "application/json").unwrap();
 
     let response = JsFuture::from(window.fetch_with_request(&request))
@@ -46,15 +49,38 @@ async fn md_from_db() -> String {
                  . dyn_into::<Response>().unwrap();
     let data = String::from( JsFuture::from(response.text().unwrap())
                            . await.unwrap()
-                           . dyn_into::<JsString>().unwrap() );
-    let data :MarkdownsJson = serde_json::from_str(data.as_str()).unwrap();
+                           . dyn_into::<JsString>().unwrap()
+                           );
+    let data :MarkdownJson = serde_json::from_str(data.as_str()).unwrap();
+
+    data.clone()
+}
+
+async fn md_to_db(md :MarkdownJson) {
+    let encoded = serde_json::to_string(&md).unwrap();
+
+    let window = web_sys::window().unwrap();
+    let mut opts = RequestInit::new();
+    opts . method("PUT")
+         . mode(RequestMode::Cors)
+         . body(Some(&encoded.into()));
 
-    String::from(&data[0].content)
+    let url_str = format!("/api/v0/markdowns/{}", md.name);
+    let request = Request::new_with_str_and_init(url_str.as_str(), &opts)
+                . unwrap();
+    request.headers().set("Content-Type", "application/json").unwrap();
+
+    let _response = JsFuture::from(window.fetch_with_request(&request))
+                  . await.unwrap()
+                  . dyn_into::<Response>().unwrap();
+
+    /* do something with the response here.... */
 }
 
 async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
                      , tx_view: broadcast::Sender<String>
-                     , mut rx_dom: broadcast::Receiver<Dom> ) {
+                     , mut rx_dom: broadcast::Receiver<Dom>
+                     , md :MarkdownJson ) {
     let dom = rx_dom.next().await.unwrap();
     let mut show_edit = false;
 
@@ -82,8 +108,39 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 
     update(&dom);
 
+    /* play with katex ==== */
+    let opts = katex::Opts::builder()
+             . output_type(katex::opts::OutputType::Mathml)
+             . build().unwrap();
+    let formula1 = katex::render_with_opts("E = mc^2", &opts).unwrap();
+    let formula2 = katex::render_with_opts("e^{i*\\pi} +1 = 0", &opts).unwrap();
+
+    if let Either::Left(dom_js) = dom.inner_read() {
+        dom_js . to_owned()
+            . dyn_into::<Node>().unwrap()
+            . child_nodes().get(1).unwrap()
+            . child_nodes().get(2).unwrap()
+            . dyn_into::<HtmlElement>().unwrap()
+            . set_inner_html(formula1.as_str())
+    };
+
+    if let Either::Left(dom_js) = dom.inner_read() {
+        dom_js . to_owned()
+            . dyn_into::<Node>().unwrap()
+            . child_nodes().get(1).unwrap()
+            . child_nodes().get(3).unwrap()
+            . dyn_into::<HtmlElement>().unwrap()
+            . set_inner_html(formula2.as_str())
+    };
+    /* =========== */
+
     while let Some(msg) = rx_logic.next().await {
         match msg {
+            AppLogic::Store => {
+                let mut new_md = md.clone();
+                new_md.content = get_md(&dom);
+                md_to_db(new_md).await;
+            },
             AppLogic::Update => update(&dom),
             AppLogic::Toggle => {
                 show_edit = ! show_edit;
@@ -101,23 +158,42 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 fn editor_view( tx_logic: broadcast::Sender<AppLogic>
               , rx_view: broadcast::Receiver<String>
               , tx_dom: broadcast::Sender<Dom>
-              , init_data: &str
+              , md: &MarkdownJson
 ) -> ViewBuilder<Dom> {
     let ns = "http://www.w3.org/2000/svg";
 
+    let input_filter = tx_logic
+                     . sink()
+                     . contra_map(|_| AppLogic::Update);
+    let store_filter = tx_logic
+                     . sink()
+                     . contra_filter_map(|e :DomEvent| {
+                         if let Either::Left(e) = e.clone_inner() {
+                             let e = e.dyn_into::<MouseEvent>().unwrap();
+                             match e.alt_key() {
+                                 true => Some(AppLogic::Store),
+                                 false => None
+                             }
+                         } else {
+                             None
+                         }
+                     });
+    let toggle_filter = tx_logic
+                      . sink()
+                      . contra_map(|_| AppLogic::Toggle);
+
     builder! {
         <div class="input"
              style:width="33%"
-             on:input=tx_logic.sink().contra_map(|_| AppLogic::Update)
+             on:input=input_filter
              capture:view=tx_dom.sink()>
             <div contenteditable="true"
                  style:cursor="text"
                  style:display=("none", rx_view)>
-                <pre>{init_data}</pre>
+                <pre on:click=store_filter>{md.content.clone()}</pre>
             </div>
             <div>
-                <button on:click=tx_logic . sink()
-                                          . contra_map(|_| AppLogic::Toggle)>
+                <button on:click=toggle_filter>
                     <svg version="1.1" id="Capa_1" xmlns=ns
                          x="0px" y="0px" viewBox="0 0 220.001 220.001"
                          style:width="1.5em" style:height="1.5em">
@@ -131,6 +207,8 @@ fn editor_view( tx_logic: broadcast::Sender<AppLogic>
                     </svg>
                 </button>
                 <div></div>
+                <div></div>
+                <div></div>
             </div>
         </div>
     }
@@ -141,13 +219,13 @@ pub async fn main() -> Result<(), JsValue> {
     panic::set_hook(Box::new(console_error_panic_hook::hook));
     console_log::init_with_level(Level::Trace).unwrap();
 
-    let data = md_from_db().await;
+    let md = md_from_db().await;
 
     let (tx_dom, rx_dom) = broadcast::bounded(1);
     let (tx_logic, rx_logic) = broadcast::bounded(1);
     let (tx_view, rx_view) = broadcast::bounded(1);
-    let comp = Component::from( editor_view(tx_logic, rx_view, tx_dom, data.as_str()) )
-             . with_logic( editor_logic(rx_logic, tx_view, rx_dom) );
+    let comp = Component::from( editor_view(tx_logic, rx_view, tx_dom, &md) )
+             . with_logic( editor_logic(rx_logic, tx_view, rx_dom, md) );
 
     let page = Component::from(builder! {{comp}});
     page.build()?.run()