google-maps-scraper-sdk 0.1.3

Google Maps Scraper / Extractor / Lead Scraper SDK for the GMaps Lead Finder Agent HTTP API
Documentation
use google_maps_scraper_sdk::{Client, ClientOptions, ScrapeOptions};
use std::env;
use std::fs;
use std::io::{self, Write};
use std::path::Path;
use std::process;

fn main() {
    let mut args: Vec<String> = env::args().skip(1).collect();
    if args.is_empty() || args.iter().any(|a| a == "-h" || a == "--help") {
        print_help();
        if args.is_empty() {
            process::exit(1);
        }
        return;
    }
    if args.iter().any(|a| a == "--version") {
        println!("0.1.1");
        return;
    }

    let cmd = args.remove(0);
    match cmd.as_str() {
        "me" => cmd_me(),
        "scrape" => {
            if args.is_empty() || args[0].starts_with('-') {
                eprintln!("error: scrape requires a keyword");
                process::exit(1);
            }
            let keyword = args.remove(0);
            let mut out: Option<String> = None;
            let mut opts = ScrapeOptions::default();
            let mut i = 0;
            while i < args.len() {
                match args[i].as_str() {
                    "--out" => {
                        i += 1;
                        out = Some(args.get(i).cloned().unwrap_or_default());
                    }
                    "--poll-interval-ms" => {
                        i += 1;
                        opts.poll_interval_ms = args.get(i).and_then(|s| s.parse().ok());
                    }
                    "--timeout-ms" => {
                        i += 1;
                        opts.timeout_ms = args.get(i).and_then(|s| s.parse().ok());
                    }
                    other => {
                        eprintln!("error: unknown argument {other}");
                        process::exit(1);
                    }
                }
                i += 1;
            }
            cmd_scrape(&keyword, out.as_deref(), opts);
        }
        other => {
            eprintln!("error: unknown command {other}");
            print_help();
            process::exit(1);
        }
    }
}

fn print_help() {
    println!(
        "gmaps-scraper (Rust) 0.1.1

Usage:
  gmaps-scraper me
  gmaps-scraper scrape \"<keyword>\" [--out leads.json|leads.csv]

Env:
  GMF_API_KEY     required
  GMF_BASE_URL    optional"
    );
}

fn client() -> Client {
    match Client::new(ClientOptions::default()) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("error: {e}");
            process::exit(1);
        }
    }
}

fn cmd_me() {
    let c = client();
    match c.me() {
        Ok(me) => {
            println!("{}", serde_json::to_string_pretty(&me).unwrap());
        }
        Err(e) => {
            eprintln!("error: {e}");
            process::exit(1);
        }
    }
}

fn cmd_scrape(keyword: &str, out: Option<&str>, opts: ScrapeOptions) {
    let c = client();
    let rows = match c.scrape(keyword, opts) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("error: {e}");
            process::exit(1);
        }
    };
    if let Err(e) = write_output(&rows, out) {
        eprintln!("error: {e}");
        process::exit(1);
    }
}

fn write_output(
    rows: &[google_maps_scraper_sdk::PlaceRow],
    out: Option<&str>,
) -> io::Result<()> {
    match out {
        None => {
            let s = serde_json::to_string_pretty(rows).unwrap();
            println!("{s}");
            Ok(())
        }
        Some(path) if path.to_ascii_lowercase().ends_with(".csv") => write_csv(path, rows),
        Some(path) => {
            if let Some(parent) = Path::new(path).parent() {
                if !parent.as_os_str().is_empty() {
                    fs::create_dir_all(parent)?;
                }
            }
            let s = serde_json::to_string_pretty(rows).unwrap();
            fs::write(path, format!("{s}\n"))?;
            eprintln!("Wrote {} rows to {path}", rows.len());
            Ok(())
        }
    }
}

fn write_csv(path: &str, rows: &[google_maps_scraper_sdk::PlaceRow]) -> io::Result<()> {
    let mut fields: Vec<String> = Vec::new();
    for row in rows {
        for k in row.keys() {
            if !fields.iter().any(|f| f == k) {
                fields.push(k.clone());
            }
        }
    }
    if fields.is_empty() {
        fields.push("Name".into());
    }
    if let Some(parent) = Path::new(path).parent() {
        if !parent.as_os_str().is_empty() {
            fs::create_dir_all(parent)?;
        }
    }
    let mut f = fs::File::create(path)?;
    writeln!(f, "{}", fields.join(","))?;
    for row in rows {
        let line: Vec<String> = fields
            .iter()
            .map(|k| csv_escape(row.get(k).map(|s| s.as_str()).unwrap_or("")))
            .collect();
        writeln!(f, "{}", line.join(","))?;
    }
    eprintln!("Wrote {} rows to {path}", rows.len());
    Ok(())
}

fn csv_escape(v: &str) -> String {
    if v.contains(',') || v.contains('"') || v.contains('\n') {
        format!("\"{}\"", v.replace('"', "\"\""))
    } else {
        v.to_string()
    }
}