unison 0.3.2

Unison is a easy to use config loader which can collect configuration from flags, environment variables, and configuration files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use std::fs::OpenOptions;
use std::path::Path;
use value::Value;
use std::io::{BufRead, BufReader, Cursor, Error as IoError, ErrorKind as IoErrorKind, Read, Seek,
              SeekFrom};
use error::Error;
use config::Kind;

impl Value {
  pub fn from_src(string: &str) -> Result<Self, Error> {
    Self::from_reader(Cursor::new(string))
  }

  pub fn from_path(path: &Path) -> Result<Self, Error> {
    Self::from_reader(BufReader::new(OpenOptions::new().read(true).open(path)?))
  }

  pub fn from_reader<R>(mut reader: R) -> Result<Self, Error>
  where
    R: Seek + BufRead,
  {
    let mut value = match Self::detect_config_type(&mut reader)? {
      Kind::Toml => Self::from_toml_reader(&mut reader)?,
      Kind::Json => Self::from_json_reader(&mut reader)?,
      Kind::Yaml => Self::from_yaml_reader(&mut reader)?,
    };
    value.eval(0);

    Ok(value)
  }

  fn detect_config_type<S>(reader: &mut S) -> Result<Kind, IoError>
  where
    S: BufRead + Seek,
  {
    reader.seek(SeekFrom::Start(0))?;

    let mut src_sample = String::new();
    for _ in 0..5 {
      if reader.read_line(&mut src_sample)? < 1 {
        break;
      };
    }
    src_sample.trim();

    let is_json = src_sample.starts_with("{");
    let is_yaml = false;
    let is_toml = src_sample.starts_with("[");

    if is_json {
      Ok(Kind::Json)
    } else if is_toml {
      Ok(Kind::Toml)
    } else if is_yaml {
      Ok(Kind::Yaml)
    } else {
      Err(IoError::new(IoErrorKind::Other, "Unsupported syntax"))
    }
  }

  fn from_toml_reader<R>(reader: &mut R) -> Result<Value, Error>
  where
    R: Read + Seek,
  {
    use toml::{from_str, Value as TomlValue};
    reader.seek(SeekFrom::Start(0))?;
    let mut string = String::new();
    reader.read_to_string(&mut string).unwrap();
    let toml_value: TomlValue = from_str(&string).map_err(|e| Error::from(e))?;
    Ok(toml_value.into())
  }

  fn from_json_reader<R>(reader: &mut R) -> Result<Value, Error>
  where
    R: Read + Seek,
  {
    use serde_json::{from_reader, Value as JsonValue};
    reader.seek(SeekFrom::Start(0))?;
    let json_value: JsonValue = from_reader(reader).map_err(|e| Error::from(e))?;
    Ok(json_value.into())
  }

  fn from_yaml_reader<R>(reader: &mut R) -> Result<Value, Error>
  where
    R: Read + Seek,
  {
    reader.seek(SeekFrom::Start(0))?;

    unimplemented!()
  }
}