serv/surwiki
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Start exploring a refactoring to components with scopes and resources

Browse source
This commit is contained in:
Magnus Hoff 2018-08-03 09:23:06 +02:00
parent 53e983bee9
commit 7e1770fb07
15 changed files with 221 additions and 197 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
src/components/changes/mod.rs Normal file
View file

@ -0,0 +1,31 @@
use diesel;
use schema::article_revisions;
mod query_parameters;
mod resource;
mod scope;
pub use self::query_parameters::QueryParameters;
pub use self::scope::Scope;
pub use self::resource::Resource;
fn apply_query_config<'a>(
mut query: article_revisions::BoxedQuery<'a, diesel::sqlite::Sqlite>,
article_id: Option<i32>,
author: Option<String>,
limit: i32,
)
-> article_revisions::BoxedQuery<'a, diesel::sqlite::Sqlite>
{
use diesel::prelude::*;
if let Some(article_id) = article_id {
query = query.filter(article_revisions::article_id.eq(article_id));
}
if let Some(author) = author {
query = query.filter(article_revisions::author.eq(author));
}
query.limit(limit as i64 + 1)
}

50
src/components/changes/query_parameters.rs Normal file
View file

@ -0,0 +1,50 @@
use serde_urlencoded;
use pagination::Pagination;
pub const DEFAULT_LIMIT: i32 = 30;
#[derive(Serialize, Deserialize, Default)]
pub struct QueryParameters {
pub after: Option<i32>,
pub before: Option<i32>,
pub article_id: Option<i32>,
pub author: Option<String>,
pub limit: Option<i32>,
}
impl QueryParameters {
pub fn pagination(self, pagination: Pagination<i32>) -> Self {
Self {
after: if let Pagination::After(x) = pagination { Some(x) } else { None },
before: if let Pagination::Before(x) = pagination { Some(x) } else { None },
..self
}
}
pub fn article_id(self, article_id: Option<i32>) -> Self {
Self { article_id, ..self }
}
pub fn author(self, author: Option<String>) -> Self {
Self { author, ..self }
}
pub fn limit(self, limit: i32) -> Self {
Self {
limit: if limit != DEFAULT_LIMIT { Some(limit) } else { None },
..self
}
}
pub fn into_link(self) -> String {
let args = serde_urlencoded::to_string(self).expect("Serializing to String cannot fail");
if args.len() > 0 {
format!("?{}", args)
} else {
"_changes".to_owned()
}
}
}

183
src/resources/changes_resource.rs → src/components/changes/resource.rs
View file

@ -1,169 +1,20 @@
use diesel;
use futures::{self, Future};
use futures::future::{done, finished};
use hyper;
use hyper::header::ContentType;
use hyper::server::*;
use serde_urlencoded;
use mimes::*;
use pagination::Pagination;
use resources::DiffQueryParameters;
use schema::article_revisions;
use site::system_page;
use state::State;
use web::{Resource, ResponseFuture};
use web;
use super::diff_resource;
use super::pagination::Pagination;
use super::TemporaryRedirectResource;
use super::apply_query_config;
use super::query_parameters;
const DEFAULT_LIMIT: i32 = 30;
type BoxResource = Box<Resource + Sync + Send>;
#[derive(Clone)]
pub struct ChangesLookup {
state: State,
show_authors: bool,
}
#[derive(Serialize, Deserialize, Default)]
pub struct QueryParameters {
after: Option<i32>,
before: Option<i32>,
article_id: Option<i32>,
author: Option<String>,
limit: Option<i32>,
}
impl QueryParameters {
pub fn pagination(self, pagination: Pagination<i32>) -> Self {
Self {
after: if let Pagination::After(x) = pagination { Some(x) } else { None },
before: if let Pagination::Before(x) = pagination { Some(x) } else { None },
..self
}
}
pub fn article_id(self, article_id: Option<i32>) -> Self {
Self { article_id, ..self }
}
pub fn author(self, author: Option<String>) -> Self {
Self { author, ..self }
}
pub fn limit(self, limit: i32) -> Self {
Self {
limit: if limit != DEFAULT_LIMIT { Some(limit) } else { None },
..self
}
}
pub fn into_link(self) -> String {
let args = serde_urlencoded::to_string(self).expect("Serializing to String cannot fail");
if args.len() > 0 {
format!("?{}", args)
} else {
"_changes".to_owned()
}
}
}
fn apply_query_config<'a>(
mut query: article_revisions::BoxedQuery<'a, diesel::sqlite::Sqlite>,
article_id: Option<i32>,
author: Option<String>,
limit: i32,
)
-> article_revisions::BoxedQuery<'a, diesel::sqlite::Sqlite>
{
use diesel::prelude::*;
if let Some(article_id) = article_id {
query = query.filter(article_revisions::article_id.eq(article_id));
}
if let Some(author) = author {
query = query.filter(article_revisions::author.eq(author));
}
query.limit(limit as i64 + 1)
}
impl ChangesLookup {
pub fn new(state: State, show_authors: bool) -> ChangesLookup {
Self { state, show_authors }
}
pub fn lookup(&self, query: Option<&str>) -> Box<Future<Item=Option<BoxResource>, Error=::web::Error>> {
use super::pagination;
let state = self.state.clone();
let show_authors = self.show_authors;
Box::new(
done((|| {
let params: QueryParameters = serde_urlencoded::from_str(query.unwrap_or(""))?;
let pagination = pagination::from_fields(params.after, params.before)?;
let limit = match params.limit {
None => Ok(DEFAULT_LIMIT),
Some(x) if 1 <= x && x <= 100 => Ok(x),
_ => Err("`limit` argument must be in range [1, 100]"),
}?;
Ok((pagination, params.article_id, params.author, limit))
})())
.and_then(move |(pagination, article_id, author, limit)| match pagination {
Pagination::After(x) => {
let author2 = author.clone();
Box::new(state.query_article_revision_stubs(move |query| {
use diesel::prelude::*;
apply_query_config(query, article_id, author2, limit)
.filter(article_revisions::sequence_number.gt(x))
.order(article_revisions::sequence_number.asc())
}).and_then(move |mut data| {
let extra_element = if data.len() > limit as usize {
data.pop()
} else {
None
};
let args =
QueryParameters {
after: None,
before: None,
article_id,
author,
limit: None,
}
.limit(limit);
Ok(Some(match extra_element {
Some(x) => Box::new(TemporaryRedirectResource::new(
args
.pagination(Pagination::Before(x.sequence_number))
.into_link()
)) as BoxResource,
None => Box::new(TemporaryRedirectResource::new(
args.into_link()
)) as BoxResource,
}))
})) as Box<Future<Item=Option<BoxResource>, Error=::web::Error>>
},
Pagination::Before(x) => Box::new(finished(Some(Box::new(ChangesResource::new(state, show_authors, Some(x), article_id, author, limit)) as BoxResource))),
Pagination::None => Box::new(finished(Some(Box::new(ChangesResource::new(state, show_authors, None, article_id, author, limit)) as BoxResource))),
})
)
}
}
pub struct ChangesResource {
pub struct Resource {
state: State,
show_authors: bool,
before: Option<i32>,
@ -172,41 +23,41 @@ pub struct ChangesResource {
limit: i32,
}
impl ChangesResource {
impl Resource {
pub fn new(state: State, show_authors: bool, before: Option<i32>, article_id: Option<i32>, author: Option<String>, limit: i32) -> Self {
Self { state, show_authors, before, article_id, author, limit }
Resource { state, show_authors, before, article_id, author, limit }
}
fn query_args(&self) -> QueryParameters {
QueryParameters {
fn query_args(&self) -> query_parameters::QueryParameters {
query_parameters::QueryParameters {
after: None,
before: self.before,
article_id: self.article_id,
author: self.author.clone(),
..QueryParameters::default()
..query_parameters::QueryParameters::default()
}
.limit(self.limit)
}
}
impl Resource for ChangesResource {
impl web::Resource for Resource {
fn allow(&self) -> Vec<hyper::Method> {
use hyper::Method::*;
vec![Options, Head, Get]
}
fn head(&self) -> ResponseFuture {
fn head(&self) -> web::ResponseFuture {
Box::new(futures::finished(Response::new()
.with_status(hyper::StatusCode::Ok)
.with_header(ContentType(TEXT_HTML.clone()))
))
}
fn get(self: Box<Self>) -> ResponseFuture {
fn get(self: Box<Self>) -> web::ResponseFuture {
use chrono::{TimeZone, Local};
struct Row<'a> {
resource: &'a ChangesResource,
resource: &'a Resource,
sequence_number: i32,
article_id: i32,
@ -239,7 +90,7 @@ impl Resource for ChangesResource {
#[derive(BartDisplay)]
#[template="templates/changes.html"]
struct Template<'a> {
resource: &'a ChangesResource,
resource: &'a Resource,
show_authors: bool,
newer: Option<NavLinks>,
@ -341,7 +192,7 @@ impl Resource for ChangesResource {
if x.revision > 1 {
Some(format!("_diff/{}?{}",
x.article_id,
diff_resource::QueryParameters::new(
DiffQueryParameters::new(
x.revision as u32 - 1,
x.revision as u32,
)

90
src/components/changes/scope.rs Normal file
View file

@ -0,0 +1,90 @@
use futures::Future;
use futures::future::{done, finished};
use serde_urlencoded;
use pagination::{self, Pagination};
use resources::TemporaryRedirectResource;
use schema::article_revisions;
use state::State;
use web;
use super::apply_query_config;
use super::query_parameters;
use super::Resource;
type BoxResource = Box<web::Resource + Sync + Send>;
#[derive(Clone)]
pub struct Scope {
state: State,
show_authors: bool,
}
impl Scope {
pub fn new(state: State, show_authors: bool) -> Scope {
Self { state, show_authors }
}
pub fn lookup(&self, query: Option<&str>) -> Box<Future<Item=Option<BoxResource>, Error=::web::Error>> {
let state = self.state.clone();
let show_authors = self.show_authors;
Box::new(
done((|| {
let params: query_parameters::QueryParameters = serde_urlencoded::from_str(query.unwrap_or(""))?;
let pagination = pagination::from_fields(params.after, params.before)?;
let limit = match params.limit {
None => Ok(query_parameters::DEFAULT_LIMIT),
Some(x) if 1 <= x && x <= 100 => Ok(x),
_ => Err("`limit` argument must be in range [1, 100]"),
}?;
Ok((pagination, params.article_id, params.author, limit))
})())
.and_then(move |(pagination, article_id, author, limit)| match pagination {
Pagination::After(x) => {
let author2 = author.clone();
Box::new(state.query_article_revision_stubs(move |query| {
use diesel::prelude::*;
apply_query_config(query, article_id, author2, limit)
.filter(article_revisions::sequence_number.gt(x))
.order(article_revisions::sequence_number.asc())
}).and_then(move |mut data| {
let extra_element = if data.len() > limit as usize {
data.pop()
} else {
None
};
let args =
query_parameters::QueryParameters {
after: None,
before: None,
article_id,
author,
limit: None,
}
.limit(limit);
Ok(Some(match extra_element {
Some(x) => Box::new(TemporaryRedirectResource::new(
args
.pagination(Pagination::Before(x.sequence_number))
.into_link()
)) as BoxResource,
None => Box::new(TemporaryRedirectResource::new(
args.into_link()
)) as BoxResource,
}))
})) as Box<Future<Item=Option<BoxResource>, Error=::web::Error>>
},
Pagination::Before(x) => Box::new(finished(Some(Box::new(Resource::new(state, show_authors, Some(x), article_id, author, limit)) as BoxResource))),
Pagination::None => Box::new(finished(Some(Box::new(Resource::new(state, show_authors, None, article_id, author, limit)) as BoxResource))),
})
)
}
}

1
src/components/mod.rs Normal file
View file

@ -0,0 +1 @@
pub mod changes;

2
src/lib.rs
View file

@ -32,10 +32,12 @@ use std::net::{IpAddr, SocketAddr};
mod assets;
mod build_config;
mod components;
mod db;
mod merge;
mod mimes;
mod models;
mod pagination;
mod rendering;
mod resources;
mod schema;

0
src/resources/pagination.rs → src/pagination.rs
View file

2
src/resources/article_resource.rs
View file

@ -13,7 +13,7 @@ use site::Layout;
use state::{State, UpdateResult, RebaseConflict};
use web::{Resource, ResponseFuture};
use super::changes_resource::QueryParameters;
use components::changes::QueryParameters;
#[derive(BartDisplay)]
#[template="templates/article.html"]

4
src/resources/article_revision_resource.rs
View file

@ -4,15 +4,15 @@ use hyper;
use hyper::header::ContentType;
use hyper::server::*;
use components::changes::QueryParameters;
use mimes::*;
use models;
use pagination::Pagination;
use rendering::render_markdown;
use site::system_page;
use web::{Resource, ResponseFuture};
use super::changes_resource::QueryParameters;
use super::diff_resource;
use super::pagination::Pagination;
pub struct ArticleRevisionResource {
data: models::ArticleRevision,

7
src/resources/diff_resource.rs
View file

@ -8,15 +8,14 @@ use hyper::header::ContentType;
use hyper::server::*;
use serde_urlencoded;
use components::changes;
use mimes::*;
use models::ArticleRevision;
use pagination::Pagination;
use site::Layout;
use state::State;
use web::{Resource, ResponseFuture};
use super::changes_resource;
use super::pagination::Pagination;
type BoxResource = Box<Resource + Sync + Send>;
#[derive(Clone)]
@ -126,7 +125,7 @@ impl Resource for DiffResource {
consecutive: self.to.revision - self.from.revision == 1,
article_id: self.from.article_id as u32,
article_history_link: &format!("_changes{}",
changes_resource::QueryParameters::default()
changes::QueryParameters::default()
.article_id(Some(self.from.article_id))
.pagination(Pagination::After(self.from.revision))
.into_link()

5
src/resources/mod.rs
View file

@ -1,9 +1,6 @@
pub mod pagination;
mod about_resource;
mod article_revision_resource;
mod article_resource;
mod changes_resource;
mod diff_resource;
mod html_resource;
mod new_article_resource;
@ -15,8 +12,8 @@ mod temporary_redirect_resource;
pub use self::about_resource::AboutResource;
pub use self::article_revision_resource::ArticleRevisionResource;
pub use self::article_resource::ArticleResource;
pub use self::changes_resource::{ChangesLookup, ChangesResource};
pub use self::diff_resource::{DiffLookup, DiffResource};
pub use self::diff_resource::QueryParameters as DiffQueryParameters;
pub use self::html_resource::HtmlResource;
pub use self::new_article_resource::NewArticleResource;
pub use self::read_only_resource::ReadOnlyResource;

8
src/site.rs
View file

@ -11,7 +11,7 @@ use hyper;
use assets::{ThemesCss, StyleCss, SearchJs};
use build_config;
use web::Lookup;
use web::Scope;
use wiki_lookup::WikiLookup;
const THEMES: [&str; 19] = ["red", "pink", "purple", "deep-purple", "indigo",
@ -115,12 +115,14 @@ impl Site {
}
fn root_base_from_request_uri(path: &str) -> Option<String> {
use std::iter::repeat;
assert!(path.starts_with("/"));
let slashes = path[1..].matches('/').count();
match slashes {
0 => None,
n => Some(::std::iter::repeat("../").take(n).collect())
n => Some(repeat("../").take(n).collect())
}
}
@ -145,7 +147,7 @@ impl Service for Site {
let base = root_base_from_request_uri(uri.path());
let base2 = base.clone(); // Bah, stupid clone
Box::new(self.root.lookup(uri.path(), uri.query())
Box::new(self.root.scope_lookup(uri.path(), uri.query())
.and_then(move |resource| match resource {
Some(mut resource) => {
use hyper::Method::*;

4
src/web/mod.rs
View file

@ -1,5 +1,5 @@
mod resource;
mod lookup;
mod scope;
pub use self::resource::*;
pub use self::lookup::*;
pub use self::scope::*;

4
src/web/lookup.rs → src/web/scope.rs
View file

@ -1,9 +1,9 @@
use futures;
pub trait Lookup {
pub trait Scope {
type Resource;
type Error;
type Future: futures::Future<Item=Option<Self::Resource>, Error=Self::Error>;
fn lookup(&self, path: &str, query: Option<&str>) -> Self::Future;
fn scope_lookup(&self, path: &str, query: Option<&str>) -> Self::Future;
}

27
src/wiki_lookup.rs
View file

@ -8,8 +8,9 @@ use percent_encoding::percent_decode;
use slug::slugify;
use resources::*;
use components::*;
use state::State;
use web::{Lookup, Resource};
use web::{Scope, Resource};
#[allow(unused)]
use assets::*;
@ -40,7 +41,7 @@ lazy_static! {
#[derive(Clone)]
pub struct WikiLookup {
state: State,
changes_lookup: ChangesLookup,
changes_lookup: changes::Scope,
diff_lookup: DiffLookup,
search_lookup: SearchLookup,
}
@ -104,15 +105,15 @@ fn fs_lookup(root: &str, path: &str) ->
impl WikiLookup {
pub fn new(state: State, show_authors: bool) -> WikiLookup {
let changes_lookup = ChangesLookup::new(state.clone(), show_authors);
let changes_lookup = changes::Scope::new(state.clone(), show_authors);
let diff_lookup = DiffLookup::new(state.clone());
let search_lookup = SearchLookup::new(state.clone());
WikiLookup { state, changes_lookup, diff_lookup, search_lookup }
}
fn revisions_lookup(&self, path: &str, _query: Option<&str>) -> <Self as Lookup>::Future {
let (article_id, revision): (i32, i32) = match (|| -> Result<_, <Self as Lookup>::Error> {
fn revisions_lookup(&self, path: &str, _query: Option<&str>) -> <Self as Scope>::Future {
let (article_id, revision): (i32, i32) = match (|| -> Result<_, <Self as Scope>::Error> {
let (article_id, tail) = split_one(path)?;
let (revision, tail) = split_one(tail.ok_or("Not found")?)?;
if tail.is_some() {
@ -135,8 +136,8 @@ impl WikiLookup {
)
}
fn by_id_lookup(&self, path: &str, _query: Option<&str>) -> <Self as Lookup>::Future {
let article_id: i32 = match (|| -> Result<_, <Self as Lookup>::Error> {
fn by_id_lookup(&self, path: &str, _query: Option<&str>) -> <Self as Scope>::Future {
let article_id: i32 = match (|| -> Result<_, <Self as Scope>::Error> {
let (article_id, tail) = split_one(path)?;
if tail.is_some() {
return Err("Not found".into());
@ -158,8 +159,8 @@ impl WikiLookup {
)
}
fn diff_lookup_f(&self, path: &str, query: Option<&str>) -> <Self as Lookup>::Future {
let article_id: u32 = match (|| -> Result<_, <Self as Lookup>::Error> {
fn diff_lookup_f(&self, path: &str, query: Option<&str>) -> <Self as Scope>::Future {
let article_id: u32 = match (|| -> Result<_, <Self as Scope>::Error> {
let (article_id, tail) = split_one(path)?;
if tail.is_some() {
return Err("Not found".into());
@ -174,7 +175,7 @@ impl WikiLookup {
Box::new(self.diff_lookup.lookup(article_id, query))
}
fn reserved_lookup(&self, path: &str, query: Option<&str>) -> <Self as Lookup>::Future {
fn reserved_lookup(&self, path: &str, query: Option<&str>) -> <Self as Scope>::Future {
let (head, tail) = match split_one(path) {
Ok(x) => x,
Err(x) => return Box::new(failed(x.into())),
@ -209,7 +210,7 @@ impl WikiLookup {
}
}
fn article_lookup(&self, path: &str, query: Option<&str>) -> <Self as Lookup>::Future {
fn article_lookup(&self, path: &str, query: Option<&str>) -> <Self as Scope>::Future {
let (slug, tail) = match split_one(path) {
Ok(x) => x,
Err(x) => return Box::new(failed(x.into())),
@ -246,12 +247,12 @@ impl WikiLookup {
}
}
impl Lookup for WikiLookup {
impl Scope for WikiLookup {
type Resource = BoxResource;
type Error = Box<::std::error::Error + Send + Sync>;
type Future = Box<Future<Item = Option<Self::Resource>, Error = Self::Error>>;
fn lookup(&self, path: &str, query: Option<&str>) -> Self::Future {
fn scope_lookup(&self, path: &str, query: Option<&str>) -> Self::Future {
assert!(path.starts_with("/"));
let path = &path[1..];