428 lines
14 KiB
Rust
428 lines
14 KiB
Rust
/*
|
|
* Copyright (C) 2021 Aravinth Manivannan <realaravinth@batsense.net>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
use std::collections::HashMap;
|
|
|
|
use crate::data::*;
|
|
use crate::proxy::StringUtils;
|
|
use get_post::*;
|
|
|
|
#[derive(Eq, PartialEq)]
|
|
enum PostitionType {
|
|
Start,
|
|
End,
|
|
}
|
|
|
|
#[derive(Default, Eq, PartialEq)]
|
|
struct ListState {
|
|
in_uli: bool,
|
|
in_oli: bool,
|
|
}
|
|
|
|
struct Markup<'a, 'b> {
|
|
markup: &'a GetPostPostContentBodyModelParagraphsMarkups,
|
|
p: &'a GetPostPostContentBodyModelParagraphs,
|
|
pos_type: PostitionType,
|
|
gists: &'b Option<Vec<(String, crate::data::GistContent)>>,
|
|
}
|
|
|
|
impl<'a, 'b> Markup<'a, 'b> {
|
|
fn start(
|
|
p: &GetPostPostContentBodyModelParagraphs,
|
|
gists: &'b Option<Vec<(String, crate::data::GistContent)>>,
|
|
pindex: usize,
|
|
state: &mut ListState,
|
|
) -> String {
|
|
let list = Self::list_close(p, state);
|
|
let resp = if p.type_ == "IMG" {
|
|
let metadata = p.metadata.as_ref().unwrap();
|
|
format!(
|
|
r#"<figure><img width="{}" src="{}" /> <figcaption>"#,
|
|
metadata.original_width.as_ref().unwrap(),
|
|
crate::V1_API_ROUTES.proxy.get_medium_asset(&metadata.id)
|
|
)
|
|
} else if p.type_ == "P" {
|
|
"<p>".into()
|
|
} else if p.type_ == "PRE" {
|
|
"<pre>".into()
|
|
} else if p.type_ == "BQ" || p.type_ == "PQ" {
|
|
"<blockquote>".into()
|
|
} else if p.type_ == "H1" {
|
|
"<h1>".into()
|
|
} else if p.type_ == "H2" {
|
|
"<h2>".into()
|
|
} else if p.type_ == "H3" {
|
|
if pindex == 0 {
|
|
log::debug!("caught heading");
|
|
"".into()
|
|
} else {
|
|
"<h3>".into()
|
|
}
|
|
} else if p.type_ == "H4" {
|
|
"<h4>".into()
|
|
} else if p.type_ == "H5" {
|
|
"<h5>".into()
|
|
} else if p.type_ == "H6" {
|
|
"<h6>".into()
|
|
} else if p.type_ == "IFRAME" {
|
|
let src = &p
|
|
.iframe
|
|
.as_ref()
|
|
.unwrap()
|
|
.media_resource
|
|
.as_ref()
|
|
.unwrap()
|
|
.href;
|
|
if src.contains("gist.github.com") {
|
|
let gist_id = crate::data::Data::get_gist_id(src);
|
|
let (_, gist) = gists
|
|
.as_ref()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|(id, _)| id == gist_id)
|
|
.as_ref()
|
|
.unwrap();
|
|
|
|
let mut gists = String::default();
|
|
for file in &gist.files {
|
|
gists += &format!(
|
|
r#"<div class="code-block gist-block">{}</div>"#,
|
|
file.get_html_content()
|
|
);
|
|
}
|
|
format!(
|
|
r#"<div class="gist_container">{gists}
|
|
<a class="gist_link" href="{}" target="_blank">See gist on GitHub</a>"#,
|
|
&gist.html_url
|
|
)
|
|
} else {
|
|
format!(r#"<iframe src="{src}" frameborder="0">"#)
|
|
}
|
|
} else if p.type_ == "ULI" {
|
|
if state.in_uli {
|
|
"<li>".into()
|
|
} else {
|
|
state.in_uli = true;
|
|
"<ul><li>".into()
|
|
}
|
|
} else if p.type_ == "OLI" {
|
|
if state.in_oli {
|
|
"<li>".into()
|
|
} else {
|
|
state.in_oli = true;
|
|
"<ol><li>".into()
|
|
}
|
|
} else if p.type_ == "MIXTAPE_EMBED" {
|
|
"<div class='mixtape'><p>".into()
|
|
} else {
|
|
log::info!("Unknown type: {}", p.type_);
|
|
r#"
|
|
<p class="libmedium__meta">
|
|
<b>From LibMedium:</b> LibMedium is built by reverse
|
|
engineering the Meduim's internal API. This post contains
|
|
markup(formatting rules) that we are unaware of.
|
|
Please report this URL <a
|
|
href="https://github.com/realaravinth/libmedium/issues/1"
|
|
rel="noreferrer">on our bug tracker</a> so that we can
|
|
improve page rendering.
|
|
<br />
|
|
Alternatively, you can also email me at realaravinth at batsense dot net!
|
|
</p>
|
|
<span>"#
|
|
.into()
|
|
};
|
|
|
|
match list {
|
|
Some(list) => format!("{list}{resp}"),
|
|
None => resp,
|
|
}
|
|
}
|
|
|
|
fn end(
|
|
p: &GetPostPostContentBodyModelParagraphs,
|
|
pindex: usize,
|
|
state: &mut ListState,
|
|
) -> String {
|
|
let resp: String = if p.type_ == "IMG" {
|
|
"</figcaption></figure>".into()
|
|
} else if p.type_ == "P" {
|
|
"</p>".into()
|
|
} else if p.type_ == "PRE" {
|
|
"</pre>".into()
|
|
} else if p.type_ == "BQ" || p.type_ == "PQ" {
|
|
"</blockquote>".into()
|
|
} else if p.type_ == "H1" {
|
|
"</h1>".into()
|
|
} else if p.type_ == "H2" {
|
|
"</h2>".into()
|
|
} else if p.type_ == "H3" {
|
|
if pindex == 0 {
|
|
log::debug!("caught heading");
|
|
"".into()
|
|
} else {
|
|
"</h3>".into()
|
|
}
|
|
} else if p.type_ == "H4" {
|
|
"</h4>".into()
|
|
} else if p.type_ == "H5" {
|
|
"</h5>".into()
|
|
} else if p.type_ == "H6" {
|
|
"</h6>".into()
|
|
} else if p.type_ == "IFRAME" {
|
|
let src = &p
|
|
.iframe
|
|
.as_ref()
|
|
.unwrap()
|
|
.media_resource
|
|
.as_ref()
|
|
.unwrap()
|
|
.href;
|
|
if src.contains("gist.github.com") {
|
|
"</div>".into()
|
|
} else {
|
|
"</iframe>".into()
|
|
}
|
|
} else if p.type_ == "OLI" || p.type_ == "ULI" {
|
|
"</li>".into()
|
|
} else if p.type_ == "MIXTAPE_EMBED" {
|
|
"</p></div>".into()
|
|
} else {
|
|
"</span>".into()
|
|
};
|
|
if state.in_oli {
|
|
if p.type_ != "OLI" {
|
|
state.in_oli = false;
|
|
format!("</ol>{resp}")
|
|
} else {
|
|
resp
|
|
}
|
|
} else if state.in_uli {
|
|
if p.type_ != "ULI" {
|
|
state.in_uli = false;
|
|
format!("</ul>{resp}")
|
|
} else {
|
|
resp
|
|
}
|
|
} else {
|
|
resp
|
|
}
|
|
}
|
|
|
|
fn list_close(
|
|
p: &GetPostPostContentBodyModelParagraphs,
|
|
state: &mut ListState,
|
|
) -> Option<String> {
|
|
if state.in_oli && p.type_ != "OLI" {
|
|
state.in_oli = false;
|
|
return Some("</ol>".to_string());
|
|
};
|
|
if state.in_uli && p.type_ != "ULI" {
|
|
state.in_uli = false;
|
|
return Some("</ul>".to_string());
|
|
};
|
|
None
|
|
}
|
|
|
|
fn apply_markup(&self, _pindex: usize) -> String {
|
|
if self.markup.type_ == "A" {
|
|
if let Some(anchor_type) = &self.markup.anchor_type {
|
|
if anchor_type == "LINK" {
|
|
if self.pos_type == PostitionType::Start {
|
|
format!(
|
|
r#"<a rel="noreferrer" href="{}">"#,
|
|
self.markup.href.as_ref().unwrap()
|
|
)
|
|
} else {
|
|
"</a>".into()
|
|
}
|
|
} else if anchor_type == "USER" {
|
|
if self.pos_type == PostitionType::Start {
|
|
format!(
|
|
r#"<a rel="noreferrer" href="https://medium.com/u/{}">"#,
|
|
self.markup.user_id.as_ref().unwrap()
|
|
)
|
|
} else {
|
|
"</a>".into()
|
|
}
|
|
} else {
|
|
// log::error!("unknown markup.anchor_type: {:?} post id {}", anchor_type, id);
|
|
if self.pos_type == PostitionType::Start {
|
|
"<span>".into()
|
|
} else {
|
|
"</span>".into()
|
|
}
|
|
}
|
|
} else {
|
|
// log::error!("unknown markup.anchor_type: {:?} post id {}", anchor_type, id);
|
|
if self.pos_type == PostitionType::Start {
|
|
"<span>".into()
|
|
} else {
|
|
"</span>".into()
|
|
}
|
|
}
|
|
} else if self.markup.type_ == "PRE" {
|
|
if self.pos_type == PostitionType::Start {
|
|
"<pre>".into()
|
|
} else {
|
|
"</pre>".into()
|
|
}
|
|
} else if self.markup.type_ == "EM" {
|
|
if self.pos_type == PostitionType::Start {
|
|
"<em>".into()
|
|
} else {
|
|
"</em>".into()
|
|
}
|
|
} else if self.markup.type_ == "STRONG" {
|
|
if self.pos_type == PostitionType::Start {
|
|
"<strong>".into()
|
|
} else {
|
|
"</strong>".into()
|
|
}
|
|
} else if self.markup.type_ == "CODE" {
|
|
if self.pos_type == PostitionType::Start {
|
|
"<code>".into()
|
|
} else {
|
|
"</code>".into()
|
|
}
|
|
} else {
|
|
// log::error!("unknown markup.type_: {:?} post id {}", markup.type_, id);
|
|
if self.pos_type == PostitionType::Start {
|
|
log::info!("Unknown type");
|
|
r#"
|
|
<p class="libmedium__meta">
|
|
<b>From LibMedium:</b> LibMedium is built by reverse
|
|
engineering the Meduim's internal API. This post contains
|
|
markup(formatting rules) that we are unaware of.
|
|
Please report this URL <a
|
|
href="https://github.com/realaravinth/libmedium/issues/1"
|
|
rel="noreferrer">on our bug tracker</a> so that we can
|
|
improve page rendering.
|
|
<br />
|
|
Alternatively, you can also email me at realaravinth at batsense dot net!
|
|
</p>
|
|
<span>"#
|
|
.into()
|
|
} else {
|
|
"</span>".into()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct PositionMap<'a, 'b> {
|
|
map: HashMap<i64, Vec<Markup<'a, 'b>>>,
|
|
arr: Vec<i64>,
|
|
}
|
|
|
|
impl<'a, 'b> PositionMap<'a, 'b> {
|
|
fn insert_if_not_exists(&mut self, pos: i64, m: Markup<'a, 'b>) {
|
|
if let Some(markups) = self.map.get_mut(&pos) {
|
|
markups.push(m);
|
|
} else {
|
|
self.map.insert(pos, vec![m]);
|
|
self.arr.push(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn apply_markup(
|
|
data: &PostResp,
|
|
gists: &Option<Vec<(String, crate::data::GistContent)>>,
|
|
) -> Vec<String> {
|
|
let mut paragraphs: Vec<String> = Vec::with_capacity(data.content.body_model.paragraphs.len());
|
|
let mut state = ListState::default();
|
|
let mut no_render_html = false;
|
|
for (pindex, p) in data.content.body_model.paragraphs.iter().enumerate() {
|
|
let mut pos = PositionMap::default();
|
|
if p.type_ == "H3" && pindex == 0 {
|
|
log::debug!("FOUND TOP LEVEL H3. Breaking");
|
|
continue;
|
|
}
|
|
for m in p.markups.iter() {
|
|
let start_markup = Markup {
|
|
markup: m,
|
|
p,
|
|
gists,
|
|
pos_type: PostitionType::Start,
|
|
};
|
|
pos.insert_if_not_exists(m.start, start_markup);
|
|
let end_markup = Markup {
|
|
markup: m,
|
|
p,
|
|
gists,
|
|
pos_type: PostitionType::End,
|
|
};
|
|
|
|
pos.insert_if_not_exists(m.end, end_markup);
|
|
}
|
|
|
|
let mut cur = 0;
|
|
|
|
fn incr_cur(cur: usize, point: i64) -> usize {
|
|
let incr = point as usize - cur;
|
|
let post_incr = cur + incr;
|
|
log::debug!(
|
|
"cur before incr: {cur}, incr by: {}, post incr: {}",
|
|
incr,
|
|
post_incr
|
|
);
|
|
post_incr
|
|
}
|
|
|
|
let mut content = String::with_capacity(p.text.len());
|
|
let start = &Markup::start(p, gists, pindex, &mut state);
|
|
content += start;
|
|
if start == "<pre>" {
|
|
no_render_html = true;
|
|
}
|
|
pos.arr.sort();
|
|
let mut page = String::default();
|
|
if let Some(first) = pos.arr.first() {
|
|
page += p.text.slice(cur..*first as usize);
|
|
cur = incr_cur(cur, *first);
|
|
for point in pos.arr.iter() {
|
|
if cur != *point as usize {
|
|
page += p.text.slice(cur..*point as usize);
|
|
}
|
|
// }
|
|
let pos_markups = pos.map.get(point).unwrap();
|
|
for m in pos_markups.iter() {
|
|
page += &m.apply_markup(pindex);
|
|
}
|
|
cur = incr_cur(cur, *point);
|
|
}
|
|
log::debug!("LAST");
|
|
page += p.text.slice(cur..);
|
|
let end = &Markup::end(p, pindex, &mut state);
|
|
if end == "</pre>" {
|
|
no_render_html = false;
|
|
}
|
|
content += &page;
|
|
content += end;
|
|
} else {
|
|
log::debug!("LAST WITH NO MARKUP");
|
|
page += p.text.slice(cur..);
|
|
if no_render_html {
|
|
page = page.replace("<", "<").replace(">", ">");
|
|
}
|
|
content += &page;
|
|
content += &Markup::end(p, pindex, &mut state);
|
|
}
|
|
paragraphs.push(content);
|
|
}
|
|
paragraphs
|
|
}
|