Struct LuaPatternBuilder 

pub struct LuaPatternBuilder { /* private fields */ }

Build a byte Lua pattern, optionally escaping ‘magic’ characters

Implementations

impl LuaPatternBuilder

pub fn new() -> LuaPatternBuilder

Create a new Lua pattern builder

Examples found in repository

examples/range.rs (line 20)

fn main() {
    let mut m = LuaPattern::new("(%a+) one");
    let text = " hello one two";
    assert!(m.matches(text));
    assert_eq!(m.capture(1), 1..6);
    assert_eq!(m.capture(0), 1..10);

    let v = m.captures(text);
    assert_eq!(v, &["hello one", "hello"]);

    let mut v = Vec::new();
    assert!(m.capture_into(text, &mut v));
    assert_eq!(v, &["hello one", "hello"]);

    let bytes = &[0xFF, 0xEE, 0x0, 0xDE, 0x24, 0x24, 0xBE, 0x0, 0x0];

    let patt = LuaPatternBuilder::new()
        .bytes_as_hex("DE24")
        .text("+")
        .bytes(&[0xBE])
        .build();

    let mut m = LuaPattern::from_bytes(&patt);
    assert!(m.matches_bytes(bytes));
    assert_eq!(&bytes[m.capture(0)], &[0xDE, 0x24, 0x24, 0xBE]);

    let mut m = LuaPattern::new("(%S+)%s*=%s*(%S+);%s*");
    let res = m.gsub("a=2; b=3; c = 4;", "'%2':%1 ");
    println!("{}", res);

    let mut m = LuaPattern::new("%s+");
    let res = m.gsub("hello dolly you're so fine", "");
    println!("{}", res);
}

pub fn text(&mut self, s: &str) -> &mut Self

Add unescaped characters from a string

let patt = lua_patterns::LuaPatternBuilder::new()
    .text("(boo)")
    .build();
assert_eq!(std::str::from_utf8(&patt).unwrap(), "(boo)");

Examples found in repository

examples/range.rs (line 22)

fn main() {
    let mut m = LuaPattern::new("(%a+) one");
    let text = " hello one two";
    assert!(m.matches(text));
    assert_eq!(m.capture(1), 1..6);
    assert_eq!(m.capture(0), 1..10);

    let v = m.captures(text);
    assert_eq!(v, &["hello one", "hello"]);

    let mut v = Vec::new();
    assert!(m.capture_into(text, &mut v));
    assert_eq!(v, &["hello one", "hello"]);

    let bytes = &[0xFF, 0xEE, 0x0, 0xDE, 0x24, 0x24, 0xBE, 0x0, 0x0];

    let patt = LuaPatternBuilder::new()
        .bytes_as_hex("DE24")
        .text("+")
        .bytes(&[0xBE])
        .build();

    let mut m = LuaPattern::from_bytes(&patt);
    assert!(m.matches_bytes(bytes));
    assert_eq!(&bytes[m.capture(0)], &[0xDE, 0x24, 0x24, 0xBE]);

    let mut m = LuaPattern::new("(%S+)%s*=%s*(%S+);%s*");
    let res = m.gsub("a=2; b=3; c = 4;", "'%2':%1 ");
    println!("{}", res);

    let mut m = LuaPattern::new("%s+");
    let res = m.gsub("hello dolly you're so fine", "");
    println!("{}", res);
}

pub fn text_lines(&mut self, lines: &str) -> &mut Self

Add unescaped characters from lines

This looks for first non-whitespace run in each line, useful for spreading patterns out and commmenting them. Works with patterns that use ‘%s’ religiously!

let patt = lua_patterns::LuaPatternBuilder::new()
    .text_lines("
      hello-dolly
      you-are-fine  # comment
      cool
     ")
    .build();
assert_eq!(std::str::from_utf8(&patt).unwrap(),
  "hello-dollyyou-are-finecool");

pub fn bytes(&mut self, b: &[u8]) -> &mut Self

Add escaped bytes from a slice

let patt = lua_patterns::LuaPatternBuilder::new()
    .text("^")
    .bytes(b"^") // magic character!
    .build();
assert_eq!(std::str::from_utf8(&patt).unwrap(), "^%^");

Examples found in repository

examples/range.rs (line 23)

fn main() {
    let mut m = LuaPattern::new("(%a+) one");
    let text = " hello one two";
    assert!(m.matches(text));
    assert_eq!(m.capture(1), 1..6);
    assert_eq!(m.capture(0), 1..10);

    let v = m.captures(text);
    assert_eq!(v, &["hello one", "hello"]);

    let mut v = Vec::new();
    assert!(m.capture_into(text, &mut v));
    assert_eq!(v, &["hello one", "hello"]);

    let bytes = &[0xFF, 0xEE, 0x0, 0xDE, 0x24, 0x24, 0xBE, 0x0, 0x0];

    let patt = LuaPatternBuilder::new()
        .bytes_as_hex("DE24")
        .text("+")
        .bytes(&[0xBE])
        .build();

    let mut m = LuaPattern::from_bytes(&patt);
    assert!(m.matches_bytes(bytes));
    assert_eq!(&bytes[m.capture(0)], &[0xDE, 0x24, 0x24, 0xBE]);

    let mut m = LuaPattern::new("(%S+)%s*=%s*(%S+);%s*");
    let res = m.gsub("a=2; b=3; c = 4;", "'%2':%1 ");
    println!("{}", res);

    let mut m = LuaPattern::new("%s+");
    let res = m.gsub("hello dolly you're so fine", "");
    println!("{}", res);
}

pub fn bytes_as_hex(&mut self, bs: &str) -> &mut Self

Add escaped bytes from hex string

This consists of adjacent pairs of hex digits.

let patt = lua_patterns::LuaPatternBuilder::new()
    .text("^")
    .bytes_as_hex("5E") // which is ASCII '^'
    .build();
assert_eq!(std::str::from_utf8(&patt).unwrap(), "^%^");

Examples found in repository

examples/range.rs (line 21)

fn main() {
    let mut m = LuaPattern::new("(%a+) one");
    let text = " hello one two";
    assert!(m.matches(text));
    assert_eq!(m.capture(1), 1..6);
    assert_eq!(m.capture(0), 1..10);

    let v = m.captures(text);
    assert_eq!(v, &["hello one", "hello"]);

    let mut v = Vec::new();
    assert!(m.capture_into(text, &mut v));
    assert_eq!(v, &["hello one", "hello"]);

    let bytes = &[0xFF, 0xEE, 0x0, 0xDE, 0x24, 0x24, 0xBE, 0x0, 0x0];

    let patt = LuaPatternBuilder::new()
        .bytes_as_hex("DE24")
        .text("+")
        .bytes(&[0xBE])
        .build();

    let mut m = LuaPattern::from_bytes(&patt);
    assert!(m.matches_bytes(bytes));
    assert_eq!(&bytes[m.capture(0)], &[0xDE, 0x24, 0x24, 0xBE]);

    let mut m = LuaPattern::new("(%S+)%s*=%s*(%S+);%s*");
    let res = m.gsub("a=2; b=3; c = 4;", "'%2':%1 ");
    println!("{}", res);

    let mut m = LuaPattern::new("%s+");
    let res = m.gsub("hello dolly you're so fine", "");
    println!("{}", res);
}

pub fn build(&mut self) -> Vec<u8>

Create the pattern

Examples found in repository

examples/range.rs (line 24)

fn main() {
    let mut m = LuaPattern::new("(%a+) one");
    let text = " hello one two";
    assert!(m.matches(text));
    assert_eq!(m.capture(1), 1..6);
    assert_eq!(m.capture(0), 1..10);

    let v = m.captures(text);
    assert_eq!(v, &["hello one", "hello"]);

    let mut v = Vec::new();
    assert!(m.capture_into(text, &mut v));
    assert_eq!(v, &["hello one", "hello"]);

    let bytes = &[0xFF, 0xEE, 0x0, 0xDE, 0x24, 0x24, 0xBE, 0x0, 0x0];

    let patt = LuaPatternBuilder::new()
        .bytes_as_hex("DE24")
        .text("+")
        .bytes(&[0xBE])
        .build();

    let mut m = LuaPattern::from_bytes(&patt);
    assert!(m.matches_bytes(bytes));
    assert_eq!(&bytes[m.capture(0)], &[0xDE, 0x24, 0x24, 0xBE]);

    let mut m = LuaPattern::new("(%S+)%s*=%s*(%S+);%s*");
    let res = m.gsub("a=2; b=3; c = 4;", "'%2':%1 ");
    println!("{}", res);

    let mut m = LuaPattern::new("%s+");
    let res = m.gsub("hello dolly you're so fine", "");
    println!("{}", res);
}

pub fn hex_to_bytes(s: &str) -> Vec<u8>

Utility to create a vector of bytes from a hex string

let bb = lua_patterns::LuaPatternBuilder::hex_to_bytes("AEFE00FE");
assert_eq!(bb, &[0xAE,0xFE,0x00,0xFE]);

pub fn bytes_to_hex(s: &[u8]) -> String

Utility to create a hex string from a slice of bytes

let hex = lua_patterns::LuaPatternBuilder::bytes_to_hex(&[0xAE,0xFE,0x00,0xFE]);
assert_eq!(hex,"AEFE00FE");