27 | * Every implementation of the Java platform is required to support the following character encodings. Consult the 28 | * release documentation for your implementation to see if any other encodings are supported. Consult the release 29 | * documentation for your implementation to see if any other encodings are supported. 30 | *
31 | * 32 | *US-ASCIIISO-8859-1UTF-8UTF-16BEUTF-16LEUTF-1672 | * Every implementation of the Java platform is required to support this character encoding. 73 | *
74 | * 75 | * @see Standard charsets 76 | */ 77 | public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1"); 78 | 79 | /** 80 | *81 | * Seven-bit ASCII, also known as ISO646-US, also known as the Basic Latin block of the Unicode character set. 82 | *
83 | *84 | * Every implementation of the Java platform is required to support this character encoding. 85 | *
86 | * 87 | * @see Standard charsets 88 | */ 89 | public static final Charset US_ASCII = Charset.forName("US-ASCII"); 90 | 91 | /** 92 | *93 | * Sixteen-bit Unicode Transformation Format, The byte order specified by a mandatory initial byte-order mark 94 | * (either order accepted on input, big-endian used on output) 95 | *
96 | *97 | * Every implementation of the Java platform is required to support this character encoding. 98 | *
99 | * 100 | * @see Standard charsets 101 | */ 102 | public static final Charset UTF_16 = Charset.forName("UTF-16"); 103 | 104 | /** 105 | *106 | * Sixteen-bit Unicode Transformation Format, big-endian byte order. 107 | *
108 | *109 | * Every implementation of the Java platform is required to support this character encoding. 110 | *
111 | * 112 | * @see Standard charsets 113 | */ 114 | public static final Charset UTF_16BE = Charset.forName("UTF-16BE"); 115 | 116 | /** 117 | *118 | * Sixteen-bit Unicode Transformation Format, little-endian byte order. 119 | *
120 | *121 | * Every implementation of the Java platform is required to support this character encoding. 122 | *
123 | * 124 | * @see Standard charsets 125 | */ 126 | public static final Charset UTF_16LE = Charset.forName("UTF-16LE"); 127 | 128 | /** 129 | *130 | * Eight-bit Unicode Transformation Format. 131 | *
132 | *133 | * Every implementation of the Java platform is required to support this character encoding. 134 | *
135 | * 136 | * @see Standard charsets 137 | */ 138 | public static final Charset UTF_8 = Charset.forName("UTF-8"); 139 | } 140 | -------------------------------------------------------------------------------- /src/java/com/jgithack/io/FileUtils.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Licensed to the Apache Software Foundation (ASF) under one or more 3 | * contributor license agreements. See the NOTICE file distributed with 4 | * this work for additional information regarding copyright ownership. 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 6 | * (the "License"); you may not use this file except in compliance with 7 | * the License. You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | package com.jgithack.io; 18 | 19 | import java.io.File; 20 | import java.io.FileInputStream; 21 | import java.io.FileNotFoundException; 22 | import java.io.FileOutputStream; 23 | import java.io.IOException; 24 | import java.io.InputStream; 25 | import java.io.OutputStream; 26 | import java.nio.charset.Charset; 27 | import java.util.List; 28 | 29 | /** 30 | * General file manipulation utilities. 31 | *32 | * Facilities are provided in the following areas: 33 | *
46 | * Origin of code: Excalibur, Alexandria, Commons-Utils
47 | *
48 | * @version $Id: FileUtils.java 1349509 2012-06-12 20:39:23Z ggregory $
49 | */
50 | public class FileUtils {
51 | //-----------------------------------------------------------------------
52 | /**
53 | * Opens a {@link FileInputStream} for the specified file, providing better
54 | * error messages than simply calling new FileInputStream(file).
55 | *
56 | * At the end of the method either the stream will be successfully opened, 57 | * or an exception will have been thrown. 58 | *
59 | * An exception is thrown if the file does not exist. 60 | * An exception is thrown if the file object exists but is a directory. 61 | * An exception is thrown if the file exists but cannot be read. 62 | * 63 | * @param file the file to open for input, must not be {@code null} 64 | * @return a new {@link FileInputStream} for the specified file 65 | * @throws FileNotFoundException if the file does not exist 66 | * @throws IOException if the file object is a directory 67 | * @throws IOException if the file cannot be read 68 | * @since 1.3 69 | */ 70 | public static FileInputStream openInputStream(File file) throws IOException { 71 | if (file.exists()) { 72 | if (file.isDirectory()) { 73 | throw new IOException("File '" + file + "' exists but is a directory"); 74 | } 75 | if (file.canRead() == false) { 76 | throw new IOException("File '" + file + "' cannot be read"); 77 | } 78 | } else { 79 | throw new FileNotFoundException("File '" + file + "' does not exist"); 80 | } 81 | return new FileInputStream(file); 82 | } 83 | 84 | /** 85 | * Opens a {@link FileOutputStream} for the specified file, checking and 86 | * creating the parent directory if it does not exist. 87 | *
88 | * At the end of the method either the stream will be successfully opened, 89 | * or an exception will have been thrown. 90 | *
91 | * The parent directory will be created if it does not exist.
92 | * The file will be created if it does not exist.
93 | * An exception is thrown if the file object exists but is a directory.
94 | * An exception is thrown if the file exists but cannot be written to.
95 | * An exception is thrown if the parent directory cannot be created.
96 | *
97 | * @param file the file to open for output, must not be {@code null}
98 | * @param append if {@code true}, then bytes will be added to the
99 | * end of the file rather than overwriting
100 | * @return a new {@link FileOutputStream} for the specified file
101 | * @throws IOException if the file object is a directory
102 | * @throws IOException if the file cannot be written to
103 | * @throws IOException if a parent directory needs creating but that fails
104 | * @since 2.1
105 | */
106 | public static FileOutputStream openOutputStream(File file, boolean append) throws IOException {
107 | if (file.exists()) {
108 | if (file.isDirectory()) {
109 | throw new IOException("File '" + file + "' exists but is a directory");
110 | }
111 | if (file.canWrite() == false) {
112 | throw new IOException("File '" + file + "' cannot be written to");
113 | }
114 | } else {
115 | File parent = file.getParentFile();
116 | if (parent != null) {
117 | if (!parent.mkdirs() && !parent.isDirectory()) {
118 | throw new IOException("Directory '" + parent + "' could not be created");
119 | }
120 | }
121 | }
122 | return new FileOutputStream(file, append);
123 | }
124 |
125 | //-----------------------------------------------------------------------
126 | /**
127 | * Reads the contents of a file into a String.
128 | * The file is always closed.
129 | *
130 | * @param file the file to read, must not be {@code null}
131 | * @param encoding the encoding to use, {@code null} means platform default
132 | * @return the file contents, never {@code null}
133 | * @throws IOException in case of an I/O error
134 | * @since 2.3
135 | */
136 | public static String readFileToString(File file, Charset encoding) throws IOException {
137 | InputStream in = null;
138 | try {
139 | in = openInputStream(file);
140 | return IOUtils.toString(in, Charsets.toCharset(encoding));
141 | } finally {
142 | IOUtils.closeQuietly(in);
143 | }
144 | }
145 |
146 | /**
147 | * Reads the contents of a file into a String using the default encoding for the VM.
148 | * The file is always closed.
149 | *
150 | * @param file the file to read, must not be {@code null}
151 | * @return the file contents, never {@code null}
152 | * @throws IOException in case of an I/O error
153 | * @since 1.3.1
154 | */
155 | public static String readFileToString(File file) throws IOException {
156 | return readFileToString(file, Charset.defaultCharset());
157 | }
158 |
159 | /**
160 | * Reads the contents of a file into a byte array.
161 | * The file is always closed.
162 | *
163 | * @param file the file to read, must not be {@code null}
164 | * @return the file contents, never {@code null}
165 | * @throws IOException in case of an I/O error
166 | * @since 1.1
167 | */
168 | public static byte[] readFileToByteArray(File file) throws IOException {
169 | InputStream in = null;
170 | try {
171 | in = openInputStream(file);
172 | return IOUtils.toByteArray(in, file.length());
173 | } finally {
174 | IOUtils.closeQuietly(in);
175 | }
176 | }
177 |
178 | /**
179 | * Reads the contents of a file line by line to a List of Strings.
180 | * The file is always closed.
181 | *
182 | * @param file the file to read, must not be {@code null}
183 | * @param encoding the encoding to use, {@code null} means platform default
184 | * @return the list of Strings representing each line in the file, never {@code null}
185 | * @throws IOException in case of an I/O error
186 | * @since 2.3
187 | */
188 | public static List
34 | * This class provides static utility methods for input/output operations.
35 | *
43 | * The byte-to-char methods and char-to-byte methods involve a conversion step.
44 | * Two methods are provided in each case, one that uses the platform default
45 | * encoding and the other which allows you to specify an encoding. You are
46 | * encouraged to always specify an encoding because relying on the platform
47 | * default can lead to unexpected results, for example when moving from
48 | * development to production.
49 | *
50 | * All the methods in this class that read a stream are buffered internally.
51 | * This means that there is no cause to use a
55 | * Wherever possible, the methods in this class do not flush or close
56 | * the stream. This is to avoid making non-portable assumptions about the
57 | * streams' origin and further use. Thus the caller is still responsible for
58 | * closing streams after use.
59 | *
60 | * Origin of code: Excalibur.
61 | *
62 | * @version $Id: IOUtils.java 1326636 2012-04-16 14:54:53Z ggregory $
63 | */
64 | public class IOUtils {
65 | // NOTE: This class is focussed on InputStream, OutputStream, Reader and
66 | // Writer. Each method should take at least one of these as a parameter,
67 | // or return one of them.
68 |
69 | private static final int EOF = -1;
70 |
71 | /**
72 | * The default buffer size ({@value}) to use for
73 | * {@link #copyLarge(InputStream, OutputStream)}
74 | * and
75 | * {@link #copyLarge(Reader, Writer)}
76 | */
77 | private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
78 |
79 | /**
80 | * Unconditionally close an
82 | * Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
83 | * This is typically used in finally blocks.
84 | *
85 | * Example code:
86 | *
109 | * Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
110 | * This is typically used in finally blocks.
111 | *
112 | * Example code:
113 | *
137 | * Equivalent to {@link Closeable#close()}, except any exceptions will be ignored.
138 | * This is typically used in finally blocks.
139 | *
140 | * Example code:
141 | *
248 | * This method buffers the input internally, so there is no need to use a
249 | *
268 | * This method buffers the input internally, so there is no need to use a
269 | *
287 | * This method buffers the input internally, so there is no need to use a
288 | *
311 | * This method uses {@link String#getBytes(String)}.
312 | *
313 | * @param data the
330 | * This method buffers the input internally, so there is no need to use a
331 | *
333 | * This method uses {@link InputStreamReader}.
334 | *
335 | * @param input the
352 | * This method buffers the input internally, so there is no need to use a
353 | *
355 | * Large streams (over 2GB) will return a chars copied value of
356 | *
378 | * This method buffers the input internally, so there is no need to use a
379 | *
381 | * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
382 | *
383 | * @param input the
397 | * This method uses the provided buffer, so there is no need to use a
398 | *
400 | *
401 | * @param input the
25 | * NOTE: This implementation, as an alternative to
26 | * Checks if a CharSequence is empty ("") or null. NOTE: This method changed in Lang version 2.0.
47 | * It no longer trims the CharSequence.
48 | * That functionality is available in isBlank(). Checks if a CharSequence is not empty ("") and not null. Checks if a CharSequence is whitespace, empty ("") or null. Checks if a CharSequence is not empty (""), not null and not whitespace only. Removes control characters (char <= 32) from both
131 | * ends of this String, handling {@code null} by returning
132 | * {@code null}. The String is trimmed using {@link String#trim()}.
135 | * Trim removes start and end characters <= 32.
136 | * To strip whitespace use {@link #strip(String)}. To trim your choice of characters, use the
139 | * {@link #strip(String, String)} methods. Removes control characters (char <= 32) from both
158 | * ends of this String returning {@code null} if the String is
159 | * empty ("") after the trim or if it is {@code null}.
160 | *
161 | * The String is trimmed using {@link String#trim()}.
162 | * Trim removes start and end characters <= 32.
163 | * To strip whitespace use {@link #stripToNull(String)}. Removes control characters (char <= 32) from both
185 | * ends of this String returning an empty String ("") if the String
186 | * is empty ("") after the trim or if it is {@code null}.
187 | *
188 | * The String is trimmed using {@link String#trim()}.
189 | * Trim removes start and end characters <= 32.
190 | * To strip whitespace use {@link #stripToEmpty(String)}.
36 | *
42 | * BufferedInputStream
52 | * or BufferedReader. The default buffer size of 4K has been shown
53 | * to be efficient in tests.
54 | * InputStream.
81 | *
87 | * byte[] data = new byte[1024];
88 | * InputStream in = null;
89 | * try {
90 | * in = new FileInputStream("foo.txt");
91 | * in.read(data);
92 | * in.close(); //close errors are handled
93 | * } catch (Exception e) {
94 | * // error handling
95 | * } finally {
96 | * IOUtils.closeQuietly(in);
97 | * }
98 | *
99 | *
100 | * @param input the InputStream to close, may be null or already closed
101 | */
102 | public static void closeQuietly(InputStream input) {
103 | closeQuietly((Closeable) input);
104 | }
105 |
106 | /**
107 | * Unconditionally close an OutputStream.
108 | *
114 | * byte[] data = "Hello, World".getBytes();
115 | *
116 | * OutputStream out = null;
117 | * try {
118 | * out = new FileOutputStream("foo.txt");
119 | * out.write(data);
120 | * out.close(); //close errors are handled
121 | * } catch (IOException e) {
122 | * // error handling
123 | * } finally {
124 | * IOUtils.closeQuietly(out);
125 | * }
126 | *
127 | *
128 | * @param output the OutputStream to close, may be null or already closed
129 | */
130 | public static void closeQuietly(OutputStream output) {
131 | closeQuietly((Closeable) output);
132 | }
133 |
134 | /**
135 | * Unconditionally close a Closeable.
136 | *
142 | * Closeable closeable = null;
143 | * try {
144 | * closeable = new FileReader("foo.txt");
145 | * // process closeable
146 | * closeable.close();
147 | * } catch (Exception e) {
148 | * // error handling
149 | * } finally {
150 | * IOUtils.closeQuietly(closeable);
151 | * }
152 | *
153 | *
154 | * @param closeable the object to close, may be null or already closed
155 | * @since 2.0
156 | */
157 | public static void closeQuietly(Closeable closeable) {
158 | try {
159 | if (closeable != null) {
160 | closeable.close();
161 | }
162 | } catch (IOException ioe) {
163 | // ignore
164 | }
165 | }
166 |
167 | /**
168 | * Returns the given reader if it is a {@link BufferedReader}, otherwise creates a toBufferedReader for the given
169 | * reader.
170 | *
171 | * @param reader
172 | * the reader to wrap or return
173 | * @return the given reader or a new {@link BufferedReader} for the given reader
174 | * @since 2.2
175 | */
176 | public static BufferedReader toBufferedReader(Reader reader) {
177 | return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(
178 | reader);
179 | }
180 |
181 | /**
182 | * Get contents of an InputStream as a byte[].
183 | * Use this method instead of toByteArray(InputStream)
184 | * when InputStream size is known.
185 | * NOTE: the method checks that the length can safely be cast to an int without truncation
186 | * before using {@link IOUtils#toByteArray(java.io.InputStream, int)} to read into the byte array.
187 | * (Arrays can have no more than Integer.MAX_VALUE entries anyway)
188 | *
189 | * @param input the InputStream to read from
190 | * @param size the size of InputStream
191 | * @return the requested byte array
192 | * @throws IOException if an I/O error occurs or InputStream size differ from parameter size
193 | * @throws IllegalArgumentException if size is less than zero or size is greater than Integer.MAX_VALUE
194 | * @see IOUtils#toByteArray(java.io.InputStream, int)
195 | * @since 2.1
196 | */
197 | public static byte[] toByteArray(InputStream input, long size) throws IOException {
198 |
199 | if (size > Integer.MAX_VALUE) {
200 | throw new IllegalArgumentException("Size cannot be greater than Integer max value: "
201 | + size);
202 | }
203 |
204 | return toByteArray(input, (int) size);
205 | }
206 |
207 | /**
208 | * Get the contents of an InputStream as a byte[].
209 | * Use this method instead of toByteArray(InputStream)
210 | * when InputStream size is known
211 | * @param input the InputStream to read from
212 | * @param size the size of InputStream
213 | * @return the requested byte array
214 | * @throws IOException if an I/O error occurs or InputStream size differ from parameter size
215 | * @throws IllegalArgumentException if size is less than zero
216 | * @since 2.1
217 | */
218 | public static byte[] toByteArray(InputStream input, int size) throws IOException {
219 |
220 | if (size < 0) {
221 | throw new IllegalArgumentException("Size must be equal or greater than zero: " + size);
222 | }
223 |
224 | if (size == 0) {
225 | return new byte[0];
226 | }
227 |
228 | byte[] data = new byte[size];
229 | int offset = 0;
230 | int readed;
231 |
232 | while (offset < size && (readed = input.read(data, offset, size - offset)) != EOF) {
233 | offset += readed;
234 | }
235 |
236 | if (offset != size) {
237 | throw new IOException("Unexpected readed size. current: " + offset + ", excepted: "
238 | + size);
239 | }
240 |
241 | return data;
242 | }
243 |
244 | /**
245 | * Get the contents of an InputStream as a String
246 | * using the specified character encoding.
247 | * BufferedInputStream.
250 | * InputStream to read from
252 | * @param encoding the encoding to use, null means platform default
253 | * @return the requested String
254 | * @throws NullPointerException if the input is null
255 | * @throws IOException if an I/O error occurs
256 | * @since 2.3
257 | */
258 | public static String toString(InputStream input, Charset encoding) throws IOException {
259 | StringBuilderWriter sw = new StringBuilderWriter();
260 | copy(input, sw, encoding);
261 | return sw.toString();
262 | }
263 |
264 | /**
265 | * Get the contents of an InputStream as a list of Strings,
266 | * one entry per line, using the specified character encoding.
267 | * BufferedInputStream.
270 | *
271 | * @param input the InputStream to read from, not null
272 | * @param encoding the encoding to use, null means platform default
273 | * @return the list of Strings, never null
274 | * @throws NullPointerException if the input is null
275 | * @throws IOException if an I/O error occurs
276 | * @since 2.3
277 | */
278 | public static ListReader as a list of Strings,
285 | * one entry per line.
286 | * BufferedReader.
289 | *
290 | * @param input the Reader to read from, not null
291 | * @return the list of Strings, never null
292 | * @throws NullPointerException if the input is null
293 | * @throws IOException if an I/O error occurs
294 | * @since 1.1
295 | */
296 | public static ListString to bytes on an
309 | * OutputStream using the specified character encoding.
310 | * String to write, null ignored
314 | * @param output the OutputStream to write to
315 | * @param encoding the encoding to use, null means platform default
316 | * @throws NullPointerException if output is null
317 | * @throws IOException if an I/O error occurs
318 | * @since 2.3
319 | */
320 | public static void write(String data, OutputStream output, Charset encoding) throws IOException {
321 | if (data != null) {
322 | output.write(data.getBytes(Charsets.toCharset(encoding)));
323 | }
324 | }
325 |
326 | /**
327 | * Copy bytes from an InputStream to chars on a
328 | * Writer using the specified character encoding.
329 | * BufferedInputStream.
332 | * InputStream to read from
336 | * @param output the Writer to write to
337 | * @param encoding the encoding to use, null means platform default
338 | * @throws NullPointerException if the input or output is null
339 | * @throws IOException if an I/O error occurs
340 | * @since 2.3
341 | */
342 | public static void copy(InputStream input, Writer output, Charset encoding) throws IOException {
343 | InputStreamReader in = new InputStreamReader(input, Charsets.toCharset(encoding));
344 | copy(in, output);
345 | }
346 |
347 | // copy from Reader
348 | //-----------------------------------------------------------------------
349 | /**
350 | * Copy chars from a Reader to a Writer.
351 | * BufferedReader.
354 | * -1 after the copy has completed since the correct
357 | * number of chars cannot be returned as an int. For large streams
358 | * use the copyLarge(Reader, Writer) method.
359 | *
360 | * @param input the Reader to read from
361 | * @param output the Writer to write to
362 | * @return the number of characters copied, or -1 if > Integer.MAX_VALUE
363 | * @throws NullPointerException if the input or output is null
364 | * @throws IOException if an I/O error occurs
365 | * @since 1.1
366 | */
367 | public static int copy(Reader input, Writer output) throws IOException {
368 | long count = copyLarge(input, output);
369 | if (count > Integer.MAX_VALUE) {
370 | return -1;
371 | }
372 | return (int) count;
373 | }
374 |
375 | /**
376 | * Copy chars from a large (over 2GB) Reader to a Writer.
377 | * BufferedReader.
380 | * Reader to read from
384 | * @param output the Writer to write to
385 | * @return the number of characters copied
386 | * @throws NullPointerException if the input or output is null
387 | * @throws IOException if an I/O error occurs
388 | * @since 1.3
389 | */
390 | public static long copyLarge(Reader input, Writer output) throws IOException {
391 | return copyLarge(input, output, new char[DEFAULT_BUFFER_SIZE]);
392 | }
393 |
394 | /**
395 | * Copy chars from a large (over 2GB) Reader to a Writer.
396 | * BufferedReader.
399 | * Reader to read from
402 | * @param output the Writer to write to
403 | * @param buffer the buffer to be used for the copy
404 | * @return the number of characters copied
405 | * @throws NullPointerException if the input or output is null
406 | * @throws IOException if an I/O error occurs
407 | * @since 2.2
408 | */
409 | public static long copyLarge(Reader input, Writer output, char[] buffer) throws IOException {
410 | long count = 0;
411 | int n = 0;
412 | while (EOF != (n = input.read(buffer))) {
413 | output.write(buffer, 0, n);
414 | count += n;
415 | }
416 | return count;
417 | }
418 | }
419 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/io/StringBuilderWriter.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 | package com.jgithack.io;
18 |
19 | import java.io.Serializable;
20 | import java.io.Writer;
21 |
22 | /**
23 | * {@link Writer} implementation that outputs to a {@link StringBuilder}.
24 | * java.io.StringWriter, provides an un-synchronized
27 | * (i.e. for use in a single thread) implementation for better performance.
28 | * For safe usage with multiple {@link Thread}s then
29 | * java.io.StringWriter should be used.
30 | *
31 | * @version $Id: StringBuilderWriter.java 1304052 2012-03-22 20:55:29Z ggregory $
32 | * @since 2.0
33 | */
34 | public class StringBuilderWriter extends Writer implements Serializable {
35 | /** serial-number */
36 | private static final long serialVersionUID = 4763830082497156825L;
37 |
38 | private final StringBuilder builder;
39 |
40 | /**
41 | * Construct a new {@link StringBuilder} instance with default capacity.
42 | */
43 | public StringBuilderWriter() {
44 | this.builder = new StringBuilder();
45 | }
46 |
47 | /**
48 | * Construct a new {@link StringBuilder} instance with the specified capacity.
49 | *
50 | * @param capacity The initial capacity of the underlying {@link StringBuilder}
51 | */
52 | public StringBuilderWriter(int capacity) {
53 | this.builder = new StringBuilder(capacity);
54 | }
55 |
56 | /**
57 | * Construct a new instance with the specified {@link StringBuilder}.
58 | *
59 | * @param builder The String builder
60 | */
61 | public StringBuilderWriter(StringBuilder builder) {
62 | this.builder = builder != null ? builder : new StringBuilder();
63 | }
64 |
65 | /**
66 | * Append a single character to this Writer.
67 | *
68 | * @param value The character to append
69 | * @return This writer instance
70 | */
71 | @Override
72 | public Writer append(char value) {
73 | builder.append(value);
74 | return this;
75 | }
76 |
77 | /**
78 | * Append a character sequence to this Writer.
79 | *
80 | * @param value The character to append
81 | * @return This writer instance
82 | */
83 | @Override
84 | public Writer append(CharSequence value) {
85 | builder.append(value);
86 | return this;
87 | }
88 |
89 | /**
90 | * Append a portion of a character sequence to the {@link StringBuilder}.
91 | *
92 | * @param value The character to append
93 | * @param start The index of the first character
94 | * @param end The index of the last character + 1
95 | * @return This writer instance
96 | */
97 | @Override
98 | public Writer append(CharSequence value, int start, int end) {
99 | builder.append(value, start, end);
100 | return this;
101 | }
102 |
103 | /**
104 | * Closing this writer has no effect.
105 | */
106 | @Override
107 | public void close() {
108 | }
109 |
110 | /**
111 | * Flushing this writer has no effect.
112 | */
113 | @Override
114 | public void flush() {
115 | }
116 |
117 | /**
118 | * Write a String to the {@link StringBuilder}.
119 | *
120 | * @param value The value to write
121 | */
122 | @Override
123 | public void write(String value) {
124 | if (value != null) {
125 | builder.append(value);
126 | }
127 | }
128 |
129 | /**
130 | * Write a portion of a character array to the {@link StringBuilder}.
131 | *
132 | * @param value The value to write
133 | * @param offset The index of the first character
134 | * @param length The number of characters to write
135 | */
136 | @Override
137 | public void write(char[] value, int offset, int length) {
138 | if (value != null) {
139 | builder.append(value, offset, length);
140 | }
141 | }
142 |
143 | /**
144 | * Return the underlying builder.
145 | *
146 | * @return The underlying builder
147 | */
148 | public StringBuilder getBuilder() {
149 | return builder;
150 | }
151 |
152 | /**
153 | * Returns {@link StringBuilder#toString()}.
154 | *
155 | * @return The contents of the String builder.
156 | */
157 | @Override
158 | public String toString() {
159 | return builder.toString();
160 | }
161 | }
162 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/lang/StringUtil.java:
--------------------------------------------------------------------------------
1 | /**
2 | * JHack.net
3 | * Copyright (c) 2004-2016 All Rights Reserved.
4 | */
5 | package com.jgithack.lang;
6 |
7 | /**
8 | * StringUtil
9 | *
10 | * @author Albert Wang
11 | * @version $Id: StringUtil.java, V0.1 Oct 30, 2016 1:35:21 AM jawangwen@qq.com $
12 | */
13 | public class StringUtil {
14 | /**
15 | * A String for a space character.
16 | *
17 | * @since 3.2
18 | */
19 | public static final String SPACE = " ";
20 |
21 | /**
22 | * The empty String {@code ""}.
23 | * @since 2.0
24 | */
25 | public static final String EMPTY = "";
26 |
27 | /**
28 | * Represents a failed index search.
29 | * @since 2.1
30 | */
31 | public static final int INDEX_NOT_FOUND = -1;
32 |
33 | // Empty checks
34 | //-----------------------------------------------------------------------
35 | /**
36 | *
39 | * StringUtils.isEmpty(null) = true
40 | * StringUtils.isEmpty("") = true
41 | * StringUtils.isEmpty(" ") = false
42 | * StringUtils.isEmpty("bob") = false
43 | * StringUtils.isEmpty(" bob ") = false
44 | *
45 | *
46 | *
62 | * StringUtils.isNotEmpty(null) = false
63 | * StringUtils.isNotEmpty("") = false
64 | * StringUtils.isNotEmpty(" ") = true
65 | * StringUtils.isNotEmpty("bob") = true
66 | * StringUtils.isNotEmpty(" bob ") = true
67 | *
68 | *
69 | * @param cs the CharSequence to check, may be null
70 | * @return {@code true} if the CharSequence is not empty and not null
71 | * @since 3.0 Changed signature from isNotEmpty(String) to isNotEmpty(CharSequence)
72 | */
73 | public static boolean isNotEmpty(final CharSequence cs) {
74 | return !isEmpty(cs);
75 | }
76 |
77 | /**
78 | *
81 | * StringUtils.isBlank(null) = true
82 | * StringUtils.isBlank("") = true
83 | * StringUtils.isBlank(" ") = true
84 | * StringUtils.isBlank("bob") = false
85 | * StringUtils.isBlank(" bob ") = false
86 | *
87 | *
88 | * @param cs the CharSequence to check, may be null
89 | * @return {@code true} if the CharSequence is null, empty or whitespace
90 | * @since 2.0
91 | * @since 3.0 Changed signature from isBlank(String) to isBlank(CharSequence)
92 | */
93 | public static boolean isBlank(final CharSequence cs) {
94 | int strLen;
95 | if (cs == null || (strLen = cs.length()) == 0) {
96 | return true;
97 | }
98 | for (int i = 0; i < strLen; i++) {
99 | if (Character.isWhitespace(cs.charAt(i)) == false) {
100 | return false;
101 | }
102 | }
103 | return true;
104 | }
105 |
106 | /**
107 | *
110 | * StringUtils.isNotBlank(null) = false
111 | * StringUtils.isNotBlank("") = false
112 | * StringUtils.isNotBlank(" ") = false
113 | * StringUtils.isNotBlank("bob") = true
114 | * StringUtils.isNotBlank(" bob ") = true
115 | *
116 | *
117 | * @param cs the CharSequence to check, may be null
118 | * @return {@code true} if the CharSequence is
119 | * not empty and not null and not whitespace
120 | * @since 2.0
121 | * @since 3.0 Changed signature from isNotBlank(String) to isNotBlank(CharSequence)
122 | */
123 | public static boolean isNotBlank(final CharSequence cs) {
124 | return !isBlank(cs);
125 | }
126 |
127 | // Trim
128 | //-----------------------------------------------------------------------
129 | /**
130 | *
142 | * StringUtils.trim(null) = null
143 | * StringUtils.trim("") = ""
144 | * StringUtils.trim(" ") = ""
145 | * StringUtils.trim("abc") = "abc"
146 | * StringUtils.trim(" abc ") = "abc"
147 | *
148 | *
149 | * @param str the String to be trimmed, may be null
150 | * @return the trimmed string, {@code null} if null String input
151 | */
152 | public static String trim(final String str) {
153 | return str == null ? null : str.trim();
154 | }
155 |
156 | /**
157 | *
166 | * StringUtils.trimToNull(null) = null
167 | * StringUtils.trimToNull("") = null
168 | * StringUtils.trimToNull(" ") = null
169 | * StringUtils.trimToNull("abc") = "abc"
170 | * StringUtils.trimToNull(" abc ") = "abc"
171 | *
172 | *
173 | * @param str the String to be trimmed, may be null
174 | * @return the trimmed String,
175 | * {@code null} if only chars <= 32, empty or null String input
176 | * @since 2.0
177 | */
178 | public static String trimToNull(final String str) {
179 | final String ts = trim(str);
180 | return isEmpty(ts) ? null : ts;
181 | }
182 |
183 | /**
184 | *
193 | * StringUtils.trimToEmpty(null) = ""
194 | * StringUtils.trimToEmpty("") = ""
195 | * StringUtils.trimToEmpty(" ") = ""
196 | * StringUtils.trimToEmpty("abc") = "abc"
197 | * StringUtils.trimToEmpty(" abc ") = "abc"
198 | *
199 | *
200 | * @param str the String to be trimmed, may be null
201 | * @return the trimmed String, or an empty String if {@code null} input
202 | * @since 2.0
203 | */
204 | public static String trimToEmpty(final String str) {
205 | return str == null ? EMPTY : str.trim();
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/log/LogUtils.java:
--------------------------------------------------------------------------------
1 | /**
2 | * JHack.com Inc.
3 | * Copyright (c) 2004-2016 All Rights Reserved.
4 | */
5 | package com.jgithack.log;
6 |
7 | import java.io.PrintWriter;
8 | import java.io.StringWriter;
9 | import java.io.Writer;
10 |
11 | /**
12 | * 简单的日志工具。。
13 | *
14 | * @author Albert Wang
15 | * @version $Id: LogUtils.java, V0.1 2016-10-29 20:02:00, jawangwen@qq.com $
16 | */
17 | public class LogUtils {
18 | public static final int DEBUG = 0;
19 | public static final int INFO = 1;
20 | public static final int WARNING = 2;
21 | public static final int ERROR = 3;
22 |
23 | private static volatile int level = DEBUG;
24 |
25 | private static volatile Print print = new Print() {
26 | @Override
27 | public void toOut(String log) {
28 | System.out.println(log);
29 | }
30 |
31 | @Override
32 | public void toErr(String log) {
33 | System.err.println(log);
34 | }
35 | };
36 |
37 | /**
38 | * 打印方案
39 | *
40 | * @author Albert Wang
41 | * @version $Id: LogUtils.java, V0.1 Nov 2, 2016 12:30:54 AM jawangwen@qq.com $
42 | */
43 | public static interface Print {
44 | /**
45 | * 打印一般信息
46 | */
47 | public void toOut(String log);
48 |
49 | /**
50 | * 打印错误信息
51 | */
52 | public void toErr(String log);
53 | }
54 |
55 | /**
56 | * 以slf4j的格式来格式化日志输出
57 | *
58 | * @param message
59 | * @param arguments
60 | * @return
61 | */
62 | public static String formatMessage(String message, Object... arguments) {
63 | if (arguments == null || arguments.length == 0) {
64 | return message;
65 | }
66 | return String.format(message, arguments);
67 | }
68 |
69 | /**
70 | * debug级别日志输出
71 | *
72 | * @param logger
73 | * @param message
74 | * @param arguments
75 | */
76 | public static void debug(String message, Object... arguments) {
77 | if (level <= DEBUG) {
78 | print.toOut(formatMessage(message, arguments));
79 | }
80 | }
81 |
82 | /**
83 | * info级别日志输出
84 | *
85 | * @param logger
86 | * @param message
87 | * @param arguments
88 | */
89 | public static void info(String message, Object... arguments) {
90 | if (level <= INFO) {
91 | print.toOut(formatMessage(message, arguments));
92 | }
93 | }
94 |
95 | /**
96 | * warn级别日志输出
97 | *
98 | * @param logger
99 | * @param message
100 | * @param arguments
101 | */
102 | public static void warn(String message, Object... arguments) {
103 | if (level <= WARNING) {
104 | print.toErr(formatMessage(message, arguments));
105 | }
106 | }
107 |
108 | /**
109 | * error级别日志输出
110 | *
111 | * @param logger
112 | * @param message
113 | * @param arguments
114 | */
115 | public static void error(String message, Object... arguments) {
116 | print.toErr(formatMessage(message, arguments));
117 | }
118 |
119 | /**
120 | * warn级别带异常堆栈日志输出
121 | *
122 | * @param logger
123 | * @param e
124 | * @param message
125 | * @param arguments
126 | */
127 | public static void warn(Throwable e, String message, Object... arguments) {
128 | if (level <= WARNING) {
129 | print.toErr(formatMessage(message, arguments) + getStackTrace(e));
130 | }
131 |
132 | }
133 |
134 | /**
135 | * error级别带异常堆栈日志输出
136 | *
137 | * @param logger
138 | * @param e
139 | * @param message
140 | * @param arguments
141 | */
142 | public static void error(Throwable e, String message, Object... arguments) {
143 | print.toErr(formatMessage(message, arguments));
144 | print.toErr(getStackTrace(e));
145 | }
146 |
147 | /**
148 | * 异常堆栈转String
149 | *
150 | * @param throwable
151 | * @return
152 | */
153 | public static String getStackTrace(Throwable throwable) {
154 | if (throwable == null) {
155 | return "";
156 | }
157 | Writer sw = new StringWriter();
158 | PrintWriter pw = new PrintWriter(sw);
159 | throwable.printStackTrace(pw);
160 | return sw.toString();
161 | }
162 |
163 | /**
164 | * Setter method for property print.
165 | *
166 | * @param print value to be assigned to property print
167 | */
168 | public static void setPrint(Print print) {
169 | LogUtils.print = print;
170 | }
171 | }
172 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/model/IndexEntry.java:
--------------------------------------------------------------------------------
1 | /**
2 | * JHack.com Inc.
3 | * Copyright (c) 2004-2016 All Rights Reserved.
4 | */
5 | package com.jgithack.model;
6 |
7 | /**
8 | * IndexEntry－.git目录下index文件的基本组成元素
9 | *
10 | * @author Albert Wang
11 | * @version $Id: IndexEntry.java, V0.1 2016-10-29 20:01:00, jawangwen@qq.com $
12 | */
13 | public class IndexEntry {
14 | private Integer id;
15 | private Integer secondsCreated;
16 | private Integer nanosecondsCreated;
17 | private Integer secondsModified;
18 | private Integer nanosecondsModified;
19 | private Integer dev;
20 | private Integer ino;
21 | private String mode;
22 | private Integer uid;
23 | private Integer gid;
24 | private Integer size;
25 | private String sha1;
26 | private Short flags;
27 | private Boolean assumeValid;
28 | private Boolean extended;
29 | private Boolean[] stage;
30 | private Short extraFlags;
31 | private Boolean reserved;
32 | private Boolean skipWorktree;
33 | private Boolean intentToAdd;
34 | private String name;
35 |
36 | /**
37 | * Getter method for property id.
38 | *
39 | * @return property value of id
40 | */
41 | public Integer getId() {
42 | return id;
43 | }
44 |
45 | /**
46 | * Setter method for property id.
47 | *
48 | * @param id value to be assigned to property id
49 | */
50 | public void setId(Integer id) {
51 | this.id = id;
52 | }
53 |
54 | /**
55 | * Getter method for property secondsCreated.
56 | *
57 | * @return property value of secondsCreated
58 | */
59 | public Integer getSecondsCreated() {
60 | return secondsCreated;
61 | }
62 |
63 | /**
64 | * Setter method for property secondsCreated.
65 | *
66 | * @param secondsCreated value to be assigned to property secondsCreated
67 | */
68 | public void setSecondsCreated(Integer secondsCreated) {
69 | this.secondsCreated = secondsCreated;
70 | }
71 |
72 | /**
73 | * Getter method for property nanosecondsCreated.
74 | *
75 | * @return property value of nanosecondsCreated
76 | */
77 | public Integer getNanosecondsCreated() {
78 | return nanosecondsCreated;
79 | }
80 |
81 | /**
82 | * Setter method for property nanosecondsCreated.
83 | *
84 | * @param nanosecondsCreated value to be assigned to property nanosecondsCreated
85 | */
86 | public void setNanosecondsCreated(Integer nanosecondsCreated) {
87 | this.nanosecondsCreated = nanosecondsCreated;
88 | }
89 |
90 | /**
91 | * Getter method for property secondsModified.
92 | *
93 | * @return property value of secondsModified
94 | */
95 | public Integer getSecondsModified() {
96 | return secondsModified;
97 | }
98 |
99 | /**
100 | * Setter method for property secondsModified.
101 | *
102 | * @param secondsModified value to be assigned to property secondsModified
103 | */
104 | public void setSecondsModified(Integer secondsModified) {
105 | this.secondsModified = secondsModified;
106 | }
107 |
108 | /**
109 | * Getter method for property nanosecondsModified.
110 | *
111 | * @return property value of nanosecondsModified
112 | */
113 | public Integer getNanosecondsModified() {
114 | return nanosecondsModified;
115 | }
116 |
117 | /**
118 | * Setter method for property nanosecondsModified.
119 | *
120 | * @param nanosecondsModified value to be assigned to property nanosecondsModified
121 | */
122 | public void setNanosecondsModified(Integer nanosecondsModified) {
123 | this.nanosecondsModified = nanosecondsModified;
124 | }
125 |
126 | /**
127 | * Getter method for property dev.
128 | *
129 | * @return property value of dev
130 | */
131 | public Integer getDev() {
132 | return dev;
133 | }
134 |
135 | /**
136 | * Setter method for property dev.
137 | *
138 | * @param dev value to be assigned to property dev
139 | */
140 | public void setDev(Integer dev) {
141 | this.dev = dev;
142 | }
143 |
144 | /**
145 | * Getter method for property ino.
146 | *
147 | * @return property value of ino
148 | */
149 | public Integer getIno() {
150 | return ino;
151 | }
152 |
153 | /**
154 | * Setter method for property ino.
155 | *
156 | * @param ino value to be assigned to property ino
157 | */
158 | public void setIno(Integer ino) {
159 | this.ino = ino;
160 | }
161 |
162 | /**
163 | * Getter method for property mode.
164 | *
165 | * @return property value of mode
166 | */
167 | public String getMode() {
168 | return mode;
169 | }
170 |
171 | /**
172 | * Setter method for property mode.
173 | *
174 | * @param mode value to be assigned to property mode
175 | */
176 | public void setMode(String mode) {
177 | this.mode = mode;
178 | }
179 |
180 | /**
181 | * Getter method for property uid.
182 | *
183 | * @return property value of uid
184 | */
185 | public Integer getUid() {
186 | return uid;
187 | }
188 |
189 | /**
190 | * Setter method for property uid.
191 | *
192 | * @param uid value to be assigned to property uid
193 | */
194 | public void setUid(Integer uid) {
195 | this.uid = uid;
196 | }
197 |
198 | /**
199 | * Getter method for property gid.
200 | *
201 | * @return property value of gid
202 | */
203 | public Integer getGid() {
204 | return gid;
205 | }
206 |
207 | /**
208 | * Setter method for property gid.
209 | *
210 | * @param gid value to be assigned to property gid
211 | */
212 | public void setGid(Integer gid) {
213 | this.gid = gid;
214 | }
215 |
216 | /**
217 | * Getter method for property size.
218 | *
219 | * @return property value of size
220 | */
221 | public Integer getSize() {
222 | return size;
223 | }
224 |
225 | /**
226 | * Setter method for property size.
227 | *
228 | * @param size value to be assigned to property size
229 | */
230 | public void setSize(Integer size) {
231 | this.size = size;
232 | }
233 |
234 | /**
235 | * Getter method for property sha1.
236 | *
237 | * @return property value of sha1
238 | */
239 | public String getSha1() {
240 | return sha1;
241 | }
242 |
243 | /**
244 | * Setter method for property sha1.
245 | *
246 | * @param sha1 value to be assigned to property sha1
247 | */
248 | public void setSha1(String sha1) {
249 | this.sha1 = sha1;
250 | }
251 |
252 | /**
253 | * Getter method for property flags.
254 | *
255 | * @return property value of flags
256 | */
257 | public Short getFlags() {
258 | return flags;
259 | }
260 |
261 | /**
262 | * Setter method for property flags.
263 | *
264 | * @param flags value to be assigned to property flags
265 | */
266 | public void setFlags(Short flags) {
267 | this.flags = flags;
268 | }
269 |
270 | /**
271 | * Getter method for property assumeValid.
272 | *
273 | * @return property value of assumeValid
274 | */
275 | public Boolean getAssumeValid() {
276 | return assumeValid;
277 | }
278 |
279 | /**
280 | * Setter method for property assumeValid.
281 | *
282 | * @param assumeValid value to be assigned to property assumeValid
283 | */
284 | public void setAssumeValid(Boolean assumeValid) {
285 | this.assumeValid = assumeValid;
286 | }
287 |
288 | /**
289 | * Getter method for property extended.
290 | *
291 | * @return property value of extended
292 | */
293 | public Boolean getExtended() {
294 | return extended;
295 | }
296 |
297 | /**
298 | * Setter method for property extended.
299 | *
300 | * @param extended value to be assigned to property extended
301 | */
302 | public void setExtended(Boolean extended) {
303 | this.extended = extended;
304 | }
305 |
306 | /**
307 | * Getter method for property stage.
308 | *
309 | * @return property value of stage
310 | */
311 | public Boolean[] getStage() {
312 | return stage;
313 | }
314 |
315 | /**
316 | * Setter method for property stage.
317 | *
318 | * @param stage value to be assigned to property stage
319 | */
320 | public void setStage(Boolean[] stage) {
321 | this.stage = stage;
322 | }
323 |
324 | /**
325 | * Getter method for property extraFlags.
326 | *
327 | * @return property value of extraFlags
328 | */
329 | public Short getExtraFlags() {
330 | return extraFlags;
331 | }
332 |
333 | /**
334 | * Setter method for property extraFlags.
335 | *
336 | * @param extraFlags value to be assigned to property extraFlags
337 | */
338 | public void setExtraFlags(Short extraFlags) {
339 | this.extraFlags = extraFlags;
340 | }
341 |
342 | /**
343 | * Getter method for property reserved.
344 | *
345 | * @return property value of reserved
346 | */
347 | public Boolean getReserved() {
348 | return reserved;
349 | }
350 |
351 | /**
352 | * Setter method for property reserved.
353 | *
354 | * @param reserved value to be assigned to property reserved
355 | */
356 | public void setReserved(Boolean reserved) {
357 | this.reserved = reserved;
358 | }
359 |
360 | /**
361 | * Getter method for property skipWorktree.
362 | *
363 | * @return property value of skipWorktree
364 | */
365 | public Boolean getSkipWorktree() {
366 | return skipWorktree;
367 | }
368 |
369 | /**
370 | * Setter method for property skipWorktree.
371 | *
372 | * @param skipWorktree value to be assigned to property skipWorktree
373 | */
374 | public void setSkipWorktree(Boolean skipWorktree) {
375 | this.skipWorktree = skipWorktree;
376 | }
377 |
378 | /**
379 | * Getter method for property intentToAdd.
380 | *
381 | * @return property value of intentToAdd
382 | */
383 | public Boolean getIntentToAdd() {
384 | return intentToAdd;
385 | }
386 |
387 | /**
388 | * Setter method for property intentToAdd.
389 | *
390 | * @param intentToAdd value to be assigned to property intentToAdd
391 | */
392 | public void setIntentToAdd(Boolean intentToAdd) {
393 | this.intentToAdd = intentToAdd;
394 | }
395 |
396 | /**
397 | * Getter method for property name.
398 | *
399 | * @return property value of name
400 | */
401 | public String getName() {
402 | return name;
403 | }
404 |
405 | /**
406 | * Setter method for property name.
407 | *
408 | * @param name value to be assigned to property name
409 | */
410 | public void setName(String name) {
411 | this.name = name;
412 | }
413 | }
414 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/ui/AboutFrame.java:
--------------------------------------------------------------------------------
1 | /**
2 | * JHack.com Inc.
3 | * Copyright (c) 2004-2016 All Rights Reserved.
4 | */
5 | package com.jgithack.ui;
6 |
7 | import java.awt.Dimension;
8 | import java.awt.event.ActionEvent;
9 | import java.awt.event.ActionListener;
10 |
11 | import javax.swing.GroupLayout;
12 | import javax.swing.JButton;
13 | import javax.swing.JEditorPane;
14 | import javax.swing.JFrame;
15 | import javax.swing.JPanel;
16 | import javax.swing.JScrollPane;
17 | import javax.swing.LayoutStyle;
18 | import javax.swing.WindowConstants;
19 |
20 | /**
21 | * AboutFrame
22 | *
23 | * @author Albert Wang
24 | * @version $Id: AboutFrame.java, V0.1 Nov 1, 2016 11:12:38 PM jawangwen@qq.com $
25 | */
26 | public class AboutFrame extends JFrame {
27 | /** serial version */
28 | private static final long serialVersionUID = -3921661806821542826L;
29 |
30 | private String message = "GitHack v1.0
JGitHack is a Java tool using \".git leak\""
32 | + " to restore web project.
\n"
33 | + "Albert Wang(jawangwen@qq.com)";
34 | private JPanel aboutPanel;
35 | private JEditorPane editorPane;
36 | private JScrollPane scrollPane;
37 | private JButton okButton;
38 |
39 | /**
40 | * Creates new form aboutFrame
41 | */
42 | public AboutFrame() {
43 | initComponents();
44 | editorPane.setCaretPosition(0);
45 | }
46 |
47 | private void initComponents() {
48 | okButton = new JButton();
49 | aboutPanel = new JPanel();
50 | scrollPane = new JScrollPane();
51 | editorPane = new JEditorPane();
52 |
53 | setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
54 |
55 | okButton.setText("OK");
56 | okButton.setAlignmentX(0.5F);
57 | okButton.addActionListener(new ActionListener() {
58 | public void actionPerformed(ActionEvent evt) {
59 | dispose();
60 | }
61 | });
62 |
63 | aboutPanel.setPreferredSize(new Dimension(450, 300));
64 |
65 | editorPane.setContentType("text/html");
66 | editorPane.setEditable(false);
67 | editorPane.setText(message);
68 | editorPane.setMinimumSize(new Dimension(150, 150));
69 | editorPane.setPreferredSize(new Dimension(150, 150));
70 | scrollPane.setViewportView(editorPane);
71 |
72 | GroupLayout aboutPanelLayout = new GroupLayout(aboutPanel);
73 | aboutPanel.setLayout(aboutPanelLayout);
74 | aboutPanelLayout.setHorizontalGroup(aboutPanelLayout.createParallelGroup(
75 | GroupLayout.Alignment.LEADING).addComponent(scrollPane, GroupLayout.DEFAULT_SIZE, 444,
76 | Short.MAX_VALUE));
77 | aboutPanelLayout.setVerticalGroup(aboutPanelLayout.createParallelGroup(
78 | GroupLayout.Alignment.LEADING).addComponent(scrollPane, GroupLayout.DEFAULT_SIZE, 311,
79 | Short.MAX_VALUE));
80 |
81 | GroupLayout layout = new GroupLayout(getContentPane());
82 | getContentPane().setLayout(layout);
83 | layout.setHorizontalGroup(layout
84 | .createParallelGroup(GroupLayout.Alignment.LEADING)
85 | .addGroup(
86 | layout.createSequentialGroup().addGap(168, 168, 168).addComponent(okButton)
87 | .addContainerGap(227, Short.MAX_VALUE))
88 | .addComponent(aboutPanel, GroupLayout.DEFAULT_SIZE, 444, Short.MAX_VALUE));
89 | layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING).addGroup(
90 | GroupLayout.Alignment.TRAILING,
91 | layout.createSequentialGroup()
92 | .addComponent(aboutPanel, GroupLayout.DEFAULT_SIZE, 311, Short.MAX_VALUE)
93 | .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED).addComponent(okButton)
94 | .addContainerGap()));
95 | pack();
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/src/java/com/jgithack/ui/HomeFrame.java:
--------------------------------------------------------------------------------
1 | /**
2 | * JHack.com Inc.
3 | * Copyright (c) 2004-2016 All Rights Reserved.
4 | */
5 | package com.jgithack.ui;
6 |
7 | import java.awt.BorderLayout;
8 | import java.awt.Container;
9 | import java.awt.Dimension;
10 | import java.awt.FlowLayout;
11 | import java.awt.event.ActionEvent;
12 | import java.awt.event.ActionListener;
13 | import java.io.File;
14 | import java.util.concurrent.BlockingQueue;
15 | import java.util.concurrent.LinkedBlockingQueue;
16 | import java.util.concurrent.ThreadPoolExecutor;
17 | import java.util.concurrent.TimeUnit;
18 | import java.util.concurrent.locks.Lock;
19 | import java.util.concurrent.locks.ReentrantLock;
20 |
21 | import javax.swing.JButton;
22 | import javax.swing.JFrame;
23 | import javax.swing.JLabel;
24 | import javax.swing.JMenu;
25 | import javax.swing.JMenuBar;
26 | import javax.swing.JMenuItem;
27 | import javax.swing.JOptionPane;
28 | import javax.swing.JPanel;
29 | import javax.swing.JScrollPane;
30 | import javax.swing.JTextArea;
31 | import javax.swing.JTextField;
32 | import javax.swing.WindowConstants;
33 | import javax.swing.event.UndoableEditEvent;
34 | import javax.swing.event.UndoableEditListener;
35 |
36 | import com.jgithack.hack.GitHack;
37 | import com.jgithack.log.LogUtils;
38 |
39 | /**
40 | * Home Frame GUI
41 | *
42 | * @author Albert Wang
43 | * @version $Id: HomeFrame.java, V0.1 Nov 1, 2016 11:12:20 PM jawangwen@qq.com $
44 | */
45 | public class HomeFrame extends JFrame {
46 | private static final long serialVersionUID = 1L;
47 |
48 | private static final String BUTTON_HACK = "Hack";
49 | private static final String BUTTON_STOP = "Stop";
50 |
51 | /** Menu bar */
52 | private JMenuBar menuBar;
53 |
54 | /** Sub menu - help */
55 | private JMenu helpMenu;
56 |
57 | /** Menu option - about */
58 | private JMenuItem aboutItem;
59 |
60 | /** Input field for remote URL */
61 | private JTextField remoteUrlField;
62 |
63 | /** Input field for download directory */
64 | private JTextField downloadField;
65 |
66 | /** Output area like terminal */
67 | private JTextArea terminalArea;
68 |
69 | /** Button to start GitHack */
70 | private JButton hackButton;
71 |
72 | /** Avoid to run GitHack repeatedly when it works */
73 | private final Lock lock = new ReentrantLock();
74 |
75 | /** thread pool queue for run GitHack asynchronously */
76 | private volatile BlockingQueue