#[ allow (unused_imports) ]
use ::std::{
cell,
env,
ffi,
fmt,
fs,
io,
iter,
mem,
path,
rc,
collections::BTreeSet,
iter::Iterator,
path::{Path, PathBuf},
str::FromStr as _,
fmt::{Write as _},
io::{Write as _},
};
use ::globset;
use ::walkdir;
use ::blake2;
use ::proc_macro2;
use crate::builder_errors::*;
#[ derive (Clone, Debug) ]
pub struct BuilderConfiguration {
pub sources : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub assets_sources : Option<PathBuf>,
#[ cfg (feature = "builder-askama") ]
pub templates_sources : Option<PathBuf>,
#[ cfg (feature = "builder-markdown") ]
pub markdowns_sources : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub assets_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub css_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub js_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub images_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub icons_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub favicons_route_base : Option<PathBuf>,
#[ cfg (feature = "builder-assets") ]
pub fonts_route_base : Option<PathBuf>,
pub outputs : PathBuf,
pub generated : PathBuf,
}
impl Default for BuilderConfiguration {
fn default () -> Self {
let _sources = Self::resolve_sources () .or_panic (0xc6e7914d);
let _outputs = Self::resolve_outputs () .or_panic (0x344e2c9e);
#[ cfg (feature = "builder-assets") ]
let _assets_sources = _sources.join ("./assets");
#[ cfg (feature = "builder-assets") ]
let _assets_sources = if _assets_sources.exists () { Some (_assets_sources) } else { None };
#[ cfg (feature = "builder-askama") ]
let _templates_sources = _sources.join ("./templates");
#[ cfg (feature = "builder-askama") ]
let _templates_sources = if _templates_sources.exists () { Some (_templates_sources) } else { None };
#[ cfg (feature = "builder-markdown") ]
let _markdowns_sources = _sources.join ("./markdown");
#[ cfg (feature = "builder-markdown") ]
let _markdowns_sources = if _markdowns_sources.exists () { Some (_markdowns_sources) } else { None };
let _generated = _outputs.join ("./hss-builder-generated-default.in");
#[ cfg (feature = "builder-assets") ]
let _assets_route_base = Some (PathBuf::from ("/assets"));
#[ cfg (feature = "builder-assets") ]
let _css_route_base = Some (PathBuf::from ("/assets/css"));
#[ cfg (feature = "builder-assets") ]
let _js_route_base = Some (PathBuf::from ("/assets/js"));
#[ cfg (feature = "builder-assets") ]
let _images_route_base = Some (PathBuf::from ("/assets/images"));
#[ cfg (feature = "builder-assets") ]
let _icons_route_base = Some (PathBuf::from ("/assets/icons"));
#[ cfg (feature = "builder-assets") ]
let _favicons_route_base = Some (PathBuf::from ("/assets/favicons"));
#[ cfg (feature = "builder-assets") ]
let _fonts_route_base = Some (PathBuf::from ("/assets/fonts"));
Self {
sources : Some (_sources),
#[ cfg (feature = "builder-assets") ]
assets_sources : _assets_sources,
#[ cfg (feature = "builder-askama") ]
templates_sources : _templates_sources,
#[ cfg (feature = "builder-markdown") ]
markdowns_sources : _markdowns_sources,
#[ cfg (feature = "builder-assets") ]
assets_route_base : _assets_route_base,
#[ cfg (feature = "builder-assets") ]
css_route_base : _css_route_base,
#[ cfg (feature = "builder-assets") ]
js_route_base : _js_route_base,
#[ cfg (feature = "builder-assets") ]
images_route_base : _images_route_base,
#[ cfg (feature = "builder-assets") ]
icons_route_base : _icons_route_base,
#[ cfg (feature = "builder-assets") ]
favicons_route_base : _favicons_route_base,
#[ cfg (feature = "builder-assets") ]
fonts_route_base : _fonts_route_base,
outputs : _outputs,
generated : _generated,
}
}
}
impl BuilderConfiguration {
pub fn minimal () -> BuilderResult<Self> {
let _sources = Self::resolve_sources () ?;
let _outputs = Self::resolve_outputs () ?;
let _generated = _outputs.join ("./hss-builder-generated-default.in");
let _builder = Self {
sources : Some (_sources),
#[ cfg (feature = "builder-assets") ]
assets_sources : None,
#[ cfg (feature = "builder-askama") ]
templates_sources : None,
#[ cfg (feature = "builder-markdown") ]
markdowns_sources : None,
#[ cfg (feature = "builder-assets") ]
assets_route_base : None,
#[ cfg (feature = "builder-assets") ]
css_route_base : None,
#[ cfg (feature = "builder-assets") ]
js_route_base : None,
#[ cfg (feature = "builder-assets") ]
images_route_base : None,
#[ cfg (feature = "builder-assets") ]
icons_route_base : None,
#[ cfg (feature = "builder-assets") ]
favicons_route_base : None,
#[ cfg (feature = "builder-assets") ]
fonts_route_base : None,
outputs : _outputs,
generated : _generated,
};
Ok (_builder)
}
pub fn resolve_sources () -> BuilderResult<PathBuf> {
let _sources = PathBuf::from (env::var ("CARGO_MANIFEST_DIR") .or_wrap (0x4c6c04d8) ?);
if ! _sources.is_dir () {
return Err (error_with_code (0x148bc689));
}
normalize_path (&_sources)
}
pub fn resolve_outputs () -> BuilderResult<PathBuf> {
let _outputs = PathBuf::from (env::var ("OUT_DIR") .or_wrap (0xf039039f) ?);
if ! _outputs.is_dir () {
return Err (error_with_code (0xfcee6b4d));
}
normalize_path (&_outputs)
}
}
pub struct Builder {
configuration : BuilderConfiguration,
generated : String,
counter : u32,
route_names : Vec<String>,
dependencies : BTreeSet<PathBuf>,
}
impl Builder {
pub fn new (_configuration : BuilderConfiguration) -> Self {
Self {
configuration : _configuration,
generated : String::with_capacity (1024 * 1024),
counter : 1,
route_names : Vec::new (),
dependencies : BTreeSet::new (),
}
}
pub fn new_with_defaults () -> Self {
Self::new (BuilderConfiguration::default ())
}
}
impl Builder {
fn route_asset_raw (&mut self, _relative : &Path, _source : &Path, _content_type : &str, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _macro : &str, _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _route = _route_builder.build (_relative, &_source, _route_base, None) ?;
let _extensions = _extensions_builder.build () ?;
let _id = self.generate_id ();
let _description = if let Some (_relative) = _source_relative {
format! ("{} ({}, from = `{}`, file = `...{}`)", _macro, _content_type, _source_0, _relative.display ())
} else {
format! ("{} ({}, file = `{}`)", _macro, _content_type, _source_0)
};
self.route_names.push (format! ("Route_{}", _id));
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source) ?;
let _mode = "auto";
writeln! (self.generated, "::hyper_static_server::resource! (Resource_{}, {}, {}, (relative_to_cwd, {:?}), {:?});", _id, _content_type, _mode, _source, _description) .infallible (0x5fa962ac);
writeln! (self.generated, "::hyper_static_server::route! (Route_{}, Resource_{}, {:?}, {});", _id, _id, _route, _extensions) .infallible (0x46de4cc9);
Ok (())
}
#[ cfg (feature = "builder-askama") ]
pub fn route_askama (&mut self, _source_0 : &str, _context : Option<(&str, Option<&str>)>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_templates_sources, _source_0) ?;
let _route_base = Some (Path::new ("/"));
self.route_askama_0 (&_relative, &_source, _context, _route_base, _route_builder, _extensions_builder, _source_0, None)
}
#[ cfg (feature = "builder-askama") ]
pub fn route_askamas (&mut self, _sources_0 : &str, _glob : Option<&str>, _context : Option<(&str, Option<&str>)>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_templates_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = Some (Path::new ("/"));
for (_relative, _source) in _files.into_iter () {
self.route_askama_0 (&_relative, &_source, _context, _route_base, _route_builder, _extensions_builder, _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-askama") ]
fn route_askama_0 (&mut self, _relative : &Path, _source : &Path, _context : Option<(&str, Option<&str>)>, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _relative_1 = _relative.with_extension ("");
let _template = _relative.strip_prefix ("/") .infallible (0x7285dc26);
let _route = _route_builder.build (&_relative_1, &_source, _route_base, None) ?;
let _extensions = _extensions_builder.build () ?;
let _id = self.generate_id ();
let _content_type = "html";
let _description = if let Some (_relative) = _source_relative {
format! ("askama ({}, from = `{}`, file = `...{}`)", _content_type, _source_0, _relative.display ())
} else {
format! ("askama ({}, file = `{}`)", _content_type, _source_0)
};
self.route_names.push (format! ("Route_{}", _id));
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source) ?;
let (_context_type, _context_path) = _context.unwrap_or (("()", None));
if let Some (_context_path) = _context_path {
let _sources = self.configuration.sources.as_ref () .map (PathBuf::as_path);
let (_, _context_path) = self.resolve_file (None, _context_path) ?;
let _context_encoding = match _context_path.extension () .or_wrap (0x70d90b37) ? .to_str () .or_wrap (0xa22f0541) ? {
"toml" => "toml",
"yaml" => "yaml",
"json" => "json",
_ =>
return Err (error_with_format (0xcbc42494, format_args! ("{}", _context_path.display ()))),
};
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_context_path) ?;
writeln! (self.generated, "::hyper_static_server::askama! (Resource_{}, Template_{}, {{ type : {}, deserialize : ({:?}, {:?}) }}, {}, {:?}, {:?});", _id, _id, _context_type, _context_encoding, _context_path, _content_type, _template, _description) .infallible (0x35966385);
} else {
writeln! (self.generated, "::hyper_static_server::askama! (Resource_{}, Template_{}, {{ type : {} }}, {}, {:?}, {:?});", _id, _id, _context_type, _content_type, _template, _description) .infallible (0x35966385);
}
writeln! (self.generated, "::hyper_static_server::route! (Route_{}, Resource_{}, {:?}, {});", _id, _id, _route, _extensions) .infallible (0x41a5ee4c);
Ok (())
}
#[ cfg (feature = "builder-askama") ]
pub fn watch_askama (&mut self, _source : &str) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_templates_sources, _source) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source) ?;
Ok (())
}
#[ cfg (feature = "builder-askama") ]
pub fn watch_askamas (&mut self, _sources : &str, _glob : Option<&str>) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_templates_sources, _sources, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_files.iter () .map (|_pair| _pair.1.as_path ())) ?;
Ok (())
}
#[ cfg (feature = "builder-askama") ]
#[ cfg (feature = "builder-markdown") ]
pub fn route_markdown_askama (&mut self, _source_markdown_0 : &str, _source_template_0 : &str, _context : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_relative_template, _source_template) = self.resolve_file (_templates_sources, _source_template_0) ?;
let _template = _relative_template.strip_prefix ("/") .infallible (0xda5e5ad4);
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source_template) ?;
let _markdowns_sources = self.configuration.markdowns_sources.as_ref () .map (PathBuf::as_path);
let (_relative_markdown, _source_markdown) = self.resolve_file (_markdowns_sources, _source_markdown_0) ?;
let _route_base = Some (Path::new ("/"));
self.route_markdown_askama_0 (&_relative_markdown, &_source_markdown, &_template, _context, _route_base, _route_builder, _extensions_builder, _source_markdown_0, None)
}
#[ cfg (feature = "builder-askama") ]
#[ cfg (feature = "builder-markdown") ]
pub fn route_markdowns_askama (&mut self, _sources_markdown_0 : &str, _glob : Option<&str>, _source_template_0 : &str, _context : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _templates_sources = self.configuration.templates_sources.as_ref () .map (PathBuf::as_path);
let (_relative_template, _source_template) = self.resolve_file (_templates_sources, _source_template_0) ?;
let _template = _relative_template.strip_prefix ("/") .infallible (0xe0168bd3);
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source_template) ?;
let _markdowns_sources = self.configuration.markdowns_sources.as_ref () .map (PathBuf::as_path);
let (_files_markdown, _folders_markdown) = self.resolve_files (_markdowns_sources, _sources_markdown_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders_markdown.iter () .map (PathBuf::as_path)) ?;
let _route_base = Some (Path::new ("/"));
for (_relative_markdown, _source_markdown) in _files_markdown.into_iter () {
self.route_markdown_askama_0 (&_relative_markdown, &_source_markdown, &_template, _context, _route_base, _route_builder, _extensions_builder, _sources_markdown_0, Some (_relative_markdown.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-askama") ]
#[ cfg (feature = "builder-markdown") ]
fn route_markdown_askama_0 (&mut self, _relative_markdown : &Path, _source_markdown : &Path, _template : &Path, _context : Option<&str>, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _relative_markdown_1 = _relative_markdown.with_extension ("");
let (_output_body, _output_title, _output_metadata, _output_frontmatter, _refresher) = if cfg! (any (not (feature = "builder-relaxed-dependencies"), not (feature = "builder-markdown-dynamic"), not (feature = "builder-askama-dynamic"), feature = "production")) {
self.dependencies_include (_source_markdown) ?;
let _markdown = self.compile_markdown_body (_source_markdown, true) ?;
let _markdown_body = _markdown.body;
let _markdown_metadata = _markdown.metadata;
let _markdown_frontmatter = _markdown.frontmatter;
let _markdown_title = _markdown_metadata.title.as_ref () .map (String::as_str) .unwrap_or ("");
let _output_title = self.configuration.outputs.join (fingerprint_data (&_markdown_title)) .with_extension ("txt");
create_file_from_str (&_output_title, _markdown_title, true, true) ?;
let _output_body = self.configuration.outputs.join (fingerprint_data (&_markdown_body)) .with_extension ("html");
create_file_from_str (&_output_body, &_markdown_body, true, true) ?;
let _output_metadata = self.configuration.outputs.join (fingerprint_data (&_markdown_body)) .with_extension ("meta");
let _markdown_metadata = ::serde_json::to_string_pretty (&_markdown_metadata) .or_wrap (0x94fe158d) ?;
create_file_from_str (&_output_metadata, &_markdown_metadata, true, true) ?;
let _output_frontmatter = if let Some (_frontmatter) = _markdown_frontmatter {
let _encoding = _frontmatter.encoding.as_ref ();
let _data = _frontmatter.data.as_ref ();
let _extension = match _encoding {
"toml" => "toml",
"yaml" => "yaml",
"json" => "json",
_ =>
return Err (error_with_format (0x75f4427f, format_args! ("{}", _encoding))),
};
let _path = self.configuration.outputs.join (fingerprint_data (&_data)) .with_extension (_extension);
create_file_from_str (&_path, &_data, true, true) ?;
Some ((_extension, _path))
} else {
None
};
(_output_body, _output_title, _output_metadata, _output_frontmatter, false)
} else {
let _token = fingerprint_data (_source_markdown.to_string_lossy () .as_bytes ());
let _output_body = self.configuration.outputs.join (&_token) .with_extension ("html");
let _output_title = self.configuration.outputs.join (&_token) .with_extension ("txt");
let _output_metadata = self.configuration.outputs.join (&_token) .with_extension ("meta");
let _output_frontmatter = self.configuration.outputs.join (&_token) .with_extension ("data");
(_output_body, _output_title, _output_metadata, Some (("auto", _output_frontmatter)), true)
};
let _route = _route_builder.build (&_relative_markdown_1, _source_markdown, _route_base, None) ?;
let _extensions = _extensions_builder.build () ?;
let _id = self.generate_id ();
let _content_type = "html";
let _description = if let Some (_relative) = _source_relative {
format! ("markdown_askama ({}, from = `{}`, file = `...{}`)", _content_type, _source_0, _relative.display ())
} else {
format! ("markdown_askama ({}, file = `{}`)", _content_type, _source_0)
};
self.route_names.push (format! ("Route_{}", _id));
let _refresher_code = if _refresher {
let (_context_encoding, _context_path) = _output_frontmatter.as_ref () .or_panic (0xc27ad812);
writeln! (self.generated, "::hyper_static_server::resource_markdown_refresher! (Refresher_{}, (relative_to_cwd, {:?}), (relative_to_cwd, {:?}), (relative_to_cwd, {:?}), (relative_to_cwd, {:?}), (relative_to_cwd, {:?}));", _id, _source_markdown, _output_body, _output_title, _output_metadata, _context_path) .infallible (0x2b54879e);
format! ("Refresher_{},", _id)
} else {
String::new ()
};
if let Some ((_context_encoding, _context_path)) = _output_frontmatter {
if let Some (_context_type) = _context {
writeln! (self.generated, "::hyper_static_server::askama_document! (Resource_{}, Template_{}, {{ type : {}, deserialize : ({:?}, {:?}) }}, {}, {:?}, {:?}, {:?}, {:?}, {} {:?});", _id, _id, _context_type, _context_encoding, _context_path, _content_type, _template, _output_body, _output_title, _output_metadata, _refresher_code, _description) .infallible (0xd64341cb);
} else {
let _context_type = _context.unwrap_or ("()");
writeln! (self.generated, "::hyper_static_server::askama_document! (Resource_{}, Template_{}, {{ type : {} }}, {}, {:?}, {:?}, {:?}, {:?}, {} {:?});", _id, _id, _context_type, _content_type, _template, _output_body, _output_title, _output_metadata, _refresher_code, _description) .infallible (0xd64341cb);
}
} else {
let _context_type = _context.unwrap_or ("()");
writeln! (self.generated, "::hyper_static_server::askama_document! (Resource_{}, Template_{}, {{ type : {} }}, {}, {:?}, {:?}, {:?}, {:?}, {} {:?});", _id, _id, _context_type, _content_type, _template, _output_body, _output_title, _output_metadata, _refresher_code, _description) .infallible (0xd64341cb);
}
writeln! (self.generated, "::hyper_static_server::route! (Route_{}, Resource_{}, {:?}, {});", _id, _id, _route, _extensions) .infallible (0xafb30ea0);
Ok (())
}
#[ cfg (feature = "builder-markdown") ]
pub fn route_markdown (&mut self, _source_0 : &str, _header_source : Option<&str>, _footer_source : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _markdowns_sources = self.configuration.markdowns_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_markdowns_sources, _source_0) ?;
let _route_base = Some (Path::new ("/"));
self.route_markdown_0 (&_relative, &_source, _header_source, _footer_source, _route_base, _route_builder, _extensions_builder, _source_0, None)
}
#[ cfg (feature = "builder-markdown") ]
pub fn route_markdowns (&mut self, _sources_0 : &str, _glob : Option<&str>, _header_source : Option<&str>, _footer_source : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _markdowns_sources = self.configuration.markdowns_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_markdowns_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = Some (Path::new ("/"));
for (_relative, _source) in _files.into_iter () {
if _source.extension () .or_wrap (0xc1ecda55) ? != "md" {
return Err (error_with_format (0x393ea45d, format_args! ("{}", _source.display ())));
}
self.route_markdown_0 (&_relative, &_source, _header_source, _footer_source, _route_base, _route_builder, _extensions_builder, _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-markdown") ]
fn route_markdown_0 (&mut self, _relative : &Path, _source : &Path, _header_source : Option<&str>, _footer_source : Option<&str>, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _markdowns_sources = self.configuration.markdowns_sources.as_ref () .map (PathBuf::as_path);
let _header_source = _header_source.map (|_source| BuilderResult::Ok (self.resolve_file (_markdowns_sources, _source) ? .1)) .transpose () ?;
let _footer_source = _footer_source.map (|_source| BuilderResult::Ok (self.resolve_file (_markdowns_sources, _source) ? .1)) .transpose () ?;
let _relative_1 = _relative.with_extension ("");
if cfg! (any (not (feature = "builder-relaxed-dependencies"), not (feature = "builder-markdown-dynamic"), feature = "production")) {
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), not (feature = "builder-markdown-dynamic"), feature = "production")) ]
{
self.dependencies_include (&_source) ?;
if let Some (_header_source) = &_header_source {
self.dependencies_include (_header_source) ?;
}
if let Some (_footer_source) = &_footer_source {
self.dependencies_include (_footer_source) ?;
}
}
let _header_source = _header_source.as_ref () .map (PathBuf::as_path);
let _footer_source = _footer_source.as_ref () .map (PathBuf::as_path);
let _html_data = self.compile_markdown_html (_source, _header_source, _footer_source) ?;
let _output = self.configuration.outputs.join (fingerprint_data (&_html_data)) .with_extension ("html");
create_file_from_str (&_output, &_html_data, true, true) ?;
self.route_asset_raw (&_relative_1, &_output, "html", _route_base, _route_builder, _extensions_builder, "markdown", _source_0, _source_relative) ?;
self.dependencies_exclude (&_output) ?;
} else {
let _route = _route_builder.build (&_relative_1, &_source, _route_base, None) ?;
let _extensions = _extensions_builder.build () ?;
let _id = self.generate_id ();
let _description = format! ("{} (file = `{}`)", "resource_markdown", _source_0);
self.route_names.push (format! ("Route_{}", _id));
writeln! (self.generated, "::hyper_static_server::resource_markdown_dynamic! (Resource_{}, {}, (relative_to_cwd, {:?}), (relative_to_cwd, {:?}), (relative_to_cwd, {:?}), {:?});", _id, "html", _source, _header_source, _footer_source, _description) .infallible (0x15f089dc);
writeln! (self.generated, "::hyper_static_server::route! (Route_{}, Resource_{}, {:?}, {});", _id, _id, _route, _extensions) .infallible (0xbf41dd16);
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn route_css (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _css_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_css_sources, _source_0) ?;
let _route_base = self.configuration.css_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_asset_raw (&_relative, &_source, "css", _route_base, _route_builder, _extensions_builder, "resource_css", _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
#[ cfg (feature = "builder-assets-sass") ]
pub fn route_sass (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _css_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_css_sources, _source_0) ?;
let _relative_1 = _relative.with_extension ("css");
let _route_base = self.configuration.css_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
if cfg! (any (not (feature = "builder-relaxed-dependencies"), not (feature = "builder-assets-sass-dynamic"), feature = "production")) {
self.dependencies_include (&_source) ?;
let _compiled = self.compile_sass (&_source) ?;
let _output = self.configuration.outputs.join (fingerprint_data (&_compiled)) .with_extension ("css");
create_file_from_str (&_output, &_compiled, true, true) ?;
self.route_asset_raw (&_relative_1, &_output, "css", _route_base, _route_builder, _extensions_builder, "resource_sass", _source_0, None) ?;
self.dependencies_exclude (&_output) ?;
} else {
let _route = _route_builder.build (&_relative_1, &_source, _route_base, None) ?;
let _extensions = _extensions_builder.build () ?;
let _id = self.generate_id ();
let _description = format! ("{} (file = `{}`)", "resource_sass", _source_0);
self.route_names.push (format! ("Route_{}", _id));
writeln! (self.generated, "::hyper_static_server::resource_sass_dynamic! (Resource_{}, {}, (relative_to_cwd, {:?}), {:?});", _id, "css", _source, _description) .infallible (0xb7dd2208);
writeln! (self.generated, "::hyper_static_server::route! (Route_{}, Resource_{}, {:?}, {});", _id, _id, _route, _extensions) .infallible (0x506e8636);
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn route_js (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _js_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_js_sources, _source_0) ?;
let _route_base = self.configuration.js_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_asset_raw (&_relative, &_source, "js", _route_base, _route_builder, _extensions_builder, "resource_js", _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_image (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source_0) ?;
let _route_base = self.configuration.images_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_image", _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_images (&mut self, _sources_0 : &str, _glob : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = self.configuration.images_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
for (_relative, _source) in _files.into_iter () {
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_image", _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn route_icon (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source_0) ?;
let _route_base = self.configuration.icons_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_icon", _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_icons (&mut self, _sources_0 : &str, _glob : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = self.configuration.icons_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
for (_relative, _source) in _files.into_iter () {
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_icon", _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn route_favicon (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source_0) ?;
let _route_base = self.configuration.favicons_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_favicon", _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_favicons (&mut self, _sources_0 : &str, _glob : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = self.configuration.favicons_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
for (_relative, _source) in _files.into_iter () {
self.route_image_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, "resource_favicon", _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
fn route_image_0 (&mut self, _relative : &Path, _source : &Path, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _macro : &str, _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _content_type = detect_content_type_from_extension (&_source) ?;
match _content_type {
"png" | "jpeg" | "icon" | "svg" =>
(),
_ =>
return Err (error_with_format (0x0fd2d804, format_args! ("{}", _source.display ()))),
};
self.route_asset_raw (_relative, _source, _content_type, _route_base, _route_builder, _extensions_builder, _macro, _source_0, _source_relative)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_font (&mut self, _source_0 : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source_0) ?;
let _route_base = self.configuration.fonts_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_font_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_fonts (&mut self, _sources_0 : &str, _glob : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = self.configuration.fonts_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
for (_relative, _source) in _files.into_iter () {
self.route_font_0 (&_relative, &_source, _route_base, _route_builder, _extensions_builder, _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
fn route_font_0 (&mut self, _relative : &Path, _source : &Path, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _content_type = detect_content_type_from_extension (&_source) ?;
match _content_type {
"font_ttf" | "font_otf" | "font_woff" | "font_woff2" =>
(),
_ =>
return Err (error_with_format (0x1a4ccbf4, format_args! ("{}", _source.display ()))),
};
self.route_asset_raw (_relative, _source, _content_type, _route_base, _route_builder, _extensions_builder, "resource_font", _source_0, _source_relative)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_asset (&mut self, _source_0 : &str, _content_type : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source_0) ?;
let _route_base = self.configuration.assets_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
self.route_asset_0 (&_relative, &_source, _content_type, _route_base, _route_builder, _extensions_builder, _source_0, None)
}
#[ cfg (feature = "builder-assets") ]
pub fn route_assets (&mut self, _sources_0 : &str, _glob : Option<&str>, _content_type : Option<&str>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources_0, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
let _route_base = self.configuration.assets_route_base.clone ();
let _route_base = _route_base.as_ref () .map (PathBuf::as_path);
for (_relative, _source) in _files.into_iter () {
self.route_asset_0 (&_relative, &_source, _content_type, _route_base, _route_builder, _extensions_builder, _sources_0, Some (_relative.as_path ())) ?;
}
Ok (())
}
#[ cfg (feature = "builder-assets") ]
fn route_asset_0 (&mut self, _relative : &Path, _source : &Path, _content_type : Option<&str>, _route_base : Option<&Path>, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized), _source_0 : &str, _source_relative : Option<&Path>) -> BuilderResult {
let _content_type = _content_type.map_or_else (|| detect_content_type_from_extension (&_source), |_content_type| Ok (_content_type)) ?;
self.route_asset_raw (_relative, _source, _content_type, _route_base, _route_builder, _extensions_builder, "resource_asset", _source_0, _source_relative)
}
#[ cfg (feature = "builder-sitemaps") ]
pub fn route_sitemap (&mut self, _prefix : &str, _format : &str, _route_builder : &(impl RoutePathBuilder + ?Sized), _extensions_builder : &(impl RouteExtensionsBuilder + ?Sized)) -> BuilderResult {
let _route = _route_builder.build (Path::new (""), Path::new (""), None, None) ?;
let _extensions = _extensions_builder.build () ?;
let _format = token_tree_parse (_format) ?;
let _id = self.generate_id ();
self.route_names.push (format! ("Route_{}", _id));
writeln! (self.generated, "::hyper_static_server::route_sitemap! (Route_{}, {:?}, {:?}, {}, {});", _id, _route, _prefix, _format, _extensions) .infallible (0x5f529a53);
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn watch_asset (&mut self, _source : &str) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_relative, _source) = self.resolve_file (_assets_sources, _source) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include (&_source) ?;
Ok (())
}
#[ cfg (feature = "builder-assets") ]
pub fn watch_assets (&mut self, _sources : &str, _glob : Option<&str>) -> BuilderResult {
let _assets_sources = self.configuration.assets_sources.as_ref () .map (PathBuf::as_path);
let (_files, _folders) = self.resolve_files (_assets_sources, _sources, _glob) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_folders.iter () .map (PathBuf::as_path)) ?;
#[ cfg (any (not (feature = "builder-relaxed-dependencies"), feature = "production")) ]
self.dependencies_include_all (_files.iter () .map (|_pair| _pair.1.as_path ())) ?;
Ok (())
}
pub fn generate (mut self) -> BuilderResult {
self.dependencies_extend () ?;
writeln! (self.generated, "::hyper_static_server::routes! (Routes, [") .infallible (0x4bf5618f);
for _route_name in self.route_names.into_iter () {
writeln! (self.generated, "\t{},", _route_name) .infallible (0x894377dd);
}
writeln! (self.generated, "]);") .infallible (0x28d1ed4d);
writeln! (self.generated, "::hyper_static_server::dependencies! (Dependencies, [") .infallible (0x1a6c02cd);
for _dependency in self.dependencies.iter () {
writeln! (self.generated, "\t{:?},", _dependency) .infallible (0x9df69eb7);
}
writeln! (self.generated, "]);") .infallible (0x57d05438);
create_file_from_str (&self.configuration.generated, &self.generated, false, true) ?;
if false {
eprintln! ("--------------------------------------------------------------------------------");
eprintln! ("{}", self.generated);
eprintln! ("--------------------------------------------------------------------------------");
}
for _dependency in self.dependencies {
println! ("cargo:rerun-if-changed={}", _dependency.display ());
}
Ok (())
}
}
impl Builder {
fn resolve_file (&self, _root : Option<&Path>, _source : &str) -> BuilderResult<(PathBuf, PathBuf)> {
let (_path, _relative_root) = self.resolve_source (_root, _source, true) ?;
if ! _path.is_file () {
return Err (error_with_format (0x039d945b, format_args! ("{}", _path.display ())));
}
self.resolve_relative_and_path (&_path, &_relative_root)
}
fn resolve_files (&self, _root : Option<&Path>, _sources : &str, _glob : Option<&str>) -> BuilderResult<(Vec<(PathBuf, PathBuf)>, Vec<PathBuf>)> {
let (_root, _relative_root) = self.resolve_source (_root, _sources, false) ?;
if ! _root.is_dir () {
return Err (error_with_code (0x621693a6));
}
let _glob = _glob.map (|_pattern| globset::Glob::new (_pattern) .or_wrap (0xf68023ce)) .transpose () ?;
let _glob = _glob.map (|_pattern| _pattern.compile_matcher ());
let mut _files = Vec::new ();
let mut _folders = Vec::new ();
let _walker = walkdir::WalkDir::new (&_root)
.follow_links (true)
.sort_by (|_left, _right| ffi::OsStr::cmp (_left.file_name (), _right.file_name ()));
for _entry in _walker {
let _entry = _entry ?;
let _path = _entry.path ();
if _path.is_file () {
if let Some (_glob) = _glob.as_ref () {
if ! _glob.is_match (_path) {
continue;
}
}
let _relative_and_path = self.resolve_relative_and_path (_path, &_relative_root) ?;
_files.push (_relative_and_path);
}
if _path.is_dir () {
let _path = normalize_path (_path) ?;
_folders.push (_path);
}
}
Ok ((_files, _folders))
}
fn resolve_source (&self, _root : Option<&Path>, _source : &str, _name_only : bool) -> BuilderResult<(PathBuf, PathBuf)> {
let _path = if _source.starts_with ("_/") || (_source == "_") {
let _root = _root.or_wrap (0x6e3319c9) ?;
if _source != "_" {
_root.join (&_source[2..])
} else {
_root.to_owned ()
}
} else if _source.starts_with ("./") || _source.starts_with ("..") || (_source == ".") || (_source == "..") {
let _root = self.configuration.sources.as_ref () .or_wrap (0x0791a9b4) ?;
_root.join (&_source)
} else if _source.starts_with (">") {
PathBuf::from (&_source[1..])
} else {
return Err (error_with_code (0x41071330));
};
if ! _path.exists () {
return Err (error_with_format (0x1086bd9d, format_args! ("{}", _path.display ())));
}
if _name_only {
let _relative_root = _path.parent () .or_wrap (0x067a2cad) ? .to_path_buf ();
Ok ((_path, _relative_root))
} else {
Ok ((_path.clone (), _path))
}
}
fn resolve_relative_and_path (&self, _path : &Path, _relative_root : &Path) -> BuilderResult<(PathBuf, PathBuf)> {
let _relative = _path.strip_prefix (_relative_root) .or_wrap (0x546e7cd9) ? .to_str () .or_wrap (0xa48f283c) ?;
let _relative = ["/", _relative].concat () .into ();
let _path = normalize_path (&_path) ?;
Ok ((_relative, _path))
}
}
impl Builder {
fn dependencies_include (&mut self, _path : &Path) -> BuilderResult {
self.dependencies.insert (_path.into ());
Ok (())
}
fn dependencies_include_all <'a> (&mut self, _paths : impl Iterator<Item = &'a Path>) -> BuilderResult {
for _path in _paths {
self.dependencies_include (_path) ?;
}
Ok (())
}
#[ allow (dead_code) ]
fn dependencies_exclude (&mut self, _path : &Path) -> BuilderResult {
self.dependencies.remove (_path.into ());
Ok (())
}
fn dependencies_extend (&mut self) -> BuilderResult {
let mut _extra = Vec::new ();
for _dependency in self.dependencies.iter () {
let _metadata = fs::symlink_metadata (_dependency) .or_wrap (0x06a4fbd5) ?;
if _metadata.file_type () .is_symlink () {
let _target = _dependency.canonicalize () .or_wrap (0x8df4310e) ?;
_extra.push (_target);
}
}
for _dependency in _extra.into_iter () {
self.dependencies.insert (_dependency);
}
self.dependencies.insert (PathBuf::from (file! ()));
Ok (())
}
}
impl Builder {
fn generate_id (&mut self) -> String {
let _id = self.counter;
self.counter += 1;
format! ("{:04}", _id)
}
}
#[ cfg (feature = "builder-assets-sass") ]
impl Builder {
fn compile_sass (&mut self, _source : &Path) -> BuilderResult<String> {
crate::support_sass::compile_sass (_source)
}
}
#[ cfg (feature = "builder-markdown") ]
impl Builder {
fn compile_markdown_body (&self, _source : &Path, _title_detect : bool) -> BuilderResult<crate::support_markdown::MarkdownOutput> {
let mut _options = crate::support_markdown::MarkdownOptions::default ();
_options.title_detect = _title_detect;
crate::support_markdown::compile_markdown_from_path (_source, Some (&_options))
}
fn compile_markdown_html (&self, _source : &Path, _header : Option<&Path>, _footer : Option<&Path>) -> BuilderResult<String> {
crate::support_markdown::compile_markdown_html_from_path (_source, _header, _footer, None)
}
}
fn create_file_from_str (_path : &Path, _data : &str, _skip_if_exists : bool, _skip_if_same : bool) -> BuilderResult {
fs::create_dir_all (_path.parent () .or_wrap (0x370af23d) ?) ?;
let _metadata = match fs::symlink_metadata (_path) {
Ok (_metadata) =>
if _metadata.is_file () {
Some (_metadata)
} else {
return Err (error_with_format (0x7b58f13c, format_args! ("{}", _path.display ())));
}
Err (_error) if _error.kind () == io::ErrorKind::NotFound =>
None,
Err (_error) =>
return Err (_error.wrap (0xb30cd904)),
};
if _skip_if_exists && _metadata.is_some () {
return Ok (());
}
if _skip_if_same && _metadata.is_some () {
let _data_old = fs::read (_path) .or_wrap (0x6c311b95) ?;
let _data_old_fingerprint = fingerprint_data (_data_old);
let _data_new_fingerprint = fingerprint_data (_data);
if _data_old_fingerprint == _data_new_fingerprint {
return Ok (());
}
}
let mut _file = fs::File::create (_path) ?;
_file.write_all (_data.as_bytes ()) ?;
Ok (())
}
pub trait RoutePathBuilder {
fn build (&self, _source_relative : &Path, _source_path : &Path, _route_prefix_hint : Option<&Path>, _route_infix_hint : Option<&Path>) -> BuilderResult<PathBuf>;
}
impl RoutePathBuilder for () {
fn build (&self, _source_relative : &Path, _source_path : &Path, _route_prefix_hint : Option<&Path>, _route_infix_hint : Option<&Path>) -> BuilderResult<PathBuf> {
generate_route (_source_relative, _route_prefix_hint, _route_infix_hint)
}
}
impl RoutePathBuilder for (bool, &str) {
fn build (&self, _source_relative : &Path, _source_path : &Path, _route_prefix_hint : Option<&Path>, _route_infix_hint : Option<&Path>) -> BuilderResult<PathBuf> {
if self.0 {
generate_route (_source_relative, Some (Path::new (self.1)), None)
} else {
normalize_route (Path::new (self.1), true, false)
}
}
}
pub trait RouteExtensionsBuilder {
fn build (&self) -> BuilderResult<proc_macro2::TokenTree>;
}
impl RouteExtensionsBuilder for () {
fn build (&self) -> BuilderResult<proc_macro2::TokenTree> {
Ok (proc_macro2::Group::new (proc_macro2::Delimiter::Parenthesis, proc_macro2::TokenStream::new ()) .into ())
}
}
impl RouteExtensionsBuilder for str {
fn build (&self) -> BuilderResult<proc_macro2::TokenTree> {
token_tree_parse (self)
}
}
fn generate_route (_source_relative : &Path, _route_prefix : Option<&Path>, _route_infix : Option<&Path>) -> BuilderResult<PathBuf> {
let _route_prefix = _route_prefix.or_wrap (0x1ba00780) ?;
if ! _route_prefix.starts_with ("/") || (_route_prefix.ends_with ("/") && _route_prefix != Path::new ("/")) {
return Err (error_with_code (0x6fc9256c));
}
if ! _source_relative.starts_with ("/") || _source_relative.ends_with ("/") {
return Err (error_with_code (0xace09af4));
}
if let Some (_route_infix) = _route_infix {
if _route_infix.starts_with ("/") || _route_infix.ends_with ("/") {
return Err (error_with_code (0xd224b592));
}
}
let _source_relative = _source_relative.strip_prefix ("/") .or_wrap (0xbd4b80bd) ?;
let _route = if let Some (_route_infix) = _route_infix {
let _route_infix = _route_infix.strip_prefix ("/") .or_wrap (0x1a7e3353) ?;
_route_prefix.join (_route_infix) .join (_source_relative)
} else {
_route_prefix.join (_source_relative)
};
normalize_route (&_route, false, false)
}
fn normalize_route (_path_0 : &Path, _keep_trailing_slash : bool, _force_trailing_slash : bool) -> BuilderResult<PathBuf> {
if ! _path_0.starts_with ("/") {
return Err (error_with_code (0x1e7f7bc0));
}
let mut _path = PathBuf::new ();
_path.push ("/");
for _component in _path_0.components () {
_path.push (_component);
}
if (_keep_trailing_slash || _force_trailing_slash) && (_path != Path::new ("/")) {
if _path_0.to_string_lossy () .ends_with ("/") || _force_trailing_slash {
let mut _path_1 = _path.clone () .into_os_string ();
_path_1.push ("/");
_path = _path_1.into ();
}
}
Ok (_path)
}
fn normalize_path (_path_0 : &Path) -> BuilderResult<PathBuf> {
let mut _path = PathBuf::new ();
for _component in _path_0.components () {
_path.push (_component);
}
Ok (_path)
}
fn detect_content_type_from_extension (_source : &Path) -> BuilderResult<&'static str> {
let _extension = _source.extension () .or_wrap (0x29957dc8) ? .to_str () .or_wrap (0x908aeea6) ?;
let _content_type = match _extension {
"text" | "txt" => "text",
"md" => "text",
"html" | "htm" => "html",
"css" => "css",
"js" => "js",
"json" => "json",
"xml" => "xml",
"png" => "png",
"jpeg" | "jpg" => "jpeg",
"ico" => "icon",
"svg" => "svg",
"ttf" => "font_ttf",
"otf" => "font_otf",
"woff" => "font_woff",
"woff2" => "font_woff2",
_ => "unknown",
};
Ok (_content_type)
}
fn token_tree_parse (_string : &str) -> BuilderResult<proc_macro2::TokenTree> {
let _stream = proc_macro2::TokenStream::from_str (_string) .or_wrap (0x72524db6) ?;
let mut _stream = _stream.into_iter ();
let _token = if let Some (_token) = _stream.next () {
_token
} else {
return Err (error_with_code (0xe9c8879a))
};
if _stream.next () .is_some () {
return Err (error_with_code (0xd96714a4))
}
Ok (_token)
}
#[ allow (dead_code) ]
fn fingerprint_data (_data : impl AsRef<[u8]>) -> String {
use blake2::Digest as _;
let mut _hasher = blake2::Blake2b::new ();
_hasher.update (_data.as_ref ());
let _hash = _hasher.finalize ();
format! ("{:x}", _hash)
}