syntax = ["syntect", "lazy_static"]

[dependencies.lazy_static]

version = "1"

optional = true

[dependencies.syntect]

version = "5"

optional = true

#[cfg(feature = "syntax")]

pub mod syntax;

#[cfg(feature = "syntax")]

pub use syntax::SYNTAX_SET;

    /// Indicates if the content of the [`Blob`] is HTML.

    #[must_use]

    pub const fn is_html(&self) -> bool {

        matches!(self.content, BlobContent::Html(_))

    }

        const FIELDS: usize = 6;

        state.serialize_field("html", &self.is_html())?;

    /// Content is syntax-highlighted HTML.

    ///

    /// Note that it is necessary to enable the `syntax` feature flag

    /// for this variant to be constructed. Use `Blob::highlighted`,

    /// instead of `Blob::new` to get highlighted content.

    Html(String),

            Self::Plain(content) | Self::Html(content) => serializer.serialize_str(content),

#[cfg(feature = "syntax")]

pub mod highlighting {

    use crate::source::syntax;

    use super::*;

    impl Blob {

        /// Returns the [`Blob`] for a file at `revision` under `path`.

        ///

        /// The content of the [`Blob`] will be highlighted, if possible.

        ///

        /// # Errors

        ///

        /// Will return [`Error`] if the project doesn't exist or a surf

        /// interaction fails.

        pub fn highlighted<P, R>(

            browser: &Repository,

            revision: &R,

            path: &P,

            theme: Option<&str>,

        ) -> Result<Blob, Error>

        where

            P: AsRef<Path>,

            R: git::Revision,

        {

            Self::make_blob(browser, revision, path, |contents| {

                content(path, &contents, theme)

            })

        }

    }

    /// Return a [`BlobContent`] given a file path, content and theme. Attempts

    /// to perform syntax highlighting when the theme is `Some`.

    fn content<P>(path: P, content: &FileContent, theme_name: Option<&str>) -> BlobContent

    where

        P: AsRef<Path>,

    {

        let content = content.as_bytes();

        let content = match str::from_utf8(content) {

            Ok(content) => content,

            Err(_) => return BlobContent::Binary(content.to_owned()),

        };

        match theme_name {

            None => BlobContent::Plain(content.to_owned()),

            Some(theme) => syntax::highlight(path, content, theme)

                .map_or_else(|| BlobContent::Plain(content.to_owned()), BlobContent::Html),

        }

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

// Copyright (C) 2019-2020 The Radicle Team <dev@radicle.xyz>

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// 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 General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <https://www.gnu.org/licenses/>.

use std::path::Path;

use syntect::{

    easy::HighlightLines,

    highlighting::ThemeSet,

    parsing::SyntaxSet,

    util::LinesWithEndings,

};

lazy_static::lazy_static! {

    // The syntax set is slow to load (~30ms), so we make sure to only load it once.

    // It _will_ affect the latency of the first request that uses syntax highlighting,

    // but this is acceptable for now.

    pub static ref SYNTAX_SET: SyntaxSet = {

        let default_set = SyntaxSet::load_defaults_newlines();

        let mut builder = default_set.into_builder();

        if cfg!(debug_assertions) {

            // In development assets are relative to the proxy source.

            // Don't crash if we aren't able to load additional syntaxes for some reason.

            builder.add_from_folder("./assets", true).ok();

        } else {

            // In production assets are relative to the proxy executable.

            let exe_path = std::env::current_exe().expect("Can't get current exe path");

            let root_path = exe_path

                .parent()

                .expect("Could not get parent path of current executable");

            let mut tmp = root_path.to_path_buf();

            tmp.push("assets");

            let asset_path = tmp.to_str().expect("Couldn't convert pathbuf to str");

            // Don't crash if we aren't able to load additional syntaxes for some reason.

            match builder.add_from_folder(asset_path, true) {

                Ok(_) => (),

                Err(err) => log::warn!("Syntax builder error : {}", err),

            };

        }

        builder.build()

    };

}

/// Return highlighted text given a file path, the original text, and

/// a theme.

pub fn highlight<P>(path: P, content: &str, theme_name: &str) -> Option<String>

where

    P: AsRef<Path>,

{

    let syntax = path

        .as_ref()

        .extension()

        .and_then(std::ffi::OsStr::to_str)

        .and_then(|ext| SYNTAX_SET.find_syntax_by_extension(ext));

    let ts = ThemeSet::load_defaults();

    let theme = ts.themes.get(theme_name);

    match (syntax, theme) {

        (Some(syntax), Some(theme)) => {

            let mut highlighter = HighlightLines::new(syntax, theme);

            let mut html = String::with_capacity(content.len());

            for line in LinesWithEndings::from(content) {

                let regions = highlighter.highlight_line(line, &SYNTAX_SET).ok()?;

                syntect::html::append_highlighted_html_for_styled_line(

                    &regions[..],

                    syntect::html::IncludeBackground::No,

                    &mut html,

                )

                .ok();

            }

            Some(html)

        },

        _ => None,

    }

}

features = ["serde", "syntax"]