diff options
| author | Sasa Zivkov <sasa.zivkov@sap.com> | 2010-05-19 16:59:28 +0200 |
|---|---|---|
| committer | Shawn O. Pearce <spearce@spearce.org> | 2010-05-19 14:37:16 -0700 |
| commit | f3d8a8ecad614906a2c4ec0077cdb24129da6c6d (patch) | |
| tree | 34d041692beff0f392c27869f49b76c0fc2053e6 /org.eclipse.jgit/src/org | |
| parent | 2e961989e42b1fe7e8bd9eaa7a3d2e88a0d1d001 (diff) | |
| download | jgit-f3d8a8ecad614906a2c4ec0077cdb24129da6c6d.tar.gz jgit-f3d8a8ecad614906a2c4ec0077cdb24129da6c6d.zip | |
Externalize strings from JGit
The strings are externalized into the root resource bundles.
The resource bundles are stored under the new "resources" source
folder to get proper maven build.
Strings from tests are, in general, not externalized. Only in
cases where it was necessary to make the test pass the strings
were externalized. This was typically necessary in cases where
e.getMessage() was used in assert and the exception message was
slightly changed due to reuse of the externalized strings.
Change-Id: Ic0f29c80b9a54fcec8320d8539a3e112852a1f7b
Signed-off-by: Sasa Zivkov <sasa.zivkov@sap.com>
Diffstat (limited to 'org.eclipse.jgit/src/org')
134 files changed, 1257 insertions, 620 deletions
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java b/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java new file mode 100644 index 0000000000..fbc17aad8e --- /dev/null +++ b/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java @@ -0,0 +1,420 @@ +/* + * Copyright (C) 2010, Sasa Zivkov <sasa.zivkov@sap.com> + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.eclipse.jgit; + +import org.eclipse.jgit.nls.NLS; +import org.eclipse.jgit.nls.TranslationBundle; + +/** + * Translation bundle for JGit core + */ +public class JGitText extends TranslationBundle { + + /** + * @return an instance of this translation bundle + */ + public static JGitText get() { + return NLS.getBundleFor(JGitText.class); + } + + /***/ public String DIRCChecksumMismatch; + /***/ public String DIRCExtensionIsTooLargeAt; + /***/ public String DIRCExtensionNotSupportedByThisVersion; + /***/ public String DIRCHasTooManyEntries; + /***/ public String JRELacksMD5Implementation; + /***/ public String URINotSupported; + /***/ public String URLNotFound; + /***/ public String aNewObjectIdIsRequired; + /***/ public String advertisementCameBefore; + /***/ public String advertisementOfCameBefore; + /***/ public String amazonS3ActionFailed; + /***/ public String amazonS3ActionFailedGivingUp; + /***/ public String anExceptionOccurredWhileTryingToAddTheIdOfHEAD; + /***/ public String anSSHSessionHasBeenAlreadyCreated; + /***/ public String atLeastOnePathIsRequired; + /***/ public String atLeastTwoFiltersNeeded; + /***/ public String badBase64InputCharacterAt; + /***/ public String badEntryDelimiter; + /***/ public String badEntryName; + /***/ public String badEscape; + /***/ public String badGroupHeader; + /***/ public String badObjectType; + /***/ public String badSectionEntry; + /***/ public String base64InputNotProperlyPadded; + /***/ public String baseLengthIncorrect; + /***/ public String blobNotFound; + /***/ public String blobNotFoundForPath; + /***/ public String cannotBeCombined; + /***/ public String cannotCombineTreeFilterWithRevFilter; + /***/ public String cannotCommitWriteTo; + /***/ public String cannotConnectPipes; + /***/ public String cannotConvertScriptToText; + /***/ public String cannotCreateConfig; + /***/ public String cannotCreateDirectory; + /***/ public String cannotCreateHEAD; + /***/ public String cannotDeleteFile; + /***/ public String cannotDeleteStaleTrackingRef2; + /***/ public String cannotDeleteStaleTrackingRef; + /***/ public String cannotDetermineProxyFor; + /***/ public String cannotDownload; + /***/ public String cannotExecute; + /***/ public String cannotGet; + /***/ public String cannotListRefs; + /***/ public String cannotLock; + /***/ public String cannotLockFile; + /***/ public String cannotLockPackIn; + /***/ public String cannotMatchOnEmptyString; + /***/ public String cannotMoveIndexTo; + /***/ public String cannotMovePackTo; + /***/ public String cannotOpenService; + /***/ public String cannotParseGitURIish; + /***/ public String cannotRead; + /***/ public String cannotReadBlob; + /***/ public String cannotReadCommit; + /***/ public String cannotReadFile; + /***/ public String cannotReadHEAD; + /***/ public String cannotReadObject; + /***/ public String cannotReadTree; + /***/ public String cannotResolveLocalTrackingRefForUpdating; + /***/ public String cannotStoreObjects; + /***/ public String cannotUnloadAModifiedTree; + /***/ public String cannotWorkWithOtherStagesThanZeroRightNow; + /***/ public String cantFindObjectInReversePackIndexForTheSpecifiedOffset; + /***/ public String cantPassMeATree; + /***/ public String channelMustBeInRange0_255; + /***/ public String characterClassIsNotSupported; + /***/ public String checkoutConflictWithFile; + /***/ public String checkoutConflictWithFiles; + /***/ public String classCastNotA; + /***/ public String collisionOn; + /***/ public String commandWasCalledInTheWrongState; + /***/ public String commitAlreadyExists; + /***/ public String commitMessageNotSpecified; + /***/ public String commitOnRepoWithoutHEADCurrentlyNotSupported; + /***/ public String compressingObjects; + /***/ public String connectionFailed; + /***/ public String connectionTimeOut; + /***/ public String contextMustBeNonNegative; + /***/ public String corruptObjectBadStream; + /***/ public String corruptObjectBadStreamCorruptHeader; + /***/ public String corruptObjectGarbageAfterSize; + /***/ public String corruptObjectIncorrectLength; + /***/ public String corruptObjectInvalidEntryMode; + /***/ public String corruptObjectInvalidMode2; + /***/ public String corruptObjectInvalidMode3; + /***/ public String corruptObjectInvalidMode; + /***/ public String corruptObjectInvalidType2; + /***/ public String corruptObjectInvalidType; + /***/ public String corruptObjectMalformedHeader; + /***/ public String corruptObjectNegativeSize; + /***/ public String corruptObjectNoAuthor; + /***/ public String corruptObjectNoCommitter; + /***/ public String corruptObjectNoHeader; + /***/ public String corruptObjectNoObject; + /***/ public String corruptObjectNoTagName; + /***/ public String corruptObjectNoTaggerBadHeader; + /***/ public String corruptObjectNoTaggerHeader; + /***/ public String corruptObjectNoType; + /***/ public String corruptObjectNotree; + /***/ public String corruptObjectPackfileChecksumIncorrect; + /***/ public String corruptionDetectedReReadingAt; + /***/ public String couldNotDeleteLockFileShouldNotHappen; + /***/ public String couldNotDeleteTemporaryIndexFileShouldNotHappen; + /***/ public String couldNotLockHEAD; + /***/ public String couldNotReadIndexInOneGo; + /***/ public String couldNotRenameDeleteOldIndex; + /***/ public String couldNotRenameTemporaryIndexFileToIndex; + /***/ public String couldNotURLEncodeToUTF8; + /***/ public String couldNotWriteFile; + /***/ public String countingObjects; + /***/ public String creatingDeltasIsNotImplemented; + /***/ public String daemonAlreadyRunning; + /***/ public String deletingNotSupported; + /***/ public String destinationIsNotAWildcard; + /***/ public String dirCacheDoesNotHaveABackingFile; + /***/ public String dirCacheFileIsNotLocked; + /***/ public String dirCacheIsNotLocked; + /***/ public String doesNotHandleMode; + /***/ public String downloadCancelled; + /***/ public String downloadCancelledDuringIndexing; + /***/ public String duplicateAdvertisementsOf; + /***/ public String duplicateRef; + /***/ public String duplicateRemoteRefUpdateIsIllegal; + /***/ public String duplicateStagesNotAllowed; + /***/ public String eitherGIT_DIRorGIT_WORK_TREEmustBePassed; + /***/ public String emptyPathNotPermitted; + /***/ public String encryptionError; + /***/ public String endOfFileInEscape; + /***/ public String entryNotFoundByPath; + /***/ public String errorDecodingFromFile; + /***/ public String errorEncodingFromFile; + /***/ public String errorInBase64CodeReadingStream; + /***/ public String errorInPackedRefs; + /***/ public String errorInvalidProtocolWantedOldNewRef; + /***/ public String errorListing; + /***/ public String errorOccurredDuringUnpackingOnTheRemoteEnd; + /***/ public String errorReadingInfoRefs; + /***/ public String exceptionCaughtDuringExecutionOfCommitCommand; + /***/ public String exceptionOccuredDuringAddingOfOptionToALogCommand; + /***/ public String expectedACKNAKFoundEOF; + /***/ public String expectedACKNAKGot; + /***/ public String expectedBooleanStringValue; + /***/ public String expectedCharacterEncodingGuesses; + /***/ public String expectedEOFReceived; + /***/ public String expectedGot; + /***/ public String expectedPktLineWithService; + /***/ public String expectedReceivedContentType; + /***/ public String expectedReportForRefNotReceived; + /***/ public String failedUpdatingRefs; + /***/ public String failureDueToOneOfTheFollowing; + /***/ public String failureUpdatingFETCH_HEAD; + /***/ public String failureUpdatingTrackingRef; + /***/ public String fileCannotBeDeleted; + /***/ public String fileIsTooBigForThisConvenienceMethod; + /***/ public String fileIsTooLarge; + /***/ public String fileModeNotSetForPath; + /***/ public String flagIsDisposed; + /***/ public String flagNotFromThis; + /***/ public String flagsAlreadyCreated; + /***/ public String funnyRefname; + /***/ public String hugeIndexesAreNotSupportedByJgitYet; + /***/ public String hunkBelongsToAnotherFile; + /***/ public String hunkDisconnectedFromFile; + /***/ public String hunkHeaderDoesNotMatchBodyLineCountOf; + /***/ public String illegalArgumentNotA; + /***/ public String illegalStateExists; + /***/ public String improperlyPaddedBase64Input; + /***/ public String inMemoryBufferLimitExceeded; + /***/ public String incorrectHashFor; + /***/ public String incorrectOBJECT_ID_LENGTH; + /***/ public String incorrectObjectType_COMMITnorTREEnorBLOBnorTAG; + /***/ public String indexFileIsInUse; + /***/ public String indexFileIsTooLargeForJgit; + /***/ public String indexSignatureIsInvalid; + /***/ public String integerValueOutOfRange; + /***/ public String internalRevisionError; + /***/ public String interruptedWriting; + /***/ public String invalidAdvertisementOf; + /***/ public String invalidAncestryLength; + /***/ public String invalidBooleanValue; + /***/ public String invalidChannel; + /***/ public String invalidCharacterInBase64Data; + /***/ public String invalidCommitParentNumber; + /***/ public String invalidEncryption; + /***/ public String invalidGitType; + /***/ public String invalidId; + /***/ public String invalidIdLength; + /***/ public String invalidIntegerValue; + /***/ public String invalidKey; + /***/ public String invalidLineInConfigFile; + /***/ public String invalidModeFor; + /***/ public String invalidModeForPath; + /***/ public String invalidObject; + /***/ public String invalidOldIdSent; + /***/ public String invalidPacketLineHeader; + /***/ public String invalidPath; + /***/ public String invalidRefName; + /***/ public String invalidStageForPath; + /***/ public String invalidTagOption; + /***/ public String invalidTimeout; + /***/ public String invalidURL; + /***/ public String invalidWildcards; + /***/ public String invalidWindowSize; + /***/ public String isAStaticFlagAndHasNorevWalkInstance; + /***/ public String kNotInRange; + /***/ public String lengthExceedsMaximumArraySize; + /***/ public String listingAlternates; + /***/ public String localObjectsIncomplete; + /***/ public String localRefIsMissingObjects; + /***/ public String lockCountMustBeGreaterOrEqual1; + /***/ public String lockError; + /***/ public String lockOnNotClosed; + /***/ public String lockOnNotHeld; + /***/ public String malformedpersonIdentString; + /***/ public String mergeStrategyAlreadyExistsAsDefault; + /***/ public String missingAccesskey; + /***/ public String missingForwardImageInGITBinaryPatch; + /***/ public String missingObject; + /***/ public String missingPrerequisiteCommits; + /***/ public String missingSecretkey; + /***/ public String mixedStagesNotAllowed; + /***/ public String multipleMergeBasesFor; + /***/ public String need2Arguments; + /***/ public String needPackOut; + /***/ public String needsAtLeastOneEntry; + /***/ public String needsWorkdir; + /***/ public String newlineInQuotesNotAllowed; + /***/ public String noApplyInDelete; + /***/ public String noClosingBracket; + /***/ public String noHEADExistsAndNoExplicitStartingRevisionWasSpecified; + /***/ public String noHMACsupport; + /***/ public String noSuchRef; + /***/ public String noXMLParserAvailable; + /***/ public String notABoolean; + /***/ public String notABundle; + /***/ public String notADIRCFile; + /***/ public String notAGitDirectory; + /***/ public String notAPACKFile; + /***/ public String notARef; + /***/ public String notASCIIString; + /***/ public String notAValidPack; + /***/ public String notFound; + /***/ public String notValid; + /***/ public String nothingToFetch; + /***/ public String nothingToPush; + /***/ public String objectAtHasBadZlibStream; + /***/ public String objectAtPathDoesNotHaveId; + /***/ public String objectIsCorrupt; + /***/ public String objectIsNotA; + /***/ public String objectNotFoundIn; + /***/ public String offsetWrittenDeltaBaseForObjectNotFoundInAPack; + /***/ public String onlyOneFetchSupported; + /***/ public String onlyOneOperationCallPerConnectionIsSupported; + /***/ public String openFilesMustBeAtLeast1; + /***/ public String openingConnection; + /***/ public String outputHasAlreadyBeenStarted; + /***/ public String packChecksumMismatch; + /***/ public String packCorruptedWhileWritingToFilesystem; + /***/ public String packDoesNotMatchIndex; + /***/ public String packFileInvalid; + /***/ public String packHasUnresolvedDeltas; + /***/ public String packObjectCountMismatch; + /***/ public String packTooLargeForIndexVersion1; + /***/ public String packetSizeMustBeAtLeast; + /***/ public String packetSizeMustBeAtMost; + /***/ public String packfileCorruptionDetected; + /***/ public String packfileIsTruncated; + /***/ public String packingCancelledDuringObjectsWriting; + /***/ public String pathIsNotInWorkingDir; + /***/ public String peeledLineBeforeRef; + /***/ public String peerDidNotSupplyACompleteObjectGraph; + /***/ public String prefixRemote; + /***/ public String problemWithResolvingPushRefSpecsLocally; + /***/ public String progressMonUploading; + /***/ public String propertyIsAlreadyNonNull; + /***/ public String pushCancelled; + /***/ public String pushIsNotSupportedForBundleTransport; + /***/ public String pushNotPermitted; + /***/ public String rawLogMessageDoesNotParseAsLogEntry; + /***/ public String readTimedOut; + /***/ public String readingObjectsFromLocalRepositoryFailed; + /***/ public String receivingObjects; + /***/ public String refUpdateReturnCodeWas; + /***/ public String reflogsNotYetSupportedByRevisionParser; + /***/ public String remoteConfigHasNoURIAssociated; + /***/ public String remoteDoesNotHaveSpec; + /***/ public String remoteDoesNotSupportSmartHTTPPush; + /***/ public String remoteHungUpUnexpectedly; + /***/ public String remoteNameCantBeNull; + /***/ public String repositoryAlreadyExists; + /***/ public String repositoryNotFound; + /***/ public String requiredHashFunctionNotAvailable; + /***/ public String resolvingDeltas; + /***/ public String serviceNotPermitted; + /***/ public String shortCompressedStreamAt; + /***/ public String shortReadOfBlock; + /***/ public String shortReadOfOptionalDIRCExtensionExpectedAnotherBytes; + /***/ public String shortSkipOfBlock; + /***/ public String smartHTTPPushDisabled; + /***/ public String sourceDestinationMustMatch; + /***/ public String sourceIsNotAWildcard; + /***/ public String sourceRefDoesntResolveToAnyObject; + /***/ public String sourceRefNotSpecifiedForRefspec; + /***/ public String staleRevFlagsOn; + /***/ public String startingReadStageWithoutWrittenRequestDataPendingIsNotSupported; + /***/ public String statelessRPCRequiresOptionToBeEnabled; + /***/ public String symlinkCannotBeWrittenAsTheLinkTarget; + /***/ public String tSizeMustBeGreaterOrEqual1; + /***/ public String theFactoryMustNotBeNull; + /***/ public String timerAlreadyTerminated; + /***/ public String topologicalSortRequired; + /***/ public String transportExceptionBadRef; + /***/ public String transportExceptionEmptyRef; + /***/ public String transportExceptionInvalid; + /***/ public String transportExceptionMissingAssumed; + /***/ public String transportExceptionReadRef; + /***/ public String treeEntryAlreadyExists; + /***/ public String treeIteratorDoesNotSupportRemove; + /***/ public String truncatedHunkLinesMissingForAncestor; + /***/ public String truncatedHunkNewLinesMissing; + /***/ public String truncatedHunkOldLinesMissing; + /***/ public String unableToCheckConnectivity; + /***/ public String unableToLockTag; + /***/ public String unableToStore; + /***/ public String unableToWrite; + /***/ public String unencodeableFile; + /***/ public String unexpectedEndOfConfigFile; + /***/ public String unexpectedHunkTrailer; + /***/ public String unexpectedOddResult; + /***/ public String unexpectedRefReport; + /***/ public String unexpectedReportLine2; + /***/ public String unexpectedReportLine; + /***/ public String unknownDIRCVersion; + /***/ public String unknownHost; + /***/ public String unknownIndexVersionOrCorruptIndex; + /***/ public String unknownObjectType; + /***/ public String unknownRepositoryFormat2; + /***/ public String unknownRepositoryFormat; + /***/ public String unmergedPath; + /***/ public String unpackError; + /***/ public String unreadablePackIndex; + /***/ public String unrecognizedRef; + /***/ public String unsupportedCommand0; + /***/ public String unsupportedEncryptionAlgorithm; + /***/ public String unsupportedEncryptionVersion; + /***/ public String unsupportedOperationNotAddAtEnd; + /***/ public String unsupportedPackIndexVersion; + /***/ public String unsupportedPackVersion; + /***/ public String updatingRefFailed; + /***/ public String userConfigFileInvalid; + /***/ public String walkFailure; + /***/ public String windowSizeMustBeLesserThanLimit; + /***/ public String windowSizeMustBePowerOf2; + /***/ public String writeTimedOut; + /***/ public String writerAlreadyInitialized; + /***/ public String writingNotPermitted; + /***/ public String writingNotSupported; + /***/ public String writingObjects; + /***/ public String wrongDecompressedLength; +} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java index 7501509d11..542c821451 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java @@ -43,7 +43,9 @@ package org.eclipse.jgit.api; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.errors.UnmergedPathException; import org.eclipse.jgit.lib.Commit; @@ -112,7 +114,7 @@ public class CommitCommand extends GitCommand<RevCommit> { Ref head = repo.getRef(Constants.HEAD); if (head == null) throw new NoHeadException( - "Commit on repo without HEAD currently not supported"); + JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported); // determine the current HEAD and the commit it is referring to ObjectId parentID = repo.resolve(Constants.HEAD + "^{commit}"); @@ -153,15 +155,11 @@ public class CommitCommand extends GitCommand<RevCommit> { case REJECTED: case LOCK_FAILURE: throw new ConcurrentRefUpdateException( - "Could lock HEAD during commit", ru.getRef(), rc); + JGitText.get().couldNotLockHEAD, ru.getRef(), rc); default: - throw new JGitInternalException( - "Updating the ref " - + Constants.HEAD - + " to " - + commitId.toString() - + " failed. ReturnCode from RefUpdate.update() was " - + rc); + throw new JGitInternalException(MessageFormat.format( + JGitText.get().updatingRefFailed + , Constants.HEAD, commitId.toString(), rc)); } } finally { index.unlock(); @@ -173,7 +171,7 @@ public class CommitCommand extends GitCommand<RevCommit> { throw e; } catch (IOException e) { throw new JGitInternalException( - "Exception caught during execution of commit command", e); + JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e); } } @@ -188,7 +186,7 @@ public class CommitCommand extends GitCommand<RevCommit> { if (message == null) // as long as we don't suppport -C option we have to have // an explicit message - throw new NoMessageException("commit message not specified"); + throw new NoMessageException(JGitText.get().commitMessageNotSpecified); if (committer == null) committer = new PersonIdent(repo); if (author == null) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/ConcurrentRefUpdateException.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/ConcurrentRefUpdateException.java index c5d9fe68dd..02bb494f66 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/api/ConcurrentRefUpdateException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/ConcurrentRefUpdateException.java @@ -37,6 +37,9 @@ */ package org.eclipse.jgit.api; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefUpdate; @@ -53,16 +56,16 @@ public class ConcurrentRefUpdateException extends GitAPIException { ConcurrentRefUpdateException(String message, Ref ref, RefUpdate.Result rc, Throwable cause) { - super((rc == null) ? message : message - + ". RefUpdate return code was: " + rc, cause); + super((rc == null) ? message : message + ". " + + MessageFormat.format(JGitText.get().refUpdateReturnCodeWas, rc), cause); this.rc = rc; this.ref = ref; } ConcurrentRefUpdateException(String message, Ref ref, RefUpdate.Result rc) { - super((rc == null) ? message : message - + ". RefUpdate return code was: " + rc); + super((rc == null) ? message : message + ". " + + MessageFormat.format(JGitText.get().refUpdateReturnCodeWas, rc)); this.rc = rc; this.ref = ref; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/GitCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/GitCommand.java index 4df5b4437b..ece467aa07 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/api/GitCommand.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/GitCommand.java @@ -37,8 +37,10 @@ */ package org.eclipse.jgit.api; +import java.text.MessageFormat; import java.util.concurrent.Callable; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Repository; /** @@ -110,8 +112,8 @@ public abstract class GitCommand<T> implements Callable<T> { */ protected void checkCallable() { if (!callable) - throw new IllegalStateException("Command " - + this.getClass().getName() - + " was called in the wrong state"); + throw new IllegalStateException(MessageFormat.format( + JGitText.get().commandWasCalledInTheWrongState + , this.getClass().getName())); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/LogCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/LogCommand.java index 4ce57201d3..414fac4f38 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/api/LogCommand.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/LogCommand.java @@ -43,7 +43,9 @@ package org.eclipse.jgit.api; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.AnyObjectId; @@ -97,13 +99,13 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> { ObjectId headId = repo.resolve(Constants.HEAD); if (headId == null) throw new NoHeadException( - "No HEAD exists and no explicit starting revision was specified"); + JGitText.get().noHEADExistsAndNoExplicitStartingRevisionWasSpecified); add(headId); } catch (IOException e) { // all exceptions thrown by add() shouldn't occur and represent // severe low-level exception which are therefore wrapped throw new JGitInternalException( - "An exception occured while trying to add the Id of HEAD", + JGitText.get().anExceptionOccurredWhileTryingToAddTheIdOfHEAD, e); } } @@ -214,9 +216,9 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> { } catch (IncorrectObjectTypeException e) { throw e; } catch (IOException e) { - throw new JGitInternalException( - "Exception occured during adding of " + start - + " as option to a Log command", e); + throw new JGitInternalException(MessageFormat.format( + JGitText.get().exceptionOccuredDuringAddingOfOptionToALogCommand + , start), e); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffFormatter.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffFormatter.java index 115d9baff3..2d552d40d9 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffFormatter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffFormatter.java @@ -50,6 +50,7 @@ import java.io.IOException; import java.io.OutputStream; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.patch.FileHeader; /** @@ -75,7 +76,7 @@ public class DiffFormatter { */ public void setContext(final int lineCount) { if (lineCount < 0) - throw new IllegalArgumentException("context must be >= 0"); + throw new IllegalArgumentException(JGitText.get().contextMustBeNonNegative); context = lineCount; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/MyersDiff.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/MyersDiff.java index 055729961b..6a4b44bff1 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/diff/MyersDiff.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/diff/MyersDiff.java @@ -44,6 +44,9 @@ package org.eclipse.jgit.diff; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.util.IntList; import org.eclipse.jgit.util.LongList; @@ -292,21 +295,21 @@ public class MyersDiff { final int getIndex(int d, int k) { // TODO: remove if (((d + k - middleK) % 2) == 1) - throw new RuntimeException("odd: " + d + " + " + k + " - " + middleK); + throw new RuntimeException(MessageFormat.format(JGitText.get().unexpectedOddResult, d, k, middleK)); return (d + k - middleK) / 2; } final int getX(int d, int k) { // TODO: remove if (k < beginK || k > endK) - throw new RuntimeException("k " + k + " not in " + beginK + " - " + endK); + throw new RuntimeException(MessageFormat.format(JGitText.get().kNotInRange, k, beginK, endK)); return x.get(getIndex(d, k)); } final long getSnake(int d, int k) { // TODO: remove if (k < beginK || k > endK) - throw new RuntimeException("k " + k + " not in " + beginK + " - " + endK); + throw new RuntimeException(MessageFormat.format(JGitText.get().kNotInRange, k, beginK, endK)); return snake.get(getIndex(d, k)); } @@ -520,7 +523,7 @@ if (k < beginK || k > endK) */ public static void main(String[] args) { if (args.length != 2) { - System.err.println("Need 2 arguments"); + System.err.println(JGitText.get().need2Arguments); System.exit(1); } try { @@ -532,4 +535,4 @@ if (k < beginK || k > endK) e.printStackTrace(); } } -}
\ No newline at end of file +} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java index 3a8abc1a73..42fea48520 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java @@ -56,9 +56,11 @@ import java.io.OutputStream; import java.io.UnsupportedEncodingException; import java.security.DigestOutputStream; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.Arrays; import java.util.Comparator; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.UnmergedPathException; import org.eclipse.jgit.lib.Constants; @@ -200,7 +202,7 @@ public class DirCache { throws CorruptObjectException, IOException { final DirCache c = new DirCache(indexLocation); if (!c.lock()) - throw new IOException("Cannot lock " + indexLocation); + throw new IOException(MessageFormat.format(JGitText.get().cannotLock, indexLocation)); try { c.read(); @@ -319,7 +321,7 @@ public class DirCache { */ public void read() throws IOException, CorruptObjectException { if (liveFile == null) - throw new IOException("DirCache does not have a backing file"); + throw new IOException(JGitText.get().dirCacheDoesNotHaveABackingFile); if (!liveFile.exists()) clear(); else if (liveFile.lastModified() != lastModified) { @@ -363,13 +365,13 @@ public class DirCache { IO.readFully(in, hdr, 0, 12); md.update(hdr, 0, 12); if (!is_DIRC(hdr)) - throw new CorruptObjectException("Not a DIRC file."); + throw new CorruptObjectException(JGitText.get().notADIRCFile); final int ver = NB.decodeInt32(hdr, 4); if (ver != 2) - throw new CorruptObjectException("Unknown DIRC version " + ver); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().unknownDIRCVersion, ver)); entryCnt = NB.decodeInt32(hdr, 8); if (entryCnt < 0) - throw new CorruptObjectException("DIRC has too many entries."); + throw new CorruptObjectException(JGitText.get().DIRCHasTooManyEntries); // Load the individual file entries. // @@ -398,9 +400,8 @@ public class DirCache { switch (NB.decodeInt32(hdr, 0)) { case EXT_TREE: { if (Integer.MAX_VALUE < sz) { - throw new CorruptObjectException("DIRC extension " - + formatExtensionName(hdr) + " is too large at " - + sz + " bytes."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().DIRCExtensionIsTooLargeAt + , formatExtensionName(hdr), sz)); } final byte[] raw = new byte[(int) sz]; IO.readFully(in, raw, 0, raw.length); @@ -421,16 +422,15 @@ public class DirCache { // _required_ to understand this index format. // Since we did not trap it above we must abort. // - throw new CorruptObjectException("DIRC extension " - + formatExtensionName(hdr) - + " not supported by this version."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().DIRCExtensionNotSupportedByThisVersion + , formatExtensionName(hdr))); } } } final byte[] exp = md.digest(); if (!Arrays.equals(exp, hdr)) { - throw new CorruptObjectException("DIRC checksum mismatch"); + throw new CorruptObjectException(JGitText.get().DIRCChecksumMismatch); } } @@ -441,9 +441,8 @@ public class DirCache { while (0 < sz) { int n = in.read(b, 0, (int) Math.min(b.length, sz)); if (n < 0) { - throw new EOFException("Short read of optional DIRC extension " - + formatExtensionName(hdr) + "; expected another " + sz - + " bytes within the section."); + throw new EOFException(MessageFormat.format(JGitText.get().shortReadOfOptionalDIRCExtensionExpectedAnotherBytes + , formatExtensionName(hdr), sz)); } md.update(b, 0, n); sz -= n; @@ -475,7 +474,7 @@ public class DirCache { */ public boolean lock() throws IOException { if (liveFile == null) - throw new IOException("DirCache does not have a backing file"); + throw new IOException(JGitText.get().dirCacheDoesNotHaveABackingFile); final LockFile tmp = new LockFile(liveFile); if (tmp.lock()) { tmp.setNeedStatInformation(true); @@ -585,10 +584,10 @@ public class DirCache { private void requireLocked(final LockFile tmp) { if (liveFile == null) - throw new IllegalStateException("DirCache is not locked"); + throw new IllegalStateException(JGitText.get().dirCacheIsNotLocked); if (tmp == null) - throw new IllegalStateException("DirCache " - + liveFile.getAbsolutePath() + " not locked."); + throw new IllegalStateException(MessageFormat.format(JGitText.get().dirCacheFileIsNotLocked + , liveFile.getAbsolutePath())); } /** diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheBuilder.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheBuilder.java index 69f5444c64..e6b6197819 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheBuilder.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheBuilder.java @@ -45,8 +45,10 @@ package org.eclipse.jgit.dircache; import java.io.IOException; +import java.text.MessageFormat; import java.util.Arrays; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.WindowCursor; @@ -101,8 +103,8 @@ public class DirCacheBuilder extends BaseDirCacheEditor { */ public void add(final DirCacheEntry newEntry) { if (newEntry.getRawMode() == 0) - throw new IllegalArgumentException("FileMode not set for path " - + newEntry.getPathString()); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().fileModeNotSetForPath + , newEntry.getPathString())); beforeAdd(newEntry); fastAdd(newEntry); } @@ -214,9 +216,9 @@ public class DirCacheBuilder extends BaseDirCacheEditor { final int peStage = lastEntry.getStage(); final int dceStage = newEntry.getStage(); if (peStage == dceStage) - throw bad(newEntry, "Duplicate stages not allowed"); + throw bad(newEntry, JGitText.get().duplicateStagesNotAllowed); if (peStage == 0 || dceStage == 0) - throw bad(newEntry, "Mixed stages not allowed"); + throw bad(newEntry, JGitText.get().mixedStagesNotAllowed); if (peStage > dceStage) sorted = false; } @@ -237,9 +239,9 @@ public class DirCacheBuilder extends BaseDirCacheEditor { final int peStage = pe.getStage(); final int ceStage = ce.getStage(); if (peStage == ceStage) - throw bad(ce, "Duplicate stages not allowed"); + throw bad(ce, JGitText.get().duplicateStagesNotAllowed); if (peStage == 0 || ceStage == 0) - throw bad(ce, "Mixed stages not allowed"); + throw bad(ce, JGitText.get().mixedStagesNotAllowed); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEditor.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEditor.java index 85ad8b4d79..77e9d51e05 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEditor.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEditor.java @@ -45,11 +45,13 @@ package org.eclipse.jgit.dircache; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; /** @@ -149,8 +151,8 @@ public class DirCacheEditor extends BaseDirCacheEditor { ent = new DirCacheEntry(e.path); e.apply(ent); if (ent.getRawMode() == 0) - throw new IllegalArgumentException("FileMode not set" - + " for path " + ent.getPathString()); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().fileModeNotSetForPath + , ent.getPathString())); } else { ent = cache.getEntry(eIdx); e.apply(ent); @@ -241,7 +243,7 @@ public class DirCacheEditor extends BaseDirCacheEditor { } public void apply(final DirCacheEntry ent) { - throw new UnsupportedOperationException("No apply in delete"); + throw new UnsupportedOperationException(JGitText.get().noApplyInDelete); } } @@ -271,7 +273,7 @@ public class DirCacheEditor extends BaseDirCacheEditor { } public void apply(final DirCacheEntry ent) { - throw new UnsupportedOperationException("No apply in delete"); + throw new UnsupportedOperationException(JGitText.get().noApplyInDelete); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java index 415de095b2..afa6bef05b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java @@ -51,8 +51,10 @@ import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.Arrays; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.FileMode; @@ -145,7 +147,7 @@ public class DirCacheEntry { for (;;) { final int c = in.read(); if (c < 0) - throw new EOFException("Short read of block."); + throw new EOFException(JGitText.get().shortReadOfBlock); if (c == 0) break; tmp.write(c); @@ -229,11 +231,11 @@ public class DirCacheEntry { */ public DirCacheEntry(final byte[] newPath, final int stage) { if (!isValidPath(newPath)) - throw new IllegalArgumentException("Invalid path: " - + toString(newPath)); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidPath + , toString(newPath))); if (stage < 0 || 3 < stage) - throw new IllegalArgumentException("Invalid stage " + stage - + " for path " + toString(newPath)); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidStageForPath + , stage, toString(newPath))); info = new byte[INFO_LEN]; infoOffset = 0; @@ -397,8 +399,8 @@ public class DirCacheEntry { switch (mode.getBits() & FileMode.TYPE_MASK) { case FileMode.TYPE_MISSING: case FileMode.TYPE_TREE: - throw new IllegalArgumentException("Invalid mode " + mode - + " for path " + getPathString()); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidModeForPath + , mode, getPathString())); } NB.encodeInt32(info, infoOffset + P_MODE, mode.getBits()); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CheckoutConflictException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CheckoutConflictException.java index b602033dc0..7c6560a3ec 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CheckoutConflictException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CheckoutConflictException.java @@ -46,6 +46,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Exception thrown if a conflict occurs during a merge checkout. @@ -59,7 +62,7 @@ public class CheckoutConflictException extends IOException { * @param file */ public CheckoutConflictException(String file) { - super("Checkout conflict with file: " + file); + super(MessageFormat.format(JGitText.get().checkoutConflictWithFile, file)); } /** @@ -68,7 +71,7 @@ public class CheckoutConflictException extends IOException { * @param files */ public CheckoutConflictException(String[] files) { - super("Checkout conflict with files: " + buildList(files)); + super(MessageFormat.format(JGitText.get().checkoutConflictWithFiles, buildList(files))); } private static String buildList(String[] files) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CompoundException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CompoundException.java index edee6084b3..1c432a817d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CompoundException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CompoundException.java @@ -48,13 +48,15 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import org.eclipse.jgit.JGitText; + /** An exception detailing multiple reasons for failure. */ public class CompoundException extends Exception { private static final long serialVersionUID = 1L; private static String format(final Collection<Throwable> causes) { final StringBuilder msg = new StringBuilder(); - msg.append("Failure due to one of the following:"); + msg.append(JGitText.get().failureDueToOneOfTheFollowing); for (final Throwable c : causes) { msg.append(" "); msg.append(c.getMessage()); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CorruptObjectException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CorruptObjectException.java index f42b0d7e19..939dc21604 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/CorruptObjectException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/CorruptObjectException.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.ObjectId; @@ -76,7 +78,7 @@ public class CorruptObjectException extends IOException { * @param why */ public CorruptObjectException(final ObjectId id, final String why) { - super("Object " + id.name() + " is corrupt: " + why); + super(MessageFormat.format(JGitText.get().objectIsCorrupt, id.name(), why)); } /** diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/EntryExistsException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/EntryExistsException.java index 893ee9ceb2..d7e587e3d0 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/EntryExistsException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/EntryExistsException.java @@ -45,6 +45,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Attempt to add an entry to a tree that already exists. @@ -59,6 +62,6 @@ public class EntryExistsException extends IOException { * @param name workdir relative file name */ public EntryExistsException(final String name) { - super("Tree entry \"" + name + "\" already exists."); + super(MessageFormat.format(JGitText.get().treeEntryAlreadyExists, name)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/IncorrectObjectTypeException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/IncorrectObjectTypeException.java index 7cf1de214f..0dac326f40 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/IncorrectObjectTypeException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/IncorrectObjectTypeException.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; @@ -69,7 +71,7 @@ public class IncorrectObjectTypeException extends IOException { * @param type object type */ public IncorrectObjectTypeException(final ObjectId id, final String type) { - super("Object " + id.name() + " is not a " + type + "."); + super(MessageFormat.format(JGitText.get().objectIsNotA, id.name(), type)); } /** diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/InvalidObjectIdException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/InvalidObjectIdException.java index e6577213ee..96c75f5558 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/InvalidObjectIdException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/InvalidObjectIdException.java @@ -46,6 +46,9 @@ package org.eclipse.jgit.errors; import java.io.UnsupportedEncodingException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Thrown when an invalid object id is passed in as an argument. @@ -61,7 +64,7 @@ public class InvalidObjectIdException extends IllegalArgumentException { * @param length of the sequence of invalid bytes. */ public InvalidObjectIdException(byte[] bytes, int offset, int length) { - super("Invalid id" + asAscii(bytes, offset, length)); + super(MessageFormat.format(JGitText.get().invalidId, asAscii(bytes, offset, length))); } private static String asAscii(byte[] bytes, int offset, int length) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingBundlePrerequisiteException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingBundlePrerequisiteException.java index 2d399543a0..63b0e200ca 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingBundlePrerequisiteException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingBundlePrerequisiteException.java @@ -46,6 +46,7 @@ package org.eclipse.jgit.errors; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.transport.URIish; @@ -57,7 +58,7 @@ public class MissingBundlePrerequisiteException extends TransportException { private static String format(final Map<ObjectId, String> missingCommits) { final StringBuilder r = new StringBuilder(); - r.append("missing prerequisite commits:"); + r.append(JGitText.get().missingPrerequisiteCommits); for (final Map.Entry<ObjectId, String> e : missingCommits.entrySet()) { r.append("\n "); r.append(e.getKey().name()); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingObjectException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingObjectException.java index 41cacb84ad..1d193e18c7 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingObjectException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/MissingObjectException.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; @@ -65,7 +67,7 @@ public class MissingObjectException extends IOException { * @param type object type */ public MissingObjectException(final ObjectId id, final String type) { - super("Missing " + type + " " + id.name()); + super(MessageFormat.format(JGitText.get().missingObject, type, id.name())); } /** diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/NoClosingBracketException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/NoClosingBracketException.java index 623dfa6ec6..25cf800fa7 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/NoClosingBracketException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/NoClosingBracketException.java @@ -46,6 +46,10 @@ package org.eclipse.jgit.errors; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; + /** * Thrown when a pattern contains a character group which is open to the right * side or a character class which is open to the right side. @@ -72,7 +76,7 @@ public class NoClosingBracketException extends InvalidPatternException { private static String createMessage(final int indexOfOpeningBracket, final String openingBracket, final String closingBracket) { - return String.format("No closing %s found for %s at index %s.", + return MessageFormat.format(JGitText.get().noClosingBracket, closingBracket, openingBracket, Integer.valueOf(indexOfOpeningBracket)); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/PackInvalidException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/PackInvalidException.java index a34b80db81..59354ddb70 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/PackInvalidException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/PackInvalidException.java @@ -45,6 +45,9 @@ package org.eclipse.jgit.errors; import java.io.File; import java.io.IOException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** Thrown when a PackFile previously failed and is known to be unusable */ public class PackInvalidException extends IOException { @@ -57,6 +60,6 @@ public class PackInvalidException extends IOException { * path of the invalid pack file. */ public PackInvalidException(final File path) { - super("Pack file invalid: " + path.getAbsolutePath()); + super(MessageFormat.format(JGitText.get().packFileInvalid, path.getAbsolutePath())); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/RepositoryNotFoundException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/RepositoryNotFoundException.java index c745e7326e..d00a766880 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/RepositoryNotFoundException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/RepositoryNotFoundException.java @@ -44,6 +44,9 @@ package org.eclipse.jgit.errors; import java.io.File; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** Indicates a local repository does not exist. */ public class RepositoryNotFoundException extends TransportException { @@ -94,6 +97,6 @@ public class RepositoryNotFoundException extends TransportException { } private static String message(final String location) { - return "repository not found: " + location; + return MessageFormat.format(JGitText.get().repositoryNotFound, location); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/RevWalkException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/RevWalkException.java index 0ad41ed173..7b9c70736b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/RevWalkException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/RevWalkException.java @@ -44,6 +44,7 @@ package org.eclipse.jgit.errors; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.revwalk.RevWalk; /** @@ -65,6 +66,6 @@ public class RevWalkException extends RuntimeException { * the checked exception that describes why the walk failed. */ public RevWalkException(final Throwable cause) { - super("Walk failure.", cause); + super(JGitText.get().walkFailure, cause); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/errors/UnmergedPathException.java b/org.eclipse.jgit/src/org/eclipse/jgit/errors/UnmergedPathException.java index 51e651ca5e..ccc960e967 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/errors/UnmergedPathException.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/errors/UnmergedPathException.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.errors; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.dircache.DirCacheEntry; /** @@ -62,7 +64,7 @@ public class UnmergedPathException extends IOException { * the first non-zero stage of the unmerged path. */ public UnmergedPathException(final DirCacheEntry dce) { - super("Unmerged path: " + dce.getPathString()); + super(MessageFormat.format(JGitText.get().unmergedPath, dce.getPathString())); entry = dce; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/AbstractHead.java b/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/AbstractHead.java index 42182965a0..cff542be2e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/AbstractHead.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/AbstractHead.java @@ -46,6 +46,8 @@ package org.eclipse.jgit.fnmatch; import java.util.List; +import org.eclipse.jgit.JGitText; + abstract class AbstractHead implements Head { private List<Head> newHeads = null; @@ -64,7 +66,7 @@ abstract class AbstractHead implements Head { */ public final void setNewHeads(List<Head> newHeads) { if (this.newHeads != null) - throw new IllegalStateException("Property is already non null"); + throw new IllegalStateException(JGitText.get().propertyIsAlreadyNonNull); this.newHeads = newHeads; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/GroupHead.java b/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/GroupHead.java index 79f64f859e..ffa34a7104 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/GroupHead.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/fnmatch/GroupHead.java @@ -44,11 +44,13 @@ package org.eclipse.jgit.fnmatch; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.InvalidPatternException; final class GroupHead extends AbstractHead { @@ -112,9 +114,9 @@ final class GroupHead extends AbstractHead { characterClasses.add(LetterPattern.INSTANCE); characterClasses.add(DigitPattern.INSTANCE); } else { - final String message = String.format( - "The character class %s is not supported.", - characterClass); + final String message = String.format(MessageFormat.format( + JGitText.get().characterClassIsNotSupported, + characterClass)); throw new InvalidPatternException(message, wholePattern); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/AbbreviatedObjectId.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/AbbreviatedObjectId.java index 9d9174111b..a150e8fea1 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/AbbreviatedObjectId.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/AbbreviatedObjectId.java @@ -43,6 +43,9 @@ package org.eclipse.jgit.lib; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.InvalidObjectIdException; import org.eclipse.jgit.util.NB; import org.eclipse.jgit.util.RawParseUtils; @@ -74,7 +77,8 @@ public final class AbbreviatedObjectId { public static final AbbreviatedObjectId fromString(final byte[] buf, final int offset, final int end) { if (end - offset > Constants.OBJECT_ID_STRING_LENGTH) - throw new IllegalArgumentException("Invalid id"); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidIdLength + , end - offset, Constants.OBJECT_ID_STRING_LENGTH)); return fromHexString(buf, offset, end); } @@ -87,7 +91,7 @@ public final class AbbreviatedObjectId { */ public static final AbbreviatedObjectId fromString(final String str) { if (str.length() > Constants.OBJECT_ID_STRING_LENGTH) - throw new IllegalArgumentException("Invalid id: " + str); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidId, str)); final byte[] b = Constants.encodeASCII(str); return fromHexString(b, 0, b.length); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/BinaryDelta.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/BinaryDelta.java index 461e6d4026..a59b335330 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/BinaryDelta.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/BinaryDelta.java @@ -44,6 +44,8 @@ package org.eclipse.jgit.lib; +import org.eclipse.jgit.JGitText; + /** * Recreate a stream from a base stream and a GIT pack delta. * <p> @@ -78,7 +80,7 @@ public class BinaryDelta { shift += 7; } while ((c & 0x80) != 0); if (base.length != baseLen) - throw new IllegalArgumentException("base length incorrect"); + throw new IllegalArgumentException(JGitText.get().baseLengthIncorrect); // Length of the resulting object (a variable length int). // @@ -132,7 +134,7 @@ public class BinaryDelta { // cmd == 0 has been reserved for future encoding but // for now its not acceptable. // - throw new IllegalArgumentException("unsupported command 0"); + throw new IllegalArgumentException(JGitText.get().unsupportedCommand0); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java index 0a4222fc38..b05942b02c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/BlobBasedConfig.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.lib; import java.io.FileNotFoundException; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ConfigInvalidException; import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.util.RawParseUtils; @@ -91,7 +93,7 @@ public class BlobBasedConfig extends Config { super(base); final ObjectLoader loader = r.openBlob(objectId); if (loader == null) - throw new IOException("Blob not found: " + objectId); + throw new IOException(MessageFormat.format(JGitText.get().blobNotFound, objectId)); fromText(RawParseUtils.decode(loader.getBytes())); } @@ -118,12 +120,12 @@ public class BlobBasedConfig extends Config { final Repository r = commit.getRepository(); final TreeWalk tree = TreeWalk.forPath(r, path, treeId); if (tree == null) - throw new FileNotFoundException("Entry not found by path: " + path); + throw new FileNotFoundException(MessageFormat.format(JGitText.get().entryNotFoundByPath, path)); final ObjectId blobId = tree.getObjectId(0); final ObjectLoader loader = tree.getRepository().openBlob(blobId); if (loader == null) - throw new IOException("Blob not found: " + blobId + " for path: " - + path); + throw new IOException(MessageFormat.format(JGitText.get().blobNotFoundForPath + , blobId, path)); fromText(RawParseUtils.decode(loader.getBytes())); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java index 65921e53c7..66dd89120c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java @@ -49,7 +49,9 @@ import java.io.ByteArrayInputStream; import java.io.DataInputStream; import java.io.IOException; import java.nio.charset.Charset; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.MissingObjectException; @@ -279,18 +281,18 @@ public class Commit implements Treeish { DataInputStream br = new DataInputStream(new ByteArrayInputStream(raw)); String n = br.readLine(); if (n == null || !n.startsWith("tree ")) { - throw new CorruptObjectException(commitId, "no tree"); + throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNotree); } while ((n = br.readLine()) != null && n.startsWith("parent ")) { // empty body } if (n == null || !n.startsWith("author ")) { - throw new CorruptObjectException(commitId, "no author"); + throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNoAuthor); } String rawAuthor = n.substring("author ".length()); n = br.readLine(); if (n == null || !n.startsWith("committer ")) { - throw new CorruptObjectException(commitId, "no committer"); + throw new CorruptObjectException(commitId, JGitText.get().corruptObjectNoCommitter); } String rawCommitter = n.substring("committer ".length()); n = br.readLine(); @@ -298,8 +300,8 @@ public class Commit implements Treeish { encoding = Charset.forName(n.substring("encoding ".length())); else if (n == null || !n.equals("")) { - throw new CorruptObjectException(commitId, - "malformed header:"+n); + throw new CorruptObjectException(commitId, MessageFormat.format( + JGitText.get().corruptObjectMalformedHeader, n)); } byte[] readBuf = new byte[br.available()]; // in-memory stream so this is all bytes left br.read(readBuf); @@ -336,12 +338,12 @@ public class Commit implements Treeish { */ public void commit() throws IOException { if (getCommitId() != null) - throw new IllegalStateException("exists " + getCommitId()); + throw new IllegalStateException(MessageFormat.format(JGitText.get().commitAlreadyExists, getCommitId())); setCommitId(new ObjectWriter(objdb).writeCommit(this)); } public String toString() { - return "Commit[" + ObjectId.toString(getCommitId()) + " " + getAuthor() + "]"; + return "Commit[" + ObjectId.toString(getCommitId()) + " " + getAuthor() + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } /** diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Config.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Config.java index 062c1c3974..7c5af1e648 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Config.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Config.java @@ -50,6 +50,7 @@ package org.eclipse.jgit.lib; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; @@ -59,6 +60,7 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicReference; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ConfigInvalidException; import org.eclipse.jgit.util.StringUtils; @@ -210,8 +212,8 @@ public class Config { final long val = getLong(section, subsection, name, defaultValue); if (Integer.MIN_VALUE <= val && val <= Integer.MAX_VALUE) return (int) val; - throw new IllegalArgumentException("Integer value " + section + "." - + name + " out of range"); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().integerValueOutOfRange + , section, name)); } /** @@ -257,8 +259,8 @@ public class Config { try { return mul * Long.parseLong(n); } catch (NumberFormatException nfe) { - throw new IllegalArgumentException("Invalid integer value: " - + section + "." + name + "=" + str); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidIntegerValue + , section, name, str)); } } @@ -303,8 +305,8 @@ public class Config { try { return StringUtils.toBoolean(n); } catch (IllegalArgumentException err) { - throw new IllegalArgumentException("Invalid boolean value: " - + section + "." + name + "=" + n); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidBooleanValue + , section, name, n)); } } @@ -819,7 +821,7 @@ public class Config { input = in.read(); } if (']' != input) - throw new ConfigInvalidException("Bad group header"); + throw new ConfigInvalidException(JGitText.get().badGroupHeader); e.suffix = ""; } else if (last != null) { @@ -835,7 +837,7 @@ public class Config { e.value = readValue(in, false, -1); } else - throw new ConfigInvalidException("Invalid line in config file"); + throw new ConfigInvalidException(JGitText.get().invalidLineInConfigFile); } state.set(newState(newEntries)); @@ -862,7 +864,7 @@ public class Config { for (;;) { int c = in.read(); if (c < 0) - throw new ConfigInvalidException("Unexpected end of config file"); + throw new ConfigInvalidException(JGitText.get().unexpectedEndOfConfigFile); if (']' == c) { in.reset(); @@ -873,7 +875,7 @@ public class Config { for (;;) { c = in.read(); if (c < 0) - throw new ConfigInvalidException("Unexpected end of config file"); + throw new ConfigInvalidException(JGitText.get().unexpectedEndOfConfigFile); if ('"' == c) { in.reset(); @@ -882,7 +884,7 @@ public class Config { if (' ' == c || '\t' == c) continue; // Skipped... - throw new ConfigInvalidException("Bad section entry: " + name); + throw new ConfigInvalidException(MessageFormat.format(JGitText.get().badSectionEntry, name)); } break; } @@ -890,7 +892,7 @@ public class Config { if (Character.isLetterOrDigit((char) c) || '.' == c || '-' == c) name.append((char) c); else - throw new ConfigInvalidException("Bad section entry: " + name); + throw new ConfigInvalidException(MessageFormat.format(JGitText.get().badSectionEntry, name)); } return name.toString(); } @@ -901,7 +903,7 @@ public class Config { for (;;) { int c = in.read(); if (c < 0) - throw new ConfigInvalidException("Unexpected end of config file"); + throw new ConfigInvalidException(JGitText.get().unexpectedEndOfConfigFile); if ('=' == c) break; @@ -910,7 +912,7 @@ public class Config { for (;;) { c = in.read(); if (c < 0) - throw new ConfigInvalidException("Unexpected end of config file"); + throw new ConfigInvalidException(JGitText.get().unexpectedEndOfConfigFile); if ('=' == c) break; @@ -922,7 +924,7 @@ public class Config { if (' ' == c || '\t' == c) continue; // Skipped... - throw new ConfigInvalidException("Bad entry delimiter"); + throw new ConfigInvalidException(JGitText.get().badEntryDelimiter); } break; } @@ -937,7 +939,7 @@ public class Config { name.append((char) c); break; } else - throw new ConfigInvalidException("Bad entry name: " + name); + throw new ConfigInvalidException(MessageFormat.format(JGitText.get().badEntryName, name)); } return name.toString(); } @@ -950,13 +952,13 @@ public class Config { int c = in.read(); if (c < 0) { if (value.length() == 0) - throw new ConfigInvalidException("Unexpected end of config file"); + throw new ConfigInvalidException(JGitText.get().unexpectedEndOfConfigFile); break; } if ('\n' == c) { if (quote) - throw new ConfigInvalidException("Newline in quotes not allowed"); + throw new ConfigInvalidException(JGitText.get().newlineInQuotesNotAllowed); in.reset(); break; } @@ -985,7 +987,7 @@ public class Config { c = in.read(); switch (c) { case -1: - throw new ConfigInvalidException("End of file in escape"); + throw new ConfigInvalidException(JGitText.get().endOfFileInEscape); case '\n': continue; case 't': @@ -1004,7 +1006,7 @@ public class Config { value.append('"'); continue; default: - throw new ConfigInvalidException("Bad escape: " + ((char) c)); + throw new ConfigInvalidException(MessageFormat.format(JGitText.get().badEscape, ((char) c))); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Constants.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Constants.java index 348905dd12..37836f3246 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Constants.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Constants.java @@ -49,7 +49,9 @@ import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.util.MutableInteger; @@ -327,8 +329,8 @@ public final class Constants { try { return MessageDigest.getInstance(HASH_FUNCTION); } catch (NoSuchAlgorithmException nsae) { - throw new RuntimeException("Required hash function " - + HASH_FUNCTION + " not available.", nsae); + throw new RuntimeException(MessageFormat.format( + JGitText.get().requiredHashFunctionNotAvailable, HASH_FUNCTION), nsae); } } @@ -349,7 +351,7 @@ public final class Constants { case OBJ_TAG: return TYPE_TAG; default: - throw new IllegalArgumentException("Bad object type: " + typeCode); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().badObjectType, typeCode)); } } @@ -373,7 +375,7 @@ public final class Constants { case OBJ_TAG: return ENCODED_TYPE_TAG; default: - throw new IllegalArgumentException("Bad object type: " + typeCode); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().badObjectType, typeCode)); } } @@ -408,7 +410,7 @@ public final class Constants { || typeString[position + 2] != 'o' || typeString[position + 3] != 'b' || typeString[position + 4] != endMark) - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); offset.value = position + 5; return Constants.OBJ_BLOB; @@ -419,7 +421,7 @@ public final class Constants { || typeString[position + 4] != 'i' || typeString[position + 5] != 't' || typeString[position + 6] != endMark) - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); offset.value = position + 7; return Constants.OBJ_COMMIT; @@ -428,7 +430,7 @@ public final class Constants { case 'a': if (typeString[position + 2] != 'g' || typeString[position + 3] != endMark) - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); offset.value = position + 4; return Constants.OBJ_TAG; @@ -436,19 +438,19 @@ public final class Constants { if (typeString[position + 2] != 'e' || typeString[position + 3] != 'e' || typeString[position + 4] != endMark) - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); offset.value = position + 5; return Constants.OBJ_TREE; default: - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); } default: - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); } } catch (ArrayIndexOutOfBoundsException bad) { - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); } } @@ -481,7 +483,7 @@ public final class Constants { for (int k = r.length - 1; k >= 0; k--) { final char c = s.charAt(k); if (c > 127) - throw new IllegalArgumentException("Not ASCII string: " + s); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().notASCIIString, s)); r[k] = (byte) c; } return r; @@ -512,7 +514,7 @@ public final class Constants { static { if (OBJECT_ID_LENGTH != newMessageDigest().getDigestLength()) - throw new LinkageError("Incorrect OBJECT_ID_LENGTH."); + throw new LinkageError(JGitText.get().incorrectOBJECT_ID_LENGTH); CHARSET = Charset.forName(CHARACTER_ENCODING); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaOfsPackedObjectLoader.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaOfsPackedObjectLoader.java index 0b7c6c45f8..d0e98a2a92 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaOfsPackedObjectLoader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaOfsPackedObjectLoader.java @@ -48,6 +48,7 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; /** Reads a deltified object which uses an offset to find its base. */ @@ -75,7 +76,7 @@ class DeltaOfsPackedObjectLoader extends DeltaPackedObjectLoader { final ObjectId id = pack.findObjectForOffset(deltaBase); if (id == null) throw new CorruptObjectException( - "Offset-written delta base for object not found in a pack"); + JGitText.get().offsetWrittenDeltaBaseForObjectNotFoundInAPack); return id; } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaPackedObjectLoader.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaPackedObjectLoader.java index b42549943a..bbc1c62a8a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaPackedObjectLoader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/DeltaPackedObjectLoader.java @@ -47,8 +47,10 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import java.text.MessageFormat; import java.util.zip.DataFormatException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; /** Reader for a deltified object stored in a pack file. */ @@ -93,8 +95,8 @@ abstract class DeltaPackedObjectLoader extends PackedObjectLoader { pack.saveCache(objectOffset, cachedBytes, objectType); } catch (DataFormatException dfe) { final CorruptObjectException coe; - coe = new CorruptObjectException("Object at " + objectOffset - + " in " + pack.getPackFile() + " has bad zlib stream"); + coe = new CorruptObjectException(MessageFormat.format(JGitText.get().objectAtHasBadZlibStream, + objectOffset, pack.getPackFile())); coe.initCause(dfe); throw coe; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/FileBasedConfig.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/FileBasedConfig.java index 315c4670ad..eb00917917 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/FileBasedConfig.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/FileBasedConfig.java @@ -52,7 +52,9 @@ package org.eclipse.jgit.lib; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ConfigInvalidException; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.RawParseUtils; @@ -110,11 +112,11 @@ public class FileBasedConfig extends Config { } catch (FileNotFoundException noFile) { clear(); } catch (IOException e) { - final IOException e2 = new IOException("Cannot read " + getFile()); + final IOException e2 = new IOException(MessageFormat.format(JGitText.get().cannotReadFile, getFile())); e2.initCause(e); throw e2; } catch (ConfigInvalidException e) { - throw new ConfigInvalidException("Cannot read " + getFile(), e); + throw new ConfigInvalidException(MessageFormat.format(JGitText.get().cannotReadFile, getFile()), e); } } @@ -134,12 +136,12 @@ public class FileBasedConfig extends Config { final byte[] out = Constants.encode(toText()); final LockFile lf = new LockFile(getFile()); if (!lf.lock()) - throw new IOException("Cannot lock " + getFile()); + throw new IOException(MessageFormat.format(JGitText.get().cannotLockFile, getFile())); try { lf.setNeedStatInformation(true); lf.write(out); if (!lf.commit()) - throw new IOException("Cannot commit write to " + getFile()); + throw new IOException(MessageFormat.format(JGitText.get().cannotCommitWriteTo, getFile())); } finally { lf.unlock(); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/GitIndex.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/GitIndex.java index bba18408c8..0203d5d44a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/GitIndex.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/GitIndex.java @@ -59,6 +59,7 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.channels.FileChannel; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.Comparator; import java.util.Date; import java.util.Iterator; @@ -66,6 +67,7 @@ import java.util.Map; import java.util.Stack; import java.util.TreeMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.NotSupportedException; @@ -238,7 +240,8 @@ public class GitIndex { buffer.order(ByteOrder.BIG_ENDIAN); int j = channel.read(buffer); if (j != buffer.capacity()) - throw new IOException("Could not read index in one go, only "+j+" out of "+buffer.capacity()+" read"); + throw new IOException(MessageFormat.format(JGitText.get().couldNotReadIndexInOneGo + , j, buffer.capacity())); buffer.flip(); header = new Header(buffer); entries.clear(); @@ -266,7 +269,7 @@ public class GitIndex { File tmpIndex = new File(cacheFile.getAbsoluteFile() + ".tmp"); File lock = new File(cacheFile.getAbsoluteFile() + ".lock"); if (!lock.createNewFile()) - throw new IOException("Index file is in use"); + throw new IOException(JGitText.get().indexFileIsInUse); try { FileOutputStream fileOutputStream = new FileOutputStream(tmpIndex); FileChannel fc = fileOutputStream.getChannel(); @@ -298,10 +301,10 @@ public class GitIndex { if (cacheFile.exists()) if (!cacheFile.delete()) throw new IOException( - "Could not rename delete old index"); + JGitText.get().couldNotRenameDeleteOldIndex); if (!tmpIndex.renameTo(cacheFile)) throw new IOException( - "Could not rename temporary index file to index"); + JGitText.get().couldNotRenameTemporaryIndexFileToIndex); changed = false; statDirty = false; lastCacheTime = cacheFile.lastModified(); @@ -309,10 +312,10 @@ public class GitIndex { } finally { if (!lock.delete()) throw new IOException( - "Could not delete lock file. Should not happen"); + JGitText.get().couldNotDeleteLockFileShouldNotHappen); if (tmpIndex.exists() && !tmpIndex.delete()) throw new IOException( - "Could not delete temporary index file. Should not happen"); + JGitText.get().couldNotDeleteTemporaryIndexFileShouldNotHappen); } } @@ -320,7 +323,7 @@ public class GitIndex { for (Iterator i = entries.values().iterator(); i.hasNext();) { Entry e = (Entry) i.next(); if (e.getStage() != 0) { - throw new NotSupportedException("Cannot work with other stages than zero right now. Won't write corrupt index."); + throw new NotSupportedException(JGitText.get().cannotWorkWithOtherStagesThanZeroRightNow); } } } @@ -339,7 +342,7 @@ public class GitIndex { static byte[] makeKey(File wd, File f) { if (!f.getPath().startsWith(wd.getPath())) - throw new Error("Path is not in working dir"); + throw new Error(JGitText.get().pathIsNotInWorkingDir); String relName = Repository.stripWorkDir(wd, f); return Constants.encode(relName); } @@ -608,7 +611,8 @@ public class GitIndex { if (!file.isDirectory()) return true; } else { - System.out.println("Does not handle mode "+mode+" ("+file+")"); + System.out.println(MessageFormat.format(JGitText.get().doesNotHandleMode + , mode, file)); return true; } } @@ -781,11 +785,11 @@ public class GitIndex { version = buf.getInt(); entries = buf.getInt(); if (signature != 0x44495243) - throw new CorruptObjectException("Index signature is invalid: " - + signature); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().indexSignatureIsInvalid, signature)); if (version != 2) - throw new CorruptObjectException( - "Unknown index version (or corrupt index):" + version); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().unknownIndexVersionOrCorruptIndex, version)); } void write(ByteBuffer buf) { @@ -877,7 +881,7 @@ public class GitIndex { ByteBuffer buffer = ByteBuffer.wrap(bytes); int j = channel.write(buffer); if (j != bytes.length) - throw new IOException("Could not write file " + file); + throw new IOException(MessageFormat.format(JGitText.get().couldNotWriteFile, file)); channel.close(); if (config_filemode() && File_hasExecute()) { if (FileMode.EXECUTABLE_FILE.equals(e.mode)) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexTreeWalker.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexTreeWalker.java index b1ee94eff7..12f9af727d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexTreeWalker.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexTreeWalker.java @@ -48,6 +48,7 @@ package org.eclipse.jgit.lib; import java.io.File; import java.io.IOException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.GitIndex.Entry; /** @@ -143,8 +144,8 @@ public class IndexTreeWalker { private void visitEntry(TreeEntry t1, TreeEntry t2, Entry i) throws IOException { - assert t1 != null || t2 != null || i != null : "Needs at least one entry"; - assert root != null : "Needs workdir"; + assert t1 != null || t2 != null || i != null : JGitText.get().needsAtLeastOneEntry; + assert root != null : JGitText.get().needsWorkdir; if (t1 != null && t1.getParent() == null) t1 = null; @@ -169,8 +170,8 @@ public class IndexTreeWalker { private void finishVisitTree(TreeEntry t1, TreeEntry t2, int curIndexPos) throws IOException { - assert t1 != null || t2 != null : "Needs at least one entry"; - assert root != null : "Needs workdir"; + assert t1 != null || t2 != null : JGitText.get().needsAtLeastOneEntry; + assert root != null : JGitText.get().needsWorkdir; if (t1 != null && t1.getParent() == null) t1 = null; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/LockFile.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/LockFile.java index bd773c4705..13f158dedf 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/LockFile.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/LockFile.java @@ -54,6 +54,9 @@ import java.io.IOException; import java.io.OutputStream; import java.nio.channels.FileLock; import java.nio.channels.OverlappingFileLockException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Git style file locking and replacement. @@ -330,7 +333,7 @@ public class LockFile { private void requireLock() { if (os == null) { unlock(); - throw new IllegalStateException("Lock on " + ref + " not held."); + throw new IllegalStateException(MessageFormat.format(JGitText.get().lockOnNotHeld, ref)); } } @@ -382,7 +385,7 @@ public class LockFile { public boolean commit() { if (os != null) { unlock(); - throw new IllegalStateException("Lock on " + ref + " not closed."); + throw new IllegalStateException(MessageFormat.format(JGitText.get().lockOnNotClosed, ref)); } saveStatInformation(); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/MutableObjectId.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/MutableObjectId.java index a6680d0551..2e0e0118f0 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/MutableObjectId.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/MutableObjectId.java @@ -46,6 +46,9 @@ package org.eclipse.jgit.lib; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.InvalidObjectIdException; import org.eclipse.jgit.util.NB; import org.eclipse.jgit.util.RawParseUtils; @@ -162,7 +165,8 @@ public class MutableObjectId extends AnyObjectId { */ public void fromString(final String str) { if (str.length() != Constants.OBJECT_ID_STRING_LENGTH) - throw new IllegalArgumentException("Invalid id: " + str); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().invalidId, str)); fromHexString(Constants.encodeASCII(str), 0); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java index 5906802d18..f32ae59510 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java @@ -48,6 +48,9 @@ import static org.eclipse.jgit.util.RawParseUtils.match; import static org.eclipse.jgit.util.RawParseUtils.nextLF; import static org.eclipse.jgit.util.RawParseUtils.parseBase10; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.util.MutableInteger; @@ -123,7 +126,8 @@ public class ObjectChecker { checkBlob(raw); break; default: - throw new CorruptObjectException("Invalid object type: " + objType); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().corruptObjectInvalidType2, objType)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectDirectory.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectDirectory.java index 024bd15b03..06700ebe1d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectDirectory.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectDirectory.java @@ -48,6 +48,7 @@ import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -59,6 +60,7 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.PackMismatchException; import org.eclipse.jgit.lib.RepositoryCache.FileKey; import org.eclipse.jgit.util.FS; @@ -175,13 +177,13 @@ public class ObjectDirectory extends ObjectDatabase { final String i = idx.getName(); if (p.length() != 50 || !p.startsWith("pack-") || !p.endsWith(".pack")) - throw new IOException("Not a valid pack " + pack); + throw new IOException(MessageFormat.format(JGitText.get().notAValidPack, pack)); if (i.length() != 49 || !i.startsWith("pack-") || !i.endsWith(".idx")) - throw new IOException("Not a valid pack " + idx); + throw new IOException(MessageFormat.format(JGitText.get().notAValidPack, idx)); if (!p.substring(0, 45).equals(i.substring(0, 45))) - throw new IOException("Pack " + pack + "does not match index"); + throw new IOException(MessageFormat.format(JGitText.get().packDoesNotMatchIndex, pack)); insertPack(new PackFile(idx, pack)); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectWriter.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectWriter.java index b75328330f..ea57a0215e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectWriter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectWriter.java @@ -53,9 +53,11 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStreamWriter; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.zip.Deflater; import java.util.zip.DeflaterOutputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ObjectWritingException; /** @@ -147,10 +149,8 @@ public class ObjectWriter { final ObjectId id = e.getId(); if (id == null) - throw new ObjectWritingException("Object at path \"" - + e.getFullName() + "\" does not have an id assigned." - + " All object ids must be assigned prior" - + " to writing a tree."); + throw new ObjectWritingException(MessageFormat.format( + JGitText.get().objectAtPathDoesNotHaveId, e.getFullName())); e.getMode().copyTo(o); o.write(' '); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackFile.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackFile.java index 63f5162631..8f4e691630 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackFile.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackFile.java @@ -52,6 +52,7 @@ import java.io.OutputStream; import java.io.RandomAccessFile; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel.MapMode; +import java.text.MessageFormat; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; @@ -60,6 +61,7 @@ import java.util.zip.CRC32; import java.util.zip.CheckedOutputStream; import java.util.zip.DataFormatException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.PackInvalidException; import org.eclipse.jgit.errors.PackMismatchException; @@ -135,7 +137,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { if (packChecksum == null) packChecksum = idx.packChecksum; else if (!Arrays.equals(packChecksum, idx.packChecksum)) - throw new PackMismatchException("Pack checksum mismatch"); + throw new PackMismatchException(JGitText.get().packChecksumMismatch); loadedIdx = idx; } catch (IOException e) { @@ -261,7 +263,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { final WindowCursor curs) throws DataFormatException, IOException { final byte[] dstbuf = new byte[totalSize]; if (curs.inflate(this, position, dstbuf, 0) != totalSize) - throw new EOFException("Short compressed stream at " + position); + throw new EOFException(MessageFormat.format(JGitText.get().shortCompressedStreamAt, position)); return dstbuf; } @@ -289,15 +291,15 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { final ObjectId id = findObjectForOffset(objectOffset); final long expected = idx.findCRC32(id); if (computed != expected) - throw new CorruptObjectException("Object at " + objectOffset - + " in " + getPackFile() + " has bad zlib stream"); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().objectAtHasBadZlibStream, objectOffset, getPackFile())); } else { try { curs.inflateVerify(this, dataOffset); } catch (DataFormatException dfe) { final CorruptObjectException coe; - coe = new CorruptObjectException("Object at " + objectOffset - + " in " + getPackFile() + " has bad zlib stream"); + coe = new CorruptObjectException(MessageFormat.format( + JGitText.get().objectAtHasBadZlibStream, objectOffset, getPackFile())); coe.initCause(dfe); throw coe; } @@ -433,24 +435,23 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { IO.readFully(fd.getChannel(), 0, buf, 0, 12); if (RawParseUtils.match(buf, 0, Constants.PACK_SIGNATURE) != 4) - throw new IOException("Not a PACK file."); + throw new IOException(JGitText.get().notAPACKFile); final long vers = NB.decodeUInt32(buf, 4); final long packCnt = NB.decodeUInt32(buf, 8); if (vers != 2 && vers != 3) - throw new IOException("Unsupported pack version " + vers + "."); + throw new IOException(MessageFormat.format(JGitText.get().unsupportedPackVersion, vers)); if (packCnt != idx.getObjectCount()) - throw new PackMismatchException("Pack object count mismatch:" - + " pack " + packCnt - + " index " + idx.getObjectCount() - + ": " + getPackFile()); + throw new PackMismatchException(MessageFormat.format( + JGitText.get().packObjectCountMismatch, packCnt, idx.getObjectCount(), getPackFile())); IO.readFully(fd.getChannel(), length - 20, buf, 0, 20); if (!Arrays.equals(buf, packChecksum)) - throw new PackMismatchException("Pack checksum mismatch:" - + " pack " + ObjectId.fromRaw(buf).name() - + " index " + ObjectId.fromRaw(idx.packChecksum).name() - + ": " + getPackFile()); + throw new PackMismatchException(MessageFormat.format( + JGitText.get().packObjectCountMismatch + , ObjectId.fromRaw(buf).name() + , ObjectId.fromRaw(idx.packChecksum).name() + , getPackFile())); } private PackedObjectLoader reader(final WindowCursor curs, @@ -494,7 +495,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { (int) dataSize, ObjectId.fromRaw(ib)); } default: - throw new IOException("Unknown object type " + typeCode + "."); + throw new IOException(MessageFormat.format(JGitText.get().unknownObjectType, typeCode)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndex.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndex.java index 2043145b89..25b4f569c1 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndex.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndex.java @@ -48,8 +48,10 @@ import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; +import java.text.MessageFormat; import java.util.Iterator; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.NB; @@ -92,14 +94,14 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { case 2: return new PackIndexV2(fd); default: - throw new IOException("Unsupported pack index version " + v); + throw new IOException(MessageFormat.format(JGitText.get().unsupportedPackIndexVersion, v)); } } return new PackIndexV1(fd, hdr); } catch (IOException ioe) { final String path = idxFile.getAbsolutePath(); final IOException err; - err = new IOException("Unreadable pack index: " + path); + err = new IOException(MessageFormat.format(JGitText.get().unreadablePackIndex, path)); err.initCause(ioe); throw err; } finally { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexV2.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexV2.java index eb644c51c4..128b2df8cb 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexV2.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexV2.java @@ -49,6 +49,7 @@ import java.util.Arrays; import java.util.Iterator; import java.util.NoSuchElementException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.NB; @@ -111,7 +112,7 @@ class PackIndexV2 extends PackIndex { final long nameLen = bucketCnt * Constants.OBJECT_ID_LENGTH; if (nameLen > Integer.MAX_VALUE) - throw new IOException("Index file is too large for jgit"); + throw new IOException(JGitText.get().indexFileIsTooLargeForJgit); final int intNameLen = (int) nameLen; final byte[] raw = new byte[intNameLen]; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriter.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriter.java index 5fcf71a781..4d2714bc55 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriter.java @@ -48,8 +48,10 @@ import java.io.BufferedOutputStream; import java.io.IOException; import java.io.OutputStream; import java.security.DigestOutputStream; +import java.text.MessageFormat; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.transport.PackedObjectInfo; import org.eclipse.jgit.util.NB; @@ -131,8 +133,8 @@ public abstract class PackIndexWriter { case 2: return new PackIndexWriterV2(dst); default: - throw new IllegalArgumentException( - "Unsupported pack index version " + version); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().unsupportedPackIndexVersion, version)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriterV1.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriterV1.java index b3be5480c9..eb44b3a8c7 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriterV1.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackIndexWriterV1.java @@ -47,6 +47,7 @@ package org.eclipse.jgit.lib; import java.io.IOException; import java.io.OutputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.transport.PackedObjectInfo; import org.eclipse.jgit.util.NB; @@ -73,7 +74,7 @@ class PackIndexWriterV1 extends PackIndexWriter { for (final PackedObjectInfo oe : entries) { if (!canStore(oe)) - throw new IOException("Pack too large for index version 1"); + throw new IOException(JGitText.get().packTooLargeForIndexVersion1); NB.encodeInt32(tmp, 0, (int) oe.getOffset()); oe.copyRawTo(tmp, 4); out.write(tmp); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackReverseIndex.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackReverseIndex.java index c0ed7b29a6..f4f57aed43 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackReverseIndex.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackReverseIndex.java @@ -43,8 +43,10 @@ package org.eclipse.jgit.lib; +import java.text.MessageFormat; import java.util.Arrays; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.lib.PackIndex.MutableEntry; @@ -94,7 +96,7 @@ class PackReverseIndex { if (n32 > Integer.MAX_VALUE || n64 > Integer.MAX_VALUE || cnt > 0xffffffffL) throw new IllegalArgumentException( - "Huge indexes are not supported by jgit, yet"); + JGitText.get().hugeIndexesAreNotSupportedByJgitYet); offsets32 = new int[(int) n32]; offsets64 = new long[(int) n64]; @@ -166,9 +168,9 @@ class PackReverseIndex { if (offset <= Integer.MAX_VALUE) { final int i32 = Arrays.binarySearch(offsets32, (int) offset); if (i32 < 0) - throw new CorruptObjectException( - "Can't find object in (reverse) pack index for the specified offset " - + offset); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().cantFindObjectInReversePackIndexForTheSpecifiedOffset + , offset)); if (i32 + 1 == offsets32.length) { if (offsets64.length > 0) @@ -179,9 +181,9 @@ class PackReverseIndex { } else { final int i64 = Arrays.binarySearch(offsets64, offset); if (i64 < 0) - throw new CorruptObjectException( - "Can't find object in (reverse) pack index for the specified offset " - + offset); + throw new CorruptObjectException(MessageFormat.format( + JGitText.get().cantFindObjectInReversePackIndexForTheSpecifiedOffset + , offset)); if (i64 + 1 == offsets64.length) return maxOffset; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackWriter.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackWriter.java index 4a205fffbe..48f41a5586 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackWriter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PackWriter.java @@ -54,6 +54,7 @@ import java.util.Iterator; import java.util.List; import java.util.zip.Deflater; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.revwalk.ObjectWalk; @@ -103,7 +104,7 @@ public class PackWriter { * * @see #preparePack(Collection, Collection) */ - public static final String COUNTING_OBJECTS_PROGRESS = "Counting objects"; + public static final String COUNTING_OBJECTS_PROGRESS = JGitText.get().countingObjects; /** * Title of {@link ProgressMonitor} task used during searching for objects @@ -111,7 +112,7 @@ public class PackWriter { * * @see #writePack(OutputStream) */ - public static final String SEARCHING_REUSE_PROGRESS = "Compressing objects"; + public static final String SEARCHING_REUSE_PROGRESS = JGitText.get().compressingObjects; /** * Title of {@link ProgressMonitor} task used during writing out pack @@ -119,7 +120,7 @@ public class PackWriter { * * @see #writePack(OutputStream) */ - public static final String WRITING_OBJECTS_PROGRESS = "Writing objects"; + public static final String WRITING_OBJECTS_PROGRESS = JGitText.get().writingObjects; /** * Default value of deltas reuse option. @@ -605,7 +606,7 @@ public class PackWriter { for (ObjectToPack otp : list) { if (initMonitor.isCancelled()) throw new IOException( - "Packing cancelled during objects writing"); + JGitText.get().packingCancelledDuringObjectsWriting); reuseLoaders.clear(); searchForReuse(reuseLoaders, otp); initMonitor.update(1); @@ -688,7 +689,7 @@ public class PackWriter { for (ObjectToPack otp : list) { if (writeMonitor.isCancelled()) throw new IOException( - "Packing cancelled during objects writing"); + JGitText.get().packingCancelledDuringObjectsWriting); if (!otp.isWritten()) writeObject(otp); } @@ -727,7 +728,7 @@ public class PackWriter { reuse.endCopyRawData(); } } else if (otp.isDeltaRepresentation()) { - throw new IOException("creating deltas is not implemented"); + throw new IOException(JGitText.get().creatingDeltasIsNotImplemented); } else { writeWholeObjectDeflate(otp); } @@ -886,11 +887,11 @@ public class PackWriter { objectsLists[object.getType()].add(otp); } catch (ArrayIndexOutOfBoundsException x) { throw new IncorrectObjectTypeException(object, - "COMMIT nor TREE nor BLOB nor TAG"); + JGitText.get().incorrectObjectType_COMMITnorTREEnorBLOBnorTAG); } catch (UnsupportedOperationException x) { // index pointing to "dummy" empty list throw new IncorrectObjectTypeException(object, - "COMMIT nor TREE nor BLOB nor TAG"); + JGitText.get().incorrectObjectType_COMMITnorTREEnorBLOBnorTAG); } objectsMap.add(otp); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PersonIdent.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PersonIdent.java index 0bc2e7a2df..522f8477b1 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/PersonIdent.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/PersonIdent.java @@ -45,11 +45,13 @@ package org.eclipse.jgit.lib; +import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Locale; import java.util.TimeZone; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.util.SystemReader; /** @@ -197,13 +199,13 @@ public class PersonIdent { public PersonIdent(final String in) { final int lt = in.indexOf('<'); if (lt == -1) { - throw new IllegalArgumentException("Malformed PersonIdent string" - + " (no < was found): " + in); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().malformedpersonIdentString, in)); } final int gt = in.indexOf('>', lt); if (gt == -1) { - throw new IllegalArgumentException("Malformed PersonIdent string" - + " (no > was found): " + in); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().malformedpersonIdentString, in)); } final int sp = in.indexOf(' ', gt + 2); if (sp == -1) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDirectory.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDirectory.java index faebbf67cc..5ba186955f 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDirectory.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefDirectory.java @@ -67,11 +67,13 @@ import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStreamReader; +import java.text.MessageFormat; import java.util.Arrays; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ObjectWritingException; import org.eclipse.jgit.revwalk.RevObject; import org.eclipse.jgit.revwalk.RevTag; @@ -493,7 +495,8 @@ public class RefDirectory extends RefDatabase { if (packed.contains(name)) { LockFile lck = new LockFile(packedRefsFile); if (!lck.lock()) - throw new IOException("Cannot lock " + packedRefsFile); + throw new IOException(MessageFormat.format( + JGitText.get().cannotLockFile, packedRefsFile)); try { PackedRefList cur = readPackedRefs(0, 0); int idx = cur.find(name); @@ -574,7 +577,7 @@ public class RefDirectory extends RefDatabase { if (dir.exists()) throw err; if (!dir.mkdirs() && !dir.isDirectory()) - throw new IOException("Cannot create directory " + dir); + throw new IOException(MessageFormat.format(JGitText.get().cannotCreateDirectory, dir)); out = new FileOutputStream(log, true); } try { @@ -677,7 +680,7 @@ public class RefDirectory extends RefDatabase { if (p.charAt(0) == '^') { if (last == null) - throw new IOException("Peeled line before ref."); + throw new IOException(JGitText.get().peeledLineBeforeRef); ObjectId id = ObjectId.fromString(p.substring(1)); last = new ObjectIdRef.PeeledTag(PACKED, last.getName(), last @@ -721,18 +724,16 @@ public class RefDirectory extends RefDatabase { try { lck.write(content); } catch (IOException ioe) { - throw new ObjectWritingException("Unable to write " + name, - ioe); + throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToWrite, name), ioe); } try { lck.waitForStatChange(); } catch (InterruptedException e) { lck.unlock(); - throw new ObjectWritingException("Interrupted writing " - + name); + throw new ObjectWritingException(MessageFormat.format(JGitText.get().interruptedWriting, name)); } if (!lck.commit()) - throw new ObjectWritingException("Unable to write " + name); + throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToWrite, name)); packedRefs.compareAndSet(oldPackedList, new PackedRefList(refs, content.length, lck.getCommitLastModified())); @@ -795,7 +796,7 @@ public class RefDirectory extends RefDatabase { n--; if (n < 6) { String content = RawParseUtils.decode(buf, 0, n); - throw new IOException("Not a ref: " + name + ": " + content); + throw new IOException(MessageFormat.format(JGitText.get().notARef, name, content)); } final String target = RawParseUtils.decode(buf, 5, n); return newSymbolicRef(modified, name, target); @@ -811,7 +812,7 @@ public class RefDirectory extends RefDatabase { while (0 < n && Character.isWhitespace(buf[n - 1])) n--; String content = RawParseUtils.decode(buf, 0, n); - throw new IOException("Not a ref: " + name + ": " + content); + throw new IOException(MessageFormat.format(JGitText.get().notARef, name, content)); } return new LooseUnpeeled(modified, name, id); } @@ -889,7 +890,7 @@ public class RefDirectory extends RefDatabase { static void delete(final File file, final int depth) throws IOException { if (!file.delete() && file.isFile()) - throw new IOException("File cannot be deleted: " + file); + throw new IOException(MessageFormat.format(JGitText.get().fileCannotBeDeleted, file)); File dir = file.getParentFile(); for (int i = 0; i < depth; ++i) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java index 553266284b..89f59150a0 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java @@ -45,7 +45,9 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevObject; @@ -395,7 +397,7 @@ public abstract class RefUpdate { private void requireCanDoUpdate() { if (newValue == null) - throw new IllegalStateException("A NewObjectId is required."); + throw new IllegalStateException(JGitText.get().aNewObjectIdIsRequired); } /** @@ -524,7 +526,7 @@ public abstract class RefUpdate { */ public Result link(String target) throws IOException { if (!target.startsWith(Constants.R_REFS)) - throw new IllegalArgumentException("Not " + Constants.R_REFS); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().illegalArgumentNotA, Constants.R_REFS)); if (getRefDatabase().isNameConflicting(getName())) return Result.LOCK_FAILURE; try { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ReflogReader.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ReflogReader.java index b394f34bb7..4c5503f321 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ReflogReader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ReflogReader.java @@ -51,6 +51,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.RawParseUtils; @@ -75,24 +76,24 @@ public class ReflogReader { pos += Constants.OBJECT_ID_STRING_LENGTH; if (raw[pos++] != ' ') throw new IllegalArgumentException( - "Raw log message does not parse as log entry"); + JGitText.get().rawLogMessageDoesNotParseAsLogEntry); newId = ObjectId.fromString(raw, pos); pos += Constants.OBJECT_ID_STRING_LENGTH; if (raw[pos++] != ' ') { throw new IllegalArgumentException( - "Raw log message does not parse as log entry"); + JGitText.get().rawLogMessageDoesNotParseAsLogEntry); } who = RawParseUtils.parsePersonIdentOnly(raw, pos); int p0 = RawParseUtils.next(raw, pos, '\t'); // personident has no // \t if (p0 == -1) { throw new IllegalArgumentException( - "Raw log message does not parse as log entry"); + JGitText.get().rawLogMessageDoesNotParseAsLogEntry); } int p1 = RawParseUtils.nextLF(raw, p0); if (p1 == -1) { throw new IllegalArgumentException( - "Raw log message does not parse as log entry"); + JGitText.get().rawLogMessageDoesNotParseAsLogEntry); } comment = RawParseUtils.decode(raw, p0, p1 - 1); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java index 9f4bb100f8..e4d857bf8d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java @@ -48,6 +48,7 @@ package org.eclipse.jgit.lib; import java.io.File; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -61,6 +62,7 @@ import java.util.Vector; import java.util.concurrent.atomic.AtomicInteger; import org.eclipse.jgit.dircache.DirCache; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.ConfigInvalidException; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.RevisionSyntaxException; @@ -191,7 +193,7 @@ public class Repository { if (d != null) gitDir = d; else - throw new IllegalArgumentException("Either GIT_DIR or GIT_WORK_TREE must be passed to Repository constructor"); + throw new IllegalArgumentException(JGitText.get().eitherGIT_DIRorGIT_WORK_TREEmustBePassed); } userConfig = SystemReader.getInstance().openUserConfig(); @@ -226,8 +228,8 @@ public class Repository { final String repositoryFormatVersion = getConfig().getString( "core", null, "repositoryFormatVersion"); if (!"0".equals(repositoryFormatVersion)) { - throw new IOException("Unknown repository format \"" - + repositoryFormatVersion + "\"; expected \"0\"."); + throw new IOException(MessageFormat.format( + JGitText.get().unknownRepositoryFormat2, repositoryFormatVersion)); } } } @@ -236,9 +238,8 @@ public class Repository { try { userConfig.load(); } catch (ConfigInvalidException e1) { - IOException e2 = new IOException("User config file " - + userConfig.getFile().getAbsolutePath() + " invalid: " - + e1); + IOException e2 = new IOException(MessageFormat.format( + JGitText.get().userConfigFileInvalid, userConfig.getFile().getAbsolutePath(), e1)); e2.initCause(e1); throw e2; } @@ -248,7 +249,7 @@ public class Repository { try { config.load(); } catch (ConfigInvalidException e1) { - IOException e2 = new IOException("Unknown repository format"); + IOException e2 = new IOException(JGitText.get().unknownRepositoryFormat); e2.initCause(e1); throw e2; } @@ -279,8 +280,7 @@ public class Repository { public void create(boolean bare) throws IOException { final RepositoryConfig cfg = getConfig(); if (cfg.getFile().exists()) { - throw new IllegalStateException("Repository already exists: " - + gitDir); + throw new IllegalStateException(MessageFormat.format(JGitText.get().repositoryAlreadyExists, gitDir)); } gitDir.mkdirs(); refs.create(); @@ -506,7 +506,7 @@ public class Repository { default: throw new IncorrectObjectTypeException(id, - "COMMIT nor TREE nor BLOB nor TAG"); + JGitText.get().incorrectObjectType_COMMITnorTREEnorBLOBnorTAG); } } @@ -727,7 +727,7 @@ public class Repository { pnum = Integer.parseInt(parentnum); } catch (NumberFormatException e) { throw new RevisionSyntaxException( - "Invalid commit parent number", + JGitText.get().invalidCommitParentNumber, revstr); } if (pnum != 0) { @@ -853,7 +853,7 @@ public class Repository { dist = Integer.parseInt(distnum); } catch (NumberFormatException e) { throw new RevisionSyntaxException( - "Invalid ancestry length", revstr); + JGitText.get().invalidAncestryLength, revstr); } while (dist > 0) { final ObjectId[] parents = ((Commit) ref).getParentIds(); @@ -877,7 +877,7 @@ public class Repository { } } if (time != null) - throw new RevisionSyntaxException("reflogs not yet supported by revision parser", revstr); + throw new RevisionSyntaxException(JGitText.get().reflogsNotYetSupportedByRevisionParser, revstr); i = m - 1; break; default: diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tag.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tag.java index 35ccf773cf..5b3531eb1f 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tag.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tag.java @@ -48,7 +48,9 @@ import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStreamReader; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.ObjectWritingException; @@ -135,18 +137,18 @@ public class Tag { new ByteArrayInputStream(raw))); String n = br.readLine(); if (n == null || !n.startsWith("object ")) { - throw new CorruptObjectException(tagId, "no object"); + throw new CorruptObjectException(tagId, JGitText.get().corruptObjectNoObject); } objId = ObjectId.fromString(n.substring(7)); n = br.readLine(); if (n == null || !n.startsWith("type ")) { - throw new CorruptObjectException(tagId, "no type"); + throw new CorruptObjectException(tagId, JGitText.get().corruptObjectNoType); } type = n.substring("type ".length()); n = br.readLine(); if (n == null || !n.startsWith("tag ")) { - throw new CorruptObjectException(tagId, "no tag name"); + throw new CorruptObjectException(tagId, JGitText.get().corruptObjectNoTagName); } tag = n.substring("tag ".length()); n = br.readLine(); @@ -154,13 +156,13 @@ public class Tag { // We should see a "tagger" header here, but some repos have tags // without it. if (n == null) - throw new CorruptObjectException(tagId, "no tagger header"); + throw new CorruptObjectException(tagId, JGitText.get().corruptObjectNoTaggerHeader); if (n.length()>0) if (n.startsWith("tagger ")) tagger = new PersonIdent(n.substring("tagger ".length())); else - throw new CorruptObjectException(tagId, "no tagger/bad header"); + throw new CorruptObjectException(tagId, JGitText.get().corruptObjectNoTaggerBadHeader); // Message should start with an empty line, but StringBuilder tempMessage = new StringBuilder(); @@ -196,7 +198,7 @@ public class Tag { */ public void tag() throws IOException { if (getTagId() != null) - throw new IllegalStateException("exists " + getTagId()); + throw new IllegalStateException(MessageFormat.format(JGitText.get().illegalStateExists, getTagId())); final ObjectId id; final RefUpdate ru; @@ -212,7 +214,7 @@ public class Tag { ru.setNewObjectId(id); ru.setRefLogMessage("tagged " + getTag(), false); if (ru.forceUpdate() == RefUpdate.Result.LOCK_FAILURE) - throw new ObjectWritingException("Unable to lock tag " + getTag()); + throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToLockTag, getTag())); } public String toString() { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tree.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tree.java index 61607cba95..2aa3098f17 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tree.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Tree.java @@ -46,7 +46,9 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.EntryExistsException; import org.eclipse.jgit.errors.MissingObjectException; @@ -245,7 +247,7 @@ public class Tree extends TreeEntry implements Treeish { */ public void unload() { if (isModified()) - throw new IllegalStateException("Cannot unload a modified tree."); + throw new IllegalStateException(JGitText.get().cannotUnloadAModifiedTree); contents = null; } @@ -555,14 +557,14 @@ public class Tree extends TreeEntry implements Treeish { while (rawPtr < rawSize) { int c = raw[rawPtr++]; if (c < '0' || c > '7') - throw new CorruptObjectException(getId(), "invalid entry mode"); + throw new CorruptObjectException(getId(), JGitText.get().corruptObjectInvalidEntryMode); int mode = c - '0'; for (;;) { c = raw[rawPtr++]; if (' ' == c) break; else if (c < '0' || c > '7') - throw new CorruptObjectException(getId(), "invalid mode"); + throw new CorruptObjectException(getId(), JGitText.get().corruptObjectInvalidMode); mode <<= 3; mode += c - '0'; } @@ -589,8 +591,8 @@ public class Tree extends TreeEntry implements Treeish { else if (FileMode.GITLINK.equals(mode)) ent = new GitlinkTreeEntry(this, id, name); else - throw new CorruptObjectException(getId(), "Invalid mode: " - + Integer.toOctalString(mode)); + throw new CorruptObjectException(getId(), MessageFormat.format( + JGitText.get().corruptObjectInvalidMode2, Integer.toOctalString(mode))); temp[nextIndex++] = ent; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/TreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/TreeIterator.java index 937baf6cc5..1f46c8f1b9 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/TreeIterator.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/TreeIterator.java @@ -47,6 +47,8 @@ package org.eclipse.jgit.lib; import java.io.IOException; import java.util.Iterator; +import org.eclipse.jgit.JGitText; + /** * A tree iterator iterates over a tree and all its members recursing into * subtrees according to order. @@ -204,6 +206,6 @@ public class TreeIterator implements Iterator<TreeEntry> { public void remove() { throw new IllegalStateException( - "TreeIterator does not support remove()"); + JGitText.get().treeIteratorDoesNotSupportRemove); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/UnpackedObjectLoader.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/UnpackedObjectLoader.java index 96a1f80241..cd2eb38ef1 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/UnpackedObjectLoader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/UnpackedObjectLoader.java @@ -50,6 +50,7 @@ import java.io.IOException; import java.util.zip.DataFormatException; import java.util.zip.Inflater; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.MutableInteger; @@ -118,25 +119,25 @@ public class UnpackedObjectLoader extends ObjectLoader { hdr.length - avail); if (uncompressed == 0) { throw new CorruptObjectException(id, - "bad stream, corrupt header"); + JGitText.get().corruptObjectBadStreamCorruptHeader); } avail += uncompressed; } catch (DataFormatException dfe) { final CorruptObjectException coe; - coe = new CorruptObjectException(id, "bad stream"); + coe = new CorruptObjectException(id, JGitText.get().corruptObjectBadStream); coe.initCause(dfe); throw coe; } if (avail < 5) - throw new CorruptObjectException(id, "no header"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectNoHeader); final MutableInteger p = new MutableInteger(); objectType = Constants.decodeTypeString(id, hdr, (byte) ' ', p); objectSize = RawParseUtils.parseBase10(hdr, p.value, p); if (objectSize < 0) - throw new CorruptObjectException(id, "negative size"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectNegativeSize); if (hdr[p.value++] != 0) - throw new CorruptObjectException(id, "garbage after size"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectGarbageAfterSize); bytes = new byte[objectSize]; if (p.value < avail) System.arraycopy(hdr, p.value, bytes, 0, avail - p.value); @@ -161,7 +162,7 @@ public class UnpackedObjectLoader extends ObjectLoader { objectType = typeCode; break; default: - throw new CorruptObjectException(id, "invalid type"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectInvalidType); } objectSize = size; @@ -182,17 +183,17 @@ public class UnpackedObjectLoader extends ObjectLoader { p += uncompressed; if (uncompressed == 0 && !inf.finished()) { throw new CorruptObjectException(id, - "bad stream, corrupt header"); + JGitText.get().corruptObjectBadStreamCorruptHeader); } } } catch (DataFormatException dfe) { final CorruptObjectException coe; - coe = new CorruptObjectException(id, "bad stream"); + coe = new CorruptObjectException(id, JGitText.get().corruptObjectBadStream); coe.initCause(dfe); throw coe; } if (p != objectSize) - throw new CorruptObjectException(id, "incorrect length"); + throw new CorruptObjectException(id, JGitText.get().corruptObjectIncorrectLength); } @Override diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WholePackedObjectLoader.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WholePackedObjectLoader.java index 5005d37f18..fcfa57339e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WholePackedObjectLoader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WholePackedObjectLoader.java @@ -46,8 +46,10 @@ package org.eclipse.jgit.lib; import java.io.IOException; +import java.text.MessageFormat; import java.util.zip.DataFormatException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; /** Reader for a non-delta (just deflated) object in a pack file. */ @@ -84,8 +86,8 @@ class WholePackedObjectLoader extends PackedObjectLoader { pack.saveCache(objectOffset, cachedBytes, objectType); } catch (DataFormatException dfe) { final CorruptObjectException coe; - coe = new CorruptObjectException("Object at " + objectOffset - + " in " + pack.getPackFile() + " has bad zlib stream"); + coe = new CorruptObjectException(MessageFormat.format(JGitText.get().objectAtHasBadZlibStream, + objectOffset, pack.getPackFile())); coe.initCause(dfe); throw coe; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WindowCache.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WindowCache.java index b2c79c1089..a44a30ee2d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WindowCache.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WindowCache.java @@ -53,6 +53,8 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReferenceArray; import java.util.concurrent.locks.ReentrantLock; +import org.eclipse.jgit.JGitText; + /** * Caches slices of a {@link PackFile} in memory for faster read access. * <p> @@ -121,9 +123,9 @@ import java.util.concurrent.locks.ReentrantLock; public class WindowCache { private static final int bits(int newSize) { if (newSize < 4096) - throw new IllegalArgumentException("Invalid window size"); + throw new IllegalArgumentException(JGitText.get().invalidWindowSize); if (Integer.bitCount(newSize) != 1) - throw new IllegalArgumentException("Window size must be power of 2"); + throw new IllegalArgumentException(JGitText.get().windowSizeMustBePowerOf2); return Integer.numberOfTrailingZeros(newSize); } @@ -247,9 +249,9 @@ public class WindowCache { tableSize = tableSize(cfg); final int lockCount = lockCount(cfg); if (tableSize < 1) - throw new IllegalArgumentException("tSize must be >= 1"); + throw new IllegalArgumentException(JGitText.get().tSizeMustBeGreaterOrEqual1); if (lockCount < 1) - throw new IllegalArgumentException("lockCount must be >= 1"); + throw new IllegalArgumentException(JGitText.get().lockCountMustBeGreaterOrEqual1); queue = new ReferenceQueue<ByteWindow>(); clock = new AtomicLong(1); @@ -278,9 +280,9 @@ public class WindowCache { openBytes = new AtomicLong(); if (maxFiles < 1) - throw new IllegalArgumentException("Open files must be >= 1"); + throw new IllegalArgumentException(JGitText.get().openFilesMustBeAtLeast1); if (maxBytes < windowSize) - throw new IllegalArgumentException("Window size must be < limit"); + throw new IllegalArgumentException(JGitText.get().windowSizeMustBeLesserThanLimit); } int getOpenFiles() { @@ -343,9 +345,9 @@ public class WindowCache { final int wsz = cfg.getPackedGitWindowSize(); final long limit = cfg.getPackedGitLimit(); if (wsz <= 0) - throw new IllegalArgumentException("Invalid window size"); + throw new IllegalArgumentException(JGitText.get().invalidWindowSize); if (limit < wsz) - throw new IllegalArgumentException("Window size must be < limit"); + throw new IllegalArgumentException(JGitText.get().windowSizeMustBeLesserThanLimit); return (int) Math.min(5 * (limit / wsz) / 2, 2000000000); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java index 76585add1e..ee78202868 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WorkDirCheckout.java @@ -49,9 +49,11 @@ package org.eclipse.jgit.lib; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.HashMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CheckoutConflictException; import org.eclipse.jgit.lib.GitIndex.Entry; @@ -189,7 +191,7 @@ public class WorkDirCheckout { for (String c : conflicts) { File conflict = new File(root, c); if (!conflict.delete()) - throw new CheckoutConflictException("Cannot delete file: " + c); + throw new CheckoutConflictException(MessageFormat.format(JGitText.get().cannotDeleteFile, c)); removeEmptyParents(conflict); } for (String r : removed) { @@ -263,7 +265,7 @@ public class WorkDirCheckout { public void visitEntry(TreeEntry treeEntry, TreeEntry auxEntry, Entry indexEntry, File file) throws IOException { if (treeEntry instanceof Tree || auxEntry instanceof Tree) { - throw new IllegalArgumentException("Can't pass me a tree!"); + throw new IllegalArgumentException(JGitText.get().cantPassMeATree); } processEntry(treeEntry, auxEntry, indexEntry); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WriteTree.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WriteTree.java index 5bb4e535e0..bb97ccced0 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/WriteTree.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/WriteTree.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.lib; import java.io.File; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.GitlinksNotSupportedException; import org.eclipse.jgit.errors.SymlinksNotSupportedException; @@ -75,10 +77,8 @@ public class WriteTree extends TreeVisitorWithCurrentDirectory { public void visitSymlink(final SymlinkTreeEntry s) throws IOException { if (s.isModified()) { - throw new SymlinksNotSupportedException("Symlink \"" - + s.getFullName() - + "\" cannot be written as the link target" - + " cannot be read from within Java."); + throw new SymlinksNotSupportedException(MessageFormat.format( + JGitText.get().symlinkCannotBeWrittenAsTheLinkTarget, s.getFullName())); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java index e7d84c68ac..d678f7c0fc 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java @@ -44,8 +44,10 @@ package org.eclipse.jgit.merge; +import java.text.MessageFormat; import java.util.HashMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Repository; /** @@ -97,8 +99,7 @@ public abstract class MergeStrategy { public static synchronized void register(final String name, final MergeStrategy imp) { if (STRATEGIES.containsKey(name)) - throw new IllegalArgumentException("Merge strategy \"" + name - + "\" already exists as a default strategy"); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().mergeStrategyAlreadyExistsAsDefault, name)); STRATEGIES.put(name, imp); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java index 275a6d68ff..38af20fb8f 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.merge; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; @@ -180,10 +182,9 @@ public abstract class Merger { return new EmptyTreeIterator(); final RevCommit base2 = walk.next(); if (base2 != null) { - throw new IOException("Multiple merge bases for:" + "\n " - + sourceCommits[aIdx].name() + "\n " - + sourceCommits[bIdx].name() + "found:" + "\n " - + base.name() + "\n " + base2.name()); + throw new IOException(MessageFormat.format(JGitText.get().multipleMergeBasesFor + , sourceCommits[aIdx].name(), sourceCommits[bIdx].name() + , base.name(), base2.name())); } return openTree(base.getTree()); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/nls/NLS.java b/org.eclipse.jgit/src/org/eclipse/jgit/nls/NLS.java index f2e379e136..6f81af845b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/nls/NLS.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/nls/NLS.java @@ -68,7 +68,8 @@ import org.eclipse.jgit.errors.TranslationStringMissingException; * </pre> */ public class NLS { - static final Locale ROOT_LOCALE = new Locale("", "", ""); + /** The root locale constant. It is defined here because the Locale.ROOT is not defined in Java 5 */ + public static final Locale ROOT_LOCALE = new Locale("", "", ""); private static final InheritableThreadLocal<NLS> local = new InheritableThreadLocal<NLS>() { protected NLS initialValue() { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/nls/TranslationBundle.java b/org.eclipse.jgit/src/org/eclipse/jgit/nls/TranslationBundle.java index c908aa0557..2c745e1f3e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/nls/TranslationBundle.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/nls/TranslationBundle.java @@ -99,7 +99,7 @@ import org.eclipse.jgit.errors.TranslationStringMissingException; * {@link ResourceBundle#getBundle(String, Locale)} method to load a resource * bundle. See the documentation of this method for a detailed explanation of * resource bundle loading strategy. After a bundle is created the - * {@link #getEffectiveLocale()} method can be used to determine whether the + * {@link #effectiveLocale()} method can be used to determine whether the * bundle really corresponds to the requested locale or is a fallback. * * <p> @@ -122,16 +122,24 @@ import org.eclipse.jgit.errors.TranslationStringMissingException; public abstract class TranslationBundle { private Locale effectiveLocale; + private ResourceBundle resourceBundle; /** * @return the locale locale used for loading the resource bundle from which * the field values were taken */ - public Locale getEffectiveLocale() { + public Locale effectiveLocale() { return effectiveLocale; } /** + * @return the resource bundle on which this translation bundle is based + */ + public ResourceBundle resourceBundle() { + return resourceBundle; + } + + /** * Injects locale specific text in all instance fields of this instance. * Only public instance fields of type <code>String</code> are considered. * <p> @@ -150,18 +158,17 @@ public abstract class TranslationBundle { */ void load(Locale locale) throws TranslationBundleLoadingException { Class bundleClass = getClass(); - ResourceBundle bundle; try { - bundle = ResourceBundle.getBundle(bundleClass.getName(), locale); + resourceBundle = ResourceBundle.getBundle(bundleClass.getName(), locale); } catch (MissingResourceException e) { throw new TranslationBundleLoadingException(bundleClass, locale, e); } - this.effectiveLocale = bundle.getLocale(); + this.effectiveLocale = resourceBundle.getLocale(); for (Field field : bundleClass.getFields()) { if (field.getType().equals(String.class)) { try { - String translatedText = bundle.getString(field.getName()); + String translatedText = resourceBundle.getString(field.getName()); field.set(this, translatedText); } catch (MissingResourceException e) { throw new TranslationStringMissingException(bundleClass, locale, field.getName(), e); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/patch/CombinedHunkHeader.java b/org.eclipse.jgit/src/org/eclipse/jgit/patch/CombinedHunkHeader.java index 781190539f..042c778510 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/patch/CombinedHunkHeader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/patch/CombinedHunkHeader.java @@ -48,7 +48,9 @@ import static org.eclipse.jgit.util.RawParseUtils.parseBase10; import java.io.IOException; import java.io.OutputStream; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AbbreviatedObjectId; import org.eclipse.jgit.util.MutableInteger; @@ -183,16 +185,14 @@ public class CombinedHunkHeader extends HunkHeader { final int cmp = o.nContext + o.nDeleted; if (cmp < o.lineCount) { final int missingCnt = o.lineCount - cmp; - script.error(buf, startOffset, "Truncated hunk, at least " - + missingCnt + " lines is missing for ancestor " - + (ancestor + 1)); + script.error(buf, startOffset, MessageFormat.format( + JGitText.get().truncatedHunkLinesMissingForAncestor, missingCnt, (ancestor + 1))); } } if (nContext + nAdded < newLineCount) { final int missingCount = newLineCount - (nContext + nAdded); - script.error(buf, startOffset, "Truncated hunk, at least " - + missingCount + " new lines is missing"); + script.error(buf, startOffset, MessageFormat.format(JGitText.get().truncatedHunkNewLinesMissing, missingCount)); } return c; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/patch/FileHeader.java b/org.eclipse.jgit/src/org/eclipse/jgit/patch/FileHeader.java index c35b613a22..25dc72af20 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/patch/FileHeader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/patch/FileHeader.java @@ -54,10 +54,12 @@ import static org.eclipse.jgit.util.RawParseUtils.parseBase10; import java.io.IOException; import java.nio.charset.CharacterCodingException; import java.nio.charset.Charset; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.diff.EditList; import org.eclipse.jgit.lib.AbbreviatedObjectId; import org.eclipse.jgit.lib.Constants; @@ -241,8 +243,7 @@ public class FileHeader { } if (charsetGuess != null && charsetGuess.length != getParentCount() + 1) - throw new IllegalArgumentException("Expected " - + (getParentCount() + 1) + " character encoding guesses"); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().expectedCharacterEncodingGuesses, (getParentCount() + 1))); if (trySimpleConversion(charsetGuess)) { Charset cs = charsetGuess != null ? charsetGuess[0] : null; @@ -302,7 +303,7 @@ public class FileHeader { } return r; } catch (IOException ioe) { - throw new RuntimeException("Cannot convert script to text", ioe); + throw new RuntimeException(JGitText.get().cannotConvertScriptToText, ioe); } finally { for (final TemporaryBuffer b : tmp) { if (b != null) @@ -410,7 +411,7 @@ public class FileHeader { void addHunk(final HunkHeader h) { if (h.getFileHeader() != this) - throw new IllegalArgumentException("Hunk belongs to another file"); + throw new IllegalArgumentException(JGitText.get().hunkBelongsToAnotherFile); if (hunks == null) hunks = new ArrayList<HunkHeader>(); hunks.add(h); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/patch/HunkHeader.java b/org.eclipse.jgit/src/org/eclipse/jgit/patch/HunkHeader.java index 9d78d0b99f..bfb20b64e9 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/patch/HunkHeader.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/patch/HunkHeader.java @@ -49,7 +49,9 @@ import static org.eclipse.jgit.util.RawParseUtils.parseBase10; import java.io.IOException; import java.io.OutputStream; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.diff.Edit; import org.eclipse.jgit.diff.EditList; import org.eclipse.jgit.lib.AbbreviatedObjectId; @@ -278,21 +280,21 @@ public class HunkHeader { if (nContext + old.nDeleted < old.lineCount) { final int missingCount = old.lineCount - (nContext + old.nDeleted); - script.error(buf, startOffset, "Truncated hunk, at least " - + missingCount + " old lines is missing"); + script.error(buf, startOffset, MessageFormat.format( + JGitText.get().truncatedHunkOldLinesMissing, missingCount)); } else if (nContext + old.nAdded < newLineCount) { final int missingCount = newLineCount - (nContext + old.nAdded); - script.error(buf, startOffset, "Truncated hunk, at least " - + missingCount + " new lines is missing"); + script.error(buf, startOffset, MessageFormat.format( + JGitText.get().truncatedHunkNewLinesMissing, missingCount)); } else if (nContext + old.nDeleted > old.lineCount || nContext + old.nAdded > newLineCount) { final String oldcnt = old.lineCount + ":" + newLineCount; final String newcnt = (nContext + old.nDeleted) + ":" + (nContext + old.nAdded); - script.warn(buf, startOffset, "Hunk header " + oldcnt - + " does not match body line count of " + newcnt); + script.warn(buf, startOffset, MessageFormat.format( + JGitText.get().hunkHeaderDoesNotMatchBodyLineCountOf, oldcnt, newcnt)); } return c; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/patch/Patch.java b/org.eclipse.jgit/src/org/eclipse/jgit/patch/Patch.java index eff5303dc5..ce006dadbf 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/patch/Patch.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/patch/Patch.java @@ -55,6 +55,7 @@ import java.io.InputStream; import java.util.ArrayList; import java.util.List; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.util.TemporaryBuffer; /** A parsed collection of {@link FileHeader}s from a unified diff patch file */ @@ -175,7 +176,7 @@ public class Patch { // have missed a file header previously. The hunk // isn't valid without knowing where it comes from. // - error(buf, c, "Hunk disconnected from file"); + error(buf, c, JGitText.get().hunkDisconnectedFromFile); c = nextLF(buf, c); continue; } @@ -300,7 +301,7 @@ public class Patch { break; default: if (match(buf, c, SIG_FOOTER) < 0) - warn(buf, c, "Unexpected hunk trailer"); + warn(buf, c, JGitText.get().unexpectedHunkTrailer); } } continue; @@ -345,7 +346,7 @@ public class Patch { if (nEnd < 0) { // Not a binary hunk. // - error(fh.buf, c, "Missing forward-image in GIT binary patch"); + error(fh.buf, c, JGitText.get().missingForwardImageInGITBinaryPatch); return c; } c = nEnd; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotCommitList.java b/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotCommitList.java index 8f6d083a32..61eed3fa9a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotCommitList.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotCommitList.java @@ -43,10 +43,12 @@ package org.eclipse.jgit.revplot; +import java.text.MessageFormat; import java.util.Collection; import java.util.HashSet; import java.util.TreeSet; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.revwalk.RevCommitList; import org.eclipse.jgit.revwalk.RevWalk; @@ -83,7 +85,7 @@ public class PlotCommitList<L extends PlotLane> extends @Override public void source(final RevWalk w) { if (!(w instanceof PlotWalk)) - throw new ClassCastException("Not a " + PlotWalk.class.getName()); + throw new ClassCastException(MessageFormat.format(JGitText.get().classCastNotA, PlotWalk.class.getName())); super.source(w); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotWalk.java b/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotWalk.java index 66756ae996..6b4ed80e15 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotWalk.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revplot/PlotWalk.java @@ -51,6 +51,7 @@ import java.util.Comparator; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Commit; import org.eclipse.jgit.lib.Ref; @@ -86,7 +87,7 @@ public class PlotWalk extends RevWalk { @Override public void sort(final RevSort s, final boolean use) { if (s == RevSort.TOPO && !use) - throw new IllegalArgumentException("Topological sort required."); + throw new IllegalArgumentException(JGitText.get().topologicalSortRequired); super.sort(s, use); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/MergeBaseGenerator.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/MergeBaseGenerator.java index 2f01f541de..edb883714b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/MergeBaseGenerator.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/MergeBaseGenerator.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.revwalk; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; @@ -118,7 +120,7 @@ class MergeBaseGenerator extends Generator { // commit admitted to the initial queue only once. If // we see this marks aren't correctly erased. // - throw new IllegalStateException("Stale RevFlags on " + c.name()); + throw new IllegalStateException(MessageFormat.format(JGitText.get().staleRevFlagsOn, c.name())); } c.flags |= flag; pending.add(c); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/ObjectWalk.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/ObjectWalk.java index ddf40ac104..11d40012c5 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/ObjectWalk.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/ObjectWalk.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.revwalk; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; @@ -273,10 +275,8 @@ public class ObjectWalk extends RevWalk { if (FileMode.GITLINK.equals(mode)) break; treeWalk.getEntryObjectId(idBuffer); - throw new CorruptObjectException("Invalid mode " + mode - + " for " + idBuffer.name() + " '" - + treeWalk.getEntryPathString() + "' in " - + currentTree.name() + "."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().corruptObjectInvalidMode3 + , mode , idBuffer.name() , treeWalk.getEntryPathString() , currentTree.name())); } treeWalk = treeWalk.next(); @@ -428,9 +428,8 @@ public class ObjectWalk extends RevWalk { if (FileMode.GITLINK.equals(mode)) break; treeWalk.getEntryObjectId(idBuffer); - throw new CorruptObjectException("Invalid mode " + mode - + " for " + idBuffer.name() + " " - + treeWalk.getEntryPathString() + " in " + tree + "."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().corruptObjectInvalidMode3 + , mode , idBuffer.name() , treeWalk.getEntryPathString() , tree)); } treeWalk = treeWalk.next(); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevFlag.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevFlag.java index 83f57d266d..e09fae43a8 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevFlag.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevFlag.java @@ -43,6 +43,10 @@ package org.eclipse.jgit.revwalk; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; + /** * Application level mark bit for {@link RevObject}s. * <p> @@ -94,8 +98,8 @@ public class RevFlag { @Override public RevWalk getRevWalk() { - throw new UnsupportedOperationException(toString() - + " is a static flag and has no RevWalk instance"); + throw new UnsupportedOperationException(MessageFormat.format( + JGitText.get().isAStaticFlagAndHasNorevWalkInstance, toString())); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevObjectList.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevObjectList.java index 0454b6ea77..5f8f419569 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevObjectList.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevObjectList.java @@ -45,8 +45,11 @@ package org.eclipse.jgit.revwalk; +import java.text.MessageFormat; import java.util.AbstractList; +import org.eclipse.jgit.JGitText; + /** * An ordered list of {@link RevObject} subclasses. * @@ -77,7 +80,7 @@ public class RevObjectList<E extends RevObject> extends AbstractList<E> { public void add(final int index, final E element) { if (index != size) - throw new UnsupportedOperationException("Not add-at-end: " + index); + throw new UnsupportedOperationException(MessageFormat.format(JGitText.get().unsupportedOperationNotAddAtEnd, index)); set(index, element); size++; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevWalk.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevWalk.java index 4c43aa14e1..94e11752c6 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevWalk.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/RevWalk.java @@ -45,11 +45,13 @@ package org.eclipse.jgit.revwalk; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.EnumSet; import java.util.Iterator; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.RevWalkException; @@ -630,7 +632,7 @@ public class RevWalk implements Iterable<RevCommit> { r = new RevTag(id); break; default: - throw new IllegalArgumentException("invalid git type: " + type); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidGitType, type)); } objects.add(r); } @@ -755,7 +757,7 @@ public class RevWalk implements Iterable<RevCommit> { break; } default: - throw new IllegalArgumentException("Bad object type: " + type); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().badObjectType, type)); } objects.add(r); } else @@ -820,8 +822,8 @@ public class RevWalk implements Iterable<RevCommit> { int allocFlag() { if (freeFlags == 0) - throw new IllegalArgumentException(32 - RESERVED_FLAGS - + " flags already created."); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().flagsAlreadyCreated, 32 - RESERVED_FLAGS)); final int m = Integer.lowestOneBit(freeFlags); freeFlags &= ~m; return m; @@ -838,9 +840,9 @@ public class RevWalk implements Iterable<RevCommit> { */ public void carry(final RevFlag flag) { if ((freeFlags & flag.mask) != 0) - throw new IllegalArgumentException(flag.name + " is disposed."); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().flagIsDisposed, flag.name)); if (flag.walker != this) - throw new IllegalArgumentException(flag.name + " not from this."); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().flagNotFromThis, flag.name)); carryFlags |= flag.mask; } @@ -1059,7 +1061,7 @@ public class RevWalk implements Iterable<RevCommit> { protected void assertNotStarted() { if (isNotStarted()) return; - throw new IllegalStateException("Output has already been started."); + throw new IllegalStateException(JGitText.get().outputHasAlreadyBeenStarted); } private boolean isNotStarted() { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/StartGenerator.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/StartGenerator.java index c5353fe8c5..5e778a416e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/StartGenerator.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/StartGenerator.java @@ -46,7 +46,9 @@ package org.eclipse.jgit.revwalk; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.revwalk.filter.AndRevFilter; @@ -88,8 +90,8 @@ class StartGenerator extends Generator { // use the bulk of the generator pipeline. // if (tf != TreeFilter.ALL) - throw new IllegalStateException("Cannot combine TreeFilter " - + tf + " with RevFilter " + rf + "."); + throw new IllegalStateException(MessageFormat.format( + JGitText.get().cannotCombineTreeFilterWithRevFilter, tf, rf)); final MergeBaseGenerator mbg = new MergeBaseGenerator(w); walker.pending = mbg; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AndRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AndRevFilter.java index 112f07aede..d4790f870c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AndRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AndRevFilter.java @@ -47,6 +47,7 @@ package org.eclipse.jgit.revwalk.filter; import java.io.IOException; import java.util.Collection; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.revwalk.RevCommit; @@ -90,7 +91,7 @@ public abstract class AndRevFilter extends RevFilter { if (list.length == 2) return create(list[0], list[1]); if (list.length < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final RevFilter[] subfilters = new RevFilter[list.length]; System.arraycopy(list, 0, subfilters, 0, list.length); return new List(subfilters); @@ -106,7 +107,7 @@ public abstract class AndRevFilter extends RevFilter { */ public static RevFilter create(final Collection<RevFilter> list) { if (list.size() < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final RevFilter[] subfilters = new RevFilter[list.size()]; list.toArray(subfilters); if (subfilters.length == 2) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AuthorRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AuthorRevFilter.java index 2ede91b57f..3f88c7b8c3 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AuthorRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/AuthorRevFilter.java @@ -45,6 +45,7 @@ package org.eclipse.jgit.revwalk.filter; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.util.RawCharSequence; import org.eclipse.jgit.util.RawParseUtils; @@ -68,7 +69,7 @@ public class AuthorRevFilter { */ public static RevFilter create(String pattern) { if (pattern.length() == 0) - throw new IllegalArgumentException("Cannot match on empty string."); + throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); if (SubStringRevFilter.safe(pattern)) return new SubStringSearch(pattern); return new PatternSearch(pattern); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/CommitterRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/CommitterRevFilter.java index 59c3e080d5..e607f4f920 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/CommitterRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/CommitterRevFilter.java @@ -45,6 +45,7 @@ package org.eclipse.jgit.revwalk.filter; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.util.RawCharSequence; import org.eclipse.jgit.util.RawParseUtils; @@ -68,7 +69,7 @@ public class CommitterRevFilter { */ public static RevFilter create(String pattern) { if (pattern.length() == 0) - throw new IllegalArgumentException("Cannot match on empty string."); + throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); if (SubStringRevFilter.safe(pattern)) return new SubStringSearch(pattern); return new PatternSearch(pattern); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/MessageRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/MessageRevFilter.java index 6ab3b1d3b0..e40fb01835 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/MessageRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/MessageRevFilter.java @@ -45,6 +45,7 @@ package org.eclipse.jgit.revwalk.filter; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.util.RawCharSequence; import org.eclipse.jgit.util.RawParseUtils; @@ -68,7 +69,7 @@ public class MessageRevFilter { */ public static RevFilter create(String pattern) { if (pattern.length() == 0) - throw new IllegalArgumentException("Cannot match on empty string."); + throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); if (SubStringRevFilter.safe(pattern)) return new SubStringSearch(pattern); return new PatternSearch(pattern); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/OrRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/OrRevFilter.java index bd1314a934..586c138fff 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/OrRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/OrRevFilter.java @@ -47,6 +47,7 @@ package org.eclipse.jgit.revwalk.filter; import java.io.IOException; import java.util.Collection; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.revwalk.RevCommit; @@ -88,7 +89,7 @@ public abstract class OrRevFilter extends RevFilter { if (list.length == 2) return create(list[0], list[1]); if (list.length < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final RevFilter[] subfilters = new RevFilter[list.length]; System.arraycopy(list, 0, subfilters, 0, list.length); return new List(subfilters); @@ -104,7 +105,7 @@ public abstract class OrRevFilter extends RevFilter { */ public static RevFilter create(final Collection<RevFilter> list) { if (list.size() < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final RevFilter[] subfilters = new RevFilter[list.size()]; list.toArray(subfilters); if (subfilters.length == 2) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/PatternMatchRevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/PatternMatchRevFilter.java index 5f2bcf26ab..c2a287958a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/PatternMatchRevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/PatternMatchRevFilter.java @@ -48,6 +48,7 @@ import java.io.IOException; import java.util.regex.Matcher; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.Constants; @@ -101,7 +102,7 @@ public abstract class PatternMatchRevFilter extends RevFilter { protected PatternMatchRevFilter(String pattern, final boolean innerString, final boolean rawEncoding, final int flags) { if (pattern.length() == 0) - throw new IllegalArgumentException("Cannot match on empty string."); + throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); patternText = pattern; if (innerString) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/RevFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/RevFilter.java index 2d67d9763a..378c906992 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/RevFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/revwalk/filter/RevFilter.java @@ -45,6 +45,7 @@ package org.eclipse.jgit.revwalk.filter; import java.io.IOException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.StopWalkException; @@ -157,7 +158,7 @@ public abstract class RevFilter { public static final RevFilter MERGE_BASE = new RevFilter() { @Override public boolean include(final RevWalk walker, final RevCommit c) { - throw new UnsupportedOperationException("Cannot be combined."); + throw new UnsupportedOperationException(JGitText.get().cannotBeCombined); } @Override diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/AmazonS3.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/AmazonS3.java index c5d6db7e3e..0430b5fdca 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/AmazonS3.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/AmazonS3.java @@ -60,6 +60,7 @@ import java.security.InvalidKeyException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.spec.InvalidKeySpecException; +import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collections; @@ -78,6 +79,7 @@ import java.util.TreeMap; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.NullProgressMonitor; import org.eclipse.jgit.lib.ProgressMonitor; @@ -158,7 +160,7 @@ public class AmazonS3 { try { return MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { - throw new RuntimeException("JRE lacks MD5 implementation", e); + throw new RuntimeException(JGitText.get().JRELacksMD5Implementation, e); } } @@ -211,11 +213,11 @@ public class AmazonS3 { public AmazonS3(final Properties props) { publicKey = props.getProperty("accesskey"); if (publicKey == null) - throw new IllegalArgumentException("Missing accesskey."); + throw new IllegalArgumentException(JGitText.get().missingAccesskey); final String secret = props.getProperty("secretkey"); if (secret == null) - throw new IllegalArgumentException("Missing secretkey."); + throw new IllegalArgumentException(JGitText.get().missingSecretkey); privateKey = new SecretKeySpec(Constants.encodeASCII(secret), HMAC); final String pacl = props.getProperty("acl", "PRIVATE"); @@ -241,9 +243,9 @@ public class AmazonS3 { encryption = WalkEncryption.NONE; } } catch (InvalidKeySpecException e) { - throw new IllegalArgumentException("Invalid encryption", e); + throw new IllegalArgumentException(JGitText.get().invalidEncryption, e); } catch (NoSuchAlgorithmException e) { - throw new IllegalArgumentException("Invalid encryption", e); + throw new IllegalArgumentException(JGitText.get().invalidEncryption, e); } maxAttempts = Integer.parseInt(props.getProperty( @@ -471,7 +473,7 @@ public class AmazonS3 { if (monitor == null) monitor = NullProgressMonitor.INSTANCE; if (monitorTask == null) - monitorTask = "Uploading " + key; + monitorTask = MessageFormat.format(JGitText.get().progressMonUploading, key); final String md5str = Base64.encodeBytes(csum); final long len = buf.length(); @@ -508,9 +510,8 @@ public class AmazonS3 { private IOException error(final String action, final String key, final HttpURLConnection c) throws IOException { - final IOException err = new IOException(action + " of '" + key - + "' failed: " + HttpSupport.response(c) + " " - + c.getResponseMessage()); + final IOException err = new IOException(MessageFormat.format(JGitText.get().amazonS3ActionFailed + , action, key, HttpSupport.response(c), c.getResponseMessage())); final ByteArrayOutputStream b = new ByteArrayOutputStream(); byte[] buf = new byte[2048]; for (;;) { @@ -527,8 +528,8 @@ public class AmazonS3 { } private IOException maxAttempts(final String action, final String key) { - return new IOException(action + " of '" + key + "' failed:" - + " Giving up after " + maxAttempts + " attempts."); + return new IOException(MessageFormat.format(JGitText.get().amazonS3ActionFailedGivingUp + , action, key, maxAttempts)); } private HttpURLConnection open(final String method, final String bucket, @@ -614,9 +615,9 @@ public class AmazonS3 { m.init(privateKey); sec = Base64.encodeBytes(m.doFinal(s.toString().getBytes("UTF-8"))); } catch (NoSuchAlgorithmException e) { - throw new IOException("No " + HMAC + " support:" + e.getMessage()); + throw new IOException(MessageFormat.format(JGitText.get().noHMACsupport, HMAC, e.getMessage())); } catch (InvalidKeyException e) { - throw new IOException("Invalid key: " + e.getMessage()); + throw new IOException(MessageFormat.format(JGitText.get().invalidKey, e.getMessage())); } c.setRequestProperty("Authorization", "AWS " + publicKey + ":" + sec); } @@ -668,7 +669,7 @@ public class AmazonS3 { try { xr = XMLReaderFactory.createXMLReader(); } catch (SAXException e) { - throw new IOException("No XML parser available."); + throw new IOException(JGitText.get().noXMLParserAvailable); } xr.setContentHandler(this); final InputStream in = c.getInputStream(); @@ -676,7 +677,7 @@ public class AmazonS3 { xr.parse(new InputSource(in)); } catch (SAXException parsingError) { final IOException p; - p = new IOException("Error listing " + prefix); + p = new IOException(MessageFormat.format(JGitText.get().errorListing, prefix)); p.initCause(parsingError); throw p; } finally { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BaseConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BaseConnection.java index 1339b86913..30d3bb13e7 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BaseConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BaseConnection.java @@ -52,6 +52,7 @@ import java.util.Collection; import java.util.Collections; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Ref; @@ -111,7 +112,7 @@ public abstract class BaseConnection implements Connection { protected void markStartedOperation() throws TransportException { if (startedOperation) throw new TransportException( - "Only one operation call per connection is supported."); + JGitText.get().onlyOneOperationCallPerConnectionIsSupported); startedOperation = true; } @@ -136,7 +137,7 @@ public abstract class BaseConnection implements Connection { */ protected void setMessageWriter(Writer writer) { if (messageWriter != null) - throw new IllegalStateException("Writer already initialized"); + throw new IllegalStateException(JGitText.get().writerAlreadyInitialized); messageWriter = writer; } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackConnection.java index 7b6d3e121a..2927cada9c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackConnection.java @@ -50,10 +50,12 @@ import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.text.MessageFormat; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NoRemoteRepositoryException; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.errors.RemoteRepositoryException; @@ -230,8 +232,8 @@ abstract class BasePackConnection extends BaseConnection { name = name.substring(0, name.length() - 3); final Ref prior = avail.get(name); if (prior == null) - throw new PackProtocolException(uri, "advertisement of " - + name + "^{} came before " + name); + throw new PackProtocolException(uri, MessageFormat.format( + JGitText.get().advertisementCameBefore, name, name)); if (prior.getPeeledObjectId() != null) throw duplicateAdvertisement(name + "^{}"); @@ -258,7 +260,7 @@ abstract class BasePackConnection extends BaseConnection { * possibly why. */ protected TransportException noRepository() { - return new NoRemoteRepositoryException(uri, "not found."); + return new NoRemoteRepositoryException(uri, JGitText.get().notFound); } protected boolean isCapableOf(final String option) { @@ -274,8 +276,7 @@ abstract class BasePackConnection extends BaseConnection { } private PackProtocolException duplicateAdvertisement(final String name) { - return new PackProtocolException(uri, "duplicate advertisements of " - + name); + return new PackProtocolException(uri, MessageFormat.format(JGitText.get().duplicateAdvertisementsOf, name)); } @Override diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackFetchConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackFetchConnection.java index 7b90ec199f..2819ae26de 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackFetchConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackFetchConnection.java @@ -47,11 +47,13 @@ package org.eclipse.jgit.transport; import java.io.IOException; import java.io.InputStream; +import java.text.MessageFormat; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.AnyObjectId; @@ -391,8 +393,7 @@ abstract class BasePackFetchConnection extends BasePackConnection implements // ACK status to tell us common objects for reuse in future // requests. If its not enabled, we can't talk to the peer. // - throw new PackProtocolException(uri, "stateless RPC requires " - + OPTION_MULTI_ACK_DETAILED + " to be enabled"); + throw new PackProtocolException(uri, MessageFormat.format(JGitText.get().statelessRPCRequiresOptionToBeEnabled, OPTION_MULTI_ACK_DETAILED)); } return line.toString(); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackPushConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackPushConnection.java index e10cefd3ab..44ccd2d6ad 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackPushConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BasePackPushConnection.java @@ -45,10 +45,12 @@ package org.eclipse.jgit.transport; import java.io.IOException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NoRemoteRepositoryException; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.PackProtocolException; @@ -137,7 +139,7 @@ class BasePackPushConnection extends BasePackConnection implements } catch (TransportException e) { // Fall through. } - return new TransportException(uri, "push not permitted"); + return new TransportException(uri, JGitText.get().pushNotPermitted); } protected void doPush(final ProgressMonitor monitor, @@ -158,8 +160,7 @@ class BasePackPushConnection extends BasePackConnection implements // int b = in.read(); if (0 <= b) - throw new TransportException(uri, "expected EOF;" - + " received '" + (char) b + "' instead"); + throw new TransportException(uri, MessageFormat.format(JGitText.get().expectedEOFReceived, (char) b)); } } } catch (TransportException e) { @@ -201,7 +202,7 @@ class BasePackPushConnection extends BasePackConnection implements } if (monitor.isCancelled()) - throw new TransportException(uri, "push cancelled"); + throw new TransportException(uri, JGitText.get().pushCancelled); pckOut.end(); outNeedsEnd = false; } @@ -252,13 +253,11 @@ class BasePackPushConnection extends BasePackConnection implements throws IOException { final String unpackLine = readStringLongTimeout(); if (!unpackLine.startsWith("unpack ")) - throw new PackProtocolException(uri, "unexpected report line: " - + unpackLine); + throw new PackProtocolException(uri, MessageFormat.format(JGitText.get().unexpectedReportLine, unpackLine)); final String unpackStatus = unpackLine.substring("unpack ".length()); if (!unpackStatus.equals("ok")) - throw new TransportException(uri, - "error occurred during unpacking on the remote end: " - + unpackStatus); + throw new TransportException(uri, MessageFormat.format( + JGitText.get().errorOccurredDuringUnpackingOnTheRemoteEnd, unpackStatus)); String refLine; while ((refLine = pckIn.readString()) != PacketLineIn.END) { @@ -272,16 +271,15 @@ class BasePackPushConnection extends BasePackConnection implements refNameEnd = refLine.indexOf(" ", 3); } if (refNameEnd == -1) - throw new PackProtocolException(uri - + ": unexpected report line: " + refLine); + throw new PackProtocolException(MessageFormat.format(JGitText.get().unexpectedReportLine2 + , uri, refLine)); final String refName = refLine.substring(3, refNameEnd); final String message = (ok ? null : refLine .substring(refNameEnd + 1)); final RemoteRefUpdate rru = refUpdates.get(refName); if (rru == null) - throw new PackProtocolException(uri - + ": unexpected ref report: " + refName); + throw new PackProtocolException(MessageFormat.format(JGitText.get().unexpectedRefReport, uri, refName)); if (ok) { rru.setStatus(Status.OK); } else { @@ -291,9 +289,8 @@ class BasePackPushConnection extends BasePackConnection implements } for (final RemoteRefUpdate rru : refUpdates.values()) { if (rru.getStatus() == Status.AWAITING_REPORT) - throw new PackProtocolException(uri - + ": expected report for ref " + rru.getRemoteName() - + " not received"); + throw new PackProtocolException(MessageFormat.format( + JGitText.get().expectedReportForRefNotReceived , uri, rru.getRemoteName())); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleFetchConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleFetchConnection.java index c788244f74..3b97dfc0d6 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleFetchConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleFetchConnection.java @@ -50,6 +50,7 @@ package org.eclipse.jgit.transport; import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -59,6 +60,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingBundlePrerequisiteException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.PackProtocolException; @@ -101,7 +103,7 @@ class BundleFetchConnection extends BaseFetchConnection { readBundleV2(); break; default: - throw new TransportException(transport.uri, "not a bundle"); + throw new TransportException(transport.uri, JGitText.get().notABundle); } } catch (TransportException err) { close(); @@ -119,7 +121,7 @@ class BundleFetchConnection extends BaseFetchConnection { final String rev = readLine(new byte[1024]); if (TransportBundle.V2_BUNDLE_SIGNATURE.equals(rev)) return 2; - throw new TransportException(transport.uri, "not a bundle"); + throw new TransportException(transport.uri, JGitText.get().notABundle); } private void readBundleV2() throws IOException { @@ -151,7 +153,7 @@ class BundleFetchConnection extends BaseFetchConnection { private PackProtocolException duplicateAdvertisement(final String name) { return new PackProtocolException(transport.uri, - "duplicate advertisements of " + name); + MessageFormat.format(JGitText.get().duplicateAdvertisementsOf, name)); } private String readLine(final byte[] hdrbuf) throws IOException { @@ -227,8 +229,8 @@ class BundleFetchConnection extends BaseFetchConnection { } catch (MissingObjectException notFound) { missing.put(p, e.getValue()); } catch (IOException err) { - throw new TransportException(transport.uri, "Cannot read commit " - + p.name(), err); + throw new TransportException(transport.uri + , MessageFormat.format(JGitText.get().cannotReadCommit, p.name()), err); } } if (!missing.isEmpty()) @@ -253,7 +255,7 @@ class BundleFetchConnection extends BaseFetchConnection { } } } catch (IOException err) { - throw new TransportException(transport.uri, "Cannot read object", err); + throw new TransportException(transport.uri, JGitText.get().cannotReadObject, err); } if (remaining > 0) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleWriter.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleWriter.java index 7b0a5eec45..7e91557b09 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleWriter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/BundleWriter.java @@ -47,11 +47,13 @@ import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; +import java.text.MessageFormat; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.TreeMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; @@ -112,9 +114,9 @@ public class BundleWriter { */ public void include(final String name, final AnyObjectId id) { if (!Repository.isValidRefName(name)) - throw new IllegalArgumentException("Invalid ref name: " + name); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidRefName, name)); if (include.containsKey(name)) - throw new IllegalStateException("Duplicate ref: " + name); + throw new IllegalStateException(JGitText.get().duplicateRef + name); include.put(name, id.toObjectId()); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/Daemon.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/Daemon.java index cafcd7b4bd..39c7ae8f01 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/Daemon.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/Daemon.java @@ -57,6 +57,7 @@ import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.Repository; @@ -250,7 +251,7 @@ public class Daemon { */ public synchronized void start() throws IOException { if (acceptThread != null) - throw new IllegalStateException("Daemon already running"); + throw new IllegalStateException(JGitText.get().daemonAlreadyRunning); final ServerSocket listenSock = new ServerSocket( myAddress != null ? myAddress.getPort() : 0, BACKLOG, diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/FetchProcess.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/FetchProcess.java index b86f86d2f9..fc203f69c8 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/FetchProcess.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/FetchProcess.java @@ -48,6 +48,7 @@ import java.io.File; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.Writer; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -57,6 +58,7 @@ import java.util.Iterator; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; @@ -122,8 +124,8 @@ class FetchProcess { final Set<Ref> matched = new HashSet<Ref>(); for (final RefSpec spec : toFetch) { if (spec.getSource() == null) - throw new TransportException( - "Source ref not specified for refspec: " + spec); + throw new TransportException(MessageFormat.format( + JGitText.get().sourceRefNotSpecifiedForRefspec, spec)); if (spec.isWildcard()) expandWildcard(spec, matched); @@ -181,8 +183,8 @@ class FetchProcess { u.update(walk); result.add(u); } catch (IOException err) { - throw new TransportException("Failure updating tracking ref " - + u.getLocalName() + ": " + err.getMessage(), err); + throw new TransportException(MessageFormat.format( + JGitText.get().failureUpdatingTrackingRef, u.getLocalName(), err.getMessage()), err); } } @@ -190,8 +192,8 @@ class FetchProcess { try { updateFETCH_HEAD(result); } catch (IOException err) { - throw new TransportException("Failure updating FETCH_HEAD: " - + err.getMessage(), err); + throw new TransportException(MessageFormat.format( + JGitText.get().failureUpdatingFETCH_HEAD, err.getMessage()), err); } } } @@ -207,7 +209,7 @@ class FetchProcess { if (transport.isCheckFetchedObjects() && !conn.didFetchTestConnectivity() && !askForIsComplete()) throw new TransportException(transport.getURI(), - "peer did not supply a complete object graph"); + JGitText.get().peerDidNotSupplyACompleteObjectGraph); } private void closeConnection(final FetchResult result) { @@ -301,7 +303,7 @@ class FetchProcess { } catch (MissingObjectException e) { return false; } catch (IOException e) { - throw new TransportException("Unable to check connectivity.", e); + throw new TransportException(JGitText.get().unableToCheckConnectivity, e); } } @@ -317,8 +319,7 @@ class FetchProcess { throws TransportException { final Ref src = conn.getRef(spec.getSource()); if (src == null) { - throw new TransportException("Remote does not have " - + spec.getSource() + " available for fetch."); + throw new TransportException(MessageFormat.format(JGitText.get().remoteDoesNotHaveSpec, spec.getSource())); } if (matched.add(src)) want(src, spec); @@ -376,9 +377,8 @@ class FetchProcess { } catch (IOException err) { // Bad symbolic ref? That is the most likely cause. // - throw new TransportException("Cannot resolve" - + " local tracking ref " + spec.getDestination() - + " for updating.", err); + throw new TransportException( MessageFormat.format( + JGitText.get().cannotResolveLocalTrackingRefForUpdating, spec.getDestination()), err); } } @@ -432,13 +432,12 @@ class FetchProcess { case FORCED: break; default: - throw new TransportException(transport.getURI(), - "Cannot delete stale tracking ref " + name + ": " - + u.getResult().name()); + throw new TransportException(transport.getURI(), MessageFormat.format( + JGitText.get().cannotDeleteStaleTrackingRef2, name, u.getResult().name())); } } catch (IOException e) { - throw new TransportException(transport.getURI(), - "Cannot delete stale tracking ref " + name, e); + throw new TransportException(transport.getURI(), MessageFormat.format( + JGitText.get().cannotDeleteStaleTrackingRef, name), e); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/IndexPack.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/IndexPack.java index 6eeccea841..2a5b4344f5 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/IndexPack.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/IndexPack.java @@ -52,6 +52,7 @@ import java.io.IOException; import java.io.InputStream; import java.io.RandomAccessFile; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -60,6 +61,7 @@ import java.util.zip.DataFormatException; import java.util.zip.Deflater; import java.util.zip.Inflater; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.AnyObjectId; @@ -82,10 +84,10 @@ import org.eclipse.jgit.util.NB; /** Indexes Git pack files for local use. */ public class IndexPack { /** Progress message when reading raw data from the pack. */ - public static final String PROGRESS_DOWNLOAD = "Receiving objects"; + public static final String PROGRESS_DOWNLOAD = JGitText.get().receivingObjects; /** Progress message when computing names of delta compressed objects. */ - public static final String PROGRESS_RESOLVE_DELTA = "Resolving deltas"; + public static final String PROGRESS_RESOLVE_DELTA = JGitText.get().resolvingDeltas; /** * Size of the internal stream buffer. @@ -392,20 +394,19 @@ public class IndexPack { indexOneObject(); progress.update(1); if (progress.isCancelled()) - throw new IOException("Download cancelled"); + throw new IOException(JGitText.get().downloadCancelled); } readPackFooter(); endInput(); progress.endTask(); if (deltaCount > 0) { if (packOut == null) - throw new IOException("need packOut"); + throw new IOException(JGitText.get().needPackOut); resolveDeltas(progress); if (entryCount < objectCount) { if (!fixThin) { - throw new IOException("pack has " - + (objectCount - entryCount) - + " unresolved deltas"); + throw new IOException(MessageFormat.format( + JGitText.get().packHasUnresolvedDeltas, (objectCount - entryCount))); } fixThinPack(progress); } @@ -458,7 +459,7 @@ public class IndexPack { resolveDeltas(entries[i]); progress.update(entryCount - before); if (progress.isCancelled()) - throw new IOException("Download cancelled during indexing"); + throw new IOException(JGitText.get().downloadCancelledDuringIndexing); } progress.endTask(); } @@ -505,12 +506,12 @@ public class IndexPack { break; } default: - throw new IOException("Unknown object type " + typeCode + "."); + throw new IOException(MessageFormat.format(JGitText.get().unknownObjectType, typeCode)); } final int crc32 = (int) crc.getValue(); if (oldCRC != crc32) - throw new IOException("Corruption detected re-reading at " + pos); + throw new IOException(MessageFormat.format(JGitText.get().corruptionDetectedReReadingAt, pos)); if (oe == null) { objectDigest.update(Constants.encodedTypeString(type)); objectDigest.update((byte) ' '); @@ -602,7 +603,7 @@ public class IndexPack { resolveChildDeltas(oe.getOffset(), typeCode, data, oe); if (progress.isCancelled()) - throw new IOException("Download cancelled during indexing"); + throw new IOException(JGitText.get().downloadCancelledDuringIndexing); } def.end(); @@ -691,7 +692,7 @@ public class IndexPack { if (!Arrays.equals(origDigest.digest(), origcsum) || !Arrays.equals(tailDigest.digest(), tailcsum)) - throw new IOException("Pack corrupted while writing to filesystem"); + throw new IOException(JGitText.get().packCorruptedWhileWritingToFilesystem); packcsum = packDigest.digest(); packOut.write(packcsum); @@ -730,11 +731,11 @@ public class IndexPack { final int p = fillFromInput(hdrln); for (int k = 0; k < Constants.PACK_SIGNATURE.length; k++) if (buf[p + k] != Constants.PACK_SIGNATURE[k]) - throw new IOException("Not a PACK file."); + throw new IOException(JGitText.get().notAPACKFile); final long vers = NB.decodeUInt32(buf, p + 4); if (vers != 2 && vers != 3) - throw new IOException("Unsupported pack version " + vers + "."); + throw new IOException(MessageFormat.format(JGitText.get().unsupportedPackVersion, vers)); objectCount = NB.decodeUInt32(buf, p + 8); use(hdrln); } @@ -750,7 +751,7 @@ public class IndexPack { packOut.write(packcsum); if (!Arrays.equals(cmpcsum, packcsum)) - throw new CorruptObjectException("Packfile checksum incorrect."); + throw new CorruptObjectException(JGitText.get().corruptObjectPackfileChecksumIncorrect); } // Cleanup all resources associated with our input parsing. @@ -814,7 +815,7 @@ public class IndexPack { break; } default: - throw new IOException("Unknown object type " + typeCode + "."); + throw new IOException(MessageFormat.format(JGitText.get().unknownObjectType, typeCode)); } } @@ -839,9 +840,8 @@ public class IndexPack { try { objCheck.check(type, data); } catch (CorruptObjectException e) { - throw new IOException("Invalid " - + Constants.typeString(type) + " " + id.name() - + ":" + e.getMessage()); + throw new IOException(MessageFormat.format(JGitText.get().invalidObject + , Constants.typeString(type) , id.name() , e.getMessage())); } } @@ -849,7 +849,7 @@ public class IndexPack { if (ldr != null) { final byte[] existingData = ldr.getCachedBytes(); if (ldr.getType() != type || !Arrays.equals(data, existingData)) { - throw new IOException("Collision on " + id.name()); + throw new IOException(MessageFormat.format(JGitText.get().collisionOn, id.name())); } } } @@ -904,7 +904,7 @@ public class IndexPack { } next = in.read(buf, next, free); if (next <= 0) - throw new EOFException("Packfile is truncated."); + throw new EOFException(JGitText.get().packfileIsTruncated); bAvail += next; } return bOffset; @@ -924,7 +924,7 @@ public class IndexPack { } next = packOut.read(buf, next, free); if (next <= 0) - throw new EOFException("Packfile is truncated."); + throw new EOFException(JGitText.get().packfileIsTruncated); bAvail += next; } return bOffset; @@ -966,7 +966,7 @@ public class IndexPack { n += inf.inflate(dst, n, free); } if (n != sz) - throw new DataFormatException("wrong decompressed length"); + throw new DataFormatException(JGitText.get().wrongDecompressedLength); n = bAvail - inf.getRemaining(); if (n > 0) { crc.update(buf, p, n); @@ -998,7 +998,7 @@ public class IndexPack { n += inf.inflate(dst, n, dst.length - n); } if (n != sz) - throw new DataFormatException("wrong decompressed length"); + throw new DataFormatException(JGitText.get().wrongDecompressedLength); n = bAvail - inf.getRemaining(); if (n > 0) { crc.update(buf, p, n); @@ -1043,8 +1043,8 @@ public class IndexPack { } private static CorruptObjectException corrupt(final DataFormatException dfe) { - return new CorruptObjectException("Packfile corruption detected: " - + dfe.getMessage()); + return new CorruptObjectException(MessageFormat.format( + JGitText.get().packfileCorruptionDetected, dfe.getMessage())); } private static class DeltaChain extends ObjectId { @@ -1138,7 +1138,7 @@ public class IndexPack { // to create it. There is no way to move this pack in. // cleanupTemporaryFiles(); - throw new IOException("Cannot create " + packDir.getAbsolutePath()); + throw new IOException(MessageFormat.format(JGitText.get().cannotCreateDirectory, packDir.getAbsolutePath())); } if (finalPack.exists()) { @@ -1154,7 +1154,7 @@ public class IndexPack { // try { if (!keep.lock(lockMessage)) - throw new IOException("Cannot lock pack in " + finalPack); + throw new IOException(MessageFormat.format(JGitText.get().cannotLockPackIn, finalPack)); } catch (IOException e) { cleanupTemporaryFiles(); throw e; @@ -1164,7 +1164,7 @@ public class IndexPack { if (!dstPack.renameTo(finalPack)) { cleanupTemporaryFiles(); keep.unlock(); - throw new IOException("Cannot move pack to " + finalPack); + throw new IOException(MessageFormat.format(JGitText.get().cannotMovePackTo, finalPack)); } if (!dstIdx.renameTo(finalIdx)) { @@ -1172,7 +1172,7 @@ public class IndexPack { keep.unlock(); if (!finalPack.delete()) finalPack.deleteOnExit(); - throw new IOException("Cannot move index to " + finalIdx); + throw new IOException(MessageFormat.format(JGitText.get().cannotMoveIndexTo, finalIdx)); } try { @@ -1199,4 +1199,4 @@ public class IndexPack { if (needNewObjectIds()) newObjectIds.add(oe); } -}
\ No newline at end of file +} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PacketLineIn.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PacketLineIn.java index 170e4ddbe0..3821d696ed 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PacketLineIn.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PacketLineIn.java @@ -47,7 +47,9 @@ package org.eclipse.jgit.transport; import java.io.IOException; import java.io.InputStream; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.MutableObjectId; @@ -82,7 +84,7 @@ class PacketLineIn { AckNackResult readACK(final MutableObjectId returnedId) throws IOException { final String line = readString(); if (line.length() == 0) - throw new PackProtocolException("Expected ACK/NAK, found EOF"); + throw new PackProtocolException(JGitText.get().expectedACKNAKFoundEOF); if ("NAK".equals(line)) return AckNackResult.NAK; if (line.startsWith("ACK ")) { @@ -98,7 +100,7 @@ class PacketLineIn { else if (arg.equals(" ready")) return AckNackResult.ACK_READY; } - throw new PackProtocolException("Expected ACK/NAK, got: " + line); + throw new PackProtocolException(MessageFormat.format(JGitText.get().expectedACKNAKGot, line)); } String readString() throws IOException { @@ -142,9 +144,9 @@ class PacketLineIn { throw new ArrayIndexOutOfBoundsException(); return len; } catch (ArrayIndexOutOfBoundsException err) { - throw new IOException("Invalid packet line header: " - + (char) lineBuffer[0] + (char) lineBuffer[1] - + (char) lineBuffer[2] + (char) lineBuffer[3]); + throw new IOException(MessageFormat.format(JGitText.get().invalidPacketLineHeader, + "" + (char) lineBuffer[0] + (char) lineBuffer[1] + + (char) lineBuffer[2] + (char) lineBuffer[3])); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java index 03b783427a..02497cb06f 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java @@ -44,10 +44,12 @@ package org.eclipse.jgit.transport; import java.io.IOException; +import java.text.MessageFormat; import java.util.Collection; import java.util.HashMap; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; @@ -66,7 +68,7 @@ import org.eclipse.jgit.transport.RemoteRefUpdate.Status; */ class PushProcess { /** Task name for {@link ProgressMonitor} used during opening connection. */ - static final String PROGRESS_OPENING_CONNECTION = "Opening connection"; + static final String PROGRESS_OPENING_CONNECTION = JGitText.get().openingConnection; /** Transport used to perform this operation. */ private final Transport transport; @@ -97,9 +99,8 @@ class PushProcess { this.toPush = new HashMap<String, RemoteRefUpdate>(); for (final RemoteRefUpdate rru : toPush) { if (this.toPush.put(rru.getRemoteName(), rru) != null) - throw new TransportException( - "Duplicate remote ref update is illegal. Affected remote name: " - + rru.getRemoteName()); + throw new TransportException(MessageFormat.format( + JGitText.get().duplicateRemoteRefUpdateIsIllegal, rru.getRemoteName())); } } @@ -200,9 +201,8 @@ class PushProcess { } catch (MissingObjectException x) { fastForward = false; } catch (Exception x) { - throw new TransportException(transport.getURI(), - "reading objects from local repository failed: " - + x.getMessage(), x); + throw new TransportException(transport.getURI(), MessageFormat.format( + JGitText.get().readingObjectsFromLocalRepositoryFailed, x.getMessage()), x); } rru.setFastForward(fastForward); if (!fastForward && !rru.isForceUpdate()) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java index 4e62d7427f..e42b7fe0c9 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java @@ -57,6 +57,7 @@ import java.io.InputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; @@ -64,6 +65,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.lib.Config; @@ -724,7 +726,7 @@ public class ReceivePack { } if (line.length() < 83) { - final String m = "error: invalid protocol: wanted 'old new ref'"; + final String m = JGitText.get().errorInvalidProtocolWantedOldNewRef; sendError(m); throw new PackProtocolException(m); } @@ -898,7 +900,7 @@ public class ReceivePack { // other requested old id is invalid. // cmd.setResult(Result.REJECTED_OTHER_REASON, - "invalid old id sent"); + JGitText.get().invalidOldIdSent); continue; } @@ -906,7 +908,7 @@ public class ReceivePack { if (ref == null) { // The ref must have been advertised in order to be updated. // - cmd.setResult(Result.REJECTED_OTHER_REASON, "no such ref"); + cmd.setResult(Result.REJECTED_OTHER_REASON, JGitText.get().noSuchRef); continue; } @@ -915,7 +917,7 @@ public class ReceivePack { // object id we advertised. // cmd.setResult(Result.REJECTED_OTHER_REASON, - "invalid old id sent"); + JGitText.get().invalidOldIdSent); continue; } @@ -958,7 +960,7 @@ public class ReceivePack { if (!cmd.getRefName().startsWith(Constants.R_REFS) || !Repository.isValidRefName(cmd.getRefName())) { - cmd.setResult(Result.REJECTED_OTHER_REASON, "funny refname"); + cmd.setResult(Result.REJECTED_OTHER_REASON, JGitText.get().funnyRefname); } } } @@ -997,8 +999,8 @@ public class ReceivePack { break; } } catch (IOException err) { - cmd.setResult(Result.REJECTED_OTHER_REASON, "lock error: " - + err.getMessage()); + cmd.setResult(Result.REJECTED_OTHER_REASON, MessageFormat.format( + JGitText.get().lockError, err.getMessage())); } } @@ -1047,7 +1049,7 @@ public class ReceivePack { private void sendStatusReport(final boolean forClient, final Reporter out) throws IOException { if (unpackError != null) { - out.sendString("unpack error " + unpackError.getMessage()); + out.sendString(MessageFormat.format(JGitText.get().unpackError, unpackError.getMessage())); if (forClient) { for (final ReceiveCommand cmd : commands) { out.sendString("ng " + cmd.getRefName() diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/RefSpec.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/RefSpec.java index 154ae3fedc..ca6f01500b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/RefSpec.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/RefSpec.java @@ -43,6 +43,9 @@ package org.eclipse.jgit.transport; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Ref; @@ -125,7 +128,7 @@ public class RefSpec { if (c == 0) { s = s.substring(1); if (isWildcard(s)) - throw new IllegalArgumentException("Invalid wildcards " + spec); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidWildcards, spec)); dstName = s; } else if (c > 0) { srcName = s.substring(0, c); @@ -133,10 +136,10 @@ public class RefSpec { if (isWildcard(srcName) && isWildcard(dstName)) wildcard = true; else if (isWildcard(srcName) || isWildcard(dstName)) - throw new IllegalArgumentException("Invalid wildcards " + spec); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidWildcards, spec)); } else { if (isWildcard(s)) - throw new IllegalArgumentException("Invalid wildcards " + spec); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidWildcards, spec)); srcName = s; } } @@ -211,9 +214,9 @@ public class RefSpec { final RefSpec r = new RefSpec(this); r.srcName = source; if (isWildcard(r.srcName) && r.dstName == null) - throw new IllegalStateException("Destination is not a wildcard."); + throw new IllegalStateException(JGitText.get().destinationIsNotAWildcard); if (isWildcard(r.srcName) != isWildcard(r.dstName)) - throw new IllegalStateException("Source/Destination must match."); + throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); return r; } @@ -250,9 +253,9 @@ public class RefSpec { final RefSpec r = new RefSpec(this); r.dstName = destination; if (isWildcard(r.dstName) && r.srcName == null) - throw new IllegalStateException("Source is not a wildcard."); + throw new IllegalStateException(JGitText.get().sourceIsNotAWildcard); if (isWildcard(r.srcName) != isWildcard(r.dstName)) - throw new IllegalStateException("Source/Destination must match."); + throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); return r; } @@ -271,7 +274,7 @@ public class RefSpec { public RefSpec setSourceDestination(final String source, final String destination) { if (isWildcard(source) != isWildcard(destination)) - throw new IllegalArgumentException("Source/Destination must match."); + throw new IllegalStateException(JGitText.get().sourceDestinationMustMatch); final RefSpec r = new RefSpec(this); r.wildcard = isWildcard(source); r.srcName = source; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/RemoteRefUpdate.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/RemoteRefUpdate.java index b2aa6335d8..1b17c9f0f4 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/RemoteRefUpdate.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/RemoteRefUpdate.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.transport; import java.io.IOException; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevWalk; @@ -184,13 +186,13 @@ public class RemoteRefUpdate { final String localName, final ObjectId expectedOldObjectId) throws IOException { if (remoteName == null) - throw new IllegalArgumentException("Remote name can't be null."); + throw new IllegalArgumentException(JGitText.get().remoteNameCantBeNull); this.srcRef = srcRef; this.newObjectId = (srcRef == null ? ObjectId.zeroId() : localDb .resolve(srcRef)); if (newObjectId == null) - throw new IOException("Source ref " + srcRef - + " doesn't resolve to any object."); + throw new IOException(MessageFormat.format( + JGitText.get().sourceRefDoesntResolveToAnyObject, srcRef)); this.remoteName = remoteName; this.forceUpdate = forceUpdate; if (localName != null && localDb != null) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandInputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandInputStream.java index 796cb745a1..1f9883e504 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandInputStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandInputStream.java @@ -49,9 +49,11 @@ import static org.eclipse.jgit.transport.SideBandOutputStream.HDR_SIZE; import java.io.IOException; import java.io.InputStream; import java.io.Writer; +import java.text.MessageFormat; import java.util.regex.Matcher; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; @@ -75,7 +77,7 @@ import org.eclipse.jgit.util.RawParseUtils; * @see SideBandOutputStream */ class SideBandInputStream extends InputStream { - private static final String PFX_REMOTE = "remote: "; + private static final String PFX_REMOTE = JGitText.get().prefixRemote; static final int CH_DATA = 1; @@ -170,7 +172,7 @@ class SideBandInputStream extends InputStream { eof = true; throw new TransportException(PFX_REMOTE + readString(available)); default: - throw new PackProtocolException("Invalid channel " + channel); + throw new PackProtocolException(MessageFormat.format(JGitText.get().invalidChannel, channel)); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandOutputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandOutputStream.java index 6e0a52627e..31acdcde5b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandOutputStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SideBandOutputStream.java @@ -45,6 +45,9 @@ package org.eclipse.jgit.transport; import java.io.IOException; import java.io.OutputStream; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Multiplexes data and progress messages. @@ -94,14 +97,11 @@ class SideBandOutputStream extends OutputStream { */ SideBandOutputStream(final int chan, final int sz, final OutputStream os) { if (chan <= 0 || chan > 255) - throw new IllegalArgumentException("channel " + chan - + " must be in range [0, 255]"); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().channelMustBeInRange0_255, chan)); if (sz <= HDR_SIZE) - throw new IllegalArgumentException("packet size " + sz - + " must be >= " + HDR_SIZE); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().packetSizeMustBeAtLeast, sz, HDR_SIZE)); else if (MAX_BUF < sz) - throw new IllegalArgumentException("packet size " + sz - + " must be <= " + MAX_BUF); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().packetSizeMustBeAtMost, sz, MAX_BUF)); out = os; buffer = new byte[sz]; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SshTransport.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SshTransport.java index 5c6b498cad..d25a7b6180 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/SshTransport.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/SshTransport.java @@ -50,6 +50,7 @@ package org.eclipse.jgit.transport; import java.net.ConnectException; import java.net.UnknownHostException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Repository; @@ -96,10 +97,10 @@ public abstract class SshTransport extends TcpTransport { */ public void setSshSessionFactory(SshSessionFactory factory) { if (factory == null) - throw new NullPointerException("The factory must not be null"); + throw new NullPointerException(JGitText.get().theFactoryMustNotBeNull); if (sock != null) throw new IllegalStateException( - "An SSH session has been already created"); + JGitText.get().anSSHSessionHasBeenAlreadyCreated); sch = factory; } @@ -133,7 +134,7 @@ public abstract class SshTransport extends TcpTransport { } catch (JSchException je) { final Throwable c = je.getCause(); if (c instanceof UnknownHostException) - throw new TransportException(uri, "unknown host"); + throw new TransportException(uri, JGitText.get().unknownHost); if (c instanceof ConnectException) throw new TransportException(uri, c.getMessage()); throw new TransportException(uri, je.getMessage(), je); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TagOpt.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TagOpt.java index 66f36a0d27..82a5f23b6a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TagOpt.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TagOpt.java @@ -44,6 +44,10 @@ package org.eclipse.jgit.transport; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; + /** Specification of annotated tag behavior during fetch. */ public enum TagOpt { /** @@ -105,6 +109,6 @@ public enum TagOpt { if (tagopt.option().equals(o)) return tagopt; } - throw new IllegalArgumentException("Invalid tag option: " + o); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidTagOption, o)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/Transport.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/Transport.java index d6400963ac..c0b2eedc00 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/Transport.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/Transport.java @@ -48,6 +48,7 @@ package org.eclipse.jgit.transport; import java.io.IOException; import java.net.URISyntaxException; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -56,6 +57,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; @@ -240,9 +242,8 @@ public abstract class Transport { throws NotSupportedException { final List<URIish> uris = getURIs(cfg, op); if (uris.isEmpty()) - throw new IllegalArgumentException( - "Remote config \"" - + cfg.getName() + "\" has no URIs associated"); + throw new IllegalArgumentException(MessageFormat.format( + JGitText.get().remoteConfigHasNoURIAssociated, cfg.getName())); final Transport tn = open(local, uris.get(0)); tn.applyConfig(cfg); return tn; @@ -351,7 +352,7 @@ public abstract class Transport { else if (TransportLocal.canHandle(remote)) return new TransportLocal(local, remote); - throw new NotSupportedException("URI not supported: " + remote); + throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, remote)); } /** @@ -787,7 +788,7 @@ public abstract class Transport { // If the caller did not ask for anything use the defaults. // if (fetch.isEmpty()) - throw new TransportException("Nothing to fetch."); + throw new TransportException(JGitText.get().nothingToFetch); toFetch = fetch; } else if (!fetch.isEmpty()) { // If the caller asked for something specific without giving @@ -862,12 +863,11 @@ public abstract class Transport { try { toPush = findRemoteRefUpdatesFor(push); } catch (final IOException e) { - throw new TransportException( - "Problem with resolving push ref specs locally: " - + e.getMessage(), e); + throw new TransportException(MessageFormat.format( + JGitText.get().problemWithResolvingPushRefSpecsLocally, e.getMessage()), e); } if (toPush.isEmpty()) - throw new TransportException("Nothing to push."); + throw new TransportException(JGitText.get().nothingToPush); } final PushProcess pushProcess = new PushProcess(this, toPush); return pushProcess.execute(monitor); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportAmazonS3.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportAmazonS3.java index a3fd1ceae5..bcf6e873fe 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportAmazonS3.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportAmazonS3.java @@ -50,6 +50,7 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.URLConnection; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; @@ -57,6 +58,7 @@ import java.util.Map; import java.util.Properties; import java.util.TreeMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; @@ -133,7 +135,7 @@ public class TransportAmazonS3 extends HttpTransport implements WalkTransport { try { props = AmazonS3.properties(propsFile); } catch (IOException e) { - throw new NotSupportedException("cannot read " + propsFile, e); + throw new NotSupportedException(MessageFormat.format(JGitText.get().cannotReadFile, propsFile), e); } } else { props = new Properties(); @@ -277,7 +279,7 @@ public class TransportAmazonS3 extends HttpTransport implements WalkTransport { + "refs"))) readRef(avail, "refs/" + n); } catch (IOException e) { - throw new TransportException(getURI(), "cannot list refs", e); + throw new TransportException(getURI(), JGitText.get().cannotListRefs, e); } } @@ -295,11 +297,12 @@ public class TransportAmazonS3 extends HttpTransport implements WalkTransport { } catch (FileNotFoundException noRef) { return null; } catch (IOException err) { - throw new TransportException(getURI(), "read " + ref, err); + throw new TransportException(getURI(), MessageFormat.format( + JGitText.get().transportExceptionReadRef, ref), err); } if (s == null) - throw new TransportException(getURI(), "Empty ref: " + rn); + throw new TransportException(getURI(), MessageFormat.format(JGitText.get().transportExceptionEmptyRef, rn)); if (s.startsWith("ref: ")) { final String target = s.substring("ref: ".length()); @@ -320,7 +323,7 @@ public class TransportAmazonS3 extends HttpTransport implements WalkTransport { return r; } - throw new TransportException(getURI(), "Bad ref: " + rn + ": " + s); + throw new TransportException(getURI(), MessageFormat.format(JGitText.get().transportExceptionBadRef, rn, s)); } private Storage loose(final Ref r) { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleFile.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleFile.java index 17e3bdd229..0245818fe3 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleFile.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleFile.java @@ -51,6 +51,7 @@ import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Repository; @@ -84,7 +85,7 @@ class TransportBundleFile extends Transport implements TransportBundle { try { src = new FileInputStream(bundle); } catch (FileNotFoundException err) { - throw new TransportException(uri, "not found"); + throw new TransportException(uri, JGitText.get().notFound); } return new BundleFetchConnection(this, src); } @@ -92,7 +93,7 @@ class TransportBundleFile extends Transport implements TransportBundle { @Override public PushConnection openPush() throws NotSupportedException { throw new NotSupportedException( - "Push is not supported for bundle transport"); + JGitText.get().pushIsNotSupportedForBundleTransport); } @Override diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleStream.java index e5188bb236..defc8c2bb6 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportBundleStream.java @@ -49,6 +49,7 @@ package org.eclipse.jgit.transport; import java.io.IOException; import java.io.InputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Repository; @@ -92,7 +93,7 @@ public class TransportBundleStream extends Transport implements TransportBundle @Override public FetchConnection openFetch() throws TransportException { if (src == null) - throw new TransportException(uri, "Only one fetch supported"); + throw new TransportException(uri, JGitText.get().onlyOneFetchSupported); try { return new BundleFetchConnection(this, src); } finally { @@ -103,7 +104,7 @@ public class TransportBundleStream extends Transport implements TransportBundle @Override public PushConnection openPush() throws NotSupportedException { throw new NotSupportedException( - "Push is not supported for bundle transport"); + JGitText.get().pushIsNotSupportedForBundleTransport); } @Override diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitAnon.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitAnon.java index 8a0b4357cd..5ad57768fe 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitAnon.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitAnon.java @@ -56,6 +56,7 @@ import java.net.InetSocketAddress; import java.net.Socket; import java.net.UnknownHostException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Repository; @@ -107,7 +108,7 @@ class TransportGitAnon extends TcpTransport implements PackTransport { // ignore a failure during close, we're already failing } if (c instanceof UnknownHostException) - throw new TransportException(uri, "unknown host"); + throw new TransportException(uri, JGitText.get().unknownHost); if (c instanceof ConnectException) throw new TransportException(uri, c.getMessage()); throw new TransportException(uri, c.getMessage(), c); @@ -151,7 +152,7 @@ class TransportGitAnon extends TcpTransport implements PackTransport { } catch (IOException err) { close(); throw new TransportException(uri, - "remote hung up unexpectedly", err); + JGitText.get().remoteHungUpUnexpectedly, err); } readAdvertisedRefs(); } @@ -190,7 +191,7 @@ class TransportGitAnon extends TcpTransport implements PackTransport { } catch (IOException err) { close(); throw new TransportException(uri, - "remote hung up unexpectedly", err); + JGitText.get().remoteHungUpUnexpectedly, err); } readAdvertisedRefs(); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitSsh.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitSsh.java index 8df3ea5b2b..34b13b2d1d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitSsh.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportGitSsh.java @@ -51,7 +51,9 @@ import java.io.InputStream; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; +import java.text.MessageFormat; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NoRemoteRepositoryException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Repository; @@ -172,8 +174,8 @@ public class TransportGitSsh extends SshTransport implements PackTransport { IOException cause = null; if (why != null && why.length() > 0) cause = new IOException(why); - throw new TransportException(uri, "cannot execute: " - + commandFor(exe), cause); + throw new TransportException(uri, MessageFormat.format( + JGitText.get().cannotExecute, commandFor(exe)), cause); } } @@ -257,7 +259,7 @@ public class TransportGitSsh extends SshTransport implements PackTransport { } catch (IOException err) { close(); throw new TransportException(uri, - "remote hung up unexpectedly", err); + JGitText.get().remoteHungUpUnexpectedly, err); } try { @@ -325,7 +327,7 @@ public class TransportGitSsh extends SshTransport implements PackTransport { } catch (IOException err) { close(); throw new TransportException(uri, - "remote hung up unexpectedly", err); + JGitText.get().remoteHungUpUnexpectedly, err); } try { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportHttp.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportHttp.java index f49828bf2d..71e7bf285e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportHttp.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportHttp.java @@ -65,6 +65,7 @@ import java.net.MalformedURLException; import java.net.Proxy; import java.net.ProxySelector; import java.net.URL; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Map; @@ -73,6 +74,7 @@ import java.util.TreeMap; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NoRemoteRepositoryException; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.PackProtocolException; @@ -170,7 +172,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, baseUrl = new URL(uriString); objectsUrl = new URL(baseUrl, "objects/"); } catch (MalformedURLException e) { - throw new NotSupportedException("Invalid URL " + uri, e); + throw new NotSupportedException(MessageFormat.format(JGitText.get().invalidURL, uri), e); } http = local.getConfig().get(HTTP_KEY); proxySelector = ProxySelector.getDefault(); @@ -216,7 +218,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, } catch (TransportException err) { throw err; } catch (IOException err) { - throw new TransportException(uri, "error reading info/refs", err); + throw new TransportException(uri, JGitText.get().errorReadingInfoRefs, err); } } @@ -265,8 +267,8 @@ public class TransportHttp extends HttpTransport implements WalkTransport, break; default: - throw new TransportException(uri, "cannot read HEAD: " + status - + " " + conn.getResponseMessage()); + throw new TransportException(uri, MessageFormat.format( + JGitText.get().cannotReadHEAD, status, conn.getResponseMessage())); } } @@ -292,11 +294,11 @@ public class TransportHttp extends HttpTransport implements WalkTransport, return new SmartHttpPushConnection(in); } else if (!useSmartHttp) { - final String msg = "smart HTTP push disabled"; + final String msg = JGitText.get().smartHTTPPushDisabled; throw new NotSupportedException(msg); } else { - final String msg = "remote does not support smart HTTP push"; + final String msg = JGitText.get().remoteDoesNotSupportSmartHTTPPush; throw new NotSupportedException(msg); } } finally { @@ -307,7 +309,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, } catch (TransportException err) { throw err; } catch (IOException err) { - throw new TransportException(uri, "error reading info/refs", err); + throw new TransportException(uri, JGitText.get().errorReadingInfoRefs, err); } } @@ -335,7 +337,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, u = new URL(b.toString()); } catch (MalformedURLException e) { - throw new NotSupportedException("Invalid URL " + uri, e); + throw new NotSupportedException(MessageFormat.format(JGitText.get().invalidURL, uri), e); } try { @@ -352,10 +354,10 @@ public class TransportHttp extends HttpTransport implements WalkTransport, return conn; case HttpURLConnection.HTTP_NOT_FOUND: - throw new NoRemoteRepositoryException(uri, u + " not found"); + throw new NoRemoteRepositoryException(uri, MessageFormat.format(JGitText.get().URLNotFound, u)); case HttpURLConnection.HTTP_FORBIDDEN: - throw new TransportException(uri, service + " not permitted"); + throw new TransportException(uri, MessageFormat.format(JGitText.get().serviceNotPermitted, service)); default: String err = status + " " + conn.getResponseMessage(); @@ -366,7 +368,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, } catch (TransportException e) { throw e; } catch (IOException e) { - throw new TransportException(uri, "cannot open " + service, e); + throw new TransportException(uri, MessageFormat.format(JGitText.get().cannotOpenService, service), e); } } @@ -389,8 +391,7 @@ public class TransportHttp extends HttpTransport implements WalkTransport, } IOException wrongContentType(String expType, String actType) { - final String why = "expected Content-Type " + expType - + "; received Content-Type " + actType; + final String why = MessageFormat.format(JGitText.get().expectedReceivedContentType, expType, actType); return new TransportException(uri, why); } @@ -410,9 +411,8 @@ public class TransportHttp extends HttpTransport implements WalkTransport, final byte[] magic = new byte[5]; IO.readFully(in, magic, 0, magic.length); if (magic[4] != '#') { - throw new TransportException(uri, "expected pkt-line with" - + " '# service=', got '" + RawParseUtils.decode(magic) - + "'"); + throw new TransportException(uri, MessageFormat.format( + JGitText.get().expectedPktLineWithService, RawParseUtils.decode(magic))); } final PacketLineIn pckIn = new PacketLineIn(new UnionInputStream( @@ -420,8 +420,8 @@ public class TransportHttp extends HttpTransport implements WalkTransport, final String exp = "# service=" + service; final String act = pckIn.readString(); if (!exp.equals(act)) { - throw new TransportException(uri, "expected '" + exp + "', got '" - + act + "'"); + throw new TransportException(uri, MessageFormat.format( + JGitText.get().expectedGot, exp, act)); } while (pckIn.readString() != PacketLineIn.END) { @@ -546,16 +546,15 @@ public class TransportHttp extends HttpTransport implements WalkTransport, } private PackProtocolException outOfOrderAdvertisement(final String n) { - return new PackProtocolException("advertisement of " + n - + "^{} came before " + n); + return new PackProtocolException(MessageFormat.format(JGitText.get().advertisementOfCameBefore, n, n)); } private PackProtocolException invalidAdvertisement(final String n) { - return new PackProtocolException("invalid advertisement of " + n); + return new PackProtocolException(MessageFormat.format(JGitText.get().invalidAdvertisementOf, n)); } private PackProtocolException duplicateAdvertisement(final String n) { - return new PackProtocolException("duplicate advertisements of " + n); + return new PackProtocolException(MessageFormat.format(JGitText.get().duplicateAdvertisementsOf, n)); } @Override @@ -667,9 +666,8 @@ public class TransportHttp extends HttpTransport implements WalkTransport, // our request buffer. Send with a Content-Length header. // if (out.length() == 0) { - throw new TransportException(uri, "Starting read stage" - + " without written request data pending" - + " is not supported"); + throw new TransportException(uri, + JGitText.get().startingReadStageWithoutWrittenRequestDataPendingIsNotSupported); } // Try to compress the content, but only if that is smaller. diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportLocal.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportLocal.java index 22c436de3a..cf4dbd5392 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportLocal.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportLocal.java @@ -56,6 +56,7 @@ import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; @@ -175,7 +176,7 @@ class TransportLocal extends Transport implements PackTransport { try { dst = new Repository(remoteGitDir); } catch (IOException err) { - throw new TransportException(uri, "not a git directory"); + throw new TransportException(uri, JGitText.get().notAGitDirectory); } final PipedInputStream in_r; @@ -199,7 +200,7 @@ class TransportLocal extends Transport implements PackTransport { out_w = new PipedOutputStream(out_r); } catch (IOException err) { dst.close(); - throw new TransportException(uri, "cannot connect pipes", err); + throw new TransportException(uri, JGitText.get().cannotConnectPipes, err); } worker = new Thread("JGit-Upload-Pack") { @@ -315,7 +316,7 @@ class TransportLocal extends Transport implements PackTransport { try { dst = new Repository(remoteGitDir); } catch (IOException err) { - throw new TransportException(uri, "not a git directory"); + throw new TransportException(uri, JGitText.get().notAGitDirectory); } final PipedInputStream in_r; @@ -331,7 +332,7 @@ class TransportLocal extends Transport implements PackTransport { out_w = new PipedOutputStream(out_r); } catch (IOException err) { dst.close(); - throw new TransportException(uri, "cannot connect pipes", err); + throw new TransportException(uri, JGitText.get().cannotConnectPipes, err); } worker = new Thread("JGit-Receive-Pack") { diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/URIish.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/URIish.java index 80b94b2324..5939bc2f28 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/URIish.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/URIish.java @@ -50,6 +50,7 @@ import java.net.URL; import java.util.regex.Matcher; import java.util.regex.Pattern; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; /** @@ -107,7 +108,7 @@ public class URIish { host = matcher.group(2); path = matcher.group(3); } else - throw new URISyntaxException(s, "Cannot parse Git URI-ish"); + throw new URISyntaxException(s, JGitText.get().cannotParseGitURIish); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java index 3d5abd34bd..3381c0724a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java @@ -47,6 +47,7 @@ import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; @@ -54,6 +55,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.lib.NullProgressMonitor; import org.eclipse.jgit.lib.ObjectId; @@ -371,7 +373,7 @@ public class UploadPack { if (line == PacketLineIn.END) break; if (!line.startsWith("want ") || line.length() < 45) - throw new PackProtocolException("expected want; got " + line); + throw new PackProtocolException(MessageFormat.format(JGitText.get().expectedGot, "want", line)); if (isFirst && line.length() > 45) { String opt = line.substring(45); @@ -387,10 +389,10 @@ public class UploadPack { try { o = walk.parseAny(id); } catch (IOException e) { - throw new PackProtocolException(id.name() + " not valid", e); + throw new PackProtocolException(MessageFormat.format(JGitText.get().notValid, id.name()), e); } if (!o.has(ADVERTISED)) - throw new PackProtocolException(id.name() + " not valid"); + throw new PackProtocolException(MessageFormat.format(JGitText.get().notValid, id.name())); want(o); } } @@ -473,7 +475,7 @@ public class UploadPack { return true; } else { - throw new PackProtocolException("expected have; got " + line); + throw new PackProtocolException(MessageFormat.format(JGitText.get().expectedGot, "have", line)); } } } @@ -521,7 +523,7 @@ public class UploadPack { i.remove(); } } catch (IOException e) { - throw new PackProtocolException("internal revision error", e); + throw new PackProtocolException(JGitText.get().internalRevisionError, e); } return wantCommits.isEmpty(); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkEncryption.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkEncryption.java index d368fb2cd7..b55de9265a 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkEncryption.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkEncryption.java @@ -51,6 +51,7 @@ import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.spec.InvalidKeySpecException; +import java.text.MessageFormat; import javax.crypto.Cipher; import javax.crypto.CipherInputStream; @@ -61,6 +62,8 @@ import javax.crypto.SecretKeyFactory; import javax.crypto.spec.PBEKeySpec; import javax.crypto.spec.PBEParameterSpec; +import org.eclipse.jgit.JGitText; + abstract class WalkEncryption { static final WalkEncryption NONE = new NoEncryption(); @@ -84,18 +87,18 @@ abstract class WalkEncryption { if (v == null) v = ""; if (!version.equals(v)) - throw new IOException("Unsupported encryption version: " + v); + throw new IOException(MessageFormat.format(JGitText.get().unsupportedEncryptionVersion, v)); v = u.getHeaderField(p + JETS3T_CRYPTO_ALG); if (v == null) v = ""; if (!name.equals(v)) - throw new IOException("Unsupported encryption algorithm: " + v); + throw new IOException(JGitText.get().unsupportedEncryptionAlgorithm + v); } IOException error(final Throwable why) { final IOException e; - e = new IOException("Encryption error: " + why.getMessage()); + e = new IOException(MessageFormat.format(JGitText.get().encryptionError, why.getMessage())); e.initCause(why); return e; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java index ba4486144d..6254745476 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java @@ -49,6 +49,7 @@ import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -58,6 +59,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Set; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CompoundException; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.MissingObjectException; @@ -261,7 +263,7 @@ class WalkFetchConnection extends BaseFetchConnection { if (inWorkQueue.add(id)) workQueue.add(id); } catch (IOException e) { - throw new TransportException("Cannot read " + id.name(), e); + throw new TransportException(MessageFormat.format(JGitText.get().cannotRead, id.name()), e); } } } @@ -280,7 +282,7 @@ class WalkFetchConnection extends BaseFetchConnection { return; } } catch (IOException e) { - throw new TransportException("Cannot read " + id.name(), e); + throw new TransportException(MessageFormat.format(JGitText.get().cannotRead, id.name()), e); } switch (obj.getType()) { @@ -297,7 +299,7 @@ class WalkFetchConnection extends BaseFetchConnection { processTag(obj); break; default: - throw new TransportException("Unknown object type " + id.name()); + throw new TransportException(MessageFormat.format(JGitText.get().unknownObjectType, id.name())); } // If we had any prior errors fetching this object they are @@ -308,7 +310,7 @@ class WalkFetchConnection extends BaseFetchConnection { private void processBlob(final RevObject obj) throws TransportException { if (!local.hasObject(obj)) - throw new TransportException("Cannot read blob " + obj.name(), + throw new TransportException(MessageFormat.format(JGitText.get().cannotReadBlob, obj.name()), new MissingObjectException(obj, Constants.TYPE_BLOB)); obj.add(COMPLETE); } @@ -331,14 +333,12 @@ class WalkFetchConnection extends BaseFetchConnection { if (FileMode.GITLINK.equals(mode)) continue; treeWalk.getObjectId(idBuffer, 0); - throw new CorruptObjectException("Invalid mode " + mode - + " for " + idBuffer.name() + " " - + treeWalk.getPathString() + " in " - + obj.getId().name() + "."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().invalidModeFor + , mode, idBuffer.name(), treeWalk.getPathString(), obj.getId().name())); } } } catch (IOException ioe) { - throw new TransportException("Cannot read tree " + obj.name(), ioe); + throw new TransportException(MessageFormat.format(JGitText.get().cannotReadTree, obj.name()), ioe); } obj.add(COMPLETE); } @@ -445,7 +445,7 @@ class WalkFetchConnection extends BaseFetchConnection { List<Throwable> failures = fetchErrors.get(id.copy()); final TransportException te; - te = new TransportException("Cannot get " + id.name() + "."); + te = new TransportException(MessageFormat.format(JGitText.get().cannotGet, id.name())); if (failures != null && !failures.isEmpty()) { if (failures.size() == 1) te.initCause(failures.get(0)); @@ -521,8 +521,8 @@ class WalkFetchConnection extends BaseFetchConnection { // the object, but after indexing we didn't // actually find it in the pack. // - recordError(id, new FileNotFoundException("Object " + id.name() - + " not found in " + pack.packName + ".")); + recordError(id, new FileNotFoundException(MessageFormat.format( + JGitText.get().objectNotFoundIn, id.name(), pack.packName))); continue; } @@ -565,7 +565,7 @@ class WalkFetchConnection extends BaseFetchConnection { recordError(id, e); return false; } catch (IOException e) { - throw new TransportException("Cannot download " + id.name(), e); + throw new TransportException(MessageFormat.format(JGitText.get().cannotDownload, id.name()), e); } } @@ -601,18 +601,15 @@ class WalkFetchConnection extends BaseFetchConnection { idBuffer.fromRaw(objectDigest.digest(), 0); if (!AnyObjectId.equals(id, idBuffer)) { - throw new TransportException("Incorrect hash for " + id.name() - + "; computed " + idBuffer.name() + " as a " - + Constants.typeString(uol.getType()) + " from " - + compressed.length + " bytes."); + throw new TransportException(MessageFormat.format(JGitText.get().incorrectHashFor + , id.name(), idBuffer.name(), Constants.typeString(uol.getType()), compressed.length)); } if (objCheck != null) { try { objCheck.check(uol.getType(), uol.getCachedBytes()); } catch (CorruptObjectException e) { - throw new TransportException("Invalid " - + Constants.typeString(uol.getType()) + " " - + id.name() + ":" + e.getMessage()); + throw new TransportException(MessageFormat.format(JGitText.get().transportExceptionInvalid + , Constants.typeString(uol.getType()), id.name(), e.getMessage())); } } } @@ -650,7 +647,7 @@ class WalkFetchConnection extends BaseFetchConnection { tmp.delete(); if (local.hasObject(id)) return; - throw new ObjectWritingException("Unable to store " + id.name() + "."); + throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToStore, id.name())); } private Collection<WalkRemoteObjectDatabase> expandOneAlternate( @@ -658,7 +655,7 @@ class WalkFetchConnection extends BaseFetchConnection { while (!noAlternatesYet.isEmpty()) { final WalkRemoteObjectDatabase wrr = noAlternatesYet.removeFirst(); try { - pm.beginTask("Listing alternates", ProgressMonitor.UNKNOWN); + pm.beginTask(JGitText.get().listingAlternates, ProgressMonitor.UNKNOWN); Collection<WalkRemoteObjectDatabase> altList = wrr .getAlternates(); if (altList != null && !altList.isEmpty()) @@ -679,15 +676,14 @@ class WalkFetchConnection extends BaseFetchConnection { try { markLocalObjComplete(revWalk.parseAny(r.getObjectId())); } catch (IOException readError) { - throw new TransportException("Local ref " + r.getName() - + " is missing object(s).", readError); + throw new TransportException(MessageFormat.format(JGitText.get().localRefIsMissingObjects, r.getName()), readError); } } for (final ObjectId id : have) { try { markLocalObjComplete(revWalk.parseAny(id)); } catch (IOException readError) { - throw new TransportException("Missing assumed "+id.name(), readError); + throw new TransportException(MessageFormat.format(JGitText.get().transportExceptionMissingAssumed, id.name()), readError); } } } @@ -726,7 +722,7 @@ class WalkFetchConnection extends BaseFetchConnection { pushLocalCommit(p); } } catch (IOException err) { - throw new TransportException("Local objects incomplete.", err); + throw new TransportException(JGitText.get().localObjectsIncomplete, err); } } @@ -769,9 +765,8 @@ class WalkFetchConnection extends BaseFetchConnection { if (FileMode.GITLINK.equals(mode)) continue; treeWalk.getObjectId(idBuffer, 0); - throw new CorruptObjectException("Invalid mode " + mode - + " for " + idBuffer.name() + " " - + treeWalk.getPathString() + " in " + tree.name() + "."); + throw new CorruptObjectException(MessageFormat.format(JGitText.get().corruptObjectInvalidMode3 + , mode, idBuffer.name(), treeWalk.getPathString(), tree.name())); } } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java index f977915bb3..0edf9678e4 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java @@ -55,6 +55,7 @@ import java.util.List; import java.util.Map; import java.util.TreeMap; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; @@ -145,7 +146,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection { final String n = u.getRemoteName(); if (!n.startsWith("refs/") || !Repository.isValidRefName(n)) { u.setStatus(Status.REJECTED_OTHER_REASON); - u.setMessage("funny refname"); + u.setMessage(JGitText.get().funnyRefname); continue; } @@ -187,14 +188,14 @@ class WalkPushConnection extends BaseConnection implements PushConnection { u.setStatus(Status.REJECTED_OTHER_REASON); u.setMessage(err.getMessage()); } - throw new TransportException(uri, "failed updating refs", err); + throw new TransportException(uri, JGitText.get().failedUpdatingRefs, err); } } try { refWriter.writeInfoRefs(); } catch (IOException err) { - throw new TransportException(uri, "failed updating refs", err); + throw new TransportException(uri, JGitText.get().failedUpdatingRefs, err); } } @@ -279,7 +280,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection { safeDelete(pathIdx); safeDelete(pathPack); - throw new TransportException(uri, "cannot store objects", err); + throw new TransportException(uri, JGitText.get().cannotStoreObjects, err); } } @@ -349,7 +350,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection { final byte[] bytes = Constants.encode(ref); dest.writeFile(ROOT_DIR + Constants.HEAD, bytes); } catch (IOException e) { - throw new TransportException(uri, "cannot create HEAD", e); + throw new TransportException(uri, JGitText.get().cannotCreateHEAD, e); } try { @@ -358,7 +359,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection { final byte[] bytes = Constants.encode(config); dest.writeFile(ROOT_DIR + "config", bytes); } catch (IOException e) { - throw new TransportException(uri, "cannot create config", e); + throw new TransportException(uri, JGitText.get().cannotCreateConfig, e); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkRemoteObjectDatabase.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkRemoteObjectDatabase.java index 2aa644ce8b..f1743b378d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkRemoteObjectDatabase.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkRemoteObjectDatabase.java @@ -50,10 +50,12 @@ import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Map; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; @@ -198,7 +200,7 @@ abstract class WalkRemoteObjectDatabase { * deletion is not supported, or deletion failed. */ void deleteFile(final String path) throws IOException { - throw new IOException("Deleting '" + path + "' not supported."); + throw new IOException(MessageFormat.format(JGitText.get().deletingNotSupported, path)); } /** @@ -230,7 +232,7 @@ abstract class WalkRemoteObjectDatabase { */ OutputStream writeFile(final String path, final ProgressMonitor monitor, final String monitorTask) throws IOException { - throw new IOException("Writing of '" + path + "' not supported."); + throw new IOException(MessageFormat.format(JGitText.get().writingNotSupported, path)); } /** @@ -428,7 +430,7 @@ abstract class WalkRemoteObjectDatabase { } catch (FileNotFoundException notPacked) { // Perhaps it wasn't worthwhile, or is just an older repository. } catch (IOException e) { - throw new TransportException(getURI(), "error in packed-refs", e); + throw new TransportException(getURI(), JGitText.get().errorInPackedRefs, e); } } @@ -449,7 +451,7 @@ abstract class WalkRemoteObjectDatabase { } if (line.charAt(0) == '^') { if (last == null) - throw new TransportException("Peeled line before ref."); + throw new TransportException(JGitText.get().peeledLineBeforeRef); final ObjectId id = ObjectId.fromString(line.substring(1)); last = new ObjectIdRef.PeeledTag(Ref.Storage.PACKED, last .getName(), last.getObjectId(), id); @@ -459,7 +461,7 @@ abstract class WalkRemoteObjectDatabase { final int sp = line.indexOf(' '); if (sp < 0) - throw new TransportException("Unrecognized ref: " + line); + throw new TransportException(MessageFormat.format(JGitText.get().unrecognizedRef, line)); final ObjectId id = ObjectId.fromString(line.substring(0, sp)); final String name = line.substring(sp + 1); if (peeled) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java index 6b8a6cea4b..013e0edb35 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java @@ -50,9 +50,11 @@ import java.nio.CharBuffer; import java.nio.charset.CharacterCodingException; import java.nio.charset.CharsetEncoder; import java.security.MessageDigest; +import java.text.MessageFormat; import java.util.Arrays; import java.util.Comparator; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.FileMode; @@ -373,7 +375,7 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator { b = enc.encode(CharBuffer.wrap(getName())); } catch (CharacterCodingException e) { // This should so never happen. - throw new RuntimeException("Unencodeable file: " + getName()); + throw new RuntimeException(MessageFormat.format(JGitText.get().unencodeableFile, getName())); } encodedNameLen = b.limit(); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/AndTreeFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/AndTreeFilter.java index 9a6156f082..12964bbe64 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/AndTreeFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/AndTreeFilter.java @@ -47,6 +47,7 @@ package org.eclipse.jgit.treewalk.filter; import java.io.IOException; import java.util.Collection; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.treewalk.TreeWalk; @@ -89,7 +90,7 @@ public abstract class AndTreeFilter extends TreeFilter { if (list.length == 2) return create(list[0], list[1]); if (list.length < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final TreeFilter[] subfilters = new TreeFilter[list.length]; System.arraycopy(list, 0, subfilters, 0, list.length); return new List(subfilters); @@ -105,7 +106,7 @@ public abstract class AndTreeFilter extends TreeFilter { */ public static TreeFilter create(final Collection<TreeFilter> list) { if (list.size() < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final TreeFilter[] subfilters = new TreeFilter[list.size()]; list.toArray(subfilters); if (subfilters.length == 2) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/OrTreeFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/OrTreeFilter.java index f14ceeab32..de5aa421a0 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/OrTreeFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/OrTreeFilter.java @@ -47,6 +47,7 @@ package org.eclipse.jgit.treewalk.filter; import java.io.IOException; import java.util.Collection; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.treewalk.TreeWalk; @@ -87,7 +88,7 @@ public abstract class OrTreeFilter extends TreeFilter { if (list.length == 2) return create(list[0], list[1]); if (list.length < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final TreeFilter[] subfilters = new TreeFilter[list.length]; System.arraycopy(list, 0, subfilters, 0, list.length); return new List(subfilters); @@ -103,7 +104,7 @@ public abstract class OrTreeFilter extends TreeFilter { */ public static TreeFilter create(final Collection<TreeFilter> list) { if (list.size() < 2) - throw new IllegalArgumentException("At least two filters needed."); + throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded); final TreeFilter[] subfilters = new TreeFilter[list.size()]; list.toArray(subfilters); if (subfilters.length == 2) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilter.java index 65451da8e6..e317789840 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilter.java @@ -44,6 +44,7 @@ package org.eclipse.jgit.treewalk.filter; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.treewalk.TreeWalk; @@ -76,7 +77,7 @@ public class PathFilter extends TreeFilter { while (path.endsWith("/")) path = path.substring(0, path.length() - 1); if (path.length() == 0) - throw new IllegalArgumentException("Empty path not permitted."); + throw new IllegalArgumentException(JGitText.get().emptyPathNotPermitted); return new PathFilter(path); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java index e58512da35..756b000684 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java @@ -48,6 +48,7 @@ import java.util.Arrays; import java.util.Collection; import java.util.Comparator; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.StopWalkException; import org.eclipse.jgit.treewalk.TreeWalk; @@ -82,7 +83,7 @@ public class PathFilterGroup { */ public static TreeFilter createFromStrings(final Collection<String> paths) { if (paths.isEmpty()) - throw new IllegalArgumentException("At least one path is required."); + throw new IllegalArgumentException(JGitText.get().atLeastOnePathIsRequired); final PathFilter[] p = new PathFilter[paths.size()]; int i = 0; for (final String s : paths) @@ -103,7 +104,7 @@ public class PathFilterGroup { */ public static TreeFilter create(final Collection<PathFilter> paths) { if (paths.isEmpty()) - throw new IllegalArgumentException("At least one path is required."); + throw new IllegalArgumentException(JGitText.get().atLeastOnePathIsRequired); final PathFilter[] p = new PathFilter[paths.size()]; paths.toArray(p); return create(p); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathSuffixFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathSuffixFilter.java index 3721ec646f..c4561c4d39 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathSuffixFilter.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathSuffixFilter.java @@ -45,6 +45,7 @@ package org.eclipse.jgit.treewalk.filter; import java.io.IOException; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.Constants; @@ -68,7 +69,7 @@ public class PathSuffixFilter extends TreeFilter { */ public static PathSuffixFilter create(String path) { if (path.length() == 0) - throw new IllegalArgumentException("Empty path not permitted."); + throw new IllegalArgumentException(JGitText.get().emptyPathNotPermitted); return new PathSuffixFilter(path); } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/Base64.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/Base64.java index 53c7beced8..1c7d397e9c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/Base64.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/Base64.java @@ -9,6 +9,9 @@ package org.eclipse.jgit.util; import java.io.Closeable; import java.io.IOException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** @@ -702,7 +705,7 @@ public class Base64 } // end if: white space, equals sign or better else { - System.err.println( "Bad Base64 input character at " + i + ": " + source[i] + "(decimal)" ); + System.err.println(MessageFormat.format(JGitText.get().badBase64InputCharacterAt, i+ source[i])); return null; } // end else: } // each input character @@ -925,7 +928,7 @@ public class Base64 // Check for size of file if( file.length() > Integer.MAX_VALUE ) { - System.err.println( "File is too big for this convenience method (" + file.length() + " bytes)." ); + System.err.println(MessageFormat.format(JGitText.get().fileIsTooBigForThisConvenienceMethod, file.length())); return null; } // end if: file too big for int index buffer = new byte[ (int)file.length() ]; @@ -946,7 +949,7 @@ public class Base64 } // end try catch( java.io.IOException e ) { - System.err.println( "Error decoding from file " + filename ); + System.err.println(MessageFormat.format(JGitText.get().errorDecodingFromFile, filename)); } // end catch: IOException finally { @@ -994,7 +997,7 @@ public class Base64 } // end try catch( java.io.IOException e ) { - System.err.println( "Error encoding from file " + filename ); + System.err.println(MessageFormat.format(JGitText.get().errorEncodingFromFile, filename)); } // end catch: IOException finally { @@ -1154,7 +1157,7 @@ public class Base64 else { // Must have broken out from above. - throw new java.io.IOException( "Improperly padded Base64 input." ); + throw new java.io.IOException(JGitText.get().improperlyPaddedBase64Input); } // end } // end else: decode @@ -1192,7 +1195,7 @@ public class Base64 else { // When JDK1.4 is more accepted, use an assertion here. - throw new java.io.IOException( "Error in Base64 code reading stream." ); + throw new java.io.IOException(JGitText.get().errorInBase64CodeReadingStream); } // end else } // end read @@ -1363,7 +1366,7 @@ public class Base64 } // end if: meaningful base64 character else if( DECODABET[ theByte & 0x7f ] != WHITE_SPACE_ENC ) { - throw new java.io.IOException( "Invalid character in Base64 data." ); + throw new java.io.IOException(JGitText.get().invalidCharacterInBase64Data); } // end else: not white space either } // end else: decoding } // end write @@ -1413,7 +1416,7 @@ public class Base64 } // end if: encoding else { - throw new java.io.IOException( "Base64 input not properly padded." ); + throw new java.io.IOException(JGitText.get().base64InputNotProperlyPadded); } // end else: decoding } // end if: buffer partially full diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/HttpSupport.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/HttpSupport.java index 2532593ec5..d3e1f60035 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/HttpSupport.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/HttpSupport.java @@ -53,6 +53,9 @@ import java.net.ProxySelector; import java.net.URISyntaxException; import java.net.URL; import java.net.URLEncoder; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** Extra utilities to support usage of HTTP. */ public class HttpSupport { @@ -133,7 +136,7 @@ public class HttpSupport { try { urlstr.append(URLEncoder.encode(key, "UTF-8")); } catch (UnsupportedEncodingException e) { - throw new RuntimeException("Could not URL encode to UTF-8", e); + throw new RuntimeException(JGitText.get().couldNotURLEncodeToUTF8, e); } } @@ -158,7 +161,7 @@ public class HttpSupport { // The standard J2SE error message is not very useful. // if ("Connection timed out: connect".equals(ce.getMessage())) - throw new ConnectException("Connection time out: " + host); + throw new ConnectException(MessageFormat.format(JGitText.get().connectionTimeOut, host)); throw new ConnectException(ce.getMessage() + " " + host); } } @@ -181,7 +184,7 @@ public class HttpSupport { return proxySelector.select(u.toURI()).get(0); } catch (URISyntaxException e) { final ConnectException err; - err = new ConnectException("Cannot determine proxy for " + u); + err = new ConnectException(MessageFormat.format(JGitText.get().cannotDetermineProxyFor, u)); err.initCause(e); throw err; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/IO.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/IO.java index 566b857460..1778654203 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/IO.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/IO.java @@ -53,6 +53,9 @@ import java.io.IOException; import java.io.InputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** * Input/Output utilities @@ -95,7 +98,7 @@ public class IO { try { final long sz = in.getChannel().size(); if (sz > max) - throw new IOException("File is too large: " + path); + throw new IOException(MessageFormat.format(JGitText.get().fileIsTooLarge, path)); final byte[] buf = new byte[(int) sz]; IO.readFully(in, buf, 0, buf.length); return buf; @@ -129,7 +132,7 @@ public class IO { while (len > 0) { final int r = fd.read(dst, off, len); if (r <= 0) - throw new EOFException("Short read of block."); + throw new EOFException(JGitText.get().shortReadOfBlock); off += r; len -= r; } @@ -158,7 +161,7 @@ public class IO { while (len > 0) { final int r = fd.read(ByteBuffer.wrap(dst, off, len), pos); if (r <= 0) - throw new EOFException("Short read of block."); + throw new EOFException(JGitText.get().shortReadOfBlock); pos += r; off += r; len -= r; @@ -187,7 +190,7 @@ public class IO { while (toSkip > 0) { final long r = fd.skip(toSkip); if (r <= 0) - throw new EOFException("Short skip of block"); + throw new EOFException(JGitText.get().shortSkipOfBlock); toSkip -= r; } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java index 67d67b90c4..f45bf2796b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java @@ -44,6 +44,7 @@ package org.eclipse.jgit.util; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.Constants; /** @@ -67,7 +68,7 @@ public class RawSubStringPattern { */ public RawSubStringPattern(final String patternText) { if (patternText.length() == 0) - throw new IllegalArgumentException("Cannot match on empty string."); + throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); needleString = patternText; final byte[] b = Constants.encode(patternText); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java index 582dce8aff..119c041570 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/StringUtils.java @@ -43,6 +43,10 @@ package org.eclipse.jgit.util; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; + /** Miscellaneous string comparison utility methods. */ public final class StringUtils { private static final char[] LC; @@ -135,7 +139,7 @@ public final class StringUtils { */ public static boolean toBoolean(final String stringValue) { if (stringValue == null) - throw new NullPointerException("Expected boolean string value"); + throw new NullPointerException(JGitText.get().expectedBooleanStringValue); if (equalsIgnoreCase("yes", stringValue) || equalsIgnoreCase("true", stringValue) @@ -150,7 +154,7 @@ public final class StringUtils { return false; } else { - throw new IllegalArgumentException("Not a boolean: " + stringValue); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().notABoolean, stringValue)); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/TemporaryBuffer.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/TemporaryBuffer.java index 95b3fa090b..6c421c5f50 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/TemporaryBuffer.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/TemporaryBuffer.java @@ -53,6 +53,7 @@ import java.io.InputStream; import java.io.OutputStream; import java.util.ArrayList; +import org.eclipse.jgit.JGitText; import org.eclipse.jgit.lib.NullProgressMonitor; import org.eclipse.jgit.lib.ProgressMonitor; @@ -196,7 +197,7 @@ public abstract class TemporaryBuffer extends OutputStream { public byte[] toByteArray() throws IOException { final long len = length(); if (Integer.MAX_VALUE < len) - throw new OutOfMemoryError("Length exceeds maximum array size"); + throw new OutOfMemoryError(JGitText.get().lengthExceedsMaximumArraySize); final byte[] out = new byte[(int) len]; int outPtr = 0; for (final Block b : blocks) { @@ -351,7 +352,7 @@ public abstract class TemporaryBuffer extends OutputStream { final long len = length(); if (Integer.MAX_VALUE < len) - throw new OutOfMemoryError("Length exceeds maximum array size"); + throw new OutOfMemoryError(JGitText.get().lengthExceedsMaximumArraySize); final byte[] out = new byte[(int) len]; final FileInputStream in = new FileInputStream(onDiskFile); try { @@ -419,7 +420,7 @@ public abstract class TemporaryBuffer extends OutputStream { @Override protected OutputStream overflow() throws IOException { - throw new IOException("In-memory buffer limit exceeded"); + throw new IOException(JGitText.get().inMemoryBufferLimitExceeded); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/DisabledOutputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/DisabledOutputStream.java index e38660d632..d95849a76b 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/DisabledOutputStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/DisabledOutputStream.java @@ -46,6 +46,8 @@ package org.eclipse.jgit.util.io; import java.io.IOException; import java.io.OutputStream; +import org.eclipse.jgit.JGitText; + /** An OutputStream which always throws IllegalStateExeption during write. */ public final class DisabledOutputStream extends OutputStream { /** The canonical instance which always throws IllegalStateException. */ @@ -61,6 +63,6 @@ public final class DisabledOutputStream extends OutputStream { // We shouldn't be writing output at this stage, there // is nobody listening to us. // - throw new IllegalStateException("Writing not permitted"); + throw new IllegalStateException(JGitText.get().writingNotPermitted); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/InterruptTimer.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/InterruptTimer.java index 91aa1cb6d2..575fa3ef0c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/InterruptTimer.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/InterruptTimer.java @@ -43,6 +43,10 @@ package org.eclipse.jgit.util.io; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; + /** * Triggers an interrupt on the calling thread if it doesn't complete a block. * <p> @@ -113,7 +117,7 @@ public final class InterruptTimer { */ public void begin(final int timeout) { if (timeout <= 0) - throw new IllegalArgumentException("Invalid timeout: " + timeout); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidTimeout, timeout)); Thread.interrupted(); state.begin(timeout); } @@ -193,7 +197,7 @@ public final class InterruptTimer { synchronized void begin(final int timeout) { if (terminated) - throw new IllegalStateException("Timer already terminated"); + throw new IllegalStateException(JGitText.get().timerAlreadyTerminated); callingThread = Thread.currentThread(); deadline = now() + timeout; notifyAll(); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutInputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutInputStream.java index 19d7933e1b..3670639c1d 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutInputStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutInputStream.java @@ -47,6 +47,9 @@ import java.io.FilterInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InterruptedIOException; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** InputStream with a configurable timeout. */ public class TimeoutInputStream extends FilterInputStream { @@ -80,7 +83,7 @@ public class TimeoutInputStream extends FilterInputStream { */ public void setTimeout(final int millis) { if (millis < 0) - throw new IllegalArgumentException("Invalid timeout: " + millis); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidTimeout, millis)); timeout = millis; } @@ -134,6 +137,6 @@ public class TimeoutInputStream extends FilterInputStream { } private static InterruptedIOException readTimedOut() { - return new InterruptedIOException("Read timed out"); + return new InterruptedIOException(JGitText.get().readTimedOut); } } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutOutputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutOutputStream.java index a826086cd1..59ac7b21e5 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutOutputStream.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/io/TimeoutOutputStream.java @@ -46,6 +46,9 @@ package org.eclipse.jgit.util.io; import java.io.IOException; import java.io.InterruptedIOException; import java.io.OutputStream; +import java.text.MessageFormat; + +import org.eclipse.jgit.JGitText; /** OutputStream with a configurable timeout. */ public class TimeoutOutputStream extends OutputStream { @@ -81,7 +84,7 @@ public class TimeoutOutputStream extends OutputStream { */ public void setTimeout(final int millis) { if (millis < 0) - throw new IllegalArgumentException("Invalid timeout: " + millis); + throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidTimeout, millis)); timeout = millis; } @@ -147,6 +150,6 @@ public class TimeoutOutputStream extends OutputStream { } private static InterruptedIOException writeTimedOut() { - return new InterruptedIOException("Write timed out"); + return new InterruptedIOException(JGitText.get().writeTimedOut); } } |