robinpath_modules/modules/

faker_mod.rs

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

static SEED: AtomicU64 = AtomicU64::new(12345);

fn next_random() -> 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(
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_nanos() as u64,
    );
    SEED.store(s, Ordering::Relaxed);
    s
}

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

fn pick_from(items: &[&str]) -> String {
    items[random_range(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) {
    rp.register_builtin("faker.seed", |args, _| {
        let s = args.first().map(|v| v.to_number() as u64).unwrap_or(12345);
        SEED.store(s, Ordering::Relaxed);
        Ok(Value::Bool(true))
    });

    rp.register_builtin("faker.name", |_args, _| {
        Ok(Value::String(format!("{} {}", pick_from(FIRST_NAMES), pick_from(LAST_NAMES))))
    });

    rp.register_builtin("faker.firstName", |_args, _| {
        Ok(Value::String(pick_from(FIRST_NAMES)))
    });

    rp.register_builtin("faker.lastName", |_args, _| {
        Ok(Value::String(pick_from(LAST_NAMES)))
    });

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

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

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

    rp.register_builtin("faker.city", |_args, _| {
        Ok(Value::String(pick_from(CITIES)))
    });

    rp.register_builtin("faker.country", |_args, _| {
        Ok(Value::String(pick_from(COUNTRIES)))
    });

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

    rp.register_builtin("faker.company", |_args, _| {
        Ok(Value::String(pick_from(COMPANIES)))
    });

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

    rp.register_builtin("faker.number", |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() as i64).abs() % (max - min)
        } else {
            min
        };
        Ok(Value::Number(val as f64))
    });

    rp.register_builtin("faker.float", |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() % 10000) as f64 / 10000.0;
        Ok(Value::Number(min + frac * (max - min)))
    });

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

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

    rp.register_builtin("faker.uuid", |_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(0, 16) as usize] as char),
                'y' => uuid.push(hex[(random_range(0, 4) + 8) as usize] as char),
                '-' | '4' => uuid.push(c),
                _ => uuid.push(c),
            }
        }
        Ok(Value::String(uuid))
    });

    rp.register_builtin("faker.pick", |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(0, items.len() as u64) as usize;
            Ok(items[idx].clone())
        } else {
            Ok(Value::Null)
        }
    });

    rp.register_builtin("faker.shuffle", |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(0, (i + 1) as u64) as usize;
                items.swap(i, j);
            }
            Ok(Value::Array(items))
        } else {
            Ok(Value::Array(vec![]))
        }
    });

    rp.register_builtin("faker.paragraph", |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(5, 15) as usize;
            let words: Vec<String> = (0..word_count).map(|_| pick_from(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(" ")))
    });

    rp.register_builtin("faker.sentence", |_args, _| {
        let word_count = random_range(5, 12) as usize;
        let words: Vec<String> = (0..word_count).map(|_| pick_from(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))
    });

    rp.register_builtin("faker.word", |_args, _| {
        Ok(Value::String(pick_from(WORDS)))
    });

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

    rp.register_builtin("faker.ip", |_args, _| {
        Ok(Value::String(format!(
            "{}.{}.{}.{}",
            random_range(1, 255),
            random_range(0, 255),
            random_range(0, 255),
            random_range(1, 255)
        )))
    });

    rp.register_builtin("faker.url", |_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(&domains);
        let path = pick_from(&paths);
        let id = random_range(1, 1000);
        Ok(Value::String(format!("https://{}/{}/{}", domain, path, id)))
    });

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