Java Groovysh类代码示例

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Test
public void shouldPluginSugar() throws Exception {
    MetaRegistryUtil.clearRegistry(new HashSet<>(Arrays.asList(TinkerGraph.class)));

    final SugarGremlinPlugin plugin = new SugarGremlinPlugin();

    final Groovysh groovysh = new Groovysh();

    final Map<String, Object> env = new HashMap<>();
    env.put("ConsolePluginAcceptor.io", new IO());
    env.put("ConsolePluginAcceptor.shell", groovysh);

    final SpyPluginAcceptor spy = new SpyPluginAcceptor(groovysh::execute, () -> env);
    plugin.pluginTo(spy);

    groovysh.getInterp().getContext().setProperty("g", TinkerFactory.createClassic());
    assertEquals(6l, ((GraphTraversal) groovysh.execute("g.traversal().V()")).count().next());
    assertEquals(6l, ((GraphTraversal) groovysh.execute("g.traversal().V")).count().next());
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
private Groovysh createShell() {
    final Groovysh shell = getGroovysh();

    // Add a hook to display some status when shutting down...
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        //
        // FIXME: We need to configure JLine to catch CTRL-C for us... Use gshell-io's InputPipe
        //

        if (shell.getHistory() != null) {
            try {
                shell.getHistory().flush();
            } catch (IOException e) {
                System.out.println("Could not flush history.");
            }
        }
    }));

    shell.register(new GetAuthsCommand(shell));
    shell.register(new SetAuthsCommand(shell));
    shell.register(new GetTimeCommand(shell));
    shell.register(new SetTimeCommand(shell));
    shell.register(new NowCommand(shell));
    return shell;
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "serial"})
private void loadDefaultScripts(final Groovysh shell) {
	if (!defaultScripts.isEmpty()) {
		Closure<Groovysh> defaultResultHook = shell.getResultHook();

		try {
			// Set a "no-op closure so we don't get per-line value output when evaluating the default script
			shell.setResultHook(new Closure<Groovysh>(this) {
				@Override
				public Groovysh call(Object... args) {
					return shell;
				}
			});

			org.codehaus.groovy.tools.shell.Command cmd = shell.getRegistry().find("load");
			for (String script : defaultScripts) {
				cmd.execute(asList(script));
			}
		} finally {
			// Restoring original result hook
			shell.setResultHook(defaultResultHook);
		}
	}
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Test
public void shouldPluginUtilities() throws Exception {
    final UtilitiesGremlinPlugin plugin = new UtilitiesGremlinPlugin();

    final Groovysh groovysh = new Groovysh();
    groovysh.getInterp().getContext().setProperty("g", TinkerFactory.createClassic());

    final Map<String, Object> env = new HashMap<>();
    env.put("ConsolePluginAcceptor.io", new IO());
    env.put("ConsolePluginAcceptor.shell", groovysh);

    final SpyPluginAcceptor spy = new SpyPluginAcceptor(groovysh::execute, () -> env);
    plugin.pluginTo(spy);

    assertThat(groovysh.execute("describeGraph(org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph)").toString(), containsString("IMPLEMENTATION - org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph"));
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * <p/>
 * Provides a base implementation for plugins by grabbing the console environment variables and assigning them
 * to the {@link #io} and {@link #shell} member variables.
 *
 * @throws IllegalEnvironmentException if {@link #requireConsoleEnvironment} is set to true and if either
 *                                     the {@link #io} and {@link #shell} member variables are null.
 */
@Override
public void pluginTo(final PluginAcceptor pluginAcceptor) throws IllegalEnvironmentException, PluginInitializationException {
    final Map<String, Object> environment = pluginAcceptor.environment();
    io = (IO) environment.get(ENV_CONSOLE_IO);
    shell = (Groovysh) environment.get(ENV_CONSOLE_SHELL);

    if (requireConsoleEnvironment && (null == io || null == shell))
        throw new IllegalEnvironmentException(this, ENV_CONSOLE_SHELL, ENV_CONSOLE_IO);

    try {
        afterPluginTo(pluginAcceptor);
    } catch (PluginInitializationException pie) {
        throw pie;
    } catch (Exception ex) {
        throw new PluginInitializationException(ex);
    }
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
/**
 * Interpret file content in given shell.
 *
 * @param script Script file that should be interpreted
 * @param shell Shell where the script should be interpreted
 * @throws IOException
 */
private static void interpretFileContent(File script, Groovysh shell) throws IOException {
  BufferedReader in = new BufferedReader(new FileReader(script));
  String line;

  // Iterate over all lines and executed them one by one
  while ((line = in.readLine()) != null) {

    // Skip comments and empty lines as we don't need to interpret those
    if(line.isEmpty() || line.startsWith("#")) {
      continue;
    }

    // Render shell and command to get user perception that it was run as usual
    print(shell.renderPrompt());
    println(line);

    // Manually trigger command line parsing
    Object result = shell.execute(line);

    if (result == null) {
      break;
    }
  }
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
public GroovyInterpreter(Binding binding) throws IOException {
	this.binding = binding;
	if (this.binding == null)
		this.binding = new Binding();

	is = new PipedInputStream();
	os = new PipedOutputStream();
	pis = new PipedInputStream(os);
	pos = new PipedOutputStream(is);

	System.setProperty(TerminalFactory.JLINE_TERMINAL, "none");
	AnsiConsole.systemInstall();
	Ansi.setDetector(new AnsiDetector());

	binding.setProperty("out", new ImmediateFlushingPrintWriter(pos));

	shell = new Groovysh(binding, new IO(pis, pos, pos));
	// {
	// @Override
	// public void displayWelcomeBanner(InteractiveShellRunner runner) {
	// // do nothing
	// }
	// };
	shell.getIo().setVerbosity(Verbosity.QUIET);
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
protected AdminHelpCommand(Groovysh shell) {
	super(shell, "adminhelp", "\\ah");  //$NON-NLS-1$ //$NON-NLS-2$
	
	//hook to introduce default imports
	final String[] imports = GroovyAdminConsole.IMPORTS.split("\n"); //$NON-NLS-1$
	for(String aimport : imports){
		shell.execute(aimport);
	}
	//for backwards compatibility add aliases to 1.7 Groovy commands
	for (Command cmd :new ArrayList<Command>(shell.getRegistry().commands())) {
		if (cmd.getHidden()) {
			continue;
		}
		String name = cmd.getName();
		if (name.startsWith(":")) { //$NON-NLS-1$
			shell.execute(":alias " + name.substring(1) + " " + name); //$NON-NLS-1$ //$NON-NLS-2$
			String shortCut = cmd.getShortcut();
			if (shortCut.startsWith(":")) { //$NON-NLS-1$
				shell.execute(":alias \\" + shortCut.substring(1) + " " + name); //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
	}
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
private void initializeShellWithScript(final IO io, final String initScriptFile, final Groovysh groovy) {
    if (initScriptFile != null) {
        String line = "";
        try {
            final BufferedReader reader = new BufferedReader(new InputStreamReader(
                    new FileInputStream(initScriptFile), Charset.forName("UTF-8")));
            while ((line = reader.readLine()) != null) {
                groovy.execute(line);
            }

            reader.close();
        } catch (FileNotFoundException fnfe) {
            io.err.println(String.format("Gremlin initialization file not found at [%s].", initScriptFile));
            System.exit(1);
        } catch (IOException ioe) {
            io.err.println(String.format("Bad line in Gremlin initialization file at [%s].", line));
            System.exit(1);
        }
    }
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
/**
 * ִ�нű��ļ�
 * @param script
 * @param shell
 * @throws IOException
 */
private static void interpretFileContent(File script, Groovysh shell) throws IOException {
	BufferedReader in = new BufferedReader(new FileReader(script));
	String line;
	// Iterate over all lines and executed them one by one
	while ((line = in.readLine()) != null) {

		// Skip comments and empty lines as we don't need to interpret those
		if (line.isEmpty() || line.startsWith("#")) {
			continue;
		}
		// Render shell and command to get user perception that it was run
		// as usual
		ShellEnvironment.print(shell.renderPrompt());
		ShellEnvironment.println(line);
		// Manually trigger command line parsing
		Object result = shell.execute(line);
		if (result != null) {
			ShellEnvironment.println(result);
		}
	}
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
private void setGroovyShell(Groovysh groovysh, GroovyShell groovyShell) throws NoSuchFieldException, IllegalAccessException {
    Field interpField = groovysh.getClass().getDeclaredField("interp");
    interpField.setAccessible(true);

    Field shellField = Interpreter.class.getDeclaredField("shell");
    shellField.setAccessible(true);

    Interpreter interpreter = (Interpreter) interpField.get(groovysh);
    shellField.set(interpreter, groovyShell);
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Test
public void shouldFailWithoutUtilitiesPlugin() throws Exception {
    final Groovysh groovysh = new Groovysh();
    try {
        groovysh.execute("describeGraph(g.class)");
        fail("Utilities were not loaded - this should fail.");
    } catch (Exception ignored) {
    }
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Test
public void shouldConstructRemoteAcceptorWhenInConsoleEnvironment() throws Exception {
    final DriverGremlinPlugin plugin = new DriverGremlinPlugin();
    final Map<String, Object> env = new HashMap<>();
    env.put("ConsolePluginAcceptor.io", new IO());
    env.put("ConsolePluginAcceptor.shell", new Groovysh());
    final SpyPluginAcceptor spy = new SpyPluginAcceptor(() -> env);
    plugin.pluginTo(spy);

    assertThat(plugin.remoteAcceptor().isPresent(), is(true));
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Test
public void shouldPluginUtilities() throws Exception {
    final UtilitiesGremlinPlugin plugin = new UtilitiesGremlinPlugin();

    final Groovysh groovysh = new Groovysh();
    groovysh.getInterp().getContext().setProperty("g", TinkerFactory.createClassic());

    final PluggedIn pluggedIn = new PluggedIn(plugin, groovysh, io, false);
    pluggedIn.activate();

    assertThat(groovysh.execute("describeGraph(org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph)").toString(), containsString("IMPLEMENTATION - org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph"));
}
 

import org.codehaus.groovy.tools.shell.Groovysh; //导入依赖的package包/类
@Override
public void pluginTo(final PluginAcceptor pluginAcceptor) {
	pluginAcceptor.addImports(IMPORTS);
	final Groovysh groovy = (Groovysh) pluginAcceptor.environment().get("ConsolePluginAcceptor.shell");
	final IO io = (IO) pluginAcceptor.environment().get("ConsolePluginAcceptor.io");      
	groovy.register(new Bio4jCommand(groovy, io));
}