@carlos-iso/versioner 0.0.2

package/src/test/smoke.js

@@ -0,0 +1,156 @@
+/**
+ * Teste de fumaça sem dependências externas.
+ *
+ * Cria um repositório Git temporário, roda init/build/minor/major
+ * e valida o resultado. Executado automaticamente no prepublishOnly.
+ *
+ *   npm test
+ */
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const BIN = path.join(__dirname, "../../", "bin", "versioner.js");
+
+let failures = 0;
+
+function assert(condition, label) {
+	if (condition) {
+		console.log(`  ✔ ${label}`);
+		return;
+	}
+
+	failures += 1;
+	console.log(`  ✖ ${label}`);
+}
+
+function run(cwd, args) {
+	return execFileSync(process.execPath, [BIN, ...args], {
+		cwd,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+		env: { ...process.env, NO_COLOR: "1" },
+	});
+}
+
+function git(cwd, args) {
+	execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+function readJSON(file) {
+	return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function setup() {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "versioner-test-"));
+
+	git(dir, ["init", "-b", "main"]);
+	git(dir, ["config", "user.email", "test@example.com"]);
+	git(dir, ["config", "user.name", "Versioner Test"]);
+
+	fs.writeFileSync(
+		path.join(dir, "package.json"),
+		JSON.stringify({ name: "demo", version: "0.0.0" }, null, 2),
+	);
+
+	fs.writeFileSync(
+		path.join(dir, "app.json"),
+		JSON.stringify({ expo: { name: "demo", version: "0.0.0" } }, null, 2),
+	);
+
+	git(dir, ["add", "."]);
+	git(dir, ["commit", "-m", "inicial"]);
+
+	return dir;
+}
+
+function main() {
+	console.log("\nVersioner · smoke test\n");
+
+	const dir = setup();
+
+	// init
+	run(dir, ["init", "--yes"]);
+
+	assert(fs.existsSync(path.join(dir, "versioner.config.json")), "init cria versioner.config.json");
+	assert(fs.existsSync(path.join(dir, ".versioner.json")), "init cria .versioner.json");
+
+	const config = readJSON(path.join(dir, "versioner.config.json"));
+
+	assert(
+		config.files.some((file) => file.path === "package.json"),
+		"init detecta package.json",
+	);
+	assert(
+		config.files.some((file) => file.field === "expo.version"),
+		"init detecta app.json (expo.version)",
+	);
+
+	// build (sem push: não há remoto)
+	run(dir, ["build", "primeira release", "--no-push"]);
+
+	assert(readJSON(path.join(dir, ".versioner.json")).build === 1, "build incrementa a build");
+	assert(readJSON(path.join(dir, "package.json")).version === "0.0.1", "build atualiza package.json");
+	assert(readJSON(path.join(dir, "app.json")).expo.version === "0.0.1", "build atualiza app.json");
+
+	// minor
+	run(dir, ["minor", "nova funcionalidade", "--no-push"]);
+
+	const afterMinor = readJSON(path.join(dir, ".versioner.json"));
+
+	assert(afterMinor.minor === 1 && afterMinor.build === 2, "minor incrementa minor e build");
+
+	// major
+	run(dir, ["major", "nova arquitetura", "--no-push", "--tag"]);
+
+	const afterMajor = readJSON(path.join(dir, ".versioner.json"));
+
+	assert(
+		afterMajor.major === 1 && afterMajor.minor === 0 && afterMajor.build === 3,
+		"major incrementa major, zera minor e incrementa build",
+	);
+
+	const tags = execFileSync("git", ["tag"], { cwd: dir, encoding: "utf8" });
+
+	assert(tags.includes("v1.0.3"), "--tag cria a tag da release");
+
+	// dry-run não altera nada
+	run(dir, ["build", "simulacao", "--dry-run"]);
+
+	assert(
+		readJSON(path.join(dir, ".versioner.json")).build === 3,
+		"--dry-run não grava alterações",
+	);
+
+	// version / status / help
+	assert(run(dir, ["version", "--raw"]).trim() === "1.0.3", "version --raw imprime a versão");
+	assert(run(dir, ["status"]).includes("Arquivos monitorados"), "status roda sem erro");
+	assert(run(dir, ["help"]).includes("build"), "help lista os comandos");
+
+	// validação de mensagem
+	let rejected = false;
+
+	try {
+		run(dir, ["build"]);
+	} catch {
+		rejected = true;
+	}
+
+	assert(rejected, "build sem mensagem é rejeitado");
+
+	// versão não pode ter avançado após a falha (rollback)
+	assert(
+		readJSON(path.join(dir, ".versioner.json")).build === 3,
+		"falha na release não avança a versão",
+	);
+
+	fs.rmSync(dir, { recursive: true, force: true });
+
+	console.log(`\n${failures ? `${failures} falha(s).` : "Todos os testes passaram."}\n`);
+
+	process.exit(failures ? 1 : 0);
+}
+
+main();

package/src/utils/args.js

@@ -0,0 +1,60 @@
+const SHORT_FLAGS = {
+	y: "yes",
+	f: "force",
+	n: "no-git",
+	d: "dry-run",
+};
+
+/**
+ * Separa flags de valores posicionais.
+ *
+ * parse(['build', 'Corrige login', '--no-push'])
+ * → { values: ['build', 'Corrige login'], flags: { 'no-push': true } }
+ *
+ * Suporta `--chave=valor`.
+ */
+function parse(argv = []) {
+	const values = [];
+	const flags = {};
+
+	for (const arg of argv) {
+		if (typeof arg !== "string") {
+			continue;
+		}
+
+		if (arg.startsWith("--")) {
+			const [key, value] = arg.slice(2).split("=");
+
+			flags[key] = value === undefined ? true : value;
+			continue;
+		}
+
+		if (arg.startsWith("-") && arg.length > 1) {
+			for (const letter of arg.slice(1)) {
+				flags[SHORT_FLAGS[letter] || letter] = true;
+			}
+			continue;
+		}
+
+		values.push(arg);
+	}
+
+	return { values, flags };
+}
+
+/**
+ * Junta os valores posicionais em uma mensagem de commit.
+ */
+function toMessage(values) {
+	return values.join(" ").trim();
+}
+
+function hasFlag(flags, ...names) {
+	return names.some((name) => flags[name] === true || flags[name] === "true");
+}
+
+module.exports = {
+	parse,
+	toMessage,
+	hasFlag,
+};

package/src/utils/file.js

@@ -0,0 +1,80 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Resolve um caminho a partir do diretório onde a CLI foi executada.
+ */
+function root(...paths) {
+	return path.join(process.cwd(), ...paths);
+}
+
+/**
+ * Resolve um caminho a partir de um diretório específico.
+ */
+function resolve(cwd, ...paths) {
+	return path.join(cwd, ...paths);
+}
+
+function exists(file) {
+	return fs.existsSync(file);
+}
+
+function isDirectory(file) {
+	return exists(file) && fs.statSync(file).isDirectory();
+}
+
+function readText(file) {
+	return fs.readFileSync(file, "utf8");
+}
+
+function writeText(file, content) {
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+
+	fs.writeFileSync(file, content, "utf8");
+}
+
+function readJSON(file) {
+	const content = readText(file);
+
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(`JSON inválido em ${path.basename(file)}: ${error.message}`);
+	}
+}
+
+/**
+ * Escreve JSON preservando a indentação já usada no arquivo
+ * (evita diffs gigantes em projetos que usam 2 espaços).
+ */
+function writeJSON(file, data, indent) {
+	const spaces = indent || detectIndent(file);
+
+	writeText(file, `${JSON.stringify(data, null, spaces)}\n`);
+}
+
+function detectIndent(file) {
+	if (!exists(file)) {
+		return 4;
+	}
+
+	const match = readText(file).match(/^[ \t]+/m);
+
+	if (!match) {
+		return 4;
+	}
+
+	return match[0].includes("\t") ? "\t" : match[0].length;
+}
+
+module.exports = {
+	root,
+	resolve,
+	exists,
+	isDirectory,
+	readText,
+	writeText,
+	readJSON,
+	writeJSON,
+	detectIndent,
+};

package/src/utils/logger.js

@@ -0,0 +1,103 @@
+const SUPPORTS_COLOR =
+	process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+
+const CODES = {
+	reset: "\u001b[0m",
+	bold: "\u001b[1m",
+	dim: "\u001b[2m",
+	red: "\u001b[31m",
+	green: "\u001b[32m",
+	yellow: "\u001b[33m",
+	blue: "\u001b[34m",
+	cyan: "\u001b[36m",
+	gray: "\u001b[90m",
+};
+
+function paint(code, text) {
+	if (!SUPPORTS_COLOR) {
+		return text;
+	}
+
+	return `${CODES[code]}${text}${CODES.reset}`;
+}
+
+class Logger {
+	constructor() {
+		this.silent = false;
+	}
+
+	setSilent(value) {
+		this.silent = Boolean(value);
+	}
+
+	write(text = "") {
+		if (this.silent) {
+			return;
+		}
+
+		console.log(text);
+	}
+
+	break() {
+		this.write("");
+	}
+
+	title(text) {
+		this.break();
+		this.write(paint("bold", paint("cyan", `▌ ${text}`)));
+		this.write(paint("gray", "─".repeat(Math.max(text.length + 2, 24))));
+	}
+
+	section(text) {
+		this.break();
+		this.write(paint("bold", text));
+	}
+
+	info(text) {
+		this.write(`${paint("blue", "ℹ")} ${text}`);
+	}
+
+	success(text) {
+		this.write(`${paint("green", "✔")} ${text}`);
+	}
+
+	warn(text) {
+		this.write(`${paint("yellow", "!")} ${text}`);
+	}
+
+	error(text) {
+		this.write(`${paint("red", "✖")} ${text}`);
+	}
+
+	step(text) {
+		this.write(`${paint("gray", "→")} ${text}`);
+	}
+
+	item(text) {
+		this.write(`  ${paint("gray", "•")} ${text}`);
+	}
+
+	muted(text) {
+		this.write(paint("gray", text));
+	}
+
+	/**
+	 * Linha de "chave: valor" alinhada.
+	 */
+	field(label, value, width = 18) {
+		const key = `${label}:`.padEnd(width, " ");
+
+		this.write(`  ${paint("gray", key)} ${value}`);
+	}
+
+	bold(text) {
+		return paint("bold", text);
+	}
+
+	dim(text) {
+		return paint("gray", text);
+	}
+}
+
+module.exports = new Logger();
+module.exports.Logger = Logger;

package/src/utils/object.js

@@ -0,0 +1,79 @@
+/**
+ * Define um valor em um caminho aninhado.
+ * Exemplo: setValue(json, "expo.version", "1.0.0")
+ */
+function setValue(object, path, value) {
+	const keys = String(path).split(".");
+
+	let current = object;
+
+	while (keys.length > 1) {
+		const key = keys.shift();
+
+		if (typeof current[key] !== "object" || current[key] === null) {
+			current[key] = {};
+		}
+
+		current = current[key];
+	}
+
+	current[keys[0]] = value;
+
+	return object;
+}
+
+/**
+ * Lê um valor em um caminho aninhado.
+ * Retorna `undefined` se o caminho não existir.
+ */
+function getValue(object, path) {
+	const keys = String(path).split(".");
+
+	let current = object;
+
+	for (const key of keys) {
+		if (typeof current !== "object" || current === null) {
+			return undefined;
+		}
+
+		current = current[key];
+	}
+
+	return current;
+}
+
+/**
+ * Merge raso-profundo usado para aplicar os defaults da configuração.
+ * Valores do `source` sobrescrevem os do `target`.
+ */
+function merge(target, source) {
+	const result = { ...target };
+
+	for (const key of Object.keys(source || {})) {
+		const value = source[key];
+
+		if (value === undefined) {
+			continue;
+		}
+
+		if (isPlainObject(value) && isPlainObject(result[key])) {
+			result[key] = merge(result[key], value);
+			continue;
+		}
+
+		result[key] = value;
+	}
+
+	return result;
+}
+
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+module.exports = {
+	setValue,
+	getValue,
+	merge,
+	isPlainObject,
+};

package/src/utils/time.js

@@ -0,0 +1,36 @@
+/**
+ * Formata uma duração em milissegundos de forma legível.
+ * A unidade já vem embutida no retorno.
+ */
+function formatDuration(milliseconds) {
+	const ms = Math.max(0, Number(milliseconds) || 0);
+
+	if (ms < 1000) {
+		return `${Math.round(ms)} ms`;
+	}
+
+	const seconds = ms / 1000;
+
+	if (seconds < 60) {
+		return `${seconds.toFixed(2)} s`;
+	}
+
+	const minutes = Math.floor(seconds / 60);
+	const remaining = (seconds % 60).toFixed(2);
+
+	return `${minutes} min ${remaining} s`;
+}
+
+/**
+ * Data legível para CHANGELOG / logs.
+ */
+function formatDate(date) {
+	const value = date instanceof Date ? date : new Date(date);
+
+	return value.toISOString().slice(0, 10);
+}
+
+module.exports = {
+	formatDuration,
+	formatDate,
+};

package/src/utils/utils.js

@@ -0,0 +1,20 @@
+/**
+ * Barrel de utilitários.
+ * Mantido para compatibilidade com os imports antigos
+ * (`require("../utils/utils")`).
+ *
+ * Em código novo, prefira importar o módulo específico:
+ * utils/file, utils/object, utils/time, utils/args.
+ */
+
+const file = require("./file");
+const object = require("./object");
+const time = require("./time");
+const args = require("./args");
+
+module.exports = {
+	...file,
+	...object,
+	...time,
+	parseArgs: args.parse,
+};