robinpath_modules/modules/

faker_mod.rs

use robinpath::{RobinPath, Value};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;

fn epoch_time_nanos() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_nanos() as u64
}

fn next_random(seed: &AtomicU64) -> u64 {
    let mut s = seed.load(Ordering::Relaxed);
    s ^= s << 13;
    s ^= s >> 7;
    s ^= s << 17;
    // Mix in some entropy from time
    s = s.wrapping_add(epoch_time_nanos());
    seed.store(s, Ordering::Relaxed);
    s
}

fn random_range(seed: &AtomicU64, min: u64, max: u64) -> u64 {
    if max <= min {
        return min;
    }
    min + next_random(seed) % (max - min)
}

fn pick_from(seed: &AtomicU64, items: &[&str]) -> String {
    items[random_range(seed, 0, items.len() as u64) as usize].to_string()
}

const FIRST_NAMES: &[&str] = &[
    "James", "Mary", "Robert", "Patricia", "John", "Jennifer", "Michael", "Linda",
    "David", "Elizabeth", "William", "Barbara", "Richard", "Susan", "Joseph", "Jessica",
    "Thomas", "Sarah", "Christopher", "Karen", "Daniel", "Lisa", "Matthew", "Nancy",
    "Anthony", "Betty", "Mark", "Margaret", "Donald", "Sandra", "Steven", "Ashley",
    "Paul", "Kimberly", "Andrew", "Emily", "Joshua", "Donna", "Kenneth", "Michelle",
    "Kevin", "Carol", "Brian", "Amanda", "George", "Dorothy", "Timothy", "Melissa",
];

const LAST_NAMES: &[&str] = &[
    "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
    "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson",
    "Thomas", "Taylor", "Moore", "Jackson", "Martin", "Lee", "Perez", "Thompson",
    "White", "Harris", "Sanchez", "Clark", "Ramirez", "Lewis", "Robinson", "Walker",
    "Young", "Allen", "King", "Wright", "Scott", "Torres", "Nguyen", "Hill", "Flores",
];

const CITIES: &[&str] = &[
    "New York", "Los Angeles", "Chicago", "Houston", "Phoenix", "Philadelphia",
    "San Antonio", "San Diego", "Dallas", "San Jose", "Austin", "Jacksonville",
    "Fort Worth", "Columbus", "Charlotte", "San Francisco", "Indianapolis", "Seattle",
    "Denver", "Washington", "Nashville", "Oklahoma City", "Portland", "Las Vegas",
];

const COUNTRIES: &[&str] = &[
    "United States", "Canada", "United Kingdom", "Australia", "Germany", "France",
    "Japan", "Brazil", "India", "Mexico", "South Korea", "Italy", "Spain", "Netherlands",
    "Sweden", "Norway", "Denmark", "Finland", "Switzerland", "Argentina", "Poland",
];

const STREETS: &[&str] = &[
    "Main St", "Oak Ave", "Elm St", "Park Blvd", "Cedar Ln", "Maple Dr",
    "Pine St", "Washington Ave", "Lake Rd", "Hill St", "River Rd", "Forest Ave",
];

const COMPANIES: &[&str] = &[
    "Acme Corp", "Globex", "Initech", "Umbrella Corp", "Stark Industries",
    "Wayne Enterprises", "Cyberdyne", "Tyrell Corp", "Soylent Corp", "Weyland-Yutani",
    "Oscorp", "LexCorp", "Massive Dynamic", "InGen", "Aperture Science",
];

const LOREM_WORDS: &[&str] = &[
    "lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit",
    "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore",
    "magna", "aliqua", "enim", "ad", "minim", "veniam", "quis", "nostrud",
    "exercitation", "ullamco", "laboris", "nisi", "aliquip", "ex", "ea", "commodo",
    "consequat", "duis", "aute", "irure", "in", "reprehenderit", "voluptate",
    "velit", "esse", "cillum", "fugiat", "nulla", "pariatur", "excepteur",
    "sint", "occaecat", "cupidatat", "non", "proident", "sunt", "culpa",
];

const WORDS: &[&str] = &[
    "ability", "accept", "across", "action", "activity", "agree", "almost", "among",
    "animal", "answer", "appear", "area", "arrive", "article", "attack", "author",
    "basket", "battle", "beauty", "become", "before", "begin", "behind", "believe",
    "camera", "career", "center", "change", "choice", "circle", "class", "clear",
    "danger", "debate", "decide", "demand", "design", "detail", "dinner", "direct",
    "effect", "effort", "energy", "engine", "enough", "entire", "escape", "expect",
];

pub fn register(rp: &mut RobinPath) {
    let seed = Arc::new(AtomicU64::new(epoch_time_nanos()));

    let sd = seed.clone();
    rp.register_builtin("faker.seed", move |args, _| {
        let s = args.first().map(|v| v.to_number() as u64).unwrap_or(12345);
        sd.store(s, Ordering::Relaxed);
        Ok(Value::Bool(true))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.name", move |_args, _| {
        Ok(Value::String(format!("{} {}", pick_from(&sd, FIRST_NAMES), pick_from(&sd, LAST_NAMES))))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.firstName", move |_args, _| {
        Ok(Value::String(pick_from(&sd, FIRST_NAMES)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.lastName", move |_args, _| {
        Ok(Value::String(pick_from(&sd, LAST_NAMES)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.email", move |_args, _| {
        let first = pick_from(&sd, FIRST_NAMES).to_lowercase();
        let last = pick_from(&sd, LAST_NAMES).to_lowercase();
        let domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com", "mail.com"];
        let domain = pick_from(&sd, &domains);
        Ok(Value::String(format!("{}.{}@{}", first, last, domain)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.phone", move |_args, _| {
        let area = random_range(&sd, 200, 999);
        let mid = random_range(&sd, 100, 999);
        let end = random_range(&sd, 1000, 9999);
        Ok(Value::String(format!("({}) {}-{}", area, mid, end)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.address", move |_args, _| {
        let num = random_range(&sd, 1, 9999);
        let street = pick_from(&sd, STREETS);
        Ok(Value::String(format!("{} {}", num, street)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.city", move |_args, _| {
        Ok(Value::String(pick_from(&sd, CITIES)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.country", move |_args, _| {
        Ok(Value::String(pick_from(&sd, COUNTRIES)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.zipCode", move |_args, _| {
        let zip = random_range(&sd, 10000, 99999);
        Ok(Value::String(format!("{}", zip)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.company", move |_args, _| {
        Ok(Value::String(pick_from(&sd, COMPANIES)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.lorem", move |args, _| {
        let count = args.first().map(|v| v.to_number() as usize).unwrap_or(10);
        let words: Vec<String> = (0..count).map(|_| pick_from(&sd, LOREM_WORDS)).collect();
        Ok(Value::String(words.join(" ")))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.number", move |args, _| {
        let min = args.first().map(|v| v.to_number() as i64).unwrap_or(0);
        let max = args.get(1).map(|v| v.to_number() as i64).unwrap_or(100);
        let val = if max > min {
            min + (next_random(&sd) as i64).abs() % (max - min)
        } else {
            min
        };
        Ok(Value::Number(val as f64))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.float", move |args, _| {
        let min = args.first().map(|v| v.to_number()).unwrap_or(0.0);
        let max = args.get(1).map(|v| v.to_number()).unwrap_or(1.0);
        let frac = (next_random(&sd) % 10000) as f64 / 10000.0;
        Ok(Value::Number(min + frac * (max - min)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.boolean", move |_args, _| {
        Ok(Value::Bool(next_random(&sd) % 2 == 0))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.date", move |_args, _| {
        let year = random_range(&sd, 2000, 2030);
        let month = random_range(&sd, 1, 13);
        let day = random_range(&sd, 1, 29);
        Ok(Value::String(format!("{:04}-{:02}-{:02}", year, month, day)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.uuid", move |_args, _| {
        let hex_chars = "0123456789abcdef";
        let hex: Vec<u8> = hex_chars.as_bytes().to_vec();
        let mut uuid = String::with_capacity(36);
        let pattern = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
        for c in pattern.chars() {
            match c {
                'x' => uuid.push(hex[random_range(&sd, 0, 16) as usize] as char),
                'y' => uuid.push(hex[(random_range(&sd, 0, 4) + 8) as usize] as char),
                '-' | '4' => uuid.push(c),
                _ => uuid.push(c),
            }
        }
        Ok(Value::String(uuid))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.pick", move |args, _| {
        let arr = args.first().cloned().unwrap_or(Value::Null);
        if let Value::Array(items) = &arr {
            if items.is_empty() {
                return Ok(Value::Null);
            }
            let idx = random_range(&sd, 0, items.len() as u64) as usize;
            Ok(items[idx].clone())
        } else {
            Ok(Value::Null)
        }
    });

    let sd = seed.clone();
    rp.register_builtin("faker.shuffle", move |args, _| {
        let arr = args.first().cloned().unwrap_or(Value::Null);
        if let Value::Array(mut items) = arr {
            let n = items.len();
            for i in (1..n).rev() {
                let j = random_range(&sd, 0, (i + 1) as u64) as usize;
                items.swap(i, j);
            }
            Ok(Value::Array(items))
        } else {
            Ok(Value::Array(vec![]))
        }
    });

    let sd = seed.clone();
    rp.register_builtin("faker.paragraph", move |args, _| {
        let sentences = args.first().map(|v| v.to_number() as usize).unwrap_or(3);
        let mut parts = Vec::new();
        for _ in 0..sentences {
            let word_count = random_range(&sd, 5, 15) as usize;
            let words: Vec<String> = (0..word_count).map(|_| pick_from(&sd, WORDS)).collect();
            let mut sentence = words.join(" ");
            if let Some(first) = sentence.get_mut(0..1) {
                first.make_ascii_uppercase();
            }
            sentence.push('.');
            parts.push(sentence);
        }
        Ok(Value::String(parts.join(" ")))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.sentence", move |_args, _| {
        let word_count = random_range(&sd, 5, 12) as usize;
        let words: Vec<String> = (0..word_count).map(|_| pick_from(&sd, WORDS)).collect();
        let mut sentence = words.join(" ");
        if let Some(first) = sentence.get_mut(0..1) {
            first.make_ascii_uppercase();
        }
        sentence.push('.');
        Ok(Value::String(sentence))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.word", move |_args, _| {
        Ok(Value::String(pick_from(&sd, WORDS)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.color", move |_args, _| {
        let r = random_range(&sd, 0, 256);
        let g = random_range(&sd, 0, 256);
        let b = random_range(&sd, 0, 256);
        Ok(Value::String(format!("#{:02x}{:02x}{:02x}", r, g, b)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.ip", move |_args, _| {
        Ok(Value::String(format!(
            "{}.{}.{}.{}",
            random_range(&sd, 1, 255),
            random_range(&sd, 0, 255),
            random_range(&sd, 0, 255),
            random_range(&sd, 1, 255)
        )))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.url", move |_args, _| {
        let domains = ["example.com", "test.org", "sample.net", "demo.io", "fake.dev"];
        let paths = ["page", "post", "article", "item", "resource", "data", "api"];
        let domain = pick_from(&sd, &domains);
        let path = pick_from(&sd, &paths);
        let id = random_range(&sd, 1, 1000);
        Ok(Value::String(format!("https://{}/{}/{}", domain, path, id)))
    });

    let sd = seed.clone();
    rp.register_builtin("faker.avatar", move |_args, _| {
        let id = random_range(&sd, 1, 100);
        Ok(Value::String(format!(
            "https://i.pravatar.cc/150?img={}",
            id
        )))
    });
}