annotate rust/hg-core/src/config/plain_info.rs @ 51470:406b413e3cf2 stable

rust-filepatterns: export glob_to_re function

Making this function public should not risk freezing the internal API,
and it can be useful for all downstream code that needs to perform
glob matching against byte strings, such as RHGitaly where it will
be useful to match on branches and tags.

use crate::utils::files::get_bytes_from_os_string;
use std::env;

/// Keeps information on whether plain mode is active.
///
/// Plain mode means that all configuration variables which affect
/// the behavior and output of Mercurial should be
/// ignored. Additionally, the output should be stable,
/// reproducible and suitable for use in scripts or applications.
///
/// The only way to trigger plain mode is by setting either the
/// `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
///
/// The return value can either be
/// - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
/// - False if feature is disabled by default and not included in HGPLAIN
/// - True otherwise
#[derive(Clone)]
pub struct PlainInfo {
    is_plain: bool,
    except: Vec<Vec<u8>>,
}

impl PlainInfo {
    fn plain_except(except: Vec<Vec<u8>>) -> Self {
        PlainInfo {
            is_plain: true,
            except,
        }
    }

    pub fn empty() -> PlainInfo {
        PlainInfo {
            is_plain: false,
            except: vec![],
        }
    }

    pub fn from_env() -> PlainInfo {
        if let Some(except) = env::var_os("HGPLAINEXCEPT") {
            PlainInfo::plain_except(
                get_bytes_from_os_string(except)
                    .split(|&byte| byte == b',')
                    .map(|x| x.to_vec())
                    .collect(),
            )
        } else {
            PlainInfo {
                is_plain: env::var_os("HGPLAIN").is_some(),
                except: vec![],
            }
        }
    }

    pub fn is_feature_plain(&self, feature: &str) -> bool {
        return self.is_plain
            && !self
                .except
                .iter()
                .any(|exception| exception.as_slice() == feature.as_bytes());
    }

    pub fn is_plain(&self) -> bool {
        self.is_plain
    }

    pub fn plainalias(&self) -> bool {
        self.is_feature_plain("alias")
    }
    pub fn plainrevsetalias(&self) -> bool {
        self.is_feature_plain("revsetalias")
    }
    pub fn plaintemplatealias(&self) -> bool {
        self.is_feature_plain("templatealias")
    }
    pub fn plaintweakdefaults(&self) -> bool {
        self.is_feature_plain("tweakdefaults")
    }
}