const LF: char = '\n';

const HASH: char = '#';

const B_SLASH: char = '\\';

const S_QUOTE: char = '\'';

const D_QUOTE: char = '"';

const EXPORT: &str = "export";

const EXPORT_WS: &str = "export ";

/// Type of the quote

#[derive(Debug, PartialEq)]

pub enum Quote {

/// When the value is single quoted i.e. `'`

Single,

/// When the value is double quoted i.e. `"`

Double,

/// When the value is not quoted

No,

}

/// To collect the info about the current line

#[derive(Debug, PartialEq)]

pub struct KeyVal<'k> {

/// `key` of the variable

pub k: &'k str,

/// `value` of the variable

pub v: String,

/// Whether the value is quoted or not

pub q: Quote,

}

/// (Can be) Used to parse the current line

///

/// Example

/// ```

/// use zenv::{Line, KeyVal, Quote};

///

/// let line = Line::from("BASIC=basic");

///

/// let k = "BASIC";

/// let v = "basic".to_string();

/// assert_eq!(line, Line::KeyVal(KeyVal { k, v, q: Quote::No }));

///

/// // Commented line

/// let empty = Line::from("# COMMENT=commented");

///

/// assert_eq!(empty, Line::Empty);

///

/// // With quotes

/// let quoted = Line::from("S_QUOTED='single_quoted'");

///

/// let k = "S_QUOTED";

/// let v = "single_quoted".to_string();

/// assert_eq!(quoted, Line::KeyVal(KeyVal { k, v, q: Quote::Single }));

/// ```

#[derive(Debug, PartialEq)]

pub enum Line<'l> {

/// When the current line is a `key=val` pair

KeyVal(KeyVal<'l>),

/// When the current line is empty

Empty,

}

impl<'l> Line<'l> {

fn replace_lf(line: &str) -> String {

let mut s = String::with_capacity(line.len());

let mut chars = line.chars();

loop {

match chars.next() {

// If \ is found

Some(x) if x == B_SLASH => match chars.next() {

// "\n" -> Chars: ['\\', 'n']

Some('n') => {

s.push(LF);

}

// "\\n" -> Chars: ['\\', '\\', 'n']

Some(B_SLASH) => {

s.push(B_SLASH);

}

Some(n) => {

s.push(x);

s.push(n);

}

None => s.push(x),

},

// chars() automagically converts \n into LF

// no special handling of new line character

Some(x) => s.push(x),

_ => break,

}

}

s

}

fn escape_lf(x: char) -> String {

if x == LF {

x.escape_debug().to_string()

} else {

x.to_string()

}

}

fn retain_quote(orgnl: &str, after: String, q: Quote) -> (String, Quote) {

// If both strings length matches then it is not closed

if orgnl.len().eq(&(after.len() + 1)) {

let new_val: String = orgnl.chars().take_while(|c| c != &HASH).collect();

(new_val.trim().to_string(), Quote::No)

} else {

(after, q)

}

}

}

impl<'l> From<&'l str> for Line<'l> {

fn from(line: &'l str) -> Self {

if line.is_empty() || line.starts_with(HASH) || line.trim().eq(EXPORT) {

return Self::Empty;

};

let mut parts = line.splitn(2, '=');

match (parts.next(), parts.next()) {

(Some(k), Some(v)) => {

let key = k.strip_prefix(EXPORT_WS).unwrap_or(k).trim();

let mut chars = v.chars();

let first = chars.next();

match first {

Some(D_QUOTE) => {

let val = {

let v: String = chars.take_while(|x| x != &D_QUOTE).collect();

Self::replace_lf(&v)

};

let (v, q) = Self::retain_quote(v, val, Quote::Double);

Line::KeyVal(KeyVal { k: key, v, q })

}

Some(S_QUOTE) => {

let val: String = chars

.take_while(|x| x != &S_QUOTE)

.map(Self::escape_lf)

.collect();

let (v, q) = Self::retain_quote(v, val, Quote::Single);

Line::KeyVal(KeyVal { k: key, v, q })

}

Some(a) => {

let mut val = Self::escape_lf(a);

val.push_str(

&chars

.take_while(|x| x != &HASH)

.map(Self::escape_lf)

.collect::<String>(),

);

Line::KeyVal(KeyVal {

k: key,

v: val.trim().to_string(),

q: Quote::No,

})

}

_ => Line::KeyVal(KeyVal {

k: key,

v: String::with_capacity(0),

q: Quote::No,

}),

}

}

_ => Self::Empty,

}

}

}