• Home
• dev.jbang
• jbang-cli
• 0.119.0
• source code
• Edit.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

dev.jbang.cli.Edit Maven / Gradle / Ivy

package dev.jbang.cli;

import static dev.jbang.Settings.CP_SEPARATOR;
import static dev.jbang.util.Util.freshly;
import static dev.jbang.util.Util.pathToString;
import static dev.jbang.util.Util.verboseMsg;
import static java.lang.System.out;

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.Callable;
import java.util.function.Function;
import java.util.stream.Collectors;

import dev.jbang.Cache;
import dev.jbang.Settings;
import dev.jbang.dependencies.DependencyUtil;
import dev.jbang.dependencies.JitPackUtil;
import dev.jbang.dependencies.MavenRepo;
import dev.jbang.net.EditorManager;
import dev.jbang.source.*;
import dev.jbang.util.CommandBuffer;
import dev.jbang.util.TemplateEngine;
import dev.jbang.util.Util;
import dev.jbang.util.Util.Shell;

import io.quarkus.qute.Template;
import picocli.CommandLine;

@CommandLine.Command(name = "edit", description = "Setup a temporary project to edit script in an IDE.")
public class Edit extends BaseCommand {

	static String[] knownEditors = { "codium", "code", "eclipse", "idea", "netbeans" };

	@CommandLine.Mixin
	ScriptMixin scriptMixin;

	@CommandLine.Mixin
	DependencyInfoMixin dependencyInfoMixin;

	@CommandLine.Parameters(index = "1", arity = "0..N")
	List additionalFiles = new ArrayList<>();

	@CommandLine.Option(names = {
			"--live" }, description = "Open directory in IDE's that support JBang or generate temporary project with option to regenerate project on dependency changes.")
	public boolean live;

	@CommandLine.Option(names = {
			"--open" }, arity = "0..1", defaultValue = "${JBANG_EDITOR:-${default.edit.open:-}}", fallbackValue = "${JBANG_EDITOR:-${default.edit.open:-}}", description = "Opens editor/IDE on the temporary project.", preprocessor = StrictParameterPreprocessor.class)
	public Optional editor;

	@CommandLine.Option(names = { "--no-open" }, description = "Explicitly prevent JBang from opening an editor/IDE")
	public boolean noOpen;

	@CommandLine.Option(names = { "-b",
			"--sandbox" }, description = "Edit in sandbox mode. Useful when the editor/IDE used has no JBang support")
	boolean sandbox;

	/**
	 * Returns a parent path if one of the targetFileNames exist in such parent.
	 *
	 * @param filePath
	 * @param targetFileNames list of markers to search for
	 * @return if found returns the marker path, if none found return null.
	 */
	static Path findNearestRoot(Path filePath, List targetFileNames) {
		Path file = filePath.toAbsolutePath().normalize();
		Path parent = file.getParent();

		// stop/skip local root dir (user.home)
		while (parent != null && !Settings.getLocalRootDir().equals(parent)) {
			for (String targetFileName : targetFileNames) {
				Path targetFile = parent.resolve(targetFileName);
				if (Files.exists(targetFile)) {
					return targetFile;
				}
			}
			parent = parent.getParent();
		}
		return null;
	}

	static List buildRootMarkers = Arrays.asList("jbang.build", "pom.xml", "build.gradle", ".jbang",
			".project");
	static List editorRootMarkers = Arrays.asList(".vscode", ".idea", ".eclipse");

	static Path safeParent(Path p) {
		if (!p.isAbsolute()) {
			p = p.toAbsolutePath();
		}
		return p.getParent();
	}

	static public Path locateProjectDir(Path location) {
		if (!Files.isDirectory(location)) {
			// peek into file and find package statement - then start searching from that
			// root instead.
			try {
				String pkg = Util.getSourcePackage(Util.readString(location)).orElse("");
				if (!"".equals(pkg)) { // if package found try resolve matching parent dirs
					String parentPath = pkg.replace(".", "/");
					if (safeParent(location).endsWith(parentPath)) {
						String relativeParent = String.join("/", Collections.nCopies(pkg.indexOf(".") + 1, ".."));
						location = safeParent(location).resolve(relativeParent);
					} else {
						location = safeParent(location);
					}
				} else {
					location = safeParent(location);
				}
			} catch (IOException e) {
				Util.verboseMsg("Could not read package from " + location, e);
				// ignore
			}
		}
		// once we have a initial root dir to search from based on package or dir.
		// Look for first level project markers by finding editor metadata
		Path nearestRoot = findNearestRoot(location, editorRootMarkers);
		if (nearestRoot == null) {
			// if no edit location found try build projects
			nearestRoot = findNearestRoot(location, buildRootMarkers);
		}
		if (nearestRoot != null) {
			Util.verboseMsg("Found project root for edit: " + nearestRoot);
			location = safeParent(nearestRoot);
		}
		return location.normalize();
	}

	@Override
	public Integer doCall() throws IOException {

		// force download sources when editing
		Util.setDownloadSources(true);

		if (!sandbox) {
			File location;
			if (scriptMixin.scriptOrFile != null) {
				location = new File(scriptMixin.scriptOrFile);
			} else {
				location = null;
			}
			info("Assuming your editor have JBang support installed. See https://jbang.dev/ide");
			info("If you prefer to open in a sandbox run with `jbang edit -b` instead.");
			Path path = null;
			if (location == null) {
				path = locateProjectDir(Paths.get("."));
			} else {
				path = locateProjectDir(location.toPath());
			}
			if (path != null && ((location != null) && !path.equals(location.toPath()))) {
				additionalFiles.add(0, pathToString(location.toPath()));
			}

			if (!noOpen) {
				openEditor(pathToString(path), additionalFiles);
			}
			System.out.println(path);
		} else {
			scriptMixin.validate(false);
			File location = new File(scriptMixin.scriptOrFile);
			info("Creating sandbox for script editing " + location);
			ProjectBuilder pb = createProjectBuilder();
			final Project prj = pb.build(scriptMixin.scriptOrFile);

			if (prj.isJar() || prj.getMainSourceSet().getSources().isEmpty()) {
				throw new ExitException(EXIT_INVALID_INPUT, "You can only edit source files");
			}

			Path project = createProjectForLinkedEdit(prj, Collections.emptyList(), false);
			String projectPathString = pathToString(project.toAbsolutePath());
			// err.println(project.getAbsolutePath());

			if (!noOpen) {
				openEditor(projectPathString, additionalFiles);
			}

			if (!live) {
				out.println(projectPathString); // quit(project.getAbsolutePath());
			} else {
				Path orginalFile = prj.getResourceRef().getFile();
				if (!Files.exists(orginalFile)) {
					throw new ExitException(EXIT_UNEXPECTED_STATE,
							"Cannot live edit " + prj.getResourceRef().getOriginalResource());
				}
				watchForChanges(orginalFile, () -> {
					// TODO only regenerate when dependencies or file/resource refs changes.
					info("Regenerating project.");
					try {
						ProjectBuilder pblive = createProjectBuilder();
						Project prjlive = pblive.build(scriptMixin.scriptOrFile);
						createProjectForLinkedEdit(prjlive, Collections.emptyList(), true);
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
					return null;
				});
			}
		}
		return EXIT_OK;
	}

	private void watchForChanges(Path orginalFile, Callable