Uclicious

• 什么是 Uclicious
• 用法
  • 原始 API
  • 派生驱动
    • 验证器
    • 类型映射
  • 支持的属性 (#[ucl(..)])
    • 结构级别
    • 字段级别
  • 其他说明
• 贡献
  • 特别感兴趣的贡献
• 目标
  • 非目标
• 特别感谢
• 授权

什么是 Uclicious

Uclicious 是一个灵活的简化样板配置框架。

Uclicious 基于 libucl 构建。如果您曾经编写过 nginx 配置，并想“天哪，我希望所有配置文件都像这样”，那么这个库就是为您准备的。内部解析器支持：nginx 类型和 json 类型的格式。JSON 解析器比其他格式更宽松：每个 json 文件都是有效的 UCL 文件，但反之则不然。它比 json 或 TOML 复杂得多，因此我建议阅读有关它的文档。UCL 的作者做了很好的文档工作。这个库提供了：派生驱动和原始 API 驱动使用模式。

用法

原始 API

原始 API 涉及通过安全 API 与 libucl 解析器交互

use uclicious::*;
let mut parser = Parser::default();
let input = r#"
test_string = "no scope"
a_float = 3.14
an_integer = 69420
is_it_good = yes
buffer_size = 1KB
interval = 1s
"#;
parser.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
let result = parser.get_object().unwrap();

let lookup_result = result.lookup("test_string").unwrap().as_string().unwrap();
assert_eq!(lookup_result.as_str(), "no scope");

let lookup_result = result.lookup("a_float").unwrap().as_f64().unwrap();
assert_eq!(lookup_result, 3.14f64);

let lookup_result = result.lookup("an_integer").unwrap().as_i64().unwrap();
assert_eq!(lookup_result, 69420i64);

let lookup_result = result.lookup("is_it_good").unwrap().as_bool().unwrap();
assert_eq!(lookup_result, true);

let lookup_result = result.lookup("buffer_size").unwrap().as_i64().unwrap();
assert_eq!(lookup_result, 1024);
let lookup_result = result.lookup("interval").unwrap().as_time().unwrap();
assert_eq!(lookup_result, 1.0f64);

为了绕过 Rust 规则，库实现了自己的 FromObject 特质以支持一些基本类型

use uclicious::*;
let mut parser = Parser::default();
let input = r#"
test_string = "no scope"
a_float = 3.14
an_integer = 69420
is_it_good = yes
buffer_size = 1KB
"#;
parser.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
let result = parser.get_object().unwrap();

let lookup_result = result.lookup("is_it_good").unwrap();
let maybe: Option<bool> = FromObject::try_from(lookup_result).unwrap();
assert_eq!(Some(true), maybe);

派生驱动

在 libUCL 的“原始”接口之上，Uclicious 提供了一种简单的方式来派生结构体的构造函数

use uclicious::*;
use std::path::PathBuf;
use std::net::SocketAddr;
use std::collections::HashMap;
use std::time::Duration;

#[derive(Debug,Uclicious)]
#[ucl(var(name = "test", value = "works"))]
struct Connection {
   #[ucl(default)]
   enabled: bool,
   host: String,
   #[ucl(default = "420")]
   port: i64,
   buffer: u64,
   #[ucl(path = "type")]
   kind: String,
   locations: Vec<PathBuf>,
   addr: SocketAddr,
   extra: Extra,
   #[ucl(path = "subsection.host")]
   hosts: Vec<String>,
   #[ucl(default)]
   option: Option<String>,
   gates: HashMap<String, bool>,
   interval: Duration,
}

#[derive(Debug,Uclicious)]
#[ucl(skip_builder)]
struct Extra {
   enabled: bool
}
let mut builder = Connection::builder().unwrap();

let input = r#"
    enabled = yes
    host = "some.fake.url"
    buffer = 1mb
    type = $test
    locations = "/etc/"
    addr = "127.0.0.1:80"
    extra = {
       enabled = on
   }
    subsection {
       host = [host1, host2]
   }
   interval = 10ms
   gates {
        feature_1 = on
        feature_2 = off
        feature_3 = on
   }"#;

builder.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
let connection: Connection = builder.build().unwrap();

如果您选择派生构建器，则 ::builder() 方法将被添加到目标结构体中。

验证器

库支持在构建结果结构体之前在值上运行可选的验证器

use uclicious::*;
mod validators {
   use uclicious::ObjectError;
    pub fn is_positive(lookup_path: &str, value: &i64) -> Result<(), ObjectError> {
        if *value > 0 {
            Ok(())
        } else {
            Err(ObjectError::other(format!("{} is not a positive number", lookup_path)))
        }
    }
}
#[derive(Debug,Uclicious)]
struct Validated {
   #[ucl(default, validate="validators::is_positive")]
    number: i64
}
let mut builder = Validated::builder().unwrap();

let input = "number = -1";
builder.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
assert!(builder.build().is_err())

类型映射

如果您的目标结构中有不实现 FromObject 的类型，您可以通过中间实现该功能的类型来使用 From 或 TryFrom

use uclicious::*;
use std::convert::{From,TryFrom};

#[derive(Debug, Eq, PartialEq)]
enum Mode {
    On,
    Off,
}

impl TryFrom<String> for Mode {
    type Error = ObjectError;
    fn try_from(src: String) -> Result<Mode, ObjectError> {
        match src.to_lowercase().as_str() {
            "on" => Ok(Mode::On),
            "off" => Ok(Mode::Off),
            _   => Err(ObjectError::other(format!("{} is not supported value", src)))
        }
    }
}

#[derive(Debug, Eq, PartialEq)]
struct WrappedInt(i64);

impl From<i64> for WrappedInt {
    fn from(src: i64) -> WrappedInt {
        WrappedInt(src)
    }
}

#[derive(Debug,Uclicious, Eq, PartialEq)]
struct Mapped {
   #[ucl(from="i64")]
    number: WrappedInt,
   #[ucl(try_from="String")]
    mode: Mode
}
let mut builder = Mapped::builder().unwrap();

let input = r#"
    number = -1,
    mode = "on"
"#;
builder.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
let actual = builder.build().unwrap();
let expected = Mapped {
number: WrappedInt(-1),
mode: Mode::On
};
assert_eq!(expected, actual);

此外，您还可以提供从 ObjectRef 到您的类型的映射

use uclicious::*;

#[derive(Debug, Eq, PartialEq)]
pub enum Mode {
    On,
    Off,
}

pub fn map_bool(src: ObjectRef) -> Result<Mode, ObjectError> {
    let bool: bool = src.try_into()?;
    if bool {
        Ok(Mode::On)
    } else {
        Ok(Mode::Off)
    }
}
#[derive(Debug,Uclicious, Eq, PartialEq)]
struct Mapped {
   #[ucl(map="map_bool")]
    mode: Mode
}
let mut builder = Mapped::builder().unwrap();

let input = r#"
    mode = on
"#;
builder.add_chunk_full(input, Priority::default(), DEFAULT_DUPLICATE_STRATEGY).unwrap();
let actual = builder.build().unwrap();
let expected = Mapped {
    mode: Mode::On
};

支持的属性 (#[ucl(..)])

结构级别

• skip_builder
  • 如果设置为 true，则不会生成构建器和构建器方法。
• parser(..)
  • 可选属性，用于配置内部解析器。
  • 具有以下嵌套属性
    • flags
      • 返回标志的函数的路径。
    • filevars(..)
      • 在解析器上调用 set_filevars
      • 具有以下嵌套属性
        • path
          • 文件路径的字符串表示。
        • expand
          • (可选) 如果设置，则变量将被展开到绝对路径。
• pre_source_hook(...)
  • 可选属性，在添加源之前运行函数
  • 可用于注册变量处理器
  • 必须接受 &mut Parser 作为参数并返回 Result<(), Into<UclError>>
• var(..)
  • 可选属性，用于在解析器上注册字符串变量。
  • 具有以下嵌套属性
    • name
      • 不带 $ 部分的变量名称。
    • value
      • 变量的字符串值。
      • libUCL 仅支持字符串变量。
• include(..)
  • 用于将文件添加到解析器中。
  • 如果文件不存在或解析失败，则构造函数将返回错误。
  • 必须指定以下源之一： path、chunk 或 chunk_static
  • 具有以下嵌套属性
    • (半可选) path = string
      • 文件路径。可以是绝对路径或相对于当前工作目录的相对路径。
    • (半可选) chunk = string
      • 作为块添加到解析器中的字符串。
    • (半可选) chunk_static = string
      • 一个文件的路径，该文件将与 include_str!() 一起包含到二进制文件中
    • (可选) priority = u32
      • 源优先级为 0-15。有关更多信息，请参阅 libUCL 文档。
    • (可选) strategy = uclicious::DuplicateStrategy
      • 用于重复键的策略。有关更多信息，请参阅 libUCL 文档。