ucd-generate 0.3.1

A program for generating packed representations of the Unicode character database that can be efficiently searched. 
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

use std::ffi::OsStr;
use std::ops;

use clap;

use crate::error::Result;
use crate::util::Filter;
use crate::writer::{Writer, WriterBuilder};

/// Wraps clap matches and provides convenient accessors to various parameters.
pub struct ArgMatches<'a>(&'a clap::ArgMatches<'a>);

impl<'a> ops::Deref for ArgMatches<'a> {
    type Target = clap::ArgMatches<'a>;
    fn deref(&self) -> &clap::ArgMatches<'a> {
        &self.0
    }
}

impl<'a> ArgMatches<'a> {
    pub fn new(matches: &'a clap::ArgMatches<'a>) -> ArgMatches<'a> {
        ArgMatches(matches)
    }

    pub fn ucd_dir(&self) -> Result<&OsStr> {
        match self.value_of_os("ucd-dir") {
            Some(x) => Ok(x),
            None => err!("missing UCD directory"),
        }
    }

    pub fn writer(&self, name: &str) -> Result<Writer> {
        let mut builder = WriterBuilder::new(name);
        builder
            .columns(79)
            .char_literals(self.is_present("chars"))
            .trie_set(self.is_present("trie-set"));
        // Some of the functionality of this crate works with a partial ucd
        // directory.
        match ucd_parse::ucd_directory_version(self.ucd_dir()?) {
            Ok((major, minor, patch)) => {
                builder.ucd_version(major, minor, patch)
            }
            Err(e) => return err!("Failed to determine UCD version: {}", e),
        };
        match self.value_of_os("fst-dir") {
            None => Ok(builder.from_stdout()),
            Some(x) => builder.from_fst_dir(x),
        }
    }

    pub fn name(&self) -> &str {
        self.value_of("name").expect("the name of the table")
    }

    /// Create a new include/exclude filter command line arguments.
    ///
    /// The given canonicalization function is applied to each element in
    /// each of the include/exclude lists provided by the end user.
    pub fn filter<F: FnMut(&str) -> Result<String>>(
        &self,
        mut canonicalize: F,
    ) -> Result<Filter> {
        Filter::new(
            self.value_of_lossy("include").map(|s| s.to_string()),
            self.value_of_lossy("exclude").map(|s| s.to_string()),
            |name| canonicalize(name),
        )
    }
}