@Nullable public static Course getCourse(String zipFilePath) { try { final JBZipFile zipFile = new JBZipFile(zipFilePath); final JBZipEntry entry = zipFile.getEntry(EduNames.COURSE_META_FILE); if (entry == null) { return null; } byte[] bytes = entry.getData(); final String jsonText = new String(bytes, CharsetToolkit.UTF8_CHARSET); Gson gson = new GsonBuilder() .registerTypeAdapter(Task.class, new StudySerializationUtils.Json.TaskAdapter()) .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES) .create(); return gson.fromJson(jsonText, Course.class); } catch (IOException e) { LOG.error("Failed to unzip course archive"); LOG.error(e); } return null; }
private String createArchive(String relativeArchivePath, String fileNameInArchive, String text) { try { File file = new File(getOrCreateProjectDir(), relativeArchivePath); ZipOutputStream output = new ZipOutputStream(new FileOutputStream(file)); try { output.putNextEntry(new ZipEntry(fileNameInArchive)); output.write(text.getBytes(CharsetToolkit.UTF8)); output.closeEntry(); } finally { output.close(); } return FileUtil.toSystemIndependentName(file.getAbsolutePath()); } catch (IOException e) { throw new RuntimeException(e); } }
public void testText() throws Exception { doTest("Text.txt"); Charset ascii = CharsetToolkit.forName("US-ASCII"); VirtualFile myVFile = myFile.getVirtualFile(); FileDocumentManager.getInstance().saveAllDocuments(); EncodingManager.getInstance().setEncoding(myVFile, ascii); UIUtil.dispatchAllInvocationEvents(); // wait for reload requests to bubble up assertEquals(ascii, myVFile.getCharset()); int start = myEditor.getCaretModel().getOffset(); type((char)0x445); type((char)0x438); int end = myEditor.getCaretModel().getOffset(); Collection<HighlightInfo> infos = doHighlighting(); HighlightInfo info = assertOneElement(infos); assertEquals("Unsupported characters for the charset 'US-ASCII'", info.getDescription()); assertEquals(start, info.startOffset); assertEquals(end, info.endOffset); backspace(); backspace(); doDoTest(true, false); }
@Nullable String readEntry(@NotNull final String endsWith) { try { return processStream(new StreamProcessor<String>() { @Override public String consume(@NotNull ZipInputStream stream) throws IOException { ZipEntry entry; while ((entry = stream.getNextEntry()) != null) { if (entry.getName().endsWith(endsWith)) { return StreamUtil.readText(stream, CharsetToolkit.UTF8_CHARSET); } } return null; } }); } catch (IOException ignored) { return null; } }
@Nullable private static Pair<Date, File> readUsageFile(File usageFile) { try { final List<String> lines = FileUtil.loadLines(usageFile, CharsetToolkit.UTF8_CHARSET.name()); if (!lines.isEmpty()) { final String dateString = lines.get(0); final Date date; synchronized (USAGE_STAMP_DATE_FORMAT) { date = USAGE_STAMP_DATE_FORMAT.parse(dateString); } final File projectFile = lines.size() > 1? new File(lines.get(1)) : null; return Pair.create(date, projectFile); } } catch (Throwable e) { LOG.info(e); } return null; }
@Override public void load(@NotNull Consumer<String> consumer) { try { BufferedReader br = new BufferedReader(new InputStreamReader(stream, CharsetToolkit.UTF8_CHARSET)); try { String line; while ((line = br.readLine()) != null) { consumer.consume(line); } } finally { br.close(); } } catch (Exception e) { Logger.getInstance(StreamLoader.class).error(e); } }
private static String convertStreamToString(InputStream is) { if (is != null) { StringBuilder sb = new StringBuilder(); try { BufferedReader reader = new BufferedReader(new InputStreamReader(is, CharsetToolkit.UTF8_CHARSET)); try { String line; while ((line = reader.readLine()) != null) { sb.append(line).append('\n'); } } finally { reader.close(); } } catch (Exception e) { throw new RuntimeException(e); } return sb.toString(); } else { return ""; } }
@Override @Nullable public Document getDocument() { if (myDocument == null) { if (isBinary()) return null; String text = null; try { Charset charset = ObjectUtils.notNull(myCharset, EncodingProjectManager.getInstance(myProject).getDefaultCharset()); text = CharsetToolkit.bytesToString(myBytes, charset); } catch (IllegalCharsetNameException ignored) { } // Still NULL? only if not supported or an exception was thrown. // Decode a string using the truly default encoding. if (text == null) text = new String(myBytes); text = LineTokenizer.correctLineSeparators(text); myDocument = EditorFactory.getInstance().createDocument(text); myDocument.setReadOnly(true); } return myDocument; }
@NotNull public static String loadTemplate(@NotNull ClassLoader loader, @NotNull String templateName, @Nullable Map<String, String> variables) throws IOException { @SuppressWarnings("IOResourceOpenedButNotSafelyClosed") InputStream stream = loader.getResourceAsStream(templateName); if (stream == null) { throw new IOException("Template '" + templateName + "' not found by " + loader); } String template = FileUtil.loadTextAndClose(new InputStreamReader(stream, CharsetToolkit.UTF8)); if (variables == null || variables.size() == 0) { return template; } StringBuilder buffer = new StringBuilder(template); for (Map.Entry<String, String> var : variables.entrySet()) { String name = var.getKey(); int pos = buffer.indexOf(name); if (pos >= 0) { buffer.replace(pos, pos + name.length(), var.getValue()); } } return buffer.toString(); }
private String executeMethod(HttpMethod method) throws Exception { String responseBody; getHttpClient().executeMethod(method); Header contentType = method.getResponseHeader("Content-Type"); if (contentType != null && contentType.getValue().contains("charset")) { // ISO-8859-1 if charset wasn't specified in response responseBody = StringUtil.notNullize(method.getResponseBodyAsString()); } else { InputStream stream = method.getResponseBodyAsStream(); responseBody = stream == null ? "" : StreamUtil.readText(stream, CharsetToolkit.UTF8_CHARSET); } if (method.getStatusCode() != HttpStatus.SC_OK) { throw new Exception("Request failed with HTTP error: " + method.getStatusText()); } return responseBody; }
@NotNull private static Document setupFileEditorAndDocument(@NotNull String fileName, @NotNull String fileText) throws IOException { EncodingProjectManager.getInstance(getProject()).setEncoding(null, CharsetToolkit.UTF8_CHARSET); EncodingProjectManager.getInstance(ProjectManager.getInstance().getDefaultProject()).setEncoding(null, CharsetToolkit.UTF8_CHARSET); PostprocessReformattingAspect.getInstance(ourProject).doPostponedFormatting(); deleteVFile(); myVFile = getSourceRoot().createChildData(null, fileName); VfsUtil.saveText(myVFile, fileText); final FileDocumentManager manager = FileDocumentManager.getInstance(); final Document document = manager.getDocument(myVFile); assertNotNull("Can't create document for '" + fileName + "'", document); manager.reloadFromDisk(document); document.insertString(0, " "); document.deleteString(0, 1); myFile = getPsiManager().findFile(myVFile); assertNotNull("Can't create PsiFile for '" + fileName + "'. Unknown file type most probably.", myFile); assertTrue(myFile.isPhysical()); myEditor = createEditor(myVFile); myVFile.setCharset(CharsetToolkit.UTF8_CHARSET); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); return document; }
@Nullable public String getContent() throws VcsException { if (myContents == null) { BufferExposingByteArrayOutputStream bos = new BufferExposingByteArrayOutputStream(2048); try { myRepository.getFile(myPath, -1, null, bos); myRepository.closeSession(); } catch (SVNException e) { throw new VcsException(e); } final byte[] bytes = bos.toByteArray(); final Charset charset = myFilePath.getCharset(); myContents = CharsetToolkit.bytesToString(bytes, charset); } return myContents; }
private synchronized void saveContext(@Nullable String entryName, String zipPostfix, @Nullable String comment) { JBZipFile archive = null; try { archive = getTasksArchive(zipPostfix); if (entryName == null) { int i = archive.getEntries().size(); do { entryName = "context" + i++; } while (archive.getEntry("/" + entryName) != null); } JBZipEntry entry = archive.getOrCreateEntry("/" + entryName); if (comment != null) { entry.setComment(comment); } Element element = new Element("context"); saveContext(element); String s = new XMLOutputter().outputString(element); entry.setData(s.getBytes(CharsetToolkit.UTF8_CHARSET)); } catch (IOException e) { LOG.error(e); } finally { closeArchive(archive); } }
public void testSaveDocument_DocumentWasChanged() throws Exception { final VirtualFile file = createFile(); final long stamp = file.getModificationStamp(); final Document document = myDocumentManager.getDocument(file); assertNotNull(file.toString(), document); WriteCommandAction.runWriteCommandAction(myProject, new Runnable() { @Override public void run() { document.insertString(0, "xxx "); } }); myDocumentManager.saveDocument(document); assertTrue(stamp != file.getModificationStamp()); assertEquals(document.getModificationStamp(), file.getModificationStamp()); assertEquals("xxx test", new String(file.contentsToByteArray(), CharsetToolkit.UTF8_CHARSET)); }
public void testSaveAllDocuments_DocumentWasChanged() throws Exception { final VirtualFile file = createFile(); final long stamp = file.getModificationStamp(); final Document document = myDocumentManager.getDocument(file); assertNotNull(file.toString(), document); WriteCommandAction.runWriteCommandAction(myProject, new Runnable() { @Override public void run() { document.insertString(0, "xxx "); } }); myDocumentManager.saveAllDocuments(); assertNotEquals(stamp, file.getModificationStamp()); assertEquals("xxx test", new String(file.contentsToByteArray(), CharsetToolkit.UTF8_CHARSET)); }
@Override protected void setUp() throws Exception { super.setUp(); Random random = new Random(); for (int i = 0; i < 1000; i++) { byte[] bytes = new byte[1000]; random.nextBytes(bytes); String key = new String(bytes, CharsetToolkit.UTF8_CHARSET); myKeys.add(key); } for (int i = 0; i < 10; i++) { PersistentHashMap<String, Record> map = createMap(FileUtil.createTempFile("persistent", "map" + i)); myMaps.add(map); } PagedFileStorage.StorageLockContext storageLockContext = new PagedFileStorage.StorageLockContext(false); myEnumerator = new PersistentStringEnumerator(FileUtil.createTempFile("persistent", "enum"), storageLockContext); myThreadPool = Executors.newFixedThreadPool(myMaps.size() + 1); }
@NotNull public static XMLOutputter createOutputter(String lineSeparator) { XMLOutputter xmlOutputter = new MyXMLOutputter(); Format format = Format.getCompactFormat(). setIndent(" "). setTextMode(Format.TextMode.TRIM). setEncoding(CharsetToolkit.UTF8). setOmitEncoding(false). setOmitDeclaration(false). setLineSeparator(lineSeparator); xmlOutputter.setFormat(format); return xmlOutputter; }
private static void writePatchesToFile(final Project project, final String path, final List<FilePatch> remainingPatches, CommitContext commitContext) { try { OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(path), CharsetToolkit.UTF8_CHARSET); try { UnifiedDiffWriter.write(project, remainingPatches, writer, "\n", commitContext); } finally { writer.close(); } } catch (IOException e) { LOG.error(e); } }
@NotNull private static Pair.NonNull<Charset, byte[]> charsetForWriting(@Nullable Project project, @NotNull VirtualFile virtualFile, @NotNull String text, @NotNull Charset existing) { Charset specified = extractCharsetFromFileContent(project, virtualFile, text); Pair.NonNull<Charset, byte[]> chosen = chooseMostlyHarmlessCharset(existing, specified, text); Charset charset = chosen.first; // in case of "UTF-16", OutputStreamWriter sometimes adds BOM on it's own. // see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6800103 byte[] bom = virtualFile.getBOM(); Charset fromBom = bom == null ? null : CharsetToolkit.guessFromBOM(bom); if (fromBom != null && !fromBom.equals(charset)) { chosen = Pair.createNonNull(fromBom, toBytes(text, fromBom)); } return chosen; }
protected void writeClassesPerModule(String packageName, JavaParameters javaParameters, Map<Module, List<String>> perModule) throws FileNotFoundException, UnsupportedEncodingException, CantRunException { if (perModule != null && perModule.size() > 1) { final String classpath = getScope() == TestSearchScope.WHOLE_PROJECT ? null : javaParameters.getClassPath().getPathsString(); final PrintWriter wWriter = new PrintWriter(myWorkingDirsFile, CharsetToolkit.UTF8); try { wWriter.println(packageName); for (Module module : perModule.keySet()) { wWriter.println(PathMacroUtil.getModuleDir(module.getModuleFilePath())); wWriter.println(module.getName()); if (classpath == null) { final JavaParameters parameters = new JavaParameters(); parameters.getClassPath().add(JavaSdkUtil.getIdeaRtJarPath()); configureRTClasspath(parameters); JavaParametersUtil.configureModule(module, parameters, JavaParameters.JDK_AND_CLASSES_AND_TESTS, getConfiguration().isAlternativeJrePathEnabled() ? getConfiguration() .getAlternativeJrePath() : null); wWriter.println(parameters.getClassPath().getPathsString()); } else { wWriter.println(classpath); } final List<String> classNames = perModule.get(module); wWriter.println(classNames.size()); for (String className : classNames) { wWriter.println(className); } } } finally { wWriter.close(); } } }
@NotNull public static String getCharset() { String value = getInstance().ENCODING; if (DEFAULT.equals(value)) { return CharsetToolkit.getDefaultSystemCharset().name(); } else { return value; } }
public void testDetectWrongEncoding() throws Exception { VirtualFile virtualFile = getVirtualFile(BASE_PATH + "/" + "Win1251.txt"); virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); configureByExistingFile(virtualFile); final Document document = FileDocumentManager.getInstance().getDocument(virtualFile); assertFalse(FileDocumentManager.getInstance().isDocumentUnsaved(document)); assertEquals(CharsetToolkit.UTF8_CHARSET, virtualFile.getCharset()); doHighlighting(); List<HighlightInfo> infos = DaemonCodeAnalyzerEx.getInstanceEx(getProject()).getFileLevelHighlights(getProject(), getFile()); HighlightInfo info = assertOneElement(infos); assertEquals("File was loaded in the wrong encoding: 'UTF-8'", info.getDescription()); }
private static void changeClassTextAndTryToNavigate(final String newClassString, PsiJavaFile psiFile, final AbstractProjectViewPSIPane pane, final String expected) throws IOException, InterruptedException { PsiClass psiClass = psiFile.getClasses()[0]; final VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); final JTree tree = pane.getTree(); setBinaryContent(virtualFile, newClassString.getBytes(CharsetToolkit.UTF8_CHARSET)); PlatformTestUtil.waitForAlarm(600); psiClass = psiFile.getClasses()[0]; pane.select(psiClass, virtualFile, true); PlatformTestUtil.assertTreeEqual(tree, expected, true); }
@NotNull public static String shiftIndentInside(@NotNull String initial, final int i, boolean shiftEmptyLines) { StringBuilder result = new StringBuilder(initial.length()); List<byte[]> lines; try { LineReader reader = new LineReader(new ByteArrayInputStream(initial.getBytes(CharsetToolkit.UTF8_CHARSET))); lines = reader.readLines(); } catch (IOException e) { throw new RuntimeException(e); } boolean first = true; for (byte[] line : lines) { try { if (!first) result.append('\n'); if (line.length > 0 || shiftEmptyLines) { StringUtil.repeatSymbol(result, ' ', i); } result.append(new String(line)); } finally { first = false; } } return result.toString(); }
@NotNull protected static String run(@NotNull File workingDir, @NotNull List<String> params, boolean ignoreNonZeroExitCode) throws ExecutionException { final ProcessBuilder builder = new ProcessBuilder().command(params); builder.directory(workingDir); builder.redirectErrorStream(true); Process clientProcess; try { clientProcess = builder.start(); } catch (IOException e) { throw new RuntimeException(e); } CapturingProcessHandler handler = new CapturingProcessHandler(clientProcess, CharsetToolkit.getDefaultSystemCharset()); ProcessOutput result = handler.runProcess(30 * 1000); if (result.isTimeout()) { throw new RuntimeException("Timeout waiting for the command execution. Command: " + StringUtil.join(params, " ")); } String stdout = result.getStdout().trim(); if (result.getExitCode() != 0) { if (ignoreNonZeroExitCode) { debug("{" + result.getExitCode() + "}"); } debug(stdout); if (!ignoreNonZeroExitCode) { throw new ExecutionException(result.getExitCode(), stdout); } } else { debug(stdout); } return stdout; }
private static char[] loadFileTextSkippingBom(File file) throws IOException { //noinspection IOResourceOpenedButNotSafelyClosed InputStream stream = CharsetToolkit.inputStreamSkippingBOM(new BufferedInputStream(new FileInputStream(file))); Reader reader = new InputStreamReader(stream); try { return FileUtilRt.loadText(reader, (int)file.length()); } finally { reader.close(); } }
@NotNull public static File createTempExecutableScript(@NotNull String prefix, @NotNull String suffix, @NotNull String content) throws IOException, ExecutionException { File tempDir = new File(PathManager.getTempPath()); File tempFile = FileUtil.createTempFile(tempDir, prefix, suffix, true, true); FileUtil.writeToFile(tempFile, content.getBytes(CharsetToolkit.UTF8)); if (!tempFile.setExecutable(true, true)) { throw new ExecutionException("Failed to make temp file executable: " + tempFile); } return tempFile; }
@NotNull static Charset getCharset(@NotNull Request request) throws IOException { String contentEncoding = request.getConnection().getContentEncoding(); if (contentEncoding != null) { try { return Charset.forName(contentEncoding); } catch (Exception ignored) { } } return CharsetToolkit.UTF8_CHARSET; }
@SuppressWarnings({"HardCodedStringLiteral"}) private static void generateIndexHtml(final PsiDirectory psiDirectory, final boolean recursive, final String outputDirectoryName) throws FileNotFoundException { String indexHtmlName = constructOutputDirectory(psiDirectory, outputDirectoryName) + File.separator + "index.html"; OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(indexHtmlName), CharsetToolkit.UTF8_CHARSET); final String title = PsiDirectoryFactory.getInstance(psiDirectory.getProject()).getQualifiedName(psiDirectory, true); try { writer.write("<html><head><title>" + title + "</title></head><body>"); if (recursive) { PsiDirectory[] directories = psiDirectory.getSubdirectories(); for(PsiDirectory directory: directories) { writer.write("<a href=\"" + directory.getName() + "/index.html\"><b>" + directory.getName() + "</b></a><br />"); } } PsiFile[] files = psiDirectory.getFiles(); for(PsiFile file: files) { if (!(file instanceof PsiBinaryFile)) { writer.write("<a href=\"" + getHTMLFileName(file) + "\">" + file.getVirtualFile().getName() + "</a><br />"); } } writer.write("</body></html>"); writer.close(); } catch (IOException e) { LOG.error(e); } }
private void parseTestResults() { try { parseTestResults(new InputStreamReader(new FileInputStream(myFile), CharsetToolkit.UTF8_CHARSET), getProcessor()); } catch (IOException e) { final String message = e.getMessage(); ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { Messages.showErrorDialog(myConsoleProperties.getProject(), message, "Failed to Parse " + myFile.getName()); } }); } }
private static List<TextFilePatch> loadPatches(Project project, final String patchPath, CommitContext commitContext, boolean loadContent) throws IOException, PatchSyntaxException { char[] text = FileUtil.loadFileText(new File(patchPath), CharsetToolkit.UTF8); PatchReader reader = new PatchReader(new CharArrayCharSequence(text), loadContent); final List<TextFilePatch> textFilePatches = reader.readAllPatches(); final TransparentlyFailedValueI<Map<String, Map<String, CharSequence>>, PatchSyntaxException> additionalInfo = reader.getAdditionalInfo( null); ApplyPatchDefaultExecutor.applyAdditionalInfoBefore(project, additionalInfo, commitContext); return textFilePatches; }
public void savePathFile(@NotNull ContentProvider contentProvider, @NotNull final File patchPath, @NotNull CommitContext commitContext) throws IOException { OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(patchPath), CharsetToolkit.UTF8_CHARSET); try { contentProvider.writeContentTo(writer, commitContext); } finally { writer.close(); } }
/** * This will print the <code>Document</code> to the given Writer. * * <p> * Warning: using your own Writer may cause the outputter's * preferred character encoding to be ignored. If you use * encodings other than UTF-8, we recommend using the method that * takes an OutputStream instead. * </p> * * @param doc <code>Document</code> to format. * @param out <code>Writer</code> to use. * @throws IOException - if there's any problem writing. */ public void output(Document doc, Writer out) throws IOException { printDeclaration(out, doc, CharsetToolkit.UTF8); // Print out root element, as well as any root level // comments and processing instructions, // starting with no indentation List content = doc.getContent(); int size = content.size(); for (int i = 0; i < size; i++) { Object obj = content.get(i); if (obj instanceof Element) { printElement(out, doc.getRootElement(), 0, createNamespaceStack()); } else if (obj instanceof Comment) { printComment(out, (Comment) obj); } else if (obj instanceof ProcessingInstruction) { printProcessingInstruction(out, (ProcessingInstruction) obj); } else if (obj instanceof DocType) { printDocType(out, doc.getDocType()); // Always print line separator after declaration, helps the // output look better and is semantically inconsequential out.write(lineSeparator); } else { // XXX if we get here then we have a illegal content, for // now we'll just ignore it } newline(out); indent(out, 0); } out.flush(); }
private void addTemplateFromFile(String fileName, File file) { Pair<String,String> nameExt = decodeFileName(fileName); final String extension = nameExt.second; final String templateQName = nameExt.first; if (templateQName.length() == 0) { return; } try { final String text = FileUtil.loadFile(file, CharsetToolkit.UTF8_CHARSET); addTemplate(templateQName, extension).setText(text); } catch (IOException e) { LOG.error(e); } }
@Override public String getCharset(@NotNull VirtualFile file, @NotNull byte[] content) { if (CharsetToolkit.hasUTF8Bom(content)) { return CharsetToolkit.UTF8; } ByteBuffer bytes = ByteBuffer.wrap(content, 0, Math.min(256, content.length)); String decoded = CharsetToolkit.UTF8_CHARSET.decode(bytes).toString(); return getCharsetFromEncodingDeclaration(StringUtil.convertLineSeparators(decoded)); }
@Override public String getCharset(@NotNull VirtualFile file, @NotNull final byte[] content) { Charset charset = EncodingRegistry.getInstance().getDefaultCharsetForPropertiesFiles(file); if (charset == null) { charset = CharsetToolkit.getDefaultSystemCharset(); } return charset.name(); }
@Override @NotNull public Object[] getVariants() { Charset[] charsets = CharsetToolkit.getAvailableCharsets(); List<LookupElement> suggestions = new ArrayList<LookupElement>(charsets.length); for (Charset charset : charsets) { suggestions.add(LookupElementBuilder.create(charset.name()).withCaseSensitivity(false)); } return suggestions.toArray(new LookupElement[suggestions.size()]); }
@Override public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { final CredentialsProvider provider = (CredentialsProvider)context.getAttribute(HttpClientContext.CREDS_PROVIDER); final Credentials credentials = provider.getCredentials(BASIC_AUTH_SCOPE); if (credentials != null) { request.addHeader(new BasicScheme(CharsetToolkit.UTF8_CHARSET).authenticate(credentials, request, context)); } final HttpHost proxyHost = ((HttpRoute)context.getAttribute(HttpClientContext.HTTP_ROUTE)).getProxyHost(); if (proxyHost != null) { final Credentials proxyCredentials = provider.getCredentials(new AuthScope(proxyHost)); if (proxyCredentials != null) { request.addHeader(BasicScheme.authenticate(proxyCredentials, CharsetToolkit.UTF8, true)); } } }
@Override public void apply(MultiMap<VirtualFile, TextFilePatchInProgress> patchGroups, LocalChangeList localList, String fileName, TransparentlyFailedValueI<Map<String, Map<String, CharSequence>>, PatchSyntaxException> additionalInfo) { final FileSaverDialog dialog = FileChooserFactory.getInstance().createSaveFileDialog( new FileSaverDescriptor("Save Patch to", ""), myProject); final VirtualFile baseDir = myProject.getBaseDir(); final VirtualFileWrapper save = dialog.save(baseDir, "TheirsChanges.patch"); if (save != null) { final CommitContext commitContext = new CommitContext(); final VirtualFile baseForPatch = myBaseForPatch == null ? baseDir : myBaseForPatch; try { final List<FilePatch> textPatches = patchGroupsToOneGroup(patchGroups, baseForPatch); commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, false); PatchWriter.writePatches(myProject, save.getFile().getPath(), textPatches, commitContext, CharsetToolkit.UTF8_CHARSET); } catch (final IOException e) { LOG.info(e); WaitForProgressToShow.runOrInvokeLaterAboveProgress(new Runnable() { @Override public void run() { Messages.showErrorDialog(myProject, VcsBundle.message("create.patch.error.title", e.getMessage()), CommonBundle.getErrorTitle()); } }, null, myProject); } } }
public static <T extends UsageDescriptor> String getDataString(@NotNull Map<GroupDescriptor, Set<T>> usages, int maxSize) { if (usages.isEmpty()) { return ""; } String dataStr = ConvertUsagesUtil.convertUsages(usages); return maxSize > 0 && dataStr.getBytes(CharsetToolkit.UTF8_CHARSET).length > maxSize ? ConvertUsagesUtil.cutDataString(dataStr, maxSize) : dataStr; }