1 /*
2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.internal.jshell.tool;
27
28 import java.io.InputStream;
29 import java.io.PrintStream;
30 import java.util.Locale;
31 import java.util.Map;
32 import java.util.Objects;
33 import java.util.Set;
34 import java.util.prefs.BackingStoreException;
35 import java.util.prefs.Preferences;
36 import jdk.jshell.tool.JavaShellToolBuilder;
37
38 /**
39 * Builder for programmatically building the jshell tool.
40 */
41 public class JShellToolBuilder implements JavaShellToolBuilder {
42
43 private static final String PREFERENCES_NODE = "tool/JShell";
44 private InputStream cmdIn = System.in;
45 private InputStream userIn = null;
46 private PrintStream cmdOut = System.out;
47 private PrintStream console = System.out;
48 private PrintStream userOut = System.out;
49 private PrintStream cmdErr = System.err;
50 private PrintStream userErr = System.err;
51 private PersistentStorage prefs = null;
52 private Map<String, String> vars = null;
53 private Locale locale = Locale.getDefault();
54 private boolean capturePrompt = false;
55
56 /**
57 * Set the input channels.
58 * Default, if not set, {@code in(System.in, null)}.
59 *
60 * @param cmdIn source of command input
61 * @param userIn source of input for running user code, or {@code null} to
62 * be extracted from cmdIn
63 * @return the {@code JavaShellToolBuilder} instance
64 */
65 @Override
66 public JavaShellToolBuilder in(InputStream cmdIn, InputStream userIn) {
67 this.cmdIn = cmdIn;
68 this.userIn = userIn;
69 return this;
70 }
71
72 /**
73 * Set the output channels. Same as {@code out(output, output, output)}.
74 * Default, if not set, {@code out(System.out)}.
75 *
76 * @param output destination of command feedback, console interaction, and
77 * user code output
78 * @return the {@code JavaShellToolBuilder} instance
79 */
80 @Override
81 public JavaShellToolBuilder out(PrintStream output) {
82 this.cmdOut = output;
83 this.console = output;
84 this.userOut = output;
85 return this;
86 }
87
88 /**
89 * Set the output channels.
90 * Default, if not set, {@code out(System.out, System.out, System.out)}.
91 *
92 * @param cmdOut destination of command feedback including error messages
93 * for users
94 * @param console destination of console interaction
95 * @param userOut destination of user code output. For example, user snippet
96 * {@code System.out.println("Hello")} when executed {@code Hello} goes to
97 * userOut.
98 * @return the {@code JavaShellToolBuilder} instance
99 */
100 @Override
101 public JavaShellToolBuilder out(PrintStream cmdOut, PrintStream console, PrintStream userOut) {
102 this.cmdOut = cmdOut;
103 this.console = console;
104 this.userOut = userOut;
105 return this;
106 }
107
108 /**
109 * Set the error channels. Same as {@code err(error, error)}.
110 * Default, if not set, {@code err(System.err)}.
111 *
112 * @param error destination of tool errors, and
113 * user code errors
114 * @return the {@code JavaShellToolBuilder} instance
115 */
116 @Override
117 public JavaShellToolBuilder err(PrintStream error) {
118 this.cmdErr = error;
119 this.userErr = error;
120 return this;
121 }
122
123 /**
124 * Set the error channels.
125 * Default, if not set, {@code err(System.err, System.err, System.err)}.
126 *
127 * @param cmdErr destination of tool start-up and fatal errors
128 * @param userErr destination of user code error output.
129 * For example, user snippet {@code System.err.println("Oops")}
130 * when executed {@code Oops} goes to userErr.
131 * @return the {@code JavaShellToolBuilder} instance
132 */
133 @Override
134 public JavaShellToolBuilder err(PrintStream cmdErr, PrintStream userErr) {
135 this.cmdErr = cmdErr;
136 this.userErr = userErr;
137 return this;
138 }
139
140 /**
141 * Set the storage mechanism for persistent information which includes
142 * input history and retained settings. Default if not set is the
143 * tool's standard persistence mechanism.
144 *
145 * @param prefs an instance of {@link java.util.prefs.Preferences} that
146 * is used to retrieve and store persistent information
147 * @return the {@code JavaShellToolBuilder} instance
148 */
149 @Override
150 public JavaShellToolBuilder persistence(Preferences prefs) {
151 this.prefs = new PreferencesStorage(prefs);
152 return this;
153 }
154
155 /**
156 * Set the storage mechanism for persistent information which includes
157 * input history and retained settings. Default if not set is the
158 * tool's standard persistence mechanism.
159 *
160 * @param prefsMap an instance of {@link java.util.Map} that
161 * is used to retrieve and store persistent information
162 * @return the {@code JavaShellToolBuilder} instance
163 */
164 @Override
165 public JavaShellToolBuilder persistence(Map<String, String> prefsMap) {
166 this.prefs = new MapStorage(prefsMap);
167 return this;
168 }
169
170 /**
171 * Set the source for environment variables.
172 * Default, if not set, {@code env(System.getenv())}.
173 *
174 * @param vars the Map of environment variable names to values
175 * @return the {@code JavaShellToolBuilder} instance
176 */
177 @Override
178 public JavaShellToolBuilder env(Map<String, String> vars) {
179 this.vars = vars;
180 return this;
181 }
182
183 /**
184 * Set the locale.
185 * Default, if not set, {@code locale(Locale.getDefault())}.
186 *
187 * @param locale the locale
188 * @return the {@code JavaShellToolBuilder} instance
189 */
190 @Override
191 public JavaShellToolBuilder locale(Locale locale) {
192 this.locale = locale;
193 return this;
194 }
195
196 /**
197 * Set if the special command capturing prompt override should be used.
198 * Default, if not set, {@code promptCapture(false)}.
199 *
200 * @param capture if {@code true}, basic prompt is the {@code ENQ}
201 * character and continuation prompt is the {@code ACK} character.
202 * If false, prompts are as set with set-up or user {@code /set} commands.
203 * @return the {@code JavaShellToolBuilder} instance
204 */
205 @Override
206 public JavaShellToolBuilder promptCapture(boolean capture) {
207 this.capturePrompt = capture;
208 return this;
209 }
210
211 /**
212 * Create a tool instance for testing. Not in JavaShellToolBuilder.
213 *
214 * @return the tool instance
215 */
216 public JShellTool rawTool() {
217 if (prefs == null) {
218 prefs = new PreferencesStorage(Preferences.userRoot().node(PREFERENCES_NODE));
219 }
220 if (vars == null) {
221 vars = System.getenv();
222 }
223 JShellTool sh = new JShellTool(cmdIn, cmdOut, cmdErr, console, userIn,
224 userOut, userErr, prefs, vars, locale);
225 sh.testPrompt = capturePrompt;
226 return sh;
227 }
228
229 /**
230 * Run an instance of the Java shell tool as configured by the other methods
231 * in this interface. This call is not destructive, more than one call of
232 * this method may be made from a configured builder.
233 *
234 * @param arguments the command-line arguments (including options), if any
235 * @throws Exception an unexpected fatal exception
236 */
237 @Override
238 public void run(String... arguments) throws Exception {
239 rawTool().start(arguments);
240 }
241
242 /**
243 * Persistence stored in Preferences.
244 */
245 private static class PreferencesStorage implements PersistentStorage {
246
247 final Preferences p;
248
249 PreferencesStorage(Preferences p) {
250 this.p = p;
251 }
252
253 @Override
254 public void clear() {
255 try {
256 p.clear();
257 } catch (BackingStoreException ex) {
258 throw new IllegalStateException(ex);
259 }
260 }
261
262 @Override
263 public String[] keys() {
264 try {
265 return p.keys();
266 } catch (BackingStoreException ex) {
267 throw new IllegalStateException(ex);
268 }
269 }
270
271 @Override
272 public String get(String key) {
273 return p.get(key, null);
274 }
275
276 @Override
277 public void put(String key, String value) {
278 p.put(key, value);
279 }
280
281 @Override
282 public void remove(String key) {
283 p.remove(key);
284 }
285
286 @Override
287 public void flush() {
288 try {
289 p.flush();
290 } catch (BackingStoreException ex) {
291 throw new IllegalStateException(ex);
292 }
293 }
294 }
295
296 /**
297 * Persistence stored in a Map.
298 */
299 private static class MapStorage implements PersistentStorage {
300
301 final Map<String, String> map;
302
303 MapStorage(Map<String, String> map) {
304 this.map = map;
305 }
306
307 @Override
308 public void clear() {
309
310 try {
311 map.clear();
312 } catch (UnsupportedOperationException ex) {
313 throw new IllegalStateException(ex);
314 }
315 }
316
317 @Override
318 public String[] keys() {
319 Set<String> ks = map.keySet();
320 return ks.toArray(new String[ks.size()]);
321 }
322
323 @Override
324 public String get(String key) {
325 Objects.requireNonNull(key);
326 return map.get(key);
327 }
328
329 @Override
330 public void put(String key, String value) {
331 Objects.requireNonNull(key);
332 Objects.requireNonNull(value);
333 map.put(key, value);
334 }
335
336 @Override
337 public void remove(String key) {
338 Objects.requireNonNull(key);
339 map.remove(key);
340 }
341
342 @Override
343 public void flush() {
344 // no-op always up-to-date
345 }
346 }
347
348 }