Follow a product
into the CSV.

run :: proc() -> int {
	arena: mem.Arena
	defer mem.arena_destroy(&arena)
	context.allocator = mem.arena_allocator(&arena)
	context.temp_allocator = context.allocator

	options, help, ok := parse_options()
	if !ok {
		fmt.eprintln("Use --help for usage.")
		return 2
	}
	if help {
		fmt.print(HELP)
		return 0
	}
	if !install_interrupts() {
		return 1
	}
	credentials, configured := load_credentials()
	success := configured && collect(options, credentials)
	if !success && cancelled() {
		fmt.eprintln("[!] Interrupted.")
		return 128 + int(interruption())
	}
// Excerpt ends here.

152 lines in the file. SHA-256 bc4704fa07bcf01ba7f68ca658eb4496774a2003f6f10ed93b9d51efefa19513

read_dotenv :: proc() -> (contents: string, ok: bool) {
	file, err := os.open(".env", {.Read, .Non_Blocking})
	if err == .Not_Exist {
		return "", true
	}
	if err != nil {
		fmt.eprintfln("[!] Cannot read .env: %s", os.error_string(err))
		return
	}
	defer os.close(file)
	info, stat_err := os.fstat(file, context.allocator)
	if stat_err != nil || info.type != .Regular || info.size > MAX_DOTENV_BYTES {
		fmt.eprintln("[!] Cannot read .env: expected a regular file no larger than 64 KiB")
		return
	}
	buffer := make([]byte, MAX_DOTENV_BYTES+1)
	total := 0
	for total < len(buffer) && !cancelled() {
		n, read_err := os.read(file, buffer[total:])
		total += n
		if read_err != nil && read_err != .EOF {
			fmt.eprintfln("[!] Cannot read .env: %s", os.error_string(read_err))
			return
		}
// Excerpt ends here.

166 lines in the file. SHA-256 7f7a5f5ce215e0952d934a29c2f7ab2d92f4102059714815c5123644f1433084

build_filters :: proc(options: Options) -> string {
	parts: [dynamic]string
	if !options.no_code {
		append(&parts, "_tags:founders-code-yes")
	}
	if options.revenue > 0 {
		append(&parts, fmt.aprintf("revenue >= %d", options.revenue))
	}
	return strings.join(parts[:], " AND ")
}

113 lines in the file. SHA-256 7dbcb98d913bf5c99bf8a6ebf5e8bb2f1ae2b9a55b80f64e4d476d9545cccbae

configure_http :: proc(handle: ^curl.CURL, url: string, headers: ^curl.slist) -> bool {
	checks := [?]curl.code{
		curl.easy_setopt(handle, .URL, strings.clone_to_cstring(url)),
		curl.easy_setopt(handle, .HTTPHEADER, headers),
		curl.easy_setopt(handle, .USERAGENT, cstring("IndieHackers-Data-Collector/2.0")),
		curl.easy_setopt(handle, .TIMEOUT_MS, c.long(15_000)),
		curl.easy_setopt(handle, .CONNECTTIMEOUT_MS, c.long(15_000)),
		curl.easy_setopt(handle, .NOSIGNAL, c.long(1)),
		curl.easy_setopt(handle, .FOLLOWLOCATION, c.long(0)),
		curl.easy_setopt(handle, .PROTOCOLS_STR, cstring("http,https")),
		curl.easy_setopt(handle, .WRITEFUNCTION, curl.write_callback(receive_body)),
		curl.easy_setopt(handle, .XFERINFOFUNCTION, curl.xferinfo_callback(transfer_progress)),
		curl.easy_setopt(handle, .NOPROGRESS, c.long(0)),
		curl.easy_setopt(handle, .ACCEPT_ENCODING, cstring("")),
	}
	for result in checks {
		if result != .E_OK {
			fmt.eprintfln("[!] Cannot configure HTTP: %s", curl.easy_strerror(result))
			return false
		}
	}
	return true
}

186 lines in the file. SHA-256 89f98fbe40906f84fb4b0d02656e5a088f985d15cb1620564b9029ece16cf1a8

decode_json :: proc(body: []byte) -> (json.Value, bool) {
	reader := JSON_Reader{
		tokenizer = json.make_tokenizer(string(body), .JSON, parse_integers = true),
		ok = true,
		remaining = 200_000,
	}
	json_advance(&reader)
	value := json_read_value(&reader, 0)
	return value, reader.ok && reader.token.kind == .EOF
}

199 lines in the file. SHA-256 790f131fbc1b1425a683933853200b12ce208836733586b95e305ec69d848c8a

decode_product :: proc(value: json.Value) -> (row: Product_Row, ok: bool) {
	hit, is_object := value.(json.Object)
	if !is_object {
		fmt.eprintln("[!] Invalid product: each hit must be an object")
		return
	}
	keys := [?]string{"name", "tagline", "revenue", "objectID", "websiteUrl", "status"}
	defaults := [?]string{"N/A", "", "0", "", "", "unknown"}
	for key, i in keys {
		field, valid := csv_field(hit, key, defaults[i])
		if !valid {
			fmt.eprintfln("[!] Invalid product: %s must be a scalar or null", key)
			return
		}
		row.fields[i] = field
	}
	row.id = row.fields[3]
	row.fields[3] = fmt.aprintf("https://www.indiehackers.com/product/%s", net.percent_encode(row.id))
	return row, true
}

82 lines in the file. SHA-256 9413d946c62d44899d68d73b34119d37ff9ff74c57c373b58fac92b592d3b6e0

export_unchanged :: proc(export: ^Export) -> bool {
	directory_info: posix.stat_t
	if posix.stat(export.directory_path, &directory_info) != .OK ||
	   directory_info.st_dev != export.directory_info.st_dev || directory_info.st_ino != export.directory_info.st_ino {
		fmt.eprintln("[!] Output directory changed during collection; export discarded")
		return false
	}
	current, exists, ok := export_snapshot(export)
	if !ok {
		return false
	}
	if exists != export.existed || exists && !same_file_snapshot(current, export.original) {
		fmt.eprintln("[!] CSV destination changed during collection; export discarded")
		return false
	}
	return true
}

239 lines in the file. SHA-256 92012f3169dccecf067baa9f2ce29b6f3e488bfa3fc97a381372759a14f2728e

interrupt_handler :: proc "c" (signal: posix.Signal) {
	// Signal handlers may only touch lock-free state; no allocation or I/O.
	intrinsics.atomic_store_explicit(&interrupted, i32(signal), .Relaxed)
}

49 lines in the file. SHA-256 5b6dd16107e8657cc179b07af0682c674dc633644e9ec30b9b5b36d654019edf