From 5babfa78b3220aea45a91bdce9718bfdf31aff85 Mon Sep 17 00:00:00 2001 From: David Kocher Date: Fri, 28 Nov 2025 15:29:52 +0100 Subject: [PATCH] Extract interface. --- .../azure/AzureAttributesFinderFeature.java | 7 +- .../core/azure/AzureContainerListService.java | 3 +- .../core/b2/B2AttributesFinderFeature.java | 11 +- .../cyberduck/core/b2/B2LargeCopyFeature.java | 3 +- .../java/ch/cyberduck/core/b2/B2Session.java | 3 +- .../core/b2/B2ObjectListServiceTest.java | 11 +- .../core/b2/B2VersionIdProviderTest.java | 3 +- .../core/b2/B2VersioningFeatureTest.java | 3 +- .../core/box/BoxAttributesFinderFeature.java | 5 +- .../brick/BrickAttributesFinderFeature.java | 3 +- .../core/brick/BrickCopyFeature.java | 3 +- .../core/brick/BrickMoveFeature.java | 3 +- .../cyberduck/core/DefaultPathAttributes.java | 752 ++++++++++++++ .../src/main/java/ch/cyberduck/core/Path.java | 6 +- .../ch/cyberduck/core/PathAttributes.java | 953 ++++-------------- .../cyberduck/core/ProxyPathAttributes.java | 342 +++++++ .../core/profiles/RemoteProfilesFinder.java | 3 +- .../serializer/PathAttributesDictionary.java | 3 +- .../DefaultComparePathFilter.java | 3 +- .../core/DefaultPathPredicateTest.java | 24 +- .../ch/cyberduck/core/PathAttributesTest.java | 14 +- .../java/ch/cyberduck/core/PathCacheTest.java | 4 +- .../core/TestPermissionAttributes.java | 2 +- .../PathAttributesDictionaryTest.java | 7 +- .../core/shared/ListFilteringFeatureTest.java | 33 +- .../ChainedComparisonServiceTest.java | 17 +- .../ChecksumComparisonServiceTest.java | 13 +- .../DefaultComparePathFilterTest.java | 5 +- .../DefaultComparisonServiceTest.java | 49 +- .../SizeComparisonServiceTest.java | 9 +- .../TimestampComparisonServiceTest.java | 14 +- .../core/transfer/SyncTransferTest.java | 19 +- .../core/transfer/UploadTransferTest.java | 2 +- .../transfer/upload/OverwriteFilterTest.java | 3 +- .../upload/RenameExistingFilterTest.java | 5 +- .../transfer/upload/RenameFilterTest.java | 5 +- .../transfer/upload/ResumeFilterTest.java | 7 +- .../cyberduck/core/worker/MoveWorkerTest.java | 3 +- .../core/worker/WriteMetadataWorkerTest.java | 6 +- .../ui/browser/RecursiveSearchFilterTest.java | 3 +- .../ui/browser/SizeTooltipServiceTest.java | 3 +- .../core/cryptomator/CryptoVault.java | 8 +- .../features/CryptoAttributesFeature.java | 3 +- .../features/CryptoCopyFeature.java | 3 +- .../features/CryptoTouchFeature.java | 3 +- .../impl/CryptoDirectoryV6Provider.java | 3 +- .../core/ctera/CteraCopyFeatureTest.java | 5 +- .../core/ctera/CteraMoveFeatureTest.java | 5 +- .../DeepboxAttributesFinderFeature.java | 11 +- .../core/deepbox/DeepboxIdProvider.java | 3 +- .../core/deepbox/DeepboxListService.java | 3 +- .../core/deepbox/DeepboxMoveFeature.java | 3 +- .../core/deepbox/DeepboxCopyFeatureTest.java | 19 +- .../deepbox/DeepboxDirectoryFeatureTest.java | 7 +- .../core/deepbox/DeepboxListServiceTest.java | 15 +- .../core/deepbox/DeepboxMoveFeatureTest.java | 5 +- .../deepbox/DeepboxRestoreFeatureTest.java | 79 +- .../core/deepbox/DeepboxTrashFeatureTest.java | 79 +- .../core/sds/SDSAttributesAdapter.java | 5 +- .../core/sds/SDSAttributesFinderFeature.java | 3 +- .../ch/cyberduck/core/sds/SDSMoveFeature.java | 3 +- .../core/sds/SDSDeleteFeatureTest.java | 3 +- .../core/sds/SDSVersioningFeatureTest.java | 3 +- .../DropboxAttributesFinderFeature.java | 5 +- .../DropboxSharedFoldersListService.java | 3 +- .../core/dropbox/DropboxLockFeatureTest.java | 7 +- .../dropbox/DropboxVersioningFeatureTest.java | 3 +- .../core/eue/EueAttributesFinderFeature.java | 3 +- .../core/eue/EueDeleteFeatureTest.java | 3 +- .../core/eue/EueListServiceTest.java | 3 +- .../core/eue/EueMoveFeatureTest.java | 5 +- .../core/eue/EueTrashFeatureTest.java | 3 +- .../ch/cyberduck/core/ftp/FTPMoveFeature.java | 3 +- .../DriveAttributesFinderFeature.java | 3 +- .../googledrive/DriveDirectoryFeature.java | 3 +- .../googledrive/DriveHomeFinderService.java | 3 +- .../DriveTeamDrivesListService.java | 3 +- .../googledrive/DriveVersioningFeature.java | 3 +- .../DefaultAttributesFinderFeatureTest.java | 7 +- .../DriveBatchTrashFeatureTest.java | 5 +- .../googledrive/DriveMoveFeatureTest.java | 3 +- .../googledrive/DriveTrashFeatureTest.java | 5 +- .../DriveVersioningFeatureTest.java | 3 +- .../GoogleStorageAttributesFinderFeature.java | 5 +- .../GoogleStorageObjectListService.java | 5 +- ...gleStorageAttributesFinderFeatureTest.java | 5 +- .../GoogleStorageReadFeatureTest.java | 3 +- .../irods/IRODSAttributesFinderFeature.java | 3 +- .../core/irods/IRODSListService.java | 3 +- .../core/manta/MantaMoveFeature.java | 3 +- .../manta/MantaObjectAttributeAdapter.java | 3 +- .../onedrive/AbstractDriveListService.java | 3 +- .../core/onedrive/SharepointListService.java | 5 +- .../GraphAttributesFinderFeature.java | 3 +- .../features/sharepoint/GroupListService.java | 3 +- .../features/sharepoint/SitesListService.java | 3 +- .../OneDriveVersioningFeatureTest.java | 3 +- .../core/onedrive/SharepointSessionTest.java | 3 +- .../SharepointVersioningFeatureTest.java | 3 +- .../SwiftAttributesFinderFeature.java | 9 +- .../openstack/SwiftContainerListService.java | 3 +- .../SwiftLargeObjectCopyFeature.java | 3 +- .../datasource/BrowserTableDataSource.java | 17 +- .../core/s3/S3AttributesAdapter.java | 3 +- .../core/s3/S3AttributesFinderFeature.java | 9 +- .../core/s3/S3BucketListService.java | 3 +- .../ch/cyberduck/core/s3/S3CopyFeature.java | 3 +- .../ch/cyberduck/core/s3/S3ListService.java | 3 +- .../ch/cyberduck/core/s3/S3MoveFeature.java | 3 +- .../core/s3/S3ObjectListService.java | 3 +- .../core/s3/S3VersionedObjectListService.java | 5 +- .../cryptomator/S3VersioningFeatureTest.java | 3 +- .../core/s3/S3MultipartUploadServiceTest.java | 3 +- .../cyberduck/core/s3/S3TouchFeatureTest.java | 17 +- .../s3/S3VersionedObjectListServiceTest.java | 3 +- .../core/s3/S3VersioningFeatureTest.java | 3 +- .../CachingAttributesFinderFeatureTest.java | 9 +- .../DefaultAttributesFinderFeatureTest.java | 7 +- .../core/smb/SMBAttributesFinderFeature.java | 5 +- .../ch/cyberduck/core/smb/SMBListService.java | 3 +- .../SpectraAttributesFinderFeature.java | 3 +- .../spectra/SpectraObjectListService.java | 5 +- .../sftp/SFTPAttributesFinderFeature.java | 3 +- .../cyberduck/core/sftp/SFTPMoveFeature.java | 3 +- .../CachingAttributesFinderFeatureTest.java | 3 +- .../StoregateAttributesFinderFeature.java | 5 +- .../core/storegate/StoregateMoveFeature.java | 3 +- .../core/dav/DAVAttributesFinderFeature.java | 5 +- .../ch/cyberduck/core/dav/DAVCopyFeature.java | 3 +- .../ch/cyberduck/core/dav/DAVMoveFeature.java | 3 +- .../ui/controller/BrowserController.cs | 2 +- 131 files changed, 1795 insertions(+), 1130 deletions(-) create mode 100644 core/src/main/java/ch/cyberduck/core/DefaultPathAttributes.java create mode 100644 core/src/main/java/ch/cyberduck/core/ProxyPathAttributes.java diff --git a/azure/src/main/java/ch/cyberduck/core/azure/AzureAttributesFinderFeature.java b/azure/src/main/java/ch/cyberduck/core/azure/AzureAttributesFinderFeature.java index 6012182991..3bab27870a 100644 --- a/azure/src/main/java/ch/cyberduck/core/azure/AzureAttributesFinderFeature.java +++ b/azure/src/main/java/ch/cyberduck/core/azure/AzureAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.azure; */ import ch.cyberduck.core.CancellingListProgressListener; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DirectoryDelimiterPathContainerService; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -62,7 +63,7 @@ public class AzureAttributesFinderFeature implements AttributesFinder, Attribute } try { if(containerService.isContainer(file)) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); final BlobContainerClient client = session.getClient().getBlobContainerClient(containerService.getContainer(file).getName()); final BlobContainerProperties properties = client.getProperties(); attributes.setETag(properties.getETag()); @@ -105,7 +106,7 @@ public class AzureAttributesFinderFeature implements AttributesFinder, Attribute } public PathAttributes toAttributes(final BlobProperties properties) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(properties.getBlobSize()); attributes.setModificationDate(properties.getLastModified().toInstant().toEpochMilli()); if(properties.getContentMd5() != null) { @@ -119,7 +120,7 @@ public class AzureAttributesFinderFeature implements AttributesFinder, Attribute } public PathAttributes toAttributes(final BlobItemProperties properties) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(properties.getContentLength()); attributes.setModificationDate(properties.getLastModified().toInstant().toEpochMilli()); attributes.setETag(properties.getETag()); diff --git a/azure/src/main/java/ch/cyberduck/core/azure/AzureContainerListService.java b/azure/src/main/java/ch/cyberduck/core/azure/AzureContainerListService.java index f69048afd1..45f5dc4421 100644 --- a/azure/src/main/java/ch/cyberduck/core/azure/AzureContainerListService.java +++ b/azure/src/main/java/ch/cyberduck/core/azure/AzureContainerListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.azure; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -46,7 +47,7 @@ public class AzureContainerListService implements RootListService { for(BlobContainerItem container : session.getClient().listBlobContainers(new ListBlobContainersOptions() .setMaxResultsPerPage(HostPreferencesFactory.get(session.getHost()).getInteger("azure.listing.chunksize")) .setDetails(new BlobContainerListDetails().setRetrieveDeleted(false).setRetrieveMetadata(true)), null)) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setETag(container.getProperties().getETag()); attributes.setModificationDate(container.getProperties().getLastModified().toInstant().toEpochMilli()); containers.add(new Path(PathNormalizer.normalize(container.getName()), EnumSet.of(Path.Type.volume, Path.Type.directory), attributes)); diff --git a/backblaze/src/main/java/ch/cyberduck/core/b2/B2AttributesFinderFeature.java b/backblaze/src/main/java/ch/cyberduck/core/b2/B2AttributesFinderFeature.java index 9e3e1be98a..c578c4536a 100644 --- a/backblaze/src/main/java/ch/cyberduck/core/b2/B2AttributesFinderFeature.java +++ b/backblaze/src/main/java/ch/cyberduck/core/b2/B2AttributesFinderFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.b2; import ch.cyberduck.core.Acl; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathContainerService; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -70,7 +71,7 @@ public class B2AttributesFinderFeature implements AttributesFinder, AttributesAd // Pending large file upload final Write.Append append = new B2LargeUploadService(session, fileid).append(file, new TransferStatus()); if(append.append) { - return new PathAttributes().setSize(append.offset); + return new DefaultPathAttributes().setSize(append.offset); } return PathAttributes.EMPTY; } @@ -145,7 +146,7 @@ public class B2AttributesFinderFeature implements AttributesFinder, AttributesAd } protected PathAttributes toAttributes(final B2FileInfoResponse response) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); if(response.getFileInfo().containsKey(X_BZ_INFO_LARGE_FILE_SHA1)) { attributes.setChecksum(Checksum.parse(response.getFileInfo().get(X_BZ_INFO_LARGE_FILE_SHA1))); } @@ -197,7 +198,7 @@ public class B2AttributesFinderFeature implements AttributesFinder, AttributesAd } protected PathAttributes toAttributes(final B2FileResponse response) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(response.getContentLength()); if(response.getFileInfo().containsKey(X_BZ_INFO_LARGE_FILE_SHA1)) { attributes.setChecksum(Checksum.parse(response.getFileInfo().get(X_BZ_INFO_LARGE_FILE_SHA1))); @@ -248,7 +249,7 @@ public class B2AttributesFinderFeature implements AttributesFinder, AttributesAd } protected PathAttributes toAttributes(final B2BucketResponse response) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setVersionId(response.getBucketId()); attributes.setRegion(response.getBucketType().name()); switch(response.getBucketType()) { @@ -259,7 +260,7 @@ public class B2AttributesFinderFeature implements AttributesFinder, AttributesAd } protected PathAttributes toAttributes(final B2FinishLargeFileResponse response) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(response.getContentLength()); if(response.getFileInfo().containsKey(X_BZ_INFO_LARGE_FILE_SHA1)) { attributes.setChecksum(Checksum.parse(response.getFileInfo().get(X_BZ_INFO_LARGE_FILE_SHA1))); diff --git a/backblaze/src/main/java/ch/cyberduck/core/b2/B2LargeCopyFeature.java b/backblaze/src/main/java/ch/cyberduck/core/b2/B2LargeCopyFeature.java index 9e660a402b..2df657ff8b 100644 --- a/backblaze/src/main/java/ch/cyberduck/core/b2/B2LargeCopyFeature.java +++ b/backblaze/src/main/java/ch/cyberduck/core/b2/B2LargeCopyFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.b2; import ch.cyberduck.core.ConnectionCallback; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.PathContainerService; @@ -129,7 +130,7 @@ public class B2LargeCopyFeature implements Copy { session.getClient().finishLargeFileUpload(response.getFileId(), checksums.toArray(new String[checksums.size()])); log.info("Finished large file upload {} with {} parts", target, completed.size()); fileid.cache(target, response.getFileId()); - return new Path(target).withAttributes(new PathAttributes(source.attributes()).setVersionId(response.getFileId())); + return new Path(target).withAttributes(new DefaultPathAttributes(source.attributes()).setVersionId(response.getFileId())); } catch(B2ApiException e) { throw new B2ExceptionMappingService(fileid).map("Cannot copy {0}", e, source); diff --git a/backblaze/src/main/java/ch/cyberduck/core/b2/B2Session.java b/backblaze/src/main/java/ch/cyberduck/core/b2/B2Session.java index d1de960072..e4acbe840a 100644 --- a/backblaze/src/main/java/ch/cyberduck/core/b2/B2Session.java +++ b/backblaze/src/main/java/ch/cyberduck/core/b2/B2Session.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.b2; import ch.cyberduck.core.AttributedList; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Host; import ch.cyberduck.core.HostKeyCallback; import ch.cyberduck.core.ListService; @@ -92,7 +93,7 @@ public class B2Session extends HttpSession { if(!response.getBuckets().isEmpty()) { buckets.addAll(response.getBuckets().entrySet().stream().map(entry -> new Path(PathNormalizer.normalize(entry.getValue()), EnumSet.of(Path.Type.directory, Path.Type.volume), - new PathAttributes().setVersionId(entry.getKey()))).collect(Collectors.toSet())); + new DefaultPathAttributes().setVersionId(entry.getKey()))).collect(Collectors.toSet())); } retryHandler.setTokens(accountId, applicationKey, response.getAuthorizationToken()); if(preferences.getBoolean("b2.upload.largeobject.auto")) { diff --git a/backblaze/src/test/java/ch/cyberduck/core/b2/B2ObjectListServiceTest.java b/backblaze/src/test/java/ch/cyberduck/core/b2/B2ObjectListServiceTest.java index 5ea17ca43b..4233aea04b 100644 --- a/backblaze/src/test/java/ch/cyberduck/core/b2/B2ObjectListServiceTest.java +++ b/backblaze/src/test/java/ch/cyberduck/core/b2/B2ObjectListServiceTest.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.b2; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AsciiRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -216,7 +217,7 @@ public class B2ObjectListServiceTest extends AbstractB2Test { assertEquals(Long.valueOf(1L), list.find(path -> path.attributes().isDuplicate()).attributes().getRevision()); } // Add hide marker - new B2DeleteFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new B2DeleteFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); { final AttributedList list = new B2ObjectListService(session, fileid).list(bucket, new DisabledListProgressListener()); assertEquals(3, list.size()); @@ -337,14 +338,14 @@ public class B2ObjectListServiceTest extends AbstractB2Test { assertSame(folder1, list.find(new SimplePathPredicate(file1)).getParent()); assertSame(folder1, list.find(new SimplePathPredicate(folder2)).getParent()); // Nullify version to add delete marker - new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file2).withAttributes(new PathAttributes(file2.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file2).withAttributes(new DefaultPathAttributes(file2.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); assertTrue(new B2ObjectListService(session, fileid, 1, VersioningConfiguration.empty()).list(folder2, new DisabledListProgressListener()).isEmpty()); assertFalse(new B2ObjectListService(session, fileid).list(folder2, new DisabledListProgressListener()).isEmpty()); new B2DeleteFeature(session, fileid).delete(Collections.singletonList(folder2), new DisabledLoginCallback(), new Delete.DisabledCallback()); assertTrue(new B2ObjectListService(session, fileid).list(folder2, new DisabledListProgressListener()).contains(file2)); assertThrows(NotfoundException.class, () -> new B2ObjectListService(session, fileid, 1, VersioningConfiguration.empty()).list(folder2, new DisabledListProgressListener())); // Nullify version to add delete marker - new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file1).withAttributes(new PathAttributes(file1.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file1).withAttributes(new DefaultPathAttributes(file1.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); assertTrue(new B2ObjectListService(session, fileid, 1, VersioningConfiguration.empty()).list(folder1, new DisabledListProgressListener()).isEmpty()); assertTrue(new B2ObjectListService(session, fileid).list(folder1, new DisabledListProgressListener()).contains(folder2)); new B2DeleteFeature(session, fileid).delete(Collections.singletonList(folder1), new DisabledLoginCallback(), new Delete.DisabledCallback()); @@ -374,7 +375,7 @@ public class B2ObjectListServiceTest extends AbstractB2Test { assertFalse(foundFolder1.attributes().isDuplicate()); } // Nullify version to add delete marker - new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file1).withAttributes(new PathAttributes(file1.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new B2DeleteFeature(session, fileid).delete(Collections.singletonList(new Path(file1).withAttributes(new DefaultPathAttributes(file1.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); assertTrue(new B2ObjectListService(session, fileid, 1, VersioningConfiguration.empty()).list(bucket, new DisabledListProgressListener()).isEmpty()); { final AttributedList list = new B2ObjectListService(session, fileid).list(bucket, new DisabledListProgressListener()); @@ -411,7 +412,7 @@ public class B2ObjectListServiceTest extends AbstractB2Test { assertFalse(foundFolder2.attributes().isDuplicate()); } // Nullify version to add delete marker - new B2DeleteFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new B2DeleteFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(null))), new DisabledLoginCallback(), new Delete.DisabledCallback()); assertTrue(new DefaultFindFeature(session).find(folder1, new DisabledListProgressListener())); assertTrue(new B2ObjectListService(session, fileid).list(folder1, new DisabledListProgressListener()).contains(folder2)); assertTrue(new DefaultFindFeature(session).find(folder2, new DisabledListProgressListener())); diff --git a/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersionIdProviderTest.java b/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersionIdProviderTest.java index 22915d6ce4..e36199cc3b 100644 --- a/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersionIdProviderTest.java +++ b/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersionIdProviderTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.b2; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledPasswordCallback; import ch.cyberduck.core.Path; @@ -52,7 +53,7 @@ public class B2VersionIdProviderTest extends AbstractB2Test { catch(NotfoundException e) { // Expected } - final PathAttributes duplicate = new PathAttributes(); + final PathAttributes duplicate = new DefaultPathAttributes(); duplicate.setVersionId("d"); duplicate.setDuplicate(true); fileid.cache(new Path(file).withAttributes(duplicate), "d"); diff --git a/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersioningFeatureTest.java b/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersioningFeatureTest.java index 9189b8d121..2e70078b91 100644 --- a/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersioningFeatureTest.java +++ b/backblaze/src/test/java/ch/cyberduck/core/b2/B2VersioningFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.b2; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -60,7 +61,7 @@ public class B2VersioningFeatureTest extends AbstractB2Test { new StreamCopier(status, status).transfer(new ByteArrayInputStream(content), out); } assertTrue(new B2FindFeature(session, fileid).find(ignored)); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final String initialVersion = test.attributes().getVersionId(); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/box/src/main/java/ch/cyberduck/core/box/BoxAttributesFinderFeature.java b/box/src/main/java/ch/cyberduck/core/box/BoxAttributesFinderFeature.java index 0176931f92..30846dc71a 100644 --- a/box/src/main/java/ch/cyberduck/core/box/BoxAttributesFinderFeature.java +++ b/box/src/main/java/ch/cyberduck/core/box/BoxAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.box; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -64,7 +65,7 @@ public class BoxAttributesFinderFeature implements AttributesFinder, AttributesA @Override public PathAttributes toAttributes(final File f) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); if(null != f.getContentModifiedAt()) { attrs.setModificationDate(f.getContentModifiedAt().getMillis()); } @@ -81,7 +82,7 @@ public class BoxAttributesFinderFeature implements AttributesFinder, AttributesA } protected PathAttributes toAttributes(final Folder f) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); if(null != f.getContentModifiedAt()) { attrs.setModificationDate(f.getContentModifiedAt().getMillis()); } diff --git a/brick/src/main/java/ch/cyberduck/core/brick/BrickAttributesFinderFeature.java b/brick/src/main/java/ch/cyberduck/core/brick/BrickAttributesFinderFeature.java index 38aa6f26cb..3f56c900db 100644 --- a/brick/src/main/java/ch/cyberduck/core/brick/BrickAttributesFinderFeature.java +++ b/brick/src/main/java/ch/cyberduck/core/brick/BrickAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.brick; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -64,7 +65,7 @@ public class BrickAttributesFinderFeature implements AttributesFinder, Attribute @Override public PathAttributes toAttributes(final FileEntity entity) { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setChecksum(Checksum.parse(entity.getMd5())); attr.setRegion(entity.getRegion()); if(entity.getSize() != null) { diff --git a/brick/src/main/java/ch/cyberduck/core/brick/BrickCopyFeature.java b/brick/src/main/java/ch/cyberduck/core/brick/BrickCopyFeature.java index b1ea3afff2..247d5757ad 100644 --- a/brick/src/main/java/ch/cyberduck/core/brick/BrickCopyFeature.java +++ b/brick/src/main/java/ch/cyberduck/core/brick/BrickCopyFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.brick; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.brick.io.swagger.client.ApiException; @@ -62,7 +63,7 @@ public class BrickCopyFeature extends BrickFileMigrationFeature implements Copy if(entity.getFileMigrationId() != null) { this.poll(client, entity); } - return new Path(target).withAttributes(new PathAttributes(file.attributes()).setVault(null)); + return new Path(target).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null)); } catch(ApiException e) { throw new BrickExceptionMappingService().map("Cannot copy {0}", e, file); diff --git a/brick/src/main/java/ch/cyberduck/core/brick/BrickMoveFeature.java b/brick/src/main/java/ch/cyberduck/core/brick/BrickMoveFeature.java index c4d356a8c6..75ac567dd2 100644 --- a/brick/src/main/java/ch/cyberduck/core/brick/BrickMoveFeature.java +++ b/brick/src/main/java/ch/cyberduck/core/brick/BrickMoveFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.brick; import ch.cyberduck.core.CaseInsensitivePathPredicate; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.brick.io.swagger.client.ApiException; @@ -60,7 +61,7 @@ public class BrickMoveFeature extends BrickFileMigrationFeature implements Move if(entity.getFileMigrationId() != null) { this.poll(client, entity); } - return new Path(target).withAttributes(new PathAttributes(file.attributes()).setVault(null)); + return new Path(target).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null)); } catch(ApiException e) { throw new BrickExceptionMappingService().map("Cannot rename {0}", e, file); diff --git a/core/src/main/java/ch/cyberduck/core/DefaultPathAttributes.java b/core/src/main/java/ch/cyberduck/core/DefaultPathAttributes.java new file mode 100644 index 0000000000..dc02c9dec5 --- /dev/null +++ b/core/src/main/java/ch/cyberduck/core/DefaultPathAttributes.java @@ -0,0 +1,752 @@ +package ch.cyberduck.core; + +/* + * Copyright (c) 2005 David Kocher. All rights reserved. + * http://cyberduck.ch/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Bug fixes, suggestions and comments should be sent to: + * dkocher@cyberduck.ch + */ + +import ch.cyberduck.core.features.Encryption; +import ch.cyberduck.core.features.Quota; +import ch.cyberduck.core.io.Checksum; +import ch.cyberduck.core.serializer.Serializer; +import ch.cyberduck.core.transfer.TransferStatus; + +import org.apache.commons.lang3.StringUtils; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** + * Attributes of a remote directory or file. + */ +public class DefaultPathAttributes implements PathAttributes, Attributes, Serializable { + private static final Logger log = LogManager.getLogger(DefaultPathAttributes.class); + + /** + * The file length + */ + private long size = TransferStatus.UNKNOWN_LENGTH; + + /** + * Quota of folder + */ + private Quota.Space quota = Quota.unknown; + + /** + * The file modification date in milliseconds + */ + private long modified = -1; + /** + * Last accessed timestamp in milliseconds + */ + private long accessed = -1; + /** + * When this file was originally created in milliseconds + */ + private long created = -1; + + private String owner; + private String group; + + private Permission permission = Permission.EMPTY; + + private Acl acl = Acl.EMPTY; + + /** + * MD5 checksum + */ + private Checksum checksum = Checksum.NONE; + + /** + * ETag header in HTTP + */ + private String etag; + + /** + * Redundancy level if available + */ + private String storageClass; + + /** + * Server side encryption (SSE) algorithm and key or null + */ + private Encryption.Algorithm encryption = Encryption.Algorithm.NONE; + + /** + * Unique identifier for a given file. Must remain constant even after updating the file. + */ + private String fileId; + + /** + * Unique identifier for a given version of a file + */ + private String versionId; + + /** + * Lock id + */ + private String lockId; + + /** + * Should be hidden in the browser by default + */ + private Boolean duplicate; + + /** + * Hidden flag set on server + */ + private Boolean hidden; + + /** + * Trashed + */ + private Boolean trashed; + + /** + * Revision number + */ + private Long revision; + + /** + * Geographical location + */ + private String region; + + /** + * + */ + private String displayname; + + private DescriptiveUrl link = DescriptiveUrl.EMPTY; + + /** + * HTTP headers + */ + private Map metadata = Collections.emptyMap(); + + /** + * Cryptomator vault + */ + private Path vault; + /** + * Cryptomator decrypted path + */ + private Path decrypted; + /** + * Cryptomator encrypted path. + */ + private Path encrypted; + /** + * Unique identifier for cryptomator + */ + private String directoryId; + + private Map custom = Collections.emptyMap(); + + private Verdict verdict; + + public DefaultPathAttributes() { + } + + public DefaultPathAttributes(final PathAttributes copy) { + size = copy.getSize(); + quota = copy.getQuota(); + modified = copy.getModificationDate(); + accessed = copy.getAccessedDate(); + created = copy.getCreationDate(); + owner = copy.getOwner(); + group = copy.getGroup(); + permission = Permission.EMPTY == copy.getPermission() ? Permission.EMPTY : new Permission(copy.getPermission()); + acl = Acl.EMPTY == copy.getAcl() ? Acl.EMPTY : new Acl(copy.getAcl()); + checksum = Checksum.NONE == copy.getChecksum() ? Checksum.NONE : new Checksum(copy.getChecksum()); + etag = copy.getETag(); + storageClass = copy.getStorageClass(); + encryption = copy.getEncryption(); + fileId = copy.getFileId(); + versionId = copy.getVersionId(); + lockId = copy.getLockId(); + duplicate = copy.isDuplicate(); + hidden = copy.isHidden(); + trashed = copy.isTrashed(); + revision = copy.getRevision(); + region = copy.getRegion(); + displayname = copy.getDisplayname(); + link = DescriptiveUrl.EMPTY == copy.getLink() ? DescriptiveUrl.EMPTY : new DescriptiveUrl(copy.getLink()); + metadata = new HashMap<>(copy.getMetadata()); + custom = new HashMap<>(copy.getCustom()); + verdict = copy.getVerdict(); + vault = copy.getVault(); + decrypted = copy.getDecrypted(); + encrypted = copy.getEncrypted(); + directoryId = copy.getDirectoryId(); + } + + @Override + public T serialize(final Serializer dict) { + if(size != -1) { + dict.setStringForKey(String.valueOf(size), "Size"); + } + if(quota != Quota.unknown) { + // Set remaining quota + dict.setStringForKey(String.valueOf(quota.available), "Quota"); + } + if(modified != -1) { + dict.setStringForKey(String.valueOf(modified), "Modified"); + } + if(created != -1) { + dict.setStringForKey(String.valueOf(created), "Created"); + } + if(revision != null) { + dict.setStringForKey(String.valueOf(revision), "Revision"); + } + if(etag != null) { + dict.setStringForKey(etag, "ETag"); + } + if(permission != Permission.EMPTY) { + dict.setObjectForKey(permission, "Permission"); + } + if(owner != null) { + dict.setStringForKey(owner, "Owner"); + } + if(group != null) { + dict.setStringForKey(group, "Group"); + } + if(acl != Acl.EMPTY) { + dict.setObjectForKey(acl, "Acl"); + } + if(link != DescriptiveUrl.EMPTY) { + final Map wrapper = new HashMap<>(); + wrapper.put("Url", link.getUrl()); + wrapper.put("Type", link.getType().name()); + dict.setMapForKey(wrapper, "Link"); + } + if(checksum != Checksum.NONE) { + final Map wrapper = new HashMap<>(); + wrapper.put("Algorithm", checksum.algorithm.name()); + wrapper.put("Hash", checksum.hash); + if(null != checksum.base64) { + wrapper.put("Base64", checksum.base64); + } + dict.setMapForKey(wrapper, "Checksum"); + } + if(StringUtils.isNotBlank(versionId)) { + dict.setStringForKey(versionId, "Version"); + } + if(StringUtils.isNotBlank(fileId)) { + dict.setStringForKey(fileId, "File Id"); + } + if(StringUtils.isNotBlank(displayname)) { + dict.setStringForKey(displayname, "Display Name"); + } + if(StringUtils.isNotBlank(lockId)) { + dict.setStringForKey(lockId, "Lock Id"); + } + if(duplicate != null) { + dict.setStringForKey(String.valueOf(duplicate), "Duplicate"); + } + if(hidden != null) { + dict.setStringForKey(String.valueOf(hidden), "Hidden"); + } + if(trashed != null) { + dict.setStringForKey(String.valueOf(trashed), "Trashed"); + } + if(StringUtils.isNotBlank(region)) { + dict.setStringForKey(region, "Region"); + } + if(StringUtils.isNotBlank(storageClass)) { + dict.setStringForKey(storageClass, "Storage Class"); + } + if(vault != null) { + if(vault.attributes() == this) { + log.debug("Skip serializing vault attribute {} to avoid recursion", vault); + } + else { + dict.setObjectForKey(vault, "Vault"); + } + } + if(!custom.isEmpty()) { + dict.setMapForKey(custom, "Custom"); + } + if(verdict != null) { + dict.setStringForKey(verdict.name(), "Verdict"); + } + return dict.getSerialized(); + } + + /** + * @return length the size of file in bytes. + */ + @Override + public long getSize() { + return size; + } + + /** + * @param size the size of file in bytes. + */ + @Override + public DefaultPathAttributes setSize(final long size) { + this.size = size; + return this; + } + + @Override + public Quota.Space getQuota() { + return quota; + } + + @Override + public DefaultPathAttributes setQuota(final Quota.Space quota) { + this.quota = quota; + return this; + } + + @Override + public long getModificationDate() { + return modified; + } + + @Override + public DefaultPathAttributes setModificationDate(final long millis) { + this.modified = millis; + return this; + } + + @Override + public long getCreationDate() { + return created; + } + + @Override + public DefaultPathAttributes setCreationDate(final long millis) { + this.created = millis; + return this; + } + + @Override + public long getAccessedDate() { + return accessed; + } + + @Override + public DefaultPathAttributes setAccessedDate(final long millis) { + this.accessed = millis; + return this; + } + + /** + * @return UNIX permissions + */ + @Override + public Permission getPermission() { + return permission; + } + + /** + * @param p UNIX permissions + */ + @Override + public DefaultPathAttributes setPermission(final Permission p) { + this.permission = p; + return this; + } + + @Override + public Acl getAcl() { + return acl; + } + + @Override + public DefaultPathAttributes setAcl(final Acl acl) { + this.acl = acl; + return this; + } + + @Override + public String getOwner() { + return owner; + } + + @Override + public DefaultPathAttributes setOwner(final String o) { + this.owner = o; + return this; + } + + @Override + public String getGroup() { + return group; + } + + @Override + public DefaultPathAttributes setGroup(final String g) { + this.group = g; + return this; + } + + @Override + public Checksum getChecksum() { + return checksum; + } + + @Override + public DefaultPathAttributes setChecksum(final Checksum checksum) { + this.checksum = checksum; + return this; + } + + @Override + public String getETag() { + return etag; + } + + @Override + public DefaultPathAttributes setETag(final String etag) { + this.etag = etag; + return this; + } + + /** + * @return Storage redundancy identifier. + */ + @Override + public String getStorageClass() { + return storageClass; + } + + /** + * @param storageClass Storage redundancy identifier. + */ + @Override + public DefaultPathAttributes setStorageClass(final String storageClass) { + this.storageClass = storageClass; + return this; + } + + @Override + public Encryption.Algorithm getEncryption() { + return encryption; + } + + @Override + public DefaultPathAttributes setEncryption(final Encryption.Algorithm encryption) { + this.encryption = encryption; + return this; + } + + /** + * A version identifying a particular revision of a file with the same path. + * + * @return Version Identifier or null if not versioned. + */ + @Override + public String getVersionId() { + return versionId; + } + + /** + * Set a unique version identifier for the revision of a file. + * + * @param versionId Revision + */ + @Override + public DefaultPathAttributes setVersionId(final String versionId) { + this.versionId = versionId; + return this; + } + + /** + * A unique identifier for a file with the same path. Remains constant over its lifetime. + * + * @return Identifier or null if there is no such concept + */ + @Override + public String getFileId() { + return fileId; + } + + @Override + public DefaultPathAttributes setFileId(final String fileId) { + this.fileId = fileId; + return this; + } + + @Override + public String getLockId() { + return lockId; + } + + @Override + public DefaultPathAttributes setLockId(final String lockId) { + this.lockId = lockId; + return this; + } + + @Override + public String getDirectoryId() { + return directoryId; + } + + @Override + public DefaultPathAttributes setDirectoryId(final String directoryId) { + this.directoryId = directoryId; + return this; + } + + @Override + public Long getRevision() { + return revision; + } + + @Override + public DefaultPathAttributes setRevision(final Long revision) { + this.revision = revision; + return this; + } + + @Override + public Path getDecrypted() { + return decrypted; + } + + @Override + public DefaultPathAttributes setDecrypted(final Path decrypted) { + this.decrypted = decrypted; + return this; + } + + @Override + public Path getEncrypted() { + return encrypted; + } + + @Override + public DefaultPathAttributes setEncrypted(final Path encrypted) { + this.encrypted = encrypted; + return this; + } + + @Override + public DefaultPathAttributes setVault(final Path vault) { + this.vault = vault; + return this; + } + + @Override + public Path getVault() { + return vault; + } + + @Override + public boolean isDuplicate() { + return duplicate != null && duplicate; + } + + /** + * Attribute to mark a file as hidden by default in addition to a filename convention. + * + * @param duplicate Flag + */ + @Override + public DefaultPathAttributes setDuplicate(final boolean duplicate) { + this.duplicate = duplicate; + return this; + } + + @Override + public Boolean isHidden() { + return hidden != null && hidden; + } + + @Override + public DefaultPathAttributes setHidden(final boolean hidden) { + this.hidden = hidden; + return this; + } + + @Override + public Boolean isTrashed() { + return trashed != null && trashed; + } + + @Override + public DefaultPathAttributes setTrashed(final boolean trashed) { + this.trashed = trashed; + return this; + } + + @Override + public Map getMetadata() { + return metadata; + } + + @Override + public DefaultPathAttributes setMetadata(final Map metadata) { + this.metadata = metadata; + return this; + } + + @Override + public String getRegion() { + return region; + } + + @Override + public DefaultPathAttributes setRegion(final String region) { + this.region = region; + return this; + } + + @Override + public String getDisplayname() { + return displayname; + } + + @Override + public DefaultPathAttributes setDisplayname(final String displayname) { + this.displayname = displayname; + return this; + } + + @Override + public DescriptiveUrl getLink() { + return link; + } + + @Override + public DefaultPathAttributes setLink(final DescriptiveUrl link) { + this.link = link; + return this; + } + + @Override + public Map getCustom() { + return custom; + } + + @Override + public DefaultPathAttributes setCustom(final Map custom) { + this.custom = custom; + return this; + } + + @Override + public DefaultPathAttributes setCustom(final String key, final String value) { + custom = new HashMap<>(custom); + custom.put(key, value); + return this; + } + + @Override + public Verdict getVerdict() { + return verdict; + } + + @Override + public DefaultPathAttributes setVerdict(final Verdict verdict) { + this.verdict = verdict; + return this; + } + + @Override + public boolean equals(final Object o) { + if(this == o) { + return true; + } + if(!(o instanceof DefaultPathAttributes)) { + return false; + } + final DefaultPathAttributes that = (DefaultPathAttributes) o; + if(modified != that.modified) { + return false; + } + if(size != that.size) { + return false; + } + if(!Objects.equals(checksum, that.checksum)) { + return false; + } + if(!Objects.equals(permission, that.permission)) { + return false; + } + if(!Objects.equals(acl, that.acl)) { + return false; + } + if(!Objects.equals(versionId, that.versionId)) { + return false; + } + if(!Objects.equals(fileId, that.fileId)) { + return false; + } + if(!Objects.equals(revision, that.revision)) { + return false; + } + if(!Objects.equals(vault, that.vault)) { + return false; + } + return true; + } + + @Override + public int hashCode() { + int result = (int) (size ^ (size >>> 32)); + result = 31 * result + (int) (modified ^ (modified >>> 32)); + result = 31 * result + (permission != null ? permission.hashCode() : 0); + result = 31 * result + (acl != null ? acl.hashCode() : 0); + result = 31 * result + (checksum != null ? checksum.hashCode() : 0); + result = 31 * result + (versionId != null ? versionId.hashCode() : 0); + result = 31 * result + (fileId != null ? fileId.hashCode() : 0); + result = 31 * result + (revision != null ? revision.hashCode() : 0); + result = 31 * result + (verdict != null ? verdict.hashCode() : 0); + result = 31 * result + (vault != null ? vault.hashCode() : 0); + return result; + } + + @Override + public String toString() { + final StringBuilder sb = new StringBuilder("PathAttributes{"); + sb.append("accessed=").append(accessed); + sb.append(", size=").append(size); + sb.append(", modified=").append(modified); + sb.append(", created=").append(created); + sb.append(", owner='").append(owner).append('\''); + sb.append(", group='").append(group).append('\''); + sb.append(", permission=").append(permission); + sb.append(", acl=").append(acl); + sb.append(", checksum='").append(checksum).append('\''); + sb.append(", etag='").append(etag).append('\''); + sb.append(", storageClass='").append(storageClass).append('\''); + sb.append(", encryption='").append(encryption).append('\''); + sb.append(", versionId='").append(versionId).append('\''); + sb.append(", fileId='").append(fileId).append('\''); + sb.append(", lockId='").append(lockId).append('\''); + sb.append(", duplicate=").append(duplicate); + sb.append(", hidden=").append(hidden); + sb.append(", trashed=").append(trashed); + sb.append(", revision=").append(revision); + sb.append(", region='").append(region).append('\''); + sb.append(", metadata=").append(metadata).append('\''); + sb.append(", custom=").append(custom).append('\''); + sb.append(", verdict=").append(verdict).append('\''); + sb.append('}'); + return sb.toString(); + } + +} diff --git a/core/src/main/java/ch/cyberduck/core/Path.java b/core/src/main/java/ch/cyberduck/core/Path.java index b7ffe103ed..435a326137 100644 --- a/core/src/main/java/ch/cyberduck/core/Path.java +++ b/core/src/main/java/ch/cyberduck/core/Path.java @@ -60,7 +60,7 @@ public class Path extends AbstractPath implements Referenceable, Serializable { this.path = copy.path; this.symlink = null == copy.symlink ? null : new Path(copy.symlink); this.type = EnumSet.copyOf(copy.type); - this.attributes = new PathAttributes(copy.attributes); + this.attributes = new DefaultPathAttributes(copy.attributes); this.alias = copy.alias; } @@ -71,7 +71,7 @@ public class Path extends AbstractPath implements Referenceable, Serializable { */ public Path(final Path parent, final String name, final EnumSet type) { this.type = type; - this.attributes = new PathAttributes(); + this.attributes = new DefaultPathAttributes(); this.attributes.setRegion(parent.attributes.getRegion()); this._setPath(parent, name); } @@ -82,7 +82,7 @@ public class Path extends AbstractPath implements Referenceable, Serializable { */ public Path(final String absolute, final EnumSet type) { this.type = type; - this.attributes = new PathAttributes(); + this.attributes = new DefaultPathAttributes(); this.setPath(absolute); } diff --git a/core/src/main/java/ch/cyberduck/core/PathAttributes.java b/core/src/main/java/ch/cyberduck/core/PathAttributes.java index b5e3a7c4a8..6a2330522b 100644 --- a/core/src/main/java/ch/cyberduck/core/PathAttributes.java +++ b/core/src/main/java/ch/cyberduck/core/PathAttributes.java @@ -22,517 +22,283 @@ import ch.cyberduck.core.features.Encryption; import ch.cyberduck.core.features.Quota; import ch.cyberduck.core.io.Checksum; import ch.cyberduck.core.serializer.Serializer; -import ch.cyberduck.core.transfer.TransferStatus; -import org.apache.commons.lang3.StringUtils; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; - -import java.util.Collections; -import java.util.HashMap; import java.util.Map; -import java.util.Objects; /** - * Attributes of a remote directory or file. + * Interface for path attributes operations. */ -public class PathAttributes implements Attributes, Serializable { - private static final Logger log = LogManager.getLogger(PathAttributes.class); - - /** - * The file length - */ - private long size = TransferStatus.UNKNOWN_LENGTH; - - /** - * Quota of folder - */ - private Quota.Space quota = Quota.unknown; - - /** - * The file modification date in milliseconds - */ - private long modified = -1; - /** - * Last accessed timestamp in milliseconds - */ - private long accessed = -1; - /** - * When this file was originally created in milliseconds - */ - private long created = -1; - - private String owner; - private String group; - - private Permission permission = Permission.EMPTY; - - private Acl acl = Acl.EMPTY; - - /** - * MD5 checksum - */ - private Checksum checksum = Checksum.NONE; - - /** - * ETag header in HTTP - */ - private String etag; - - /** - * Redundancy level if available - */ - private String storageClass; - - /** - * Server side encryption (SSE) algorithm and key or null - */ - private Encryption.Algorithm encryption = Encryption.Algorithm.NONE; - - /** - * Unique identifier for a given file. Must remain constant even after updating the file. - */ - private String fileId; - - /** - * Unique identifier for a given version of a file - */ - private String versionId; - - /** - * Lock id - */ - private String lockId; - - /** - * Should be hidden in the browser by default - */ - private Boolean duplicate; - - /** - * Hidden flag set on server - */ - private Boolean hidden; - - /** - * Trashed - */ - private Boolean trashed; - - /** - * Revision number - */ - private Long revision; - - /** - * Geographical location - */ - private String region; - - /** - * - */ - private String displayname; - - private DescriptiveUrl link = DescriptiveUrl.EMPTY; - - /** - * HTTP headers - */ - private Map metadata = Collections.emptyMap(); - - /** - * Cryptomator vault - */ - private Path vault; - /** - * Cryptomator decrypted path - */ - private Path decrypted; - /** - * Cryptomator encrypted path. - */ - private Path encrypted; - /** - * Unique identifier for cryptomator - */ - private String directoryId; - - private Map custom = Collections.emptyMap(); - - private Verdict verdict; - - public enum Verdict { - pending, - clean, - malicious - } - - public PathAttributes() { - } - - public PathAttributes(final PathAttributes copy) { - size = copy.size; - quota = copy.quota; - modified = copy.modified; - accessed = copy.accessed; - created = copy.created; - owner = copy.owner; - group = copy.group; - permission = Permission.EMPTY == copy.permission ? Permission.EMPTY : new Permission(copy.permission); - acl = Acl.EMPTY == copy.acl ? Acl.EMPTY : new Acl(copy.acl); - checksum = Checksum.NONE == copy.checksum ? Checksum.NONE : new Checksum(copy.checksum); - etag = copy.etag; - storageClass = copy.storageClass; - encryption = copy.encryption; - fileId = copy.fileId; - versionId = copy.versionId; - lockId = copy.lockId; - duplicate = copy.duplicate; - hidden = copy.hidden; - trashed = copy.trashed; - revision = copy.revision; - region = copy.region; - displayname = copy.displayname; - link = DescriptiveUrl.EMPTY == copy.link ? DescriptiveUrl.EMPTY : new DescriptiveUrl(copy.link); - metadata = new HashMap<>(copy.metadata); - custom = new HashMap<>(copy.custom); - verdict = copy.verdict; - vault = copy.vault; - decrypted = copy.decrypted; - encrypted = copy.encrypted; - directoryId = copy.directoryId; - } - - @Override - public T serialize(final Serializer dict) { - if(size != -1) { - dict.setStringForKey(String.valueOf(size), "Size"); +public interface PathAttributes extends Attributes, Serializable { + DefaultPathAttributes EMPTY = new DefaultPathAttributes() { + @Override + public T serialize(final Serializer dict) { + return super.serialize(dict); } - if(quota != Quota.unknown) { - // Set remaining quota - dict.setStringForKey(String.valueOf(quota.available), "Quota"); + + @Override + public DefaultPathAttributes setSize(final long size) { + return this; } - if(modified != -1) { - dict.setStringForKey(String.valueOf(modified), "Modified"); + + @Override + public DefaultPathAttributes setQuota(final Quota.Space quota) { + return this; } - if(created != -1) { - dict.setStringForKey(String.valueOf(created), "Created"); + + @Override + public DefaultPathAttributes setModificationDate(final long millis) { + return this; } - if(revision != null) { - dict.setStringForKey(String.valueOf(revision), "Revision"); + + @Override + public DefaultPathAttributes setCreationDate(final long millis) { + return this; } - if(etag != null) { - dict.setStringForKey(etag, "ETag"); + + @Override + public DefaultPathAttributes setAccessedDate(final long millis) { + return this; } - if(permission != Permission.EMPTY) { - dict.setObjectForKey(permission, "Permission"); + + @Override + public DefaultPathAttributes setPermission(final Permission p) { + return this; } - if(owner != null) { - dict.setStringForKey(owner, "Owner"); + + @Override + public DefaultPathAttributes setAcl(final Acl acl) { + return this; } - if(group != null) { - dict.setStringForKey(group, "Group"); + + @Override + public DefaultPathAttributes setOwner(final String o) { + return this; } - if(acl != Acl.EMPTY) { - dict.setObjectForKey(acl, "Acl"); + + @Override + public DefaultPathAttributes setGroup(final String g) { + return this; } - if(link != DescriptiveUrl.EMPTY) { - final Map wrapper = new HashMap<>(); - wrapper.put("Url", link.getUrl()); - wrapper.put("Type", link.getType().name()); - dict.setMapForKey(wrapper, "Link"); + + @Override + public DefaultPathAttributes setChecksum(final Checksum checksum) { + return this; } - if(checksum != Checksum.NONE) { - final Map wrapper = new HashMap<>(); - wrapper.put("Algorithm", checksum.algorithm.name()); - wrapper.put("Hash", checksum.hash); - if(null != checksum.base64) { - wrapper.put("Base64", checksum.base64); - } - dict.setMapForKey(wrapper, "Checksum"); + + @Override + public DefaultPathAttributes setETag(final String etag) { + return this; } - if(StringUtils.isNotBlank(versionId)) { - dict.setStringForKey(versionId, "Version"); + + @Override + public DefaultPathAttributes setStorageClass(final String storageClass) { + return this; } - if(StringUtils.isNotBlank(fileId)) { - dict.setStringForKey(fileId, "File Id"); + + @Override + public DefaultPathAttributes setEncryption(final Encryption.Algorithm encryption) { + return this; } - if(StringUtils.isNotBlank(displayname)) { - dict.setStringForKey(displayname, "Display Name"); + + @Override + public DefaultPathAttributes setVersionId(final String versionId) { + return this; } - if(StringUtils.isNotBlank(lockId)) { - dict.setStringForKey(lockId, "Lock Id"); + + @Override + public DefaultPathAttributes setFileId(final String fileId) { + return this; } - if(duplicate != null) { - dict.setStringForKey(String.valueOf(duplicate), "Duplicate"); + + @Override + public DefaultPathAttributes setLockId(final String lockId) { + return this; } - if(hidden != null) { - dict.setStringForKey(String.valueOf(hidden), "Hidden"); + + @Override + public DefaultPathAttributes setDirectoryId(final String directoryId) { + return this; } - if(trashed != null) { - dict.setStringForKey(String.valueOf(trashed), "Trashed"); + + @Override + public DefaultPathAttributes setRevision(final Long revision) { + return this; } - if(StringUtils.isNotBlank(region)) { - dict.setStringForKey(region, "Region"); + + @Override + public DefaultPathAttributes setDecrypted(final Path decrypted) { + return this; } - if(StringUtils.isNotBlank(storageClass)) { - dict.setStringForKey(storageClass, "Storage Class"); + + @Override + public DefaultPathAttributes setEncrypted(final Path encrypted) { + return this; } - if(vault != null) { - if(vault.attributes() == this) { - log.debug("Skip serializing vault attribute {} to avoid recursion", vault); - } - else { - dict.setObjectForKey(vault, "Vault"); - } + + @Override + public DefaultPathAttributes setVault(final Path vault) { + return this; } - if(!custom.isEmpty()) { - dict.setMapForKey(custom, "Custom"); + + @Override + public DefaultPathAttributes setDuplicate(final boolean duplicate) { + return this; } - if(verdict != null) { - dict.setStringForKey(verdict.name(), "Verdict"); + + @Override + public DefaultPathAttributes setHidden(final boolean hidden) { + return this; } - return dict.getSerialized(); - } + + @Override + public DefaultPathAttributes setTrashed(final boolean trashed) { + return this; + } + + @Override + public DefaultPathAttributes setMetadata(final Map metadata) { + return this; + } + + @Override + public DefaultPathAttributes setRegion(final String region) { + return this; + } + + @Override + public DefaultPathAttributes setDisplayname(final String displayname) { + return this; + } + + @Override + public DefaultPathAttributes setLink(final DescriptiveUrl link) { + return this; + } + + @Override + public DefaultPathAttributes setCustom(final Map custom) { + return this; + } + + @Override + public DefaultPathAttributes setCustom(final String key, final String value) { + return this; + } + + @Override + public DefaultPathAttributes setVerdict(final Verdict verdict) { + return this; + } + }; /** * @return length the size of file in bytes. */ - @Override - public long getSize() { - return size; - } - /** * @param size the size of file in bytes. */ - public PathAttributes setSize(final long size) { - this.size = size; - return this; - } + PathAttributes setSize(long size); - public Quota.Space getQuota() { - return quota; - } + Quota.Space getQuota(); - public PathAttributes setQuota(final Quota.Space quota) { - this.quota = quota; - return this; - } + PathAttributes setQuota(Quota.Space quota); - @Override - public long getModificationDate() { - return modified; - } + PathAttributes setModificationDate(long millis); - public PathAttributes setModificationDate(final long millis) { - this.modified = millis; - return this; - } + PathAttributes setCreationDate(long millis); - @Override - public long getCreationDate() { - return created; - } - - public PathAttributes setCreationDate(final long millis) { - this.created = millis; - return this; - } - - @Override - public long getAccessedDate() { - return accessed; - } - - public PathAttributes setAccessedDate(final long millis) { - this.accessed = millis; - return this; - } - - /** - * @return UNIX permissions - */ - @Override - public Permission getPermission() { - return permission; - } + PathAttributes setAccessedDate(long millis); /** * @param p UNIX permissions */ - public PathAttributes setPermission(final Permission p) { - this.permission = p; - return this; - } + PathAttributes setPermission(Permission p); - public Acl getAcl() { - return acl; - } + Acl getAcl(); - public PathAttributes setAcl(final Acl acl) { - this.acl = acl; - return this; - } + PathAttributes setAcl(Acl acl); - @Override - public String getOwner() { - return owner; - } + PathAttributes setOwner(String o); - public PathAttributes setOwner(final String o) { - this.owner = o; - return this; - } + PathAttributes setGroup(String g); - @Override - public String getGroup() { - return group; - } + Checksum getChecksum(); - public PathAttributes setGroup(final String g) { - this.group = g; - return this; - } + PathAttributes setChecksum(Checksum checksum); - public Checksum getChecksum() { - return checksum; - } + String getETag(); - public PathAttributes setChecksum(final Checksum checksum) { - this.checksum = checksum; - return this; - } - - public String getETag() { - return etag; - } - - public PathAttributes setETag(final String etag) { - this.etag = etag; - return this; - } + PathAttributes setETag(String etag); /** * @return Storage redundancy identifier. */ - public String getStorageClass() { - return storageClass; - } + String getStorageClass(); /** * @param storageClass Storage redundancy identifier. */ - public PathAttributes setStorageClass(final String storageClass) { - this.storageClass = storageClass; - return this; - } + PathAttributes setStorageClass(String storageClass); - public Encryption.Algorithm getEncryption() { - return encryption; - } + Encryption.Algorithm getEncryption(); - public PathAttributes setEncryption(final Encryption.Algorithm encryption) { - this.encryption = encryption; - return this; - } + PathAttributes setEncryption(Encryption.Algorithm encryption); /** * A version identifying a particular revision of a file with the same path. * * @return Version Identifier or null if not versioned. */ - public String getVersionId() { - return versionId; - } + String getVersionId(); /** * Set a unique version identifier for the revision of a file. * * @param versionId Revision */ - public PathAttributes setVersionId(final String versionId) { - this.versionId = versionId; - return this; - } + PathAttributes setVersionId(String versionId); /** * A unique identifier for a file with the same path. Remains constant over its lifetime. * * @return Identifier or null if there is no such concept */ - public String getFileId() { - return fileId; - } + String getFileId(); - public PathAttributes setFileId(final String fileId) { - this.fileId = fileId; - return this; - } + PathAttributes setFileId(String fileId); - public String getLockId() { - return lockId; - } + String getLockId(); - public PathAttributes setLockId(final String lockId) { - this.lockId = lockId; - return this; - } + PathAttributes setLockId(String lockId); - public String getDirectoryId() { - return directoryId; - } + String getDirectoryId(); - public PathAttributes setDirectoryId(final String directoryId) { - this.directoryId = directoryId; - return this; - } + PathAttributes setDirectoryId(String directoryId); /** * @return The incrementing revision number of the file or null if not versioned. */ - public Long getRevision() { - return revision; - } + Long getRevision(); - public PathAttributes setRevision(final Long revision) { - this.revision = revision; - return this; - } + PathAttributes setRevision(Long revision); /** * @return Null if path is missing flag encrypted */ - public Path getDecrypted() { - return decrypted; - } + Path getDecrypted(); - public PathAttributes setDecrypted(final Path decrypted) { - this.decrypted = decrypted; - return this; - } + PathAttributes setDecrypted(Path decrypted); /** * @return Null if path is missing flag decrypted */ - public Path getEncrypted() { - return encrypted; - } + Path getEncrypted(); - public PathAttributes setEncrypted(final Path encrypted) { - this.encrypted = encrypted; - return this; - } + PathAttributes setEncrypted(Path encrypted); - public PathAttributes setVault(final Path vault) { - this.vault = vault; - return this; - } + PathAttributes setVault(Path vault); - public Path getVault() { - return vault; - } + Path getVault(); /** * If the path should not be displayed in a browser by default unless the user explicitly chooses to show hidden @@ -540,341 +306,52 @@ public class PathAttributes implements Attributes, Serializable { * * @return True if hidden by default. */ - public boolean isDuplicate() { - return duplicate != null && duplicate; - } + boolean isDuplicate(); /** * Attribute to mark a file as hidden by default in addition to a filename convention. * * @param duplicate Flag */ - public PathAttributes setDuplicate(final boolean duplicate) { - this.duplicate = duplicate; - return this; + PathAttributes setDuplicate(boolean duplicate); + + Boolean isHidden(); + + PathAttributes setHidden(boolean hidden); + + Boolean isTrashed(); + + PathAttributes setTrashed(boolean trashed); + + Map getMetadata(); + + PathAttributes setMetadata(Map metadata); + + String getRegion(); + + PathAttributes setRegion(String region); + + String getDisplayname(); + + PathAttributes setDisplayname(String displayname); + + DescriptiveUrl getLink(); + + PathAttributes setLink(DescriptiveUrl link); + + Map getCustom(); + + PathAttributes setCustom(Map custom); + + PathAttributes setCustom(String key, String value); + + Verdict getVerdict(); + + PathAttributes setVerdict(Verdict verdict); + + enum Verdict { + pending, + clean, + malicious } - - public Boolean isHidden() { - return hidden != null && hidden; - } - - public PathAttributes setHidden(final boolean hidden) { - this.hidden = hidden; - return this; - } - - public Boolean isTrashed() { - return trashed != null && trashed; - } - - public PathAttributes setTrashed(final boolean trashed) { - this.trashed = trashed; - return this; - } - - public Map getMetadata() { - return metadata; - } - - public PathAttributes setMetadata(final Map metadata) { - this.metadata = metadata; - return this; - } - - public String getRegion() { - return region; - } - - public PathAttributes setRegion(final String region) { - this.region = region; - return this; - } - - public String getDisplayname() { - return displayname; - } - - public PathAttributes setDisplayname(final String displayname) { - this.displayname = displayname; - return this; - } - - public DescriptiveUrl getLink() { - return link; - } - - public PathAttributes setLink(final DescriptiveUrl link) { - this.link = link; - return this; - } - - public Map getCustom() { - return custom; - } - - public PathAttributes setCustom(final Map custom) { - this.custom = custom; - return this; - } - - public PathAttributes setCustom(final String key, final String value) { - custom = new HashMap<>(custom); - custom.put(key, value); - return this; - } - - public Verdict getVerdict() { - return verdict; - } - - public PathAttributes setVerdict(final Verdict verdict) { - this.verdict = verdict; - return this; - } - - @Override - public boolean equals(final Object o) { - if(this == o) { - return true; - } - if(!(o instanceof PathAttributes)) { - return false; - } - final PathAttributes that = (PathAttributes) o; - if(modified != that.modified) { - return false; - } - if(size != that.size) { - return false; - } - if(!Objects.equals(checksum, that.checksum)) { - return false; - } - if(!Objects.equals(permission, that.permission)) { - return false; - } - if(!Objects.equals(acl, that.acl)) { - return false; - } - if(!Objects.equals(versionId, that.versionId)) { - return false; - } - if(!Objects.equals(fileId, that.fileId)) { - return false; - } - if(!Objects.equals(revision, that.revision)) { - return false; - } - if(!Objects.equals(vault, that.vault)) { - return false; - } - return true; - } - - @Override - public int hashCode() { - int result = (int) (size ^ (size >>> 32)); - result = 31 * result + (int) (modified ^ (modified >>> 32)); - result = 31 * result + (permission != null ? permission.hashCode() : 0); - result = 31 * result + (acl != null ? acl.hashCode() : 0); - result = 31 * result + (checksum != null ? checksum.hashCode() : 0); - result = 31 * result + (versionId != null ? versionId.hashCode() : 0); - result = 31 * result + (fileId != null ? fileId.hashCode() : 0); - result = 31 * result + (revision != null ? revision.hashCode() : 0); - result = 31 * result + (verdict != null ? verdict.hashCode() : 0); - result = 31 * result + (vault != null ? vault.hashCode() : 0); - return result; - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("PathAttributes{"); - sb.append("accessed=").append(accessed); - sb.append(", size=").append(size); - sb.append(", modified=").append(modified); - sb.append(", created=").append(created); - sb.append(", owner='").append(owner).append('\''); - sb.append(", group='").append(group).append('\''); - sb.append(", permission=").append(permission); - sb.append(", acl=").append(acl); - sb.append(", checksum='").append(checksum).append('\''); - sb.append(", etag='").append(etag).append('\''); - sb.append(", storageClass='").append(storageClass).append('\''); - sb.append(", encryption='").append(encryption).append('\''); - sb.append(", versionId='").append(versionId).append('\''); - sb.append(", fileId='").append(fileId).append('\''); - sb.append(", lockId='").append(lockId).append('\''); - sb.append(", duplicate=").append(duplicate); - sb.append(", hidden=").append(hidden); - sb.append(", trashed=").append(trashed); - sb.append(", revision=").append(revision); - sb.append(", region='").append(region).append('\''); - sb.append(", metadata=").append(metadata).append('\''); - sb.append(", custom=").append(custom).append('\''); - sb.append(", verdict=").append(verdict).append('\''); - sb.append('}'); - return sb.toString(); - } - - public static final PathAttributes EMPTY = new PathAttributes() { - @Override - public T serialize(final Serializer dict) { - return super.serialize(dict); - } - - @Override - public PathAttributes setSize(final long size) { - return this; - } - - @Override - public PathAttributes setQuota(final Quota.Space quota) { - return this; - } - - @Override - public PathAttributes setModificationDate(final long millis) { - return this; - } - - @Override - public PathAttributes setCreationDate(final long millis) { - return this; - } - - @Override - public PathAttributes setAccessedDate(final long millis) { - return this; - } - - @Override - public PathAttributes setPermission(final Permission p) { - return this; - } - - @Override - public PathAttributes setAcl(final Acl acl) { - return this; - } - - @Override - public PathAttributes setOwner(final String o) { - return this; - } - - @Override - public PathAttributes setGroup(final String g) { - return this; - } - - @Override - public PathAttributes setChecksum(final Checksum checksum) { - return this; - } - - @Override - public PathAttributes setETag(final String etag) { - return this; - } - - @Override - public PathAttributes setStorageClass(final String storageClass) { - return this; - } - - @Override - public PathAttributes setEncryption(final Encryption.Algorithm encryption) { - return this; - } - - @Override - public PathAttributes setVersionId(final String versionId) { - return this; - } - - @Override - public PathAttributes setFileId(final String fileId) { - return this; - } - - @Override - public PathAttributes setLockId(final String lockId) { - return this; - } - - @Override - public PathAttributes setDirectoryId(final String directoryId) { - return this; - } - - @Override - public PathAttributes setRevision(final Long revision) { - return this; - } - - @Override - public PathAttributes setDecrypted(final Path decrypted) { - return this; - } - - @Override - public PathAttributes setEncrypted(final Path encrypted) { - return this; - } - - @Override - public PathAttributes setVault(final Path vault) { - return this; - } - - @Override - public PathAttributes setDuplicate(final boolean duplicate) { - return this; - } - - @Override - public PathAttributes setHidden(final boolean hidden) { - return this; - } - - @Override - public PathAttributes setTrashed(final boolean trashed) { - return this; - } - - @Override - public PathAttributes setMetadata(final Map metadata) { - return this; - } - - @Override - public PathAttributes setRegion(final String region) { - return this; - } - - @Override - public PathAttributes setDisplayname(final String displayname) { - return this; - } - - @Override - public PathAttributes setLink(final DescriptiveUrl link) { - return this; - } - - @Override - public PathAttributes setCustom(final Map custom) { - return this; - } - - @Override - public PathAttributes setCustom(final String key, final String value) { - return this; - } - - @Override - public PathAttributes setVerdict(final Verdict verdict) { - return this; - } - }; } diff --git a/core/src/main/java/ch/cyberduck/core/ProxyPathAttributes.java b/core/src/main/java/ch/cyberduck/core/ProxyPathAttributes.java new file mode 100644 index 0000000000..f7847a5ddc --- /dev/null +++ b/core/src/main/java/ch/cyberduck/core/ProxyPathAttributes.java @@ -0,0 +1,342 @@ +package ch.cyberduck.core; + +/* + * Copyright (c) 2002-2025 iterate GmbH. All rights reserved. + * https://cyberduck.io/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +import ch.cyberduck.core.features.Encryption; +import ch.cyberduck.core.features.Quota; +import ch.cyberduck.core.io.Checksum; +import ch.cyberduck.core.serializer.Serializer; + +import java.util.Map; + +public class ProxyPathAttributes implements PathAttributes { + + private final PathAttributes proxy; + + public ProxyPathAttributes(final PathAttributes proxy) { + this.proxy = proxy; + } + + @Override + public PathAttributes setSize(final long size) { + return proxy.setSize(size); + } + + @Override + public Quota.Space getQuota() { + return proxy.getQuota(); + } + + @Override + public PathAttributes setQuota(final Quota.Space quota) { + return proxy.setQuota(quota); + } + + @Override + public PathAttributes setModificationDate(final long millis) { + return proxy.setModificationDate(millis); + } + + @Override + public PathAttributes setCreationDate(final long millis) { + return proxy.setCreationDate(millis); + } + + @Override + public PathAttributes setAccessedDate(final long millis) { + return proxy.setAccessedDate(millis); + } + + @Override + public PathAttributes setPermission(final Permission p) { + return proxy.setPermission(p); + } + + @Override + public Acl getAcl() { + return proxy.getAcl(); + } + + @Override + public PathAttributes setAcl(final Acl acl) { + return proxy.setAcl(acl); + } + + @Override + public PathAttributes setOwner(final String o) { + return proxy.setOwner(o); + } + + @Override + public PathAttributes setGroup(final String g) { + return proxy.setGroup(g); + } + + @Override + public Checksum getChecksum() { + return proxy.getChecksum(); + } + + @Override + public PathAttributes setChecksum(final Checksum checksum) { + return proxy.setChecksum(checksum); + } + + @Override + public String getETag() { + return proxy.getETag(); + } + + @Override + public PathAttributes setETag(final String etag) { + return proxy.setETag(etag); + } + + @Override + public String getStorageClass() { + return proxy.getStorageClass(); + } + + @Override + public PathAttributes setStorageClass(final String storageClass) { + return proxy.setStorageClass(storageClass); + } + + @Override + public Encryption.Algorithm getEncryption() { + return proxy.getEncryption(); + } + + @Override + public PathAttributes setEncryption(final Encryption.Algorithm encryption) { + return proxy.setEncryption(encryption); + } + + @Override + public String getVersionId() { + return proxy.getVersionId(); + } + + @Override + public PathAttributes setVersionId(final String versionId) { + return proxy.setVersionId(versionId); + } + + @Override + public String getFileId() { + return proxy.getFileId(); + } + + @Override + public PathAttributes setFileId(final String fileId) { + return proxy.setFileId(fileId); + } + + @Override + public String getLockId() { + return proxy.getLockId(); + } + + @Override + public PathAttributes setLockId(final String lockId) { + return proxy.setLockId(lockId); + } + + @Override + public String getDirectoryId() { + return proxy.getDirectoryId(); + } + + @Override + public PathAttributes setDirectoryId(final String directoryId) { + return proxy.setDirectoryId(directoryId); + } + + @Override + public Long getRevision() { + return proxy.getRevision(); + } + + @Override + public PathAttributes setRevision(final Long revision) { + return proxy.setRevision(revision); + } + + @Override + public Path getDecrypted() { + return proxy.getDecrypted(); + } + + @Override + public PathAttributes setDecrypted(final Path decrypted) { + return proxy.setDecrypted(decrypted); + } + + @Override + public Path getEncrypted() { + return proxy.getEncrypted(); + } + + @Override + public PathAttributes setEncrypted(final Path encrypted) { + return proxy.setEncrypted(encrypted); + } + + @Override + public PathAttributes setVault(final Path vault) { + return proxy.setVault(vault); + } + + @Override + public Path getVault() { + return proxy.getVault(); + } + + @Override + public boolean isDuplicate() { + return proxy.isDuplicate(); + } + + @Override + public PathAttributes setDuplicate(final boolean duplicate) { + return proxy.setDuplicate(duplicate); + } + + @Override + public Boolean isHidden() { + return proxy.isHidden(); + } + + @Override + public PathAttributes setHidden(final boolean hidden) { + return proxy.setHidden(hidden); + } + + @Override + public Boolean isTrashed() { + return proxy.isTrashed(); + } + + @Override + public PathAttributes setTrashed(final boolean trashed) { + return proxy.setTrashed(trashed); + } + + @Override + public Map getMetadata() { + return proxy.getMetadata(); + } + + @Override + public PathAttributes setMetadata(final Map metadata) { + return proxy.setMetadata(metadata); + } + + @Override + public String getRegion() { + return proxy.getRegion(); + } + + @Override + public PathAttributes setRegion(final String region) { + return proxy.setRegion(region); + } + + @Override + public String getDisplayname() { + return proxy.getDisplayname(); + } + + @Override + public PathAttributes setDisplayname(final String displayname) { + return proxy.setDisplayname(displayname); + } + + @Override + public DescriptiveUrl getLink() { + return proxy.getLink(); + } + + @Override + public PathAttributes setLink(final DescriptiveUrl link) { + return proxy.setLink(link); + } + + @Override + public Map getCustom() { + return proxy.getCustom(); + } + + @Override + public PathAttributes setCustom(final Map custom) { + return proxy.setCustom(custom); + } + + @Override + public PathAttributes setCustom(final String key, final String value) { + return proxy.setCustom(key, value); + } + + @Override + public Verdict getVerdict() { + return proxy.getVerdict(); + } + + @Override + public PathAttributes setVerdict(final Verdict verdict) { + return proxy.setVerdict(verdict); + } + + @Override + public long getSize() { + return proxy.getSize(); + } + + @Override + public long getModificationDate() { + return proxy.getModificationDate(); + } + + @Override + public long getCreationDate() { + return proxy.getCreationDate(); + } + + @Override + public long getAccessedDate() { + return proxy.getAccessedDate(); + } + + @Override + public Permission getPermission() { + return proxy.getPermission(); + } + + @Override + public String getOwner() { + return proxy.getOwner(); + } + + @Override + public String getGroup() { + return proxy.getGroup(); + } + + @Override + public T serialize(final Serializer dict) { + return proxy.serialize(dict); + } +} diff --git a/core/src/main/java/ch/cyberduck/core/profiles/RemoteProfilesFinder.java b/core/src/main/java/ch/cyberduck/core/profiles/RemoteProfilesFinder.java index 686b1e7cbb..c8cf0cd38f 100644 --- a/core/src/main/java/ch/cyberduck/core/profiles/RemoteProfilesFinder.java +++ b/core/src/main/java/ch/cyberduck/core/profiles/RemoteProfilesFinder.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.profiles; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledProgressListener; @@ -97,7 +98,7 @@ public class RemoteProfilesFinder implements ProfilesFinder { final Read read = session.getFeature(Read.class); log.info("Download profile {}", file); // Read latest version - try(InputStream in = read.read(file.withAttributes(new PathAttributes(file.attributes()) + try(InputStream in = read.read(file.withAttributes(new DefaultPathAttributes(file.attributes()) // Read latest version .setVersionId(null)), new TransferStatus().setLength(TransferStatus.UNKNOWN_LENGTH), new DisabledConnectionCallback()); OutputStream out = local.getOutputStream(false)) { IOUtils.copy(in, out); diff --git a/core/src/main/java/ch/cyberduck/core/serializer/PathAttributesDictionary.java b/core/src/main/java/ch/cyberduck/core/serializer/PathAttributesDictionary.java index 0ad7f805a2..a55f7ed81a 100644 --- a/core/src/main/java/ch/cyberduck/core/serializer/PathAttributesDictionary.java +++ b/core/src/main/java/ch/cyberduck/core/serializer/PathAttributesDictionary.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.serializer; * feedback@cyberduck.ch */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.DeserializerFactory; import ch.cyberduck.core.PathAttributes; @@ -42,7 +43,7 @@ public class PathAttributesDictionary { public PathAttributes deserialize(final T serialized) { final Deserializer dict = factory.create(serialized); - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); final String sizeObj = dict.stringForKey("Size"); if(sizeObj != null) { attributes.setSize(Long.parseLong(sizeObj)); diff --git a/core/src/main/java/ch/cyberduck/core/synchronization/DefaultComparePathFilter.java b/core/src/main/java/ch/cyberduck/core/synchronization/DefaultComparePathFilter.java index 7d034c3edd..156a00e1f2 100644 --- a/core/src/main/java/ch/cyberduck/core/synchronization/DefaultComparePathFilter.java +++ b/core/src/main/java/ch/cyberduck/core/synchronization/DefaultComparePathFilter.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.synchronization; * dkocher@cyberduck.ch */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Local; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; @@ -67,7 +68,7 @@ public class DefaultComparePathFilter implements ComparePathFilter { return Comparison.equal; } final PathAttributes remote = attribute.find(file); - final PathAttributes current = new PathAttributes() + final PathAttributes current = new DefaultPathAttributes() .setModificationDate(local.attributes().getModificationDate()) .setSize(local.attributes().getSize()); // We must always compare the size because the download filter will have already created a temporary 0 byte file diff --git a/core/src/test/java/ch/cyberduck/core/DefaultPathPredicateTest.java b/core/src/test/java/ch/cyberduck/core/DefaultPathPredicateTest.java index c9d8896c99..3aa4b971bf 100644 --- a/core/src/test/java/ch/cyberduck/core/DefaultPathPredicateTest.java +++ b/core/src/test/java/ch/cyberduck/core/DefaultPathPredicateTest.java @@ -76,34 +76,34 @@ public class DefaultPathPredicateTest { @Test public void testPredicateVersionIdFile() { - final Path t = new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setVersionId("1")); + final Path t = new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setVersionId("1")); assertTrue(new DefaultPathPredicate(t).test(t)); - assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setVersionId("1")))); - assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setVersionId("2")))); + assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setVersionId("1")))); + assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setVersionId("2")))); } @Test public void testPredicateFileIdFile() { - final Path t = new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setFileId("1")); + final Path t = new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setFileId("1")); assertTrue(new DefaultPathPredicate(t).test(t)); - assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setFileId("1")))); - assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setFileId("2")))); + assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setFileId("1")))); + assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setFileId("2")))); } @Test public void testPredicateVersionIdDirectory() { - final Path t = new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setVersionId("1")); + final Path t = new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setVersionId("1")); assertTrue(new DefaultPathPredicate(t).test(t)); - assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setVersionId("1")))); - assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setVersionId("2")))); + assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setVersionId("1")))); + assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setVersionId("2")))); } @Test public void testPredicateFileIdDirectory() { - final Path t = new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setFileId("1")); + final Path t = new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setFileId("1")); assertTrue(new DefaultPathPredicate(t).test(t)); - assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setFileId("1")))); - assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new PathAttributes().setFileId("2")))); + assertTrue(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setFileId("1")))); + assertFalse(new DefaultPathPredicate(t).test(new Path("/f", EnumSet.of(Path.Type.directory), new DefaultPathAttributes().setFileId("2")))); } @Test diff --git a/core/src/test/java/ch/cyberduck/core/PathAttributesTest.java b/core/src/test/java/ch/cyberduck/core/PathAttributesTest.java index d6c8215cad..35da8f4d8f 100644 --- a/core/src/test/java/ch/cyberduck/core/PathAttributesTest.java +++ b/core/src/test/java/ch/cyberduck/core/PathAttributesTest.java @@ -17,7 +17,7 @@ public class PathAttributesTest { @Test public void testCopy() { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(1L); attributes.setQuota(new Quota.Space(1L, 10L)); attributes.setModificationDate(System.currentTimeMillis()); @@ -31,7 +31,7 @@ public class PathAttributesTest { attributes.setVerdict(PathAttributes.Verdict.pending); attributes.setTrashed(true); attributes.setHidden(true); - final PathAttributes clone = new PathAttributes(attributes); + final PathAttributes clone = new DefaultPathAttributes(attributes); assertEquals(clone.getPermission(), attributes.getPermission()); assertEquals(clone.getModificationDate(), attributes.getModificationDate()); assertEquals(clone, attributes); @@ -49,7 +49,7 @@ public class PathAttributesTest { @Test public void testPermissions() { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); assertNull(attributes.getOwner()); assertNull(attributes.getGroup()); assertNotNull(attributes.getPermission()); @@ -59,17 +59,17 @@ public class PathAttributesTest { @Test public void testEquals() { - assertEquals(new PathAttributes(), new PathAttributes()); - final PathAttributes r1 = new PathAttributes(); + assertEquals(new DefaultPathAttributes(), new DefaultPathAttributes()); + final PathAttributes r1 = new DefaultPathAttributes(); r1.setVersionId("r1"); - final PathAttributes r2 = new PathAttributes(); + final PathAttributes r2 = new DefaultPathAttributes(); r2.setVersionId("r2"); assertNotEquals(r1, r2); } @Test public void testSerialize() { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(100); attributes.setModificationDate(System.currentTimeMillis()); attributes.setPermission(new Permission("644")); diff --git a/core/src/test/java/ch/cyberduck/core/PathCacheTest.java b/core/src/test/java/ch/cyberduck/core/PathCacheTest.java index e1ced7d977..50bfd7a48f 100644 --- a/core/src/test/java/ch/cyberduck/core/PathCacheTest.java +++ b/core/src/test/java/ch/cyberduck/core/PathCacheTest.java @@ -69,7 +69,7 @@ public class PathCacheTest { @Test public void testDirectoryWithFileIdDefaultPredicate() { final PathCache cache = new PathCache(1); - final Path f = new Path("/", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setFileId("1")); + final Path f = new Path("/", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setFileId("1")); assertFalse(cache.containsKey(f)); cache.put(f, new AttributedList<>()); assertTrue(cache.containsKey(f)); @@ -86,7 +86,7 @@ public class PathCacheTest { return new SimplePathPredicate(file); } }; - final Path f = new Path("/", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setFileId("1")); + final Path f = new Path("/", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setFileId("1")); assertFalse(cache.containsKey(f)); cache.put(f, new AttributedList<>()); assertTrue(cache.containsKey(f)); diff --git a/core/src/test/java/ch/cyberduck/core/TestPermissionAttributes.java b/core/src/test/java/ch/cyberduck/core/TestPermissionAttributes.java index 9cc8670ead..7b568ab210 100644 --- a/core/src/test/java/ch/cyberduck/core/TestPermissionAttributes.java +++ b/core/src/test/java/ch/cyberduck/core/TestPermissionAttributes.java @@ -1,6 +1,6 @@ package ch.cyberduck.core; -public class TestPermissionAttributes extends PathAttributes { +public class TestPermissionAttributes extends DefaultPathAttributes { public TestPermissionAttributes(Permission.Action action) { this(action, action); } diff --git a/core/src/test/java/ch/cyberduck/core/serializer/PathAttributesDictionaryTest.java b/core/src/test/java/ch/cyberduck/core/serializer/PathAttributesDictionaryTest.java index acd669b5ff..1e4d1a91d4 100644 --- a/core/src/test/java/ch/cyberduck/core/serializer/PathAttributesDictionaryTest.java +++ b/core/src/test/java/ch/cyberduck/core/serializer/PathAttributesDictionaryTest.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.serializer; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.Permission; @@ -29,7 +30,7 @@ public class PathAttributesDictionaryTest { @Test public void testSerialize() { - PathAttributes attributes = new PathAttributes(); + PathAttributes attributes = new DefaultPathAttributes(); attributes.setOwner("u"); attributes.setGroup("g"); attributes.setTrashed(true); @@ -48,7 +49,7 @@ public class PathAttributesDictionaryTest { @Test public void testGetAsDictionary() { - PathAttributes attributes = new PathAttributes(); + PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(3L); attributes.setChecksum(Checksum.parse("da39a3ee5e6b4b0d3255bfef95601890afd80709")); attributes.setModificationDate(5343L); @@ -62,7 +63,7 @@ public class PathAttributesDictionaryTest { @Test public void testSerializeHashCode() { - PathAttributes attributes = new PathAttributes(); + PathAttributes attributes = new DefaultPathAttributes(); attributes.setPermission(new Permission(644)); attributes.setDuplicate(true); attributes.setVersionId("v-1"); diff --git a/core/src/test/java/ch/cyberduck/core/shared/ListFilteringFeatureTest.java b/core/src/test/java/ch/cyberduck/core/shared/ListFilteringFeatureTest.java index 8a7dc3da17..a23aaef5e7 100644 --- a/core/src/test/java/ch/cyberduck/core/shared/ListFilteringFeatureTest.java +++ b/core/src/test/java/ch/cyberduck/core/shared/ListFilteringFeatureTest.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.shared; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.Protocol; @@ -37,32 +38,32 @@ public class ListFilteringFeatureTest { assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file))).test( new Path(Home.root(), "F", EnumSet.of(Path.Type.file)) )); - assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v1")) + assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v1")) )); - assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v2")) + assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v2")) )); - assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setVersionId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setVersionId("v2")) + assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setVersionId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setVersionId("v2")) )); - assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setFileId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setFileId("v1")) + assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setFileId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setFileId("v1")) )); - assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setFileId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setFileId("v2")) + assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setFileId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setFileId("v2")) )); - assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setFileId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new PathAttributes().setFileId("v2")) + assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setFileId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.directory)).withAttributes(new DefaultPathAttributes().setFileId("v2")) )); assertTrue(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v1")) + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v1")) )); - assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setVersionId("v1"))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes()) + assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setVersionId("v1"))).test( + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes()) )); assertFalse(new ListFilteringFeature.ListFilteringPredicate(Protocol.Case.insensitive, new Path(Home.root(), "f", EnumSet.of(Path.Type.file))).test( - new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes() { + new Path(Home.root(), "f", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes() { @Override public boolean isDuplicate() { return true; diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/ChainedComparisonServiceTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/ChainedComparisonServiceTest.java index dd937b1e43..2c8989ed1d 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/ChainedComparisonServiceTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/ChainedComparisonServiceTest.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.synchronization; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -30,31 +31,31 @@ public class ChainedComparisonServiceTest { @Test public void testCompare() { assertEquals(Comparison.equal, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L), new PathAttributes().setModificationDate(1000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L), new DefaultPathAttributes().setModificationDate(1000L) )); assertEquals(Comparison.equal, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L).setSize(1000L), new PathAttributes().setModificationDate(1000L).setSize(1000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L).setSize(1000L), new DefaultPathAttributes().setModificationDate(1000L).setSize(1000L) )); assertEquals(Comparison.remote, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L), new PathAttributes().setModificationDate(2000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L), new DefaultPathAttributes().setModificationDate(2000L) )); assertEquals(Comparison.remote, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L).setSize(1000L), new PathAttributes().setModificationDate(2000L).setSize(1000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L).setSize(1000L), new DefaultPathAttributes().setModificationDate(2000L).setSize(1000L) )); assertEquals(Comparison.unknown, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes(), new PathAttributes() + Path.Type.file, new DefaultPathAttributes(), new DefaultPathAttributes() )); assertEquals(Comparison.equal, new ChainedComparisonService(new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L).setSize(1000L), new PathAttributes().setModificationDate(1000L).setSize(2000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L).setSize(1000L), new DefaultPathAttributes().setModificationDate(1000L).setSize(2000L) )); assertEquals(Comparison.notequal, new ChainedComparisonService(EnumSet.of(Comparison.unknown, Comparison.equal), new TimestampComparisonService(), new SizeComparisonService()).compare( - Path.Type.file, new PathAttributes().setModificationDate(1000L).setSize(1000L), new PathAttributes().setModificationDate(1000L).setSize(2000L) + Path.Type.file, new DefaultPathAttributes().setModificationDate(1000L).setSize(1000L), new DefaultPathAttributes().setModificationDate(1000L).setSize(2000L) )); } @Test public void testHashCode() { - final PathAttributes attr = new PathAttributes().setModificationDate(1000L).setSize(2L); + final PathAttributes attr = new DefaultPathAttributes().setModificationDate(1000L).setSize(2L); assertEquals(0, new ChainedComparisonService(new TimestampComparisonService()).hashCode(Path.Type.file, PathAttributes.EMPTY)); assertNotEquals(0, new ChainedComparisonService(new TimestampComparisonService()).hashCode(Path.Type.file, attr)); assertEquals(new ChainedComparisonService(new TimestampComparisonService()).hashCode(Path.Type.file, attr), diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/ChecksumComparisonServiceTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/ChecksumComparisonServiceTest.java index b5b2749c6c..6a9153a03b 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/ChecksumComparisonServiceTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/ChecksumComparisonServiceTest.java @@ -1,5 +1,6 @@ package ch.cyberduck.core.synchronization; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.io.Checksum; @@ -14,26 +15,26 @@ public class ChecksumComparisonServiceTest { @Test public void testCompare() { ComparisonService s = new ChecksumComparisonService(); - assertEquals(Comparison.equal, s.compare(Path.Type.file, new PathAttributes() { + assertEquals(Comparison.equal, s.compare(Path.Type.file, new DefaultPathAttributes() { @Override public Checksum getChecksum() { return new Checksum(HashAlgorithm.md5, "a"); } - }, new PathAttributes().setChecksum(new Checksum(HashAlgorithm.md5, "a")) + }, new DefaultPathAttributes().setChecksum(new Checksum(HashAlgorithm.md5, "a")) )); - assertEquals(Comparison.notequal, s.compare(Path.Type.file, new PathAttributes() { + assertEquals(Comparison.notequal, s.compare(Path.Type.file, new DefaultPathAttributes() { @Override public Checksum getChecksum() { return new Checksum(HashAlgorithm.md5, "b"); } - }, new PathAttributes().setChecksum(new Checksum(HashAlgorithm.md5, "a")))); + }, new DefaultPathAttributes().setChecksum(new Checksum(HashAlgorithm.md5, "a")))); } @Test public void testDirectory() { ComparisonService s = new ChecksumComparisonService(); - assertEquals(Comparison.unknown, s.compare(Path.Type.directory, new PathAttributes(), - new PathAttributes())); + assertEquals(Comparison.unknown, s.compare(Path.Type.directory, new DefaultPathAttributes(), + new DefaultPathAttributes())); } } diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparePathFilterTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparePathFilterTest.java index 5edaaaedd5..d2cab680de 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparePathFilterTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparePathFilterTest.java @@ -1,6 +1,7 @@ package ch.cyberduck.core.synchronization; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.ListProgressListener; @@ -36,7 +37,7 @@ public class DefaultComparePathFilterTest { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { attr.set(true); - return new PathAttributes() { + return new DefaultPathAttributes() { @Override public Checksum getChecksum() { return new Checksum(HashAlgorithm.md5, "a"); @@ -163,7 +164,7 @@ public class DefaultComparePathFilterTest { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { attr.set(true); - return new PathAttributes() { + return new DefaultPathAttributes() { @Override public Checksum getChecksum() { return new Checksum(HashAlgorithm.md5, "b"); diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparisonServiceTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparisonServiceTest.java index 04e380ad0b..b99a44043e 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparisonServiceTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/DefaultComparisonServiceTest.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.synchronization; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.TestProtocol; @@ -28,14 +29,14 @@ public class DefaultComparisonServiceTest { @Test public void testCompareFile() { final DefaultComparisonService c = new DefaultComparisonService(new TestProtocol()); - assertEquals(Comparison.equal, c.compare(Path.Type.file, new PathAttributes().setETag("1"), new PathAttributes().setETag("1"))); - assertEquals(1519, c.hashCode(Path.Type.file, new PathAttributes().setETag("1"))); - assertEquals(Comparison.unknown, c.compare(Path.Type.file, new PathAttributes().setETag("1"), new PathAttributes().setETag("2"))); - assertEquals(Comparison.equal, c.compare(Path.Type.file, new PathAttributes().setETag("1").setSize(1000L), new PathAttributes().setETag("2").setSize(1000L))); - assertEquals(Comparison.equal, c.compare(Path.Type.file, new PathAttributes().setETag("1").setSize(1000L).setModificationDate(1680879106939L), new PathAttributes().setETag("2").setSize(1000L).setModificationDate(1680879106939L))); - assertEquals(709040760, c.hashCode(Path.Type.file, new PathAttributes().setETag("1").setModificationDate(1680879106939L))); - assertEquals(709040760, c.hashCode(Path.Type.file, new PathAttributes().setETag("1").setModificationDate(1680879106000L))); - assertEquals(Comparison.local, c.compare(Path.Type.file, new PathAttributes().setETag("1").setSize(1000L).setModificationDate(1680879107939L), new PathAttributes().setETag("2").setSize(1000L).setModificationDate(1680879106939L))); + assertEquals(Comparison.equal, c.compare(Path.Type.file, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("1"))); + assertEquals(1519, c.hashCode(Path.Type.file, new DefaultPathAttributes().setETag("1"))); + assertEquals(Comparison.unknown, c.compare(Path.Type.file, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("2"))); + assertEquals(Comparison.equal, c.compare(Path.Type.file, new DefaultPathAttributes().setETag("1").setSize(1000L), new DefaultPathAttributes().setETag("2").setSize(1000L))); + assertEquals(Comparison.equal, c.compare(Path.Type.file, new DefaultPathAttributes().setETag("1").setSize(1000L).setModificationDate(1680879106939L), new DefaultPathAttributes().setETag("2").setSize(1000L).setModificationDate(1680879106939L))); + assertEquals(709040760, c.hashCode(Path.Type.file, new DefaultPathAttributes().setETag("1").setModificationDate(1680879106939L))); + assertEquals(709040760, c.hashCode(Path.Type.file, new DefaultPathAttributes().setETag("1").setModificationDate(1680879106000L))); + assertEquals(Comparison.local, c.compare(Path.Type.file, new DefaultPathAttributes().setETag("1").setSize(1000L).setModificationDate(1680879107939L), new DefaultPathAttributes().setETag("2").setSize(1000L).setModificationDate(1680879106939L))); } @Test @@ -47,13 +48,13 @@ public class DefaultComparisonServiceTest { return DirectoryTimestamp.implicit; } }); - assertEquals(Comparison.equal, c.compare(Path.Type.directory, new PathAttributes().setETag("1"), new PathAttributes().setETag("1"))); - assertEquals(1519, c.hashCode(Path.Type.directory, new PathAttributes().setETag("1"))); - assertEquals(Comparison.notequal, c.compare(Path.Type.directory, new PathAttributes().setETag("1"), new PathAttributes().setETag("2"))); - assertEquals(Comparison.equal, c.compare(Path.Type.directory, new PathAttributes().setModificationDate(1680879106939L), new PathAttributes().setModificationDate(1680879106939L))); - assertEquals(1546892887, c.hashCode(Path.Type.directory, new PathAttributes().setModificationDate(1680879106939L))); - assertEquals(1546892887, c.hashCode(Path.Type.directory, new PathAttributes().setModificationDate(1680879106000L))); - assertEquals(Comparison.local, c.compare(Path.Type.directory, new PathAttributes().setModificationDate(1680879107939L), new PathAttributes().setModificationDate(1680879106939L))); + assertEquals(Comparison.equal, c.compare(Path.Type.directory, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("1"))); + assertEquals(1519, c.hashCode(Path.Type.directory, new DefaultPathAttributes().setETag("1"))); + assertEquals(Comparison.notequal, c.compare(Path.Type.directory, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("2"))); + assertEquals(Comparison.equal, c.compare(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879106939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); + assertEquals(1546892887, c.hashCode(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879106939L))); + assertEquals(1546892887, c.hashCode(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879106000L))); + assertEquals(Comparison.local, c.compare(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879107939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); } { final DefaultComparisonService c = new DefaultComparisonService(new TestProtocol() { @@ -62,20 +63,20 @@ public class DefaultComparisonServiceTest { return DirectoryTimestamp.explicit; } }); - assertEquals(0, c.hashCode(Path.Type.directory, new PathAttributes())); - assertEquals(Comparison.equal, c.compare(Path.Type.directory, new PathAttributes().setETag("1"), new PathAttributes().setETag("1"))); - assertEquals(1519, c.hashCode(Path.Type.directory, new PathAttributes().setETag("1"))); - assertEquals(Comparison.notequal, c.compare(Path.Type.directory, new PathAttributes().setETag("1"), new PathAttributes().setETag("2"))); - assertEquals(Comparison.unknown, c.compare(Path.Type.directory, new PathAttributes().setModificationDate(1680879106939L), new PathAttributes().setModificationDate(1680879106939L))); - assertEquals(0, c.hashCode(Path.Type.directory, new PathAttributes().setModificationDate(1680879106939L))); - assertEquals(Comparison.unknown, c.compare(Path.Type.directory, new PathAttributes().setModificationDate(1680879107939L), new PathAttributes().setModificationDate(1680879106939L))); + assertEquals(0, c.hashCode(Path.Type.directory, new DefaultPathAttributes())); + assertEquals(Comparison.equal, c.compare(Path.Type.directory, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("1"))); + assertEquals(1519, c.hashCode(Path.Type.directory, new DefaultPathAttributes().setETag("1"))); + assertEquals(Comparison.notequal, c.compare(Path.Type.directory, new DefaultPathAttributes().setETag("1"), new DefaultPathAttributes().setETag("2"))); + assertEquals(Comparison.unknown, c.compare(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879106939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); + assertEquals(0, c.hashCode(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879106939L))); + assertEquals(Comparison.unknown, c.compare(Path.Type.directory, new DefaultPathAttributes().setModificationDate(1680879107939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); } } @Test public void testCompareSymlink() { final DefaultComparisonService c = new DefaultComparisonService(new TestProtocol()); - assertEquals(Comparison.equal, c.compare(Path.Type.symboliclink, new PathAttributes().setModificationDate(1680879106939L), new PathAttributes().setModificationDate(1680879106939L))); - assertEquals(Comparison.local, c.compare(Path.Type.symboliclink, new PathAttributes().setModificationDate(1680879107939L), new PathAttributes().setModificationDate(1680879106939L))); + assertEquals(Comparison.equal, c.compare(Path.Type.symboliclink, new DefaultPathAttributes().setModificationDate(1680879106939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); + assertEquals(Comparison.local, c.compare(Path.Type.symboliclink, new DefaultPathAttributes().setModificationDate(1680879107939L), new DefaultPathAttributes().setModificationDate(1680879106939L))); } } \ No newline at end of file diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/SizeComparisonServiceTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/SizeComparisonServiceTest.java index 2024a6f12c..d411f34dc4 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/SizeComparisonServiceTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/SizeComparisonServiceTest.java @@ -1,5 +1,6 @@ package ch.cyberduck.core.synchronization; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -12,9 +13,9 @@ public class SizeComparisonServiceTest { @Test public void testCompare() { ComparisonService s = new SizeComparisonService(); - assertEquals(Comparison.remote, s.compare(Path.Type.file, new PathAttributes().setSize(0L), new PathAttributes().setSize(1L))); - assertEquals(Comparison.local, s.compare(Path.Type.file, new PathAttributes().setSize(1L), new PathAttributes().setSize(0L))); - assertEquals(Comparison.equal, s.compare(Path.Type.file, new PathAttributes().setSize(1L), new PathAttributes().setSize(1L))); - assertEquals(Comparison.notequal, s.compare(Path.Type.file, new PathAttributes().setSize(2L), new PathAttributes().setSize(1L))); + assertEquals(Comparison.remote, s.compare(Path.Type.file, new DefaultPathAttributes().setSize(0L), new DefaultPathAttributes().setSize(1L))); + assertEquals(Comparison.local, s.compare(Path.Type.file, new DefaultPathAttributes().setSize(1L), new DefaultPathAttributes().setSize(0L))); + assertEquals(Comparison.equal, s.compare(Path.Type.file, new DefaultPathAttributes().setSize(1L), new DefaultPathAttributes().setSize(1L))); + assertEquals(Comparison.notequal, s.compare(Path.Type.file, new DefaultPathAttributes().setSize(2L), new DefaultPathAttributes().setSize(1L))); } } diff --git a/core/src/test/java/ch/cyberduck/core/synchronization/TimestampComparisonServiceTest.java b/core/src/test/java/ch/cyberduck/core/synchronization/TimestampComparisonServiceTest.java index 22e8fbdc2b..40962dc033 100644 --- a/core/src/test/java/ch/cyberduck/core/synchronization/TimestampComparisonServiceTest.java +++ b/core/src/test/java/ch/cyberduck/core/synchronization/TimestampComparisonServiceTest.java @@ -1,5 +1,6 @@ package ch.cyberduck.core.synchronization; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -17,12 +18,12 @@ public class TimestampComparisonServiceTest { public void testCompareEqual() { TimestampComparisonService s = new TimestampComparisonService(); final long timestamp = System.currentTimeMillis(); - assertEquals(Comparison.equal, s.compare(Path.Type.file, new PathAttributes().setModificationDate(timestamp), new PathAttributes().setModificationDate(timestamp))); - final int hashCode = s.hashCode(Path.Type.file, new PathAttributes().setModificationDate(timestamp)); - assertEquals(Comparison.equal, s.compare(Path.Type.file, new PathAttributes().setModificationDate(timestamp), new PathAttributes().setModificationDate( + assertEquals(Comparison.equal, s.compare(Path.Type.file, new DefaultPathAttributes().setModificationDate(timestamp), new DefaultPathAttributes().setModificationDate(timestamp))); + final int hashCode = s.hashCode(Path.Type.file, new DefaultPathAttributes().setModificationDate(timestamp)); + assertEquals(Comparison.equal, s.compare(Path.Type.file, new DefaultPathAttributes().setModificationDate(timestamp), new DefaultPathAttributes().setModificationDate( TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(timestamp)) ))); - assertEquals(hashCode, s.hashCode(Path.Type.file, new PathAttributes().setModificationDate( + assertEquals(hashCode, s.hashCode(Path.Type.file, new DefaultPathAttributes().setModificationDate( TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(timestamp)) ))); } @@ -32,8 +33,9 @@ public class TimestampComparisonServiceTest { TimestampComparisonService s = new TimestampComparisonService(); final long timestamp = Calendar.getInstance(TimeZone.getDefault()).getTimeInMillis(); assertEquals(Comparison.local, s.compare(Path.Type.file, - new PathAttributes().setModificationDate(timestamp), - new PathAttributes() { + new DefaultPathAttributes().setModificationDate(timestamp), + new + DefaultPathAttributes() { @Override public long getModificationDate() { final Calendar c = Calendar.getInstance(TimeZone.getDefault()); diff --git a/core/src/test/java/ch/cyberduck/core/transfer/SyncTransferTest.java b/core/src/test/java/ch/cyberduck/core/transfer/SyncTransferTest.java index db4f27f0a8..f3266c09c0 100644 --- a/core/src/test/java/ch/cyberduck/core/transfer/SyncTransferTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/SyncTransferTest.java @@ -18,20 +18,7 @@ package ch.cyberduck.core.transfer; * dkocher@cyberduck.ch */ -import ch.cyberduck.core.AttributedList; -import ch.cyberduck.core.DisabledListProgressListener; -import ch.cyberduck.core.DisabledProgressListener; -import ch.cyberduck.core.Host; -import ch.cyberduck.core.ListProgressListener; -import ch.cyberduck.core.Local; -import ch.cyberduck.core.LocalAttributes; -import ch.cyberduck.core.NullLocal; -import ch.cyberduck.core.NullSession; -import ch.cyberduck.core.NullTransferSession; -import ch.cyberduck.core.Path; -import ch.cyberduck.core.PathAttributes; -import ch.cyberduck.core.PathCache; -import ch.cyberduck.core.TestProtocol; +import ch.cyberduck.core.*; import ch.cyberduck.core.local.DefaultLocalDirectoryFeature; import ch.cyberduck.core.synchronization.Comparison; @@ -118,8 +105,8 @@ public class SyncTransferTest { @Test public void testFilterMirror() throws Exception { final Path p = new Path("t", EnumSet.of(Path.Type.directory)); - final Path a = new Path(p, "a", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setSize(2L)); - final Path b = new Path(p, "b", EnumSet.of(Path.Type.file)).withAttributes(new PathAttributes().setSize(1L)); + final Path a = new Path(p, "a", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setSize(2L)); + final Path b = new Path(p, "b", EnumSet.of(Path.Type.file)).withAttributes(new DefaultPathAttributes().setSize(1L)); final PathCache cache = new PathCache(1); cache.put(p, new AttributedList<>(Arrays.asList(a, b))); SyncTransfer t = new SyncTransfer(new Host(new TestProtocol()), new TransferItem(p, new NullLocal(System.getProperty("java.io.tmpdir"), "t"))); diff --git a/core/src/test/java/ch/cyberduck/core/transfer/UploadTransferTest.java b/core/src/test/java/ch/cyberduck/core/transfer/UploadTransferTest.java index 97a053aac6..a7fd694fbb 100755 --- a/core/src/test/java/ch/cyberduck/core/transfer/UploadTransferTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/UploadTransferTest.java @@ -393,7 +393,7 @@ public class UploadTransferTest { return (T) new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; } diff --git a/core/src/test/java/ch/cyberduck/core/transfer/upload/OverwriteFilterTest.java b/core/src/test/java/ch/cyberduck/core/transfer/upload/OverwriteFilterTest.java index ace7c02764..df16df913a 100644 --- a/core/src/test/java/ch/cyberduck/core/transfer/upload/OverwriteFilterTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/upload/OverwriteFilterTest.java @@ -1,6 +1,7 @@ package ch.cyberduck.core.transfer.upload; import ch.cyberduck.core.Acl; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.ListProgressListener; @@ -144,7 +145,7 @@ public class OverwriteFilterTest { final AttributesFinder attributes = new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; final Find find = new Find() { diff --git a/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameExistingFilterTest.java b/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameExistingFilterTest.java index 2ed4339a9a..0dc13a1827 100755 --- a/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameExistingFilterTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameExistingFilterTest.java @@ -2,6 +2,7 @@ package ch.cyberduck.core.transfer.upload; import ch.cyberduck.core.AttributedList; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.ListProgressListener; @@ -106,7 +107,7 @@ public class RenameExistingFilterTest { final AttributesFinder attributes = new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; final Host host = new Host(new TestProtocol()); @@ -189,7 +190,7 @@ public class RenameExistingFilterTest { final AttributesFinder attributes = new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; final Host host = new Host(new TestProtocol()); diff --git a/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameFilterTest.java b/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameFilterTest.java index 9312ae229d..d5d664cb0e 100644 --- a/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameFilterTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/upload/RenameFilterTest.java @@ -1,5 +1,6 @@ package ch.cyberduck.core.transfer.upload; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.ListProgressListener; @@ -37,7 +38,7 @@ public class RenameFilterTest { final AttributesFinder attributes = new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; final Find find = new Find() { @@ -78,7 +79,7 @@ public class RenameFilterTest { final AttributesFinder attributes = new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { - return new PathAttributes(); + return new DefaultPathAttributes(); } }; final Find find = new Find() { diff --git a/core/src/test/java/ch/cyberduck/core/transfer/upload/ResumeFilterTest.java b/core/src/test/java/ch/cyberduck/core/transfer/upload/ResumeFilterTest.java index 6ffa1ec320..96a8a5ad78 100644 --- a/core/src/test/java/ch/cyberduck/core/transfer/upload/ResumeFilterTest.java +++ b/core/src/test/java/ch/cyberduck/core/transfer/upload/ResumeFilterTest.java @@ -1,6 +1,7 @@ package ch.cyberduck.core.transfer.upload; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.ListProgressListener; @@ -150,7 +151,7 @@ public class ResumeFilterTest { @Override public AttributedList list(final Path folder, final ListProgressListener listener) throws BackgroundException { final AttributedList list = new AttributedList<>(Collections.singletonList(new Path(folder, "t", EnumSet.of(Path.Type.file)) - .withAttributes(new PathAttributes().setSize(3L)))); + .withAttributes(new DefaultPathAttributes().setSize(3L)))); listener.chunk(folder, list); return list; } @@ -189,7 +190,7 @@ public class ResumeFilterTest { @Override public AttributedList list(final Path folder, final ListProgressListener listener) throws BackgroundException { final AttributedList list = new AttributedList<>(Collections.singletonList(new Path(folder, "t", EnumSet.of(Path.Type.file)) - .withAttributes(new PathAttributes().setSize(2L)))); + .withAttributes(new DefaultPathAttributes().setSize(2L)))); listener.chunk(folder, list); return list; } @@ -234,7 +235,7 @@ public class ResumeFilterTest { @Override public AttributedList list(final Path folder, final ListProgressListener listener) throws BackgroundException { final AttributedList list = new AttributedList<>(Collections.singletonList(new Path(folder, "t", EnumSet.of(Path.Type.file)) - .withAttributes(new PathAttributes().setSize(4L)))); + .withAttributes(new DefaultPathAttributes().setSize(4L)))); listener.chunk(folder, list); return list; } diff --git a/core/src/test/java/ch/cyberduck/core/worker/MoveWorkerTest.java b/core/src/test/java/ch/cyberduck/core/worker/MoveWorkerTest.java index 453be867cf..07e8a3856f 100644 --- a/core/src/test/java/ch/cyberduck/core/worker/MoveWorkerTest.java +++ b/core/src/test/java/ch/cyberduck/core/worker/MoveWorkerTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.worker; import ch.cyberduck.core.AttributedList; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; @@ -84,7 +85,7 @@ public class MoveWorkerTest { if(type == Move.class) { return (T) new Move() { private final AtomicInteger count = new AtomicInteger(); - private final PathAttributes attr = new PathAttributes().setSize(1L); + private final PathAttributes attr = new DefaultPathAttributes().setSize(1L); @Override public Path move(final Path file, final Path renamed, final TransferStatus status, final Delete.Callback callback, final ConnectionCallback connectionCallback) { diff --git a/core/src/test/java/ch/cyberduck/core/worker/WriteMetadataWorkerTest.java b/core/src/test/java/ch/cyberduck/core/worker/WriteMetadataWorkerTest.java index 24b651d650..23b95e2611 100644 --- a/core/src/test/java/ch/cyberduck/core/worker/WriteMetadataWorkerTest.java +++ b/core/src/test/java/ch/cyberduck/core/worker/WriteMetadataWorkerTest.java @@ -1,5 +1,6 @@ package ch.cyberduck.core.worker; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Host; import ch.cyberduck.core.NullSession; @@ -210,7 +211,8 @@ public class WriteMetadataWorkerTest { @Test public void testRunDifferent() throws Exception { - final PathAttributes attributesA = new PathAttributes(); + final PathAttributes attributesA = new + DefaultPathAttributes(); { final Map map = new HashMap<>(); map.put("equal", "equal"); @@ -218,7 +220,7 @@ public class WriteMetadataWorkerTest { map.put("unique", "unique"); attributesA.setMetadata(map); } - final PathAttributes attributesB = new PathAttributes(); + final PathAttributes attributesB = new DefaultPathAttributes(); { final Map map = new HashMap<>(); map.put("equal", "equal"); diff --git a/core/src/test/java/ch/cyberduck/ui/browser/RecursiveSearchFilterTest.java b/core/src/test/java/ch/cyberduck/ui/browser/RecursiveSearchFilterTest.java index d9af34cc84..9270292cb1 100644 --- a/core/src/test/java/ch/cyberduck/ui/browser/RecursiveSearchFilterTest.java +++ b/core/src/test/java/ch/cyberduck/ui/browser/RecursiveSearchFilterTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.ui.browser; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -62,6 +63,6 @@ public class RecursiveSearchFilterTest { @Test public void testAcceptFileVersions() { final RecursiveSearchFilter f = new RecursiveSearchFilter(new AttributedList<>(Arrays.asList(new Path("/f", EnumSet.of(Path.Type.file))))); - assertTrue(f.accept(new Path("/f", EnumSet.of(Path.Type.file), new PathAttributes().setVersionId("1")))); + assertTrue(f.accept(new Path("/f", EnumSet.of(Path.Type.file), new DefaultPathAttributes().setVersionId("1")))); } } diff --git a/core/src/test/java/ch/cyberduck/ui/browser/SizeTooltipServiceTest.java b/core/src/test/java/ch/cyberduck/ui/browser/SizeTooltipServiceTest.java index 6be936c7ee..e42eaee103 100644 --- a/core/src/test/java/ch/cyberduck/ui/browser/SizeTooltipServiceTest.java +++ b/core/src/test/java/ch/cyberduck/ui/browser/SizeTooltipServiceTest.java @@ -15,6 +15,7 @@ package ch.cyberduck.ui.browser; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -31,7 +32,7 @@ public class SizeTooltipServiceTest { @Test public void testGetTooltip() { final SizeTooltipService s = new SizeTooltipService(); - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setSize(-1L); assertEquals("--", s.getTooltip(new Path("/p", EnumSet.of(Path.Type.file), attr))); attr.setSize(0L); diff --git a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/CryptoVault.java b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/CryptoVault.java index 57c4562346..ef40d3a7f3 100644 --- a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/CryptoVault.java +++ b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/CryptoVault.java @@ -126,10 +126,10 @@ public class CryptoVault implements Vault { final EnumSet type = EnumSet.copyOf(home.getType()); type.add(Path.Type.vault); if(home.isRoot()) { - this.vault = new Path(home.getAbsolute(), type, new PathAttributes(home.attributes())); + this.vault = new Path(home.getAbsolute(), type, new DefaultPathAttributes(home.attributes())); } else { - this.vault = new Path(home.getParent(), home.getName(), type, new PathAttributes(home.attributes())); + this.vault = new Path(home.getParent(), home.getName(), type, new DefaultPathAttributes(home.attributes())); } } @@ -427,7 +427,7 @@ public class CryptoVault implements Vault { parent = directoryProvider.toEncrypted(session, file.getParent().attributes().getDirectoryId(), file.getParent()); filename = directoryProvider.toEncrypted(session, parent.attributes().getDirectoryId(), file.getName(), file.getType()); } - final PathAttributes attributes = new PathAttributes(file.attributes()); + final PathAttributes attributes = new DefaultPathAttributes(file.attributes()); attributes.setDirectoryId(null); if(!file.isFile() && !metadata) { // The directory is different from the metadata file used to resolve the actual folder @@ -484,7 +484,7 @@ public class CryptoVault implements Vault { final String cleartextFilename = fileNameCryptor.decryptFilename( vaultVersion == VAULT_VERSION_DEPRECATED ? BaseEncoding.base32() : BaseEncoding.base64Url(), ciphertext, file.getParent().attributes().getDirectoryId().getBytes(StandardCharsets.UTF_8)); - final PathAttributes attributes = new PathAttributes(file.attributes()); + final PathAttributes attributes = new DefaultPathAttributes(file.attributes()); if(this.isDirectory(inflated)) { if(Permission.EMPTY != attributes.getPermission()) { final Permission permission = new Permission(attributes.getPermission()); diff --git a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoAttributesFeature.java b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoAttributesFeature.java index 5276d3e3d0..cb2ac2eb71 100644 --- a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoAttributesFeature.java +++ b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoAttributesFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.cryptomator.features; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.MemoryListProgressListener; import ch.cyberduck.core.Path; @@ -41,7 +42,7 @@ public class CryptoAttributesFeature implements AttributesFinder { public PathAttributes find(final Path file, final ListProgressListener listener) throws BackgroundException { final MemoryListProgressListener memory = new MemoryListProgressListener(); // Fetch with any directory listing stored in memory encrypted - final PathAttributes attributes = new PathAttributes(delegate.find(vault.encrypt(session, file, true), memory)); + final PathAttributes attributes = new DefaultPathAttributes(delegate.find(vault.encrypt(session, file, true), memory)); final Path directory = file.getParent(); // Decrypt directory listing and forward to proxy new DecryptingListProgressListener(session, vault, directory, listener).chunk(directory, memory.getContents()); diff --git a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoCopyFeature.java b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoCopyFeature.java index 83d536d17b..03cbd6a03b 100644 --- a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoCopyFeature.java +++ b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoCopyFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.cryptomator.features; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.Session; @@ -73,7 +74,7 @@ public class CryptoCopyFeature implements Copy { public TransferStatus setResponse(final PathAttributes attributes) { status.setResponse(attributes); // Will be converted back to clear text when decrypting file below set in default copy feature implementation using writer. - super.setResponse(new PathAttributes(attributes).setSize(vault.toCiphertextSize(0L, attributes.getSize()))); + super.setResponse(new DefaultPathAttributes(attributes).setSize(vault.toCiphertextSize(0L, attributes.getSize()))); return this; } } : status, diff --git a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoTouchFeature.java b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoTouchFeature.java index e8864566a9..592f036709 100644 --- a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoTouchFeature.java +++ b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/features/CryptoTouchFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.cryptomator.features; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -54,7 +55,7 @@ public class CryptoTouchFeature implements Touch { public TransferStatus setResponse(final PathAttributes attributes) { status.setResponse(attributes); // Will be converted back to clear text when decrypting file below set in default touch feature implementation using writer. - super.setResponse(new PathAttributes(attributes).setSize(vault.toCiphertextSize(0L, attributes.getSize()))); + super.setResponse(new DefaultPathAttributes(attributes).setSize(vault.toCiphertextSize(0L, attributes.getSize()))); return this; } }); diff --git a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/impl/CryptoDirectoryV6Provider.java b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/impl/CryptoDirectoryV6Provider.java index 13b1323fb9..519f4f4bcf 100644 --- a/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/impl/CryptoDirectoryV6Provider.java +++ b/cryptomator/src/main/java/ch/cyberduck/core/cryptomator/impl/CryptoDirectoryV6Provider.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.cryptomator.impl; */ import ch.cyberduck.core.CacheReference; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.RandomStringService; @@ -78,7 +79,7 @@ public class CryptoDirectoryV6Provider implements CryptoDirectory { throw new NotfoundException(directory.getAbsolute()); } if(new SimplePathPredicate(directory).test(home) || directory.isChild(home)) { - final PathAttributes attributes = new PathAttributes(directory.attributes()); + final PathAttributes attributes = new DefaultPathAttributes(directory.attributes()); // The root of the vault is a different target directory and file ids always correspond to the metadata file attributes.setVersionId(null); attributes.setFileId(null); diff --git a/ctera/src/test/java/ch/cyberduck/core/ctera/CteraCopyFeatureTest.java b/ctera/src/test/java/ch/cyberduck/core/ctera/CteraCopyFeatureTest.java index dda1c97024..03898013a1 100644 --- a/ctera/src/test/java/ch/cyberduck/core/ctera/CteraCopyFeatureTest.java +++ b/ctera/src/test/java/ch/cyberduck/core/ctera/CteraCopyFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.ctera; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -77,7 +78,7 @@ public class CteraCopyFeatureTest extends AbstractCteraTest { target.getParent().setAttributes(target.getParent().attributes().setAcl(new Acl(new Acl.CanonicalUser(), CteraAttributesFinderFeature.CREATEDIRECTORIESPERMISSION))); final CteraAttributesFinderFeature mock = mock(CteraAttributesFinderFeature.class); // target exists and not writable - when(mock.find(eq(target))).thenReturn(new PathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); + when(mock.find(eq(target))).thenReturn(new DefaultPathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); final AccessDeniedException accessDeniedException = assertThrows(AccessDeniedException.class, () -> new CteraCopyFeature(session).preflight(source, Optional.of(target))); assertTrue(accessDeniedException.getDetail().contains(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), target.getName()))); } @@ -92,7 +93,7 @@ public class CteraCopyFeatureTest extends AbstractCteraTest { target.getParent().setAttributes(target.getParent().attributes().setAcl(new Acl(new Acl.CanonicalUser()))); final CteraAttributesFinderFeature mock = mock(CteraAttributesFinderFeature.class); // target exists and not writable - when(mock.find(eq(target))).thenReturn(new PathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); + when(mock.find(eq(target))).thenReturn(new DefaultPathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); final AccessDeniedException accessDeniedException = assertThrows(AccessDeniedException.class, () -> new CteraCopyFeature(session).preflight(source, Optional.of(target))); assertTrue(accessDeniedException.getDetail().contains(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), target.getName()))); } diff --git a/ctera/src/test/java/ch/cyberduck/core/ctera/CteraMoveFeatureTest.java b/ctera/src/test/java/ch/cyberduck/core/ctera/CteraMoveFeatureTest.java index 858eda2fe0..6ef2b7c8fc 100644 --- a/ctera/src/test/java/ch/cyberduck/core/ctera/CteraMoveFeatureTest.java +++ b/ctera/src/test/java/ch/cyberduck/core/ctera/CteraMoveFeatureTest.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.ctera; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.LocaleFactory; @@ -178,7 +179,7 @@ public class CteraMoveFeatureTest extends AbstractCteraTest { target.getParent().setAttributes(target.getParent().attributes().setAcl(new Acl(new Acl.CanonicalUser(), CteraAttributesFinderFeature.CREATEDIRECTORIESPERMISSION))); final CteraAttributesFinderFeature mock = mock(CteraAttributesFinderFeature.class); // target exists and not writable - when(mock.find(eq(target))).thenReturn(new PathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); + when(mock.find(eq(target))).thenReturn(new DefaultPathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); final AccessDeniedException accessDeniedException = assertThrows(AccessDeniedException.class, () -> new CteraMoveFeature(session).preflight(source, Optional.of(target))); assertTrue(accessDeniedException.getDetail().contains(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), target.getName()))); } @@ -204,7 +205,7 @@ public class CteraMoveFeatureTest extends AbstractCteraTest { target.getParent().setAttributes(target.getParent().attributes().setAcl(new Acl(new Acl.CanonicalUser()))); final CteraAttributesFinderFeature mock = mock(CteraAttributesFinderFeature.class); // target exists and not writable - when(mock.find(eq(target))).thenReturn(new PathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); + when(mock.find(eq(target))).thenReturn(new DefaultPathAttributes().setAcl(new Acl(new Acl.CanonicalUser()))); final AccessDeniedException accessDeniedException = assertThrows(AccessDeniedException.class, () -> new CteraMoveFeature(session).preflight(source, Optional.of(target))); assertTrue(accessDeniedException.getDetail().contains(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), target.getName()))); } diff --git a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxAttributesFinderFeature.java b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxAttributesFinderFeature.java index a44eda8b4e..18627eb0b7 100644 --- a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxAttributesFinderFeature.java +++ b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.deepbox; */ import ch.cyberduck.core.Acl; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -146,7 +147,7 @@ public class DeepboxAttributesFinderFeature implements AttributesFinder, Attribu final String boxNodeId = fileid.getBoxNodeId(file); // map BoxAccessPolicy to CANLISTCHILDREN and CANADDCHILDREN for third level final Box box = new BoxRestControllerApi(session.getClient()).getBox(deepBoxNodeId, boxNodeId); - final PathAttributes attr = new PathAttributes().setFileId(fileId); + final PathAttributes attr = new DefaultPathAttributes().setFileId(fileId); final Acl acl = new Acl(new Acl.CanonicalUser()); final BoxAccessPolicy boxPolicy = box.getBoxPolicy(); if(containerService.isInbox(file)) { @@ -200,26 +201,26 @@ public class DeepboxAttributesFinderFeature implements AttributesFinder, Attribu } public PathAttributes toAttributes(final Box box) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); attrs.setFileId(box.getBoxNodeId()); return attrs; } public PathAttributes toAttributes(final DeepBox deepBox) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); attrs.setFileId(deepBox.getDeepBoxNodeId()); return attrs; } public PathAttributes toAttributes(final CompanyRoles company) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); attrs.setFileId(company.getGroupId()); return attrs; } @Override public PathAttributes toAttributes(final Node node) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); attrs.setFileId(node.getNodeId()); attrs.setCreationDate(node.getCreated().getTime().getMillis()); attrs.setModificationDate(node.getModified().getTime().getMillis()); diff --git a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxIdProvider.java b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxIdProvider.java index 1804cecdfb..7e32ae8e50 100644 --- a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxIdProvider.java +++ b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxIdProvider.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.deepbox; */ import ch.cyberduck.core.CachingFileIdProvider; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.deepbox.io.swagger.client.ApiException; @@ -135,7 +136,7 @@ public class DeepboxIdProvider extends CachingFileIdProvider implements FileIdPr return file; } } - final Path deepbox = new Path(result, deepboxName, type, new PathAttributes(combined.attributes()).setFileId(null)); + final Path deepbox = new Path(result, deepboxName, type, new DefaultPathAttributes(combined.attributes()).setFileId(null)); result = new Path(deepbox, boxName, type, segment.attributes()); } else { diff --git a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxListService.java b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxListService.java index fb49d941b2..46327ede04 100644 --- a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxListService.java +++ b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxListService.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.deepbox; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; @@ -359,7 +360,7 @@ public class DeepboxListService implements ListService { list.add(new Path(directory, String.format("%s (%s)", DeepboxPathNormalizer.name(box.getCompany().getDisplayName()), DeepboxPathNormalizer.name(box.getBoxName())), EnumSet.of(Path.Type.directory, Path.Type.volume), - new PathAttributes().setFileId(box.getBoxNodeId()).setCustom(DeepboxIdProvider.DEEPBOX_NAME_PROEPRTY_KEY, box.getDeepBoxName())) + new DefaultPathAttributes().setFileId(box.getBoxNodeId()).setCustom(DeepboxIdProvider.DEEPBOX_NAME_PROEPRTY_KEY, box.getDeepBoxName())) ); } // Mark duplicates diff --git a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxMoveFeature.java b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxMoveFeature.java index fd77782e5e..79411906a5 100644 --- a/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxMoveFeature.java +++ b/deepbox/src/main/java/ch/cyberduck/core/deepbox/DeepboxMoveFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.deepbox; import ch.cyberduck.core.Acl; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -74,7 +75,7 @@ public class DeepboxMoveFeature implements Move { } fileid.cache(file, null); fileid.cache(renamed, sourceId); - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setFileId(sourceId)); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setFileId(sourceId)); } catch(ApiException e) { throw new DeepboxExceptionMappingService(fileid).map("Cannot rename {0}", e, file); diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxCopyFeatureTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxCopyFeatureTest.java index a0890446d6..b522b9c4f7 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxCopyFeatureTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxCopyFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.deepbox; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -48,12 +49,12 @@ public class DeepboxCopyFeatureTest extends AbstractDeepboxTest { final Path copy = new Path(documents, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)); new DeepboxCopyFeature(session, fileid).copy(test, copy, new TransferStatus(), new DisabledConnectionCallback(), new DisabledStreamListener()); try { - assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(copy.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(copy.withAttributes(new DefaultPathAttributes()))); } finally { - new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); - new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(copy.withAttributes(new PathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(copy.withAttributes(new DefaultPathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); } } @@ -65,7 +66,7 @@ public class DeepboxCopyFeatureTest extends AbstractDeepboxTest { new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory)), new TransferStatus()); final Path copy = new Path(documents, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory)); assertThrows(UnsupportedException.class, () -> new DeepboxCopyFeature(session, fileid).preflight(directory, Optional.of(copy))); - new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(directory.withAttributes(new PathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(directory.withAttributes(new DefaultPathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); } @Test @@ -94,17 +95,17 @@ public class DeepboxCopyFeatureTest extends AbstractDeepboxTest { final PathAttributes originalTargetAttributes = new DeepboxAttributesFinderFeature(session, fileid).find(target); new DeepboxCopyFeature(session, fileid).copy(test, target, new TransferStatus().setExists(true), new DisabledConnectionCallback(), new DisabledStreamListener()); - assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(target.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(target.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxFindFeature(session, fileid).find(targetInTrash)); - final PathAttributes overriddenTargetAttributes = new DeepboxAttributesFinderFeature(session, fileid).find(target.withAttributes(new PathAttributes())); + final PathAttributes overriddenTargetAttributes = new DeepboxAttributesFinderFeature(session, fileid).find(target.withAttributes(new DefaultPathAttributes())); assertNotNull(originalTestAttributes.getFileId()); assertNotEquals(originalTestAttributes.getFileId(), overriddenTargetAttributes.getFileId()); assertNotEquals(originalTestAttributes.getModificationDate(), overriddenTargetAttributes.getModificationDate()); assertEquals(originalTestAttributes.getChecksum(), overriddenTargetAttributes.getChecksum()); - final PathAttributes trashedTargetAttributes = new DeepboxAttributesFinderFeature(session, fileid).find(targetInTrash.withAttributes(new PathAttributes())); + final PathAttributes trashedTargetAttributes = new DeepboxAttributesFinderFeature(session, fileid).find(targetInTrash.withAttributes(new DefaultPathAttributes())); assertNotNull(originalTargetAttributes.getFileId()); assertEquals(originalTargetAttributes.getFileId(), trashedTargetAttributes.getFileId()); assertEquals(originalTargetAttributes.getModificationDate(), trashedTargetAttributes.getModificationDate()); diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxDirectoryFeatureTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxDirectoryFeatureTest.java index 2f2ba87a16..1864a6ec3f 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxDirectoryFeatureTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxDirectoryFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.deepbox; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -126,11 +127,11 @@ public class DeepboxDirectoryFeatureTest extends AbstractDeepboxTest { final Path parent = new Path("/ORG 4 - DeepBox Desktop App/ORG 4 - DeepBox Desktop App/ORG3:Box1/Documents", EnumSet.of(Path.Type.directory)); final Path folder = new Path(parent, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory)); directory.mkdir(new DeepboxWriteFeature(session, nodeid), folder, new TransferStatus()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new PathAttributes()), new DisabledListProgressListener())); + assertTrue(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new DefaultPathAttributes()), new DisabledListProgressListener())); assertEquals(0, new DeepboxListService(session, nodeid).list(folder, new DisabledListProgressListener()).size()); new DeepboxDeleteFeature(session, nodeid).delete(Collections.singletonList(folder), new DisabledLoginCallback(), new Delete.DisabledCallback()); - assertThrows(NotfoundException.class, () -> nodeid.getFileId(folder.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new PathAttributes()))); + assertThrows(NotfoundException.class, () -> nodeid.getFileId(folder.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new DefaultPathAttributes()))); } @Test diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxListServiceTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxListServiceTest.java index 11d48303da..5a80593acd 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxListServiceTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxListServiceTest.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.deepbox; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -71,7 +72,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { // no modification/creation date for DeepBoxes assertTrue(f.attributes().getModificationDate() < 0); assertTrue(f.attributes().getCreationDate() < 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(new Path(f.getAbsolute(), f.getType()))); } } @@ -91,7 +92,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { // no modification/creation date for Companies assertTrue(f.attributes().getModificationDate() < 0); assertTrue(f.attributes().getCreationDate() < 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(new Path(f.getAbsolute(), f.getType()))); } } @@ -131,7 +132,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { // no modification/creation date for Boxes assertTrue(f.attributes().getModificationDate() < 0); assertTrue(f.attributes().getCreationDate() < 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(new Path(f.getAbsolute(), f.getType()))); } } @@ -151,7 +152,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { // no modification/creation date for Boxes assertTrue(f.attributes().getModificationDate() < 0); assertTrue(f.attributes().getCreationDate() < 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(new Path(f.getAbsolute(), f.getType()))); } } @@ -198,7 +199,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { assertFalse(f.getName().contains(String.valueOf(Path.DELIMITER))); assertTrue(f.attributes().getModificationDate() > 0); assertTrue(f.attributes().getCreationDate() > 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(f)); } } @@ -215,7 +216,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { assertFalse(f.getName().contains(String.valueOf(Path.DELIMITER))); assertTrue(f.attributes().getModificationDate() > 0); assertTrue(f.attributes().getCreationDate() > 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(new Path(f.getAbsolute(), f.getType()))); } } @@ -245,7 +246,7 @@ public class DeepboxListServiceTest extends AbstractDeepboxTest { assertFalse(f.getName().contains(String.valueOf(Path.DELIMITER))); assertTrue(f.attributes().getModificationDate() > 0); assertTrue(f.attributes().getCreationDate() > 0); - assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new PathAttributes()))); + assertNotNull(nodeid.getFileId(new Path(f).withAttributes(new DefaultPathAttributes()))); assertEquals(f.attributes(), new DeepboxAttributesFinderFeature(session, nodeid).find(f)); } } diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxMoveFeatureTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxMoveFeatureTest.java index 872c38b705..bf5c9bca46 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxMoveFeatureTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxMoveFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.deepbox; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledPasswordCallback; @@ -61,7 +62,7 @@ public class DeepboxMoveFeatureTest extends AbstractDeepboxTest { final Path moved = new DeepboxMoveFeature(session, fileid).move(test, new Path(documents, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus(), new Delete.DisabledCallback(), new DisabledConnectionCallback()); assertEquals(sourceId, moved.attributes().getFileId()); - assertFalse(new DeepboxFindFeature(session, fileid).find(new Path(test).withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(new Path(test).withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxFindFeature(session, fileid).find(moved)); assertEquals(test.attributes().getModificationDate(), moved.attributes().getModificationDate()); assertEquals(test.attributes().getChecksum(), moved.attributes().getChecksum()); @@ -80,7 +81,7 @@ public class DeepboxMoveFeatureTest extends AbstractDeepboxTest { final Path target = new Path(documents, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory)); final Path moved = new DeepboxMoveFeature(session, fileid).move(test, target, new TransferStatus(), new Delete.DisabledCallback(), new DisabledConnectionCallback()); assertEquals(sourceId, moved.attributes().getFileId()); - assertFalse(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxFindFeature(session, fileid).find(target)); new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(target), new DisabledLoginCallback(), new Delete.DisabledCallback()); diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxRestoreFeatureTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxRestoreFeatureTest.java index e083f8e1fc..a791a40881 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxRestoreFeatureTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxRestoreFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.deepbox; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -48,24 +49,24 @@ public class DeepboxRestoreFeatureTest extends AbstractDeepboxTest { new DeepboxTouchFeature(session, fileid).touch(new DeepboxWriteFeature(session, fileid), test, new TransferStatus()); final String nodeId = new DeepboxAttributesFinderFeature(session, fileid).find(test).getFileId(); - assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); new DeepboxTrashFeature(session, fileid).delete(Collections.singletonList(test), new DisabledLoginCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes()))); - assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes())).getFileId()); - assertThrows(NotfoundException.class, () -> new DeepboxAttributesFinderFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes())).getFileId()); + assertFalse(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); + assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes())).getFileId()); + assertThrows(NotfoundException.class, () -> new DeepboxAttributesFinderFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes())).getFileId()); final DeepboxRestoreFeature restore = new DeepboxRestoreFeature(session, fileid); restore.restore(testInTrash, new DisabledLoginCallback()); - assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes()))); - assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(test.withAttributes(new PathAttributes())).getFileId()); - assertThrows(NotfoundException.class, () -> new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); + assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(test.withAttributes(new DefaultPathAttributes())).getFileId()); + assertThrows(NotfoundException.class, () -> new DeepboxAttributesFinderFeature(session, fileid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); - new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); } @Test @@ -91,40 +92,40 @@ public class DeepboxRestoreFeatureTest extends AbstractDeepboxTest { new DeepboxTouchFeature(session, fileid).touch(new DeepboxWriteFeature(session, fileid), file, new TransferStatus()); final String nodeId = new DeepboxAttributesFinderFeature(session, fileid).find(file).getFileId(); - assertTrue(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxFindFeature(session, fileid).find(file)); - assertFalse(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new DefaultPathAttributes()))); new DeepboxTrashFeature(session, fileid).delete(Collections.singletonList(folder), new DisabledLoginCallback(), new Delete.DisabledCallback()); - assertThrows(NotfoundException.class, () -> fileid.getFileId(folder.withAttributes(new PathAttributes()))); - assertThrows(NotfoundException.class, () -> fileid.getFileId(subfolderWithContent.withAttributes(new PathAttributes()))); - assertThrows(NotfoundException.class, () -> fileid.getFileId(file.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(file.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new PathAttributes()))); - assertEquals(folderId, new DeepboxAttributesFinderFeature(session, fileid).find(folderInTrash.withAttributes(new PathAttributes())).getFileId()); - assertEquals(subFolderId, new DeepboxAttributesFinderFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new PathAttributes())).getFileId()); - assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(fileInTrash.withAttributes(new PathAttributes())).getFileId()); + assertThrows(NotfoundException.class, () -> fileid.getFileId(folder.withAttributes(new DefaultPathAttributes()))); + assertThrows(NotfoundException.class, () -> fileid.getFileId(subfolderWithContent.withAttributes(new DefaultPathAttributes()))); + assertThrows(NotfoundException.class, () -> fileid.getFileId(file.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new DefaultPathAttributes()))); + assertEquals(folderId, new DeepboxAttributesFinderFeature(session, fileid).find(folderInTrash.withAttributes(new DefaultPathAttributes())).getFileId()); + assertEquals(subFolderId, new DeepboxAttributesFinderFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new DefaultPathAttributes())).getFileId()); + assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(fileInTrash.withAttributes(new DefaultPathAttributes())).getFileId()); final DeepboxRestoreFeature restore = new DeepboxRestoreFeature(session, fileid); restore.restore(folderInTrash, new DisabledLoginCallback()); - assertTrue(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, fileid).find(file.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new PathAttributes()))); - assertEquals(folderId, new DeepboxAttributesFinderFeature(session, fileid).find(folder.withAttributes(new PathAttributes())).getFileId()); - assertEquals(subFolderId, new DeepboxAttributesFinderFeature(session, fileid).find(subfolderWithContent.withAttributes(new PathAttributes())).getFileId()); - assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(file.withAttributes(new PathAttributes())).getFileId()); + assertTrue(new DeepboxFindFeature(session, fileid).find(folder.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(subfolderWithContent.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(folderInTrash.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(subfolderWithContentInTrash.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, fileid).find(fileInTrash.withAttributes(new DefaultPathAttributes()))); + assertEquals(folderId, new DeepboxAttributesFinderFeature(session, fileid).find(folder.withAttributes(new DefaultPathAttributes())).getFileId()); + assertEquals(subFolderId, new DeepboxAttributesFinderFeature(session, fileid).find(subfolderWithContent.withAttributes(new DefaultPathAttributes())).getFileId()); + assertEquals(nodeId, new DeepboxAttributesFinderFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes())).getFileId()); - new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(folder.withAttributes(new PathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new DeepboxDeleteFeature(session, fileid).delete(Collections.singletonList(folder.withAttributes(new DefaultPathAttributes())), new DisabledLoginCallback(), new Delete.DisabledCallback()); } } \ No newline at end of file diff --git a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxTrashFeatureTest.java b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxTrashFeatureTest.java index 0fa9876384..f732e503d9 100644 --- a/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxTrashFeatureTest.java +++ b/deepbox/src/test/java/ch/cyberduck/core/deepbox/DeepboxTrashFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.deepbox; import ch.cyberduck.core.Acl; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledPasswordCallback; import ch.cyberduck.core.Path; @@ -84,11 +85,11 @@ public class DeepboxTrashFeatureTest extends AbstractDeepboxTest { new DeepboxTouchFeature(session, nodeid).touch(new DeepboxWriteFeature(session, nodeid), file, new TransferStatus()); assertTrue(new DeepboxFindFeature(session, nodeid).find(file)); new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(folder), new DisabledLoginCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(folder.withAttributes(new DefaultPathAttributes()))); assertFalse(new DefaultFindFeature(session).find(folder)); - assertFalse(new DeepboxFindFeature(session, nodeid).find(subfolderWithContent.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(subfolderWithContent.withAttributes(new DefaultPathAttributes()))); assertThrows(NotfoundException.class, () -> new DefaultFindFeature(session).find(subfolderWithContent)); - assertFalse(new DeepboxFindFeature(session, nodeid).find(file.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(file.withAttributes(new DefaultPathAttributes()))); // file not in trash is deleted but not purged (i.e. moved to the trash) final Path folderInTrash = new Path(trash, folder.getName(), EnumSet.of(Path.Type.directory)); assertTrue(new DeepboxFindFeature(session, nodeid).find(folderInTrash)); @@ -198,36 +199,36 @@ public class DeepboxTrashFeatureTest extends AbstractDeepboxTest { final Path testInTrash = new Path(trash, test.getName(), EnumSet.of(Path.Type.file)); new DeepboxTouchFeature(session, nodeid).touch(new DeepboxWriteFeature(session, nodeid), test, new TransferStatus()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxRestoreFeature(session, nodeid).restore(testInTrash.withAttributes(new PathAttributes()), new DisabledLoginCallback()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxRestoreFeature(session, nodeid).restore(testInTrash.withAttributes(new DefaultPathAttributes()), new DisabledLoginCallback()); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(testInTrash.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(testInTrash.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); } @Test @@ -239,37 +240,37 @@ public class DeepboxTrashFeatureTest extends AbstractDeepboxTest { final Path testInTrash = new Path(trash, test.getName(), EnumSet.of(Path.Type.directory)); new DeepboxDirectoryFeature(session, nodeid).mkdir(new DeepboxWriteFeature(session, nodeid), test, new TransferStatus()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxRestoreFeature(session, nodeid).restore(testInTrash.withAttributes(new PathAttributes()), new DisabledLoginCallback()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxRestoreFeature(session, nodeid).restore(testInTrash.withAttributes(new DefaultPathAttributes()), new DisabledLoginCallback()); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(testInTrash).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); - new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(testInTrash.withAttributes(new PathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(testInTrash.withAttributes(new DefaultPathAttributes())), new DisabledPasswordCallback(), new Delete.DisabledCallback()); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); } @Test @@ -282,15 +283,15 @@ public class DeepboxTrashFeatureTest extends AbstractDeepboxTest { final Path testInTrash = new Path(trash, test.getName(), EnumSet.of(Path.Type.file)); new DeepboxTouchFeature(session, nodeid).touch(new DeepboxWriteFeature(session, nodeid), test, new TransferStatus()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); } @Test @@ -303,14 +304,14 @@ public class DeepboxTrashFeatureTest extends AbstractDeepboxTest { final Path testInTrash = new Path(trash, test.getName(), EnumSet.of(Path.Type.directory)); new DeepboxDirectoryFeature(session, nodeid).mkdir(new DeepboxWriteFeature(session, nodeid), test, new TransferStatus()); - assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertTrue(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANDELETE)); assertTrue(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANPURGE)); assertFalse(new DeepboxAttributesFinderFeature(session, nodeid).find(test).getAcl().get(new Acl.CanonicalUser()).contains(CANREVERT)); new DeepboxTrashFeature(session, nodeid).delete(Collections.singletonList(test), new DisabledPasswordCallback(), new Delete.DisabledCallback()); - assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new PathAttributes()))); - assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new PathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(test.withAttributes(new DefaultPathAttributes()))); + assertFalse(new DeepboxFindFeature(session, nodeid).find(testInTrash.withAttributes(new DefaultPathAttributes()))); } } diff --git a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesAdapter.java b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesAdapter.java index ddfca9559c..c83d4464c3 100644 --- a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesAdapter.java +++ b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesAdapter.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.sds; */ import ch.cyberduck.core.Acl; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.Permission; @@ -46,7 +47,7 @@ public class SDSAttributesAdapter implements AttributesAdapter { @Override public PathAttributes toAttributes(final Node node) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setVersionId(String.valueOf(node.getId())); attributes.setRevision(node.getBranchVersion()); if(node.isIsEncrypted() != null && !node.isIsEncrypted()) { @@ -107,7 +108,7 @@ public class SDSAttributesAdapter implements AttributesAdapter { } public PathAttributes toAttributes(final DeletedNode node) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setDuplicate(true); attributes.setVersionId(String.valueOf(node.getId())); attributes.setCreationDate(node.getCreatedAt() != null ? node.getCreatedAt().getMillis() : -1L); diff --git a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesFinderFeature.java b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesFinderFeature.java index 866e82a8fc..f6da2a3ab5 100644 --- a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesFinderFeature.java +++ b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.sds; */ import ch.cyberduck.core.Acl; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -53,7 +54,7 @@ public class SDSAttributesFinderFeature implements AttributesFinder { public PathAttributes find(final Path file, final ListProgressListener listener) throws BackgroundException { if(file.isRoot()) { // {"code":400,"message":"Bad Request","debugInfo":"Node ID must be positive.","errorCode":-80001} - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); if(session.userAccount().isUserInRole(SDSPermissionsFeature.ROOM_MANAGER_ROLE)) { // We need to map user roles to ACLs in order to decide if creating a top-level room is allowed final Acl acl = new Acl(); diff --git a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSMoveFeature.java b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSMoveFeature.java index 0a7042293f..0684c1734f 100644 --- a/dracoon/src/main/java/ch/cyberduck/core/sds/SDSMoveFeature.java +++ b/dracoon/src/main/java/ch/cyberduck/core/sds/SDSMoveFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.sds; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -102,7 +103,7 @@ public class SDSMoveFeature implements Move { nodeid.cache(renamed, file.attributes().getVersionId()); nodeid.cache(file, null); // Copy original file attributes - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setVersionId(String.valueOf(nodeId))); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(String.valueOf(nodeId))); } } catch(ApiException e) { diff --git a/dracoon/src/test/java/ch/cyberduck/core/sds/SDSDeleteFeatureTest.java b/dracoon/src/test/java/ch/cyberduck/core/sds/SDSDeleteFeatureTest.java index 1b0de514d1..2f1448b23e 100644 --- a/dracoon/src/test/java/ch/cyberduck/core/sds/SDSDeleteFeatureTest.java +++ b/dracoon/src/test/java/ch/cyberduck/core/sds/SDSDeleteFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.sds; import ch.cyberduck.core.AbstractPath; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledProgressListener; import ch.cyberduck.core.Local; @@ -61,7 +62,7 @@ public class SDSDeleteFeatureTest extends AbstractSDSTest { assertNotNull(versionId); new SDSDeleteFeature(session, nodeid).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); try { - new SDSDeleteFeature(session, nodeid).delete(Collections.singletonList(file.withAttributes(new PathAttributes().setVersionId(versionId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + new SDSDeleteFeature(session, nodeid).delete(Collections.singletonList(file.withAttributes(new DefaultPathAttributes().setVersionId(versionId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); fail(); } catch(NotfoundException e) { diff --git a/dracoon/src/test/java/ch/cyberduck/core/sds/SDSVersioningFeatureTest.java b/dracoon/src/test/java/ch/cyberduck/core/sds/SDSVersioningFeatureTest.java index 0879e76858..e6ee4e859e 100644 --- a/dracoon/src/test/java/ch/cyberduck/core/sds/SDSVersioningFeatureTest.java +++ b/dracoon/src/test/java/ch/cyberduck/core/sds/SDSVersioningFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.sds; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathPredicate; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; @@ -50,7 +51,7 @@ public class SDSVersioningFeatureTest extends AbstractSDSTest { final Path room = new SDSDirectoryFeature(session, nodeid).mkdir( new SDSDirectS3MultipartWriteFeature(session, nodeid), new Path(new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory, Path.Type.volume)), new TransferStatus()); final Path test = new SDSTouchFeature(session, nodeid).touch(new SDSDirectS3MultipartWriteFeature(session, nodeid), new Path(room, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final String initialVersion = test.attributes().getVersionId(); final SDSVersioningFeature feature = new SDSVersioningFeature(session, nodeid); { diff --git a/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxAttributesFinderFeature.java b/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxAttributesFinderFeature.java index 7eb465883a..bda814fa05 100644 --- a/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxAttributesFinderFeature.java +++ b/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.dropbox; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -56,7 +57,7 @@ public class DropboxAttributesFinderFeature implements AttributesFinder, Attribu // Retrieve the namespace ID for a users home folder and team root folder final FullAccount account = new DbxUserUsersRequests(session.getClient()).getCurrentAccount(); log.debug("Set root namespace {}", account.getRootInfo().getRootNamespaceId()); - return new PathAttributes().setFileId(account.getRootInfo().getRootNamespaceId()); + return new DefaultPathAttributes().setFileId(account.getRootInfo().getRootNamespaceId()); } final Metadata metadata = new DbxUserFilesRequests(session.getClient(file)).getMetadata(containerService.getKey(file)); if(metadata instanceof FileMetadata) { @@ -78,7 +79,7 @@ public class DropboxAttributesFinderFeature implements AttributesFinder, Attribu @Override public PathAttributes toAttributes(final Metadata metadata) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); if(metadata instanceof FileMetadata) { final FileMetadata file = (FileMetadata) metadata; attributes.setSize(file.getSize()); diff --git a/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxSharedFoldersListService.java b/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxSharedFoldersListService.java index b811274ea6..990551746b 100644 --- a/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxSharedFoldersListService.java +++ b/dropbox/src/main/java/ch/cyberduck/core/dropbox/DropboxSharedFoldersListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.dropbox; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -67,7 +68,7 @@ public class DropboxSharedFoldersListService implements ListService { } protected Path parse(final Path directory, final SharedFolderMetadata metadata) { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); return new Path(directory, PathNormalizer.name(metadata.getName()), EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.shared), attr); } diff --git a/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxLockFeatureTest.java b/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxLockFeatureTest.java index d832681b3f..1e73f2ba7e 100644 --- a/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxLockFeatureTest.java +++ b/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxLockFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.dropbox; import ch.cyberduck.core.AbstractDropboxTest; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -58,7 +59,7 @@ public class DropboxLockFeatureTest extends AbstractDropboxTest { @Test(expected = InteroperabilityException.class) public void testLock() throws Exception { final DropboxTouchFeature touch = new DropboxTouchFeature(session); - final Path file = touch.touch(new DropboxWriteFeature(session), new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.shared)).withAttributes(new PathAttributes().setFileId("7581509952")), + final Path file = touch.touch(new DropboxWriteFeature(session), new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.shared)).withAttributes(new DefaultPathAttributes().setFileId("7581509952")), new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus()); final DropboxLockFeature f = new DropboxLockFeature(session); final String lock = f.lock(file); @@ -71,7 +72,7 @@ public class DropboxLockFeatureTest extends AbstractDropboxTest { @Ignore @Test(expected = NotfoundException.class) public void testLockNoSuchFile() throws Exception { - final Path file = new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.shared)).withAttributes(new PathAttributes().setFileId("7581509952")), + final Path file = new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.shared)).withAttributes(new DefaultPathAttributes().setFileId("7581509952")), new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)); final DropboxLockFeature f = new DropboxLockFeature(session); f.lock(file); @@ -80,7 +81,7 @@ public class DropboxLockFeatureTest extends AbstractDropboxTest { @Test public void testLockNotfound() throws Exception { final DropboxTouchFeature touch = new DropboxTouchFeature(session); - final Path file = touch.touch(new DropboxWriteFeature(session), new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.shared)).withAttributes(new PathAttributes().setFileId("7581509952")), + final Path file = touch.touch(new DropboxWriteFeature(session), new Path(new Path(new DefaultHomeFinderService(session).find(), "Projects", EnumSet.of(Path.Type.directory, Path.Type.shared)).withAttributes(new DefaultPathAttributes().setFileId("7581509952")), new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus()); final DropboxLockFeature f = new DropboxLockFeature(session); f.unlock(file, "l"); diff --git a/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxVersioningFeatureTest.java b/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxVersioningFeatureTest.java index af85615ba4..053a67d12e 100644 --- a/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxVersioningFeatureTest.java +++ b/dropbox/src/test/java/ch/cyberduck/core/dropbox/DropboxVersioningFeatureTest.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.dropbox; import ch.cyberduck.core.AbstractDropboxTest; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -56,7 +57,7 @@ public class DropboxVersioningFeatureTest extends AbstractDropboxTest { assertEquals(test.attributes().getVersionId(), new DropboxAttributesFinderFeature(session).find(test).getVersionId()); final DropboxVersioningFeature feature = new DropboxVersioningFeature(session); assertEquals(0, feature.list(test, new DisabledListProgressListener()).size()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final String initialVersion = test.attributes().getVersionId(); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/eue/src/main/java/ch/cyberduck/core/eue/EueAttributesFinderFeature.java b/eue/src/main/java/ch/cyberduck/core/eue/EueAttributesFinderFeature.java index 1ef7a489c6..e0e6e1ed0c 100644 --- a/eue/src/main/java/ch/cyberduck/core/eue/EueAttributesFinderFeature.java +++ b/eue/src/main/java/ch/cyberduck/core/eue/EueAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.eue; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -103,7 +104,7 @@ public class EueAttributesFinderFeature implements AttributesFinder { protected PathAttributes toAttributes(final Uifs entity, final UiWin32 uiwin32, final ShareCreationResponseEntity share) { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setDisplayname(entity.getName()); // Matches ETag response header attr.setETag(StringUtils.remove(entity.getMetaETag(), '"')); diff --git a/eue/src/test/java/ch/cyberduck/core/eue/EueDeleteFeatureTest.java b/eue/src/test/java/ch/cyberduck/core/eue/EueDeleteFeatureTest.java index e891ab1f42..3b522d5c02 100644 --- a/eue/src/test/java/ch/cyberduck/core/eue/EueDeleteFeatureTest.java +++ b/eue/src/test/java/ch/cyberduck/core/eue/EueDeleteFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.eue; import ch.cyberduck.core.AbstractPath; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -120,7 +121,7 @@ public class EueDeleteFeatureTest extends AbstractEueSessionTest { new EueDeleteFeature(session, fileid).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); try { new EueDeleteFeature(session, fileid).delete(Collections.singletonList( - file.withAttributes(new PathAttributes().setFileId(resourceId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + file.withAttributes(new DefaultPathAttributes().setFileId(resourceId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); fail(); } catch(NotfoundException e) { diff --git a/eue/src/test/java/ch/cyberduck/core/eue/EueListServiceTest.java b/eue/src/test/java/ch/cyberduck/core/eue/EueListServiceTest.java index 883a937de3..54568e7212 100644 --- a/eue/src/test/java/ch/cyberduck/core/eue/EueListServiceTest.java +++ b/eue/src/test/java/ch/cyberduck/core/eue/EueListServiceTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.eue; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathPredicate; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.DisabledListProgressListener; @@ -58,7 +59,7 @@ public class EueListServiceTest extends AbstractEueSessionTest { assertEquals(bucket.attributes(), new EueAttributesFinderFeature(session, fileid).find(bucket, new DisabledListProgressListener())); } assertNotNull(list.find(f -> f.attributes().getFileId().equals(EueResourceIdProvider.TRASH))); - assertTrue(list.contains(new Path("Gelöschte Dateien", EnumSet.of(directory)).withAttributes(new PathAttributes().setFileId("TRASH")))); + assertTrue(list.contains(new Path("Gelöschte Dateien", EnumSet.of(directory)).withAttributes(new DefaultPathAttributes().setFileId("TRASH")))); assertEquals(folder.attributes().getFileId(), list.find(new SimplePathPredicate(folder)).attributes().getFileId()); assertSame(root, list.find(new SimplePathPredicate(folder)).getParent()); new EueDeleteFeature(session, fileid).delete(Collections.singletonList(folder), new DisabledLoginCallback(), new Delete.DisabledCallback()); diff --git a/eue/src/test/java/ch/cyberduck/core/eue/EueMoveFeatureTest.java b/eue/src/test/java/ch/cyberduck/core/eue/EueMoveFeatureTest.java index 9badaa63ab..bc945f957c 100644 --- a/eue/src/test/java/ch/cyberduck/core/eue/EueMoveFeatureTest.java +++ b/eue/src/test/java/ch/cyberduck/core/eue/EueMoveFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.eue; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -140,7 +141,7 @@ public class EueMoveFeatureTest extends AbstractEueSessionTest { final String resourceId = file.attributes().getFileId(); new EueDeleteFeature(session, fileid).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); try { - new EueMoveFeature(session, fileid).move(file.withAttributes(new PathAttributes().setFileId(resourceId)), + new EueMoveFeature(session, fileid).move(file.withAttributes(new DefaultPathAttributes().setFileId(resourceId)), new Path(new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus(), new Delete.DisabledCallback(), new DisabledConnectionCallback()); fail(); } @@ -155,7 +156,7 @@ public class EueMoveFeatureTest extends AbstractEueSessionTest { final Path file = new EueTouchFeature(session, fileid).touch(new EueWriteFeature(session, fileid), new Path(new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus()); final String resourceId = file.attributes().getFileId(); new EueDeleteFeature(session, fileid).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); - new EueMoveFeature(session, fileid).move(file.withAttributes(new PathAttributes().setFileId(resourceId)), + new EueMoveFeature(session, fileid).move(file.withAttributes(new DefaultPathAttributes().setFileId(resourceId)), new Path(new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus(), new Delete.DisabledCallback(), new DisabledConnectionCallback()); } diff --git a/eue/src/test/java/ch/cyberduck/core/eue/EueTrashFeatureTest.java b/eue/src/test/java/ch/cyberduck/core/eue/EueTrashFeatureTest.java index 2b119feee8..7febe28f6f 100644 --- a/eue/src/test/java/ch/cyberduck/core/eue/EueTrashFeatureTest.java +++ b/eue/src/test/java/ch/cyberduck/core/eue/EueTrashFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.eue; import ch.cyberduck.core.AbstractPath; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -148,7 +149,7 @@ public class EueTrashFeatureTest extends AbstractEueSessionTest { try { // Skip file already in trash new EueTrashFeature(session, fileid).delete(Collections.singletonList( - file.withAttributes(new PathAttributes().setFileId(resourceId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); + file.withAttributes(new DefaultPathAttributes().setFileId(resourceId))), new DisabledLoginCallback(), new Delete.DisabledCallback()); } catch(NotfoundException e) { fail(); diff --git a/ftp/src/main/java/ch/cyberduck/core/ftp/FTPMoveFeature.java b/ftp/src/main/java/ch/cyberduck/core/ftp/FTPMoveFeature.java index 4918708ac7..e558b19dd7 100644 --- a/ftp/src/main/java/ch/cyberduck/core/ftp/FTPMoveFeature.java +++ b/ftp/src/main/java/ch/cyberduck/core/ftp/FTPMoveFeature.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.ftp; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.exception.BackgroundException; @@ -51,7 +52,7 @@ public class FTPMoveFeature implements Move { throw new FTPException(session.getClient().getReplyCode(), session.getClient().getReplyString()); } // Copy original file attributes - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setVault(null)); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null)); } catch(IOException e) { throw new FTPExceptionMappingService().map("Cannot rename {0}", e, file); diff --git a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveAttributesFinderFeature.java b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveAttributesFinderFeature.java index b356c584f5..d9b6f816e0 100644 --- a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveAttributesFinderFeature.java +++ b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googledrive; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathContainerService; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.ListProgressListener; @@ -99,7 +100,7 @@ public class DriveAttributesFinderFeature implements AttributesFinder, Attribute return PathAttributes.EMPTY; } } - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setFileId(f.getId()); if(null != f.getTrashed()) { if(f.getTrashed()) { diff --git a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveDirectoryFeature.java b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveDirectoryFeature.java index e677d3f20a..fa5106a272 100644 --- a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveDirectoryFeature.java +++ b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveDirectoryFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.googledrive; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.SimplePathPredicate; @@ -51,7 +52,7 @@ public class DriveDirectoryFeature implements Directory { final TeamDrive execute = session.getClient().teamdrives().create( new UUIDRandomStringService().random(), new TeamDrive().setName(folder.getName()) ).execute(); - return folder.withAttributes(new PathAttributes(folder.attributes()).setFileId(execute.getId())); + return folder.withAttributes(new DefaultPathAttributes(folder.attributes()).setFileId(execute.getId())); } else { try { diff --git a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveHomeFinderService.java b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveHomeFinderService.java index e8e84ba202..835da2d9d8 100644 --- a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveHomeFinderService.java +++ b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveHomeFinderService.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.googledrive; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -30,7 +31,7 @@ public class DriveHomeFinderService extends AbstractHomeFeature { public static final Path MYDRIVE_FOLDER = new Path(PathNormalizer.normalize(LocaleFactory.localizedString("My Drive", "Google Drive")), - EnumSet.of(Path.Type.directory, Path.Type.placeholder, Path.Type.volume), new PathAttributes().setFileId(ROOT_FOLDER_ID)); + EnumSet.of(Path.Type.directory, Path.Type.placeholder, Path.Type.volume), new DefaultPathAttributes().setFileId(ROOT_FOLDER_ID)); public static final Path SHARED_FOLDER_NAME = new Path(PathNormalizer.normalize(LocaleFactory.localizedString("Shared with me", "Google Drive")), diff --git a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveTeamDrivesListService.java b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveTeamDrivesListService.java index 5662a72e28..582d24c8b5 100644 --- a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveTeamDrivesListService.java +++ b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveTeamDrivesListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googledrive; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -60,7 +61,7 @@ public class DriveTeamDrivesListService implements ListService { .execute(); for(TeamDrive f : list.getTeamDrives()) { final Path child = new Path(directory, f.getName(), EnumSet.of(Path.Type.directory, Path.Type.volume), - new PathAttributes().setFileId(f.getId())); + new DefaultPathAttributes().setFileId(f.getId())); children.add(child); } listener.chunk(directory, children); diff --git a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveVersioningFeature.java b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveVersioningFeature.java index 174d77caba..3703d14db9 100644 --- a/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveVersioningFeature.java +++ b/googledrive/src/main/java/ch/cyberduck/core/googledrive/DriveVersioningFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googledrive; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.PasswordCallback; import ch.cyberduck.core.Path; @@ -107,7 +108,7 @@ public class DriveVersioningFeature implements Versioning { } private PathAttributes toAttributes(final Revision f) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(f.getSize()); if(f.getModifiedTime() != null) { attributes.setModificationDate(f.getModifiedTime().getValue()); diff --git a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DefaultAttributesFinderFeatureTest.java b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DefaultAttributesFinderFeatureTest.java index c0d9019f71..d47e8b7f7d 100644 --- a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DefaultAttributesFinderFeatureTest.java +++ b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DefaultAttributesFinderFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googledrive; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -81,10 +82,10 @@ public class DefaultAttributesFinderFeatureTest extends AbstractDriveTest { final HttpResponseOutputStream out = new DriveWriteFeature(session, fileid).write(file, status, new DisabledConnectionCallback()); IOUtils.copy(new ByteArrayInputStream(content), out); out.close(); - assertEquals(initialFileid, f.find(file.withAttributes(new PathAttributes(file.attributes()).setFileId(initialFileid))).getFileId()); + assertEquals(initialFileid, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setFileId(initialFileid))).getFileId()); final String newFileid = out.getStatus().getId(); - assertEquals(newFileid, f.find(file.withAttributes(new PathAttributes(file.attributes()).setFileId(newFileid))).getFileId()); - assertNotEquals(initialFileid, f.find(file.withAttributes(new PathAttributes(file.attributes()).setFileId(newFileid))).getFileId()); + assertEquals(newFileid, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setFileId(newFileid))).getFileId()); + assertNotEquals(initialFileid, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setFileId(newFileid))).getFileId()); assertEquals(out.getStatus().getId(), f.find(file).getFileId()); new DriveDeleteFeature(session, fileid).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); } diff --git a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveBatchTrashFeatureTest.java b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveBatchTrashFeatureTest.java index da696dc688..54a3b430d7 100644 --- a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveBatchTrashFeatureTest.java +++ b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveBatchTrashFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googledrive; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledPasswordCallback; import ch.cyberduck.core.Path; @@ -52,8 +53,8 @@ public class DriveBatchTrashFeatureTest extends AbstractDriveTest { final String fileId = file.attributes().getFileId(); new DriveBatchTrashFeature(session, fileid).delete(Collections.singletonList(file), new DisabledPasswordCallback(), new Delete.DisabledCallback()); assertFalse(new DriveFindFeature(session, fileid).find(file)); - assertTrue(new DriveFindFeature(session, fileid).find(file.withAttributes(new PathAttributes().setFileId(fileId)))); - final PathAttributes attributesInTrash = new DriveAttributesFinderFeature(session, fileid).find(file.withAttributes(new PathAttributes().setFileId(fileId))); + assertTrue(new DriveFindFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes().setFileId(fileId)))); + final PathAttributes attributesInTrash = new DriveAttributesFinderFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes().setFileId(fileId))); assertTrue(attributesInTrash.isTrashed()); new DriveBatchTrashFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(attributesInTrash)), new DisabledPasswordCallback(), new Delete.DisabledCallback()); assertFalse(new DriveFindFeature(session, fileid).find(file.withAttributes(attributesInTrash))); diff --git a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveMoveFeatureTest.java b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveMoveFeatureTest.java index c8a1420148..bdfc752647 100644 --- a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveMoveFeatureTest.java +++ b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveMoveFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.googledrive; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -88,7 +89,7 @@ public class DriveMoveFeatureTest extends AbstractDriveTest { final AttributedList files = new DriveListService(session, fileid).list(folder, new DisabledListProgressListener()); // Replaced file is trashed assertEquals(2, files.size()); - assertTrue(files.get(new Path(test).withAttributes(new PathAttributes().setFileId(firstVersion))).attributes().isTrashed()); + assertTrue(files.get(new Path(test).withAttributes(new DefaultPathAttributes().setFileId(firstVersion))).attributes().isTrashed()); assertFalse(files.get(target).attributes().isHidden()); assertTrue(find.find(target)); new DriveDeleteFeature(session, fileid).delete(Collections.singletonList(folder), new DisabledLoginCallback(), new Delete.DisabledCallback()); diff --git a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveTrashFeatureTest.java b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveTrashFeatureTest.java index 694850259a..15fbe4c3f8 100644 --- a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveTrashFeatureTest.java +++ b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveTrashFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.googledrive; import ch.cyberduck.core.AbstractPath; import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.DisabledPasswordCallback; @@ -67,8 +68,8 @@ public class DriveTrashFeatureTest extends AbstractDriveTest { final String fileId = file.attributes().getFileId(); new DriveTrashFeature(session, fileid).delete(Collections.singletonList(file), new DisabledPasswordCallback(), new Delete.DisabledCallback()); assertFalse(new DriveFindFeature(session, fileid).find(file)); - assertTrue(new DriveFindFeature(session, fileid).find(file.withAttributes(new PathAttributes().setFileId(fileId)))); - final PathAttributes attributesInTrash = new DriveAttributesFinderFeature(session, fileid).find(file.withAttributes(new PathAttributes().setFileId(fileId))); + assertTrue(new DriveFindFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes().setFileId(fileId)))); + final PathAttributes attributesInTrash = new DriveAttributesFinderFeature(session, fileid).find(file.withAttributes(new DefaultPathAttributes().setFileId(fileId))); assertTrue(attributesInTrash.isTrashed()); new DriveTrashFeature(session, fileid).delete(Collections.singletonList(file.withAttributes(attributesInTrash)), new DisabledPasswordCallback(), new Delete.DisabledCallback()); assertFalse(new DriveFindFeature(session, fileid).find(file.withAttributes(attributesInTrash))); diff --git a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveVersioningFeatureTest.java b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveVersioningFeatureTest.java index 6431b459d7..eedf8b4114 100644 --- a/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveVersioningFeatureTest.java +++ b/googledrive/src/test/java/ch/cyberduck/core/googledrive/DriveVersioningFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.googledrive; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -56,7 +57,7 @@ public class DriveVersioningFeatureTest extends AbstractDriveTest { assertEquals(test.attributes().getVersionId(), attr.find(test).getVersionId()); final DriveVersioningFeature feature = new DriveVersioningFeature(session, fileid); assertEquals(0, feature.list(test, new DisabledListProgressListener()).size()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); { final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeature.java b/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeature.java index 0eca396bc6..a48f97a614 100644 --- a/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeature.java +++ b/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googlestorage; */ import ch.cyberduck.core.CancellingListProgressListener; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -142,7 +143,7 @@ public class GoogleStorageAttributesFinderFeature implements AttributesFinder, A } protected PathAttributes toAttributes(final Bucket bucket) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setRegion(bucket.getLocation()); attributes.setStorageClass(bucket.getStorageClass()); attributes.setCreationDate(bucket.getTimeCreated().getValue()); @@ -159,7 +160,7 @@ public class GoogleStorageAttributesFinderFeature implements AttributesFinder, A @Override public PathAttributes toAttributes(final StorageObject object) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); if(object.getSize() != null) { attributes.setSize(object.getSize().longValue()); } diff --git a/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageObjectListService.java b/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageObjectListService.java index af4c4a8b67..05016cd5aa 100644 --- a/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageObjectListService.java +++ b/googlestorage/src/main/java/ch/cyberduck/core/googlestorage/GoogleStorageObjectListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.googlestorage; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -151,7 +152,7 @@ public class GoogleStorageObjectListService implements ListService { } else { final Path file; - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setRegion(bucket.attributes().getRegion()); if(null == delimiter) { // When searching for files recursively @@ -206,7 +207,7 @@ public class GoogleStorageObjectListService implements ListService { return pool.execute(new BackgroundExceptionCallable() { @Override public Path call() throws BackgroundException { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setRegion(bucket.attributes().getRegion()); final String key = StringUtils.removeEnd(prefix, String.valueOf(Path.DELIMITER)); try { diff --git a/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeatureTest.java b/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeatureTest.java index a9f5cc885b..5f82bbcfcd 100644 --- a/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeatureTest.java +++ b/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageAttributesFinderFeatureTest.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.googlestorage; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AsciiRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -80,13 +81,13 @@ public class GoogleStorageAttributesFinderFeatureTest extends AbstractGoogleStor new StreamCopier(status, status).transfer(new ByteArrayInputStream(content), out); out.close(); final Path update = new Path(container, test.getName(), test.getType(), - new PathAttributes().setVersionId(String.valueOf(out.getStatus().getGeneration()))); + new DefaultPathAttributes().setVersionId(String.valueOf(out.getStatus().getGeneration()))); final PathAttributes attributes = new GoogleStorageAttributesFinderFeature(session).find(update); assertFalse(attributes.isDuplicate()); final AttributedList versions = new GoogleStorageVersioningFeature(session).list(update, new DisabledListProgressListener()); assertEquals(1, versions.size()); assertFalse(versions.isEmpty()); - assertEquals(new Path(test).withAttributes(new PathAttributes(test.attributes()).setVersionId(versionId)), versions.get(0)); + assertEquals(new Path(test).withAttributes(new DefaultPathAttributes(test.attributes()).setVersionId(versionId)), versions.get(0)); for(Path version : versions) { assertTrue(version.attributes().isDuplicate()); } diff --git a/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageReadFeatureTest.java b/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageReadFeatureTest.java index 026562f23c..25484e365f 100644 --- a/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageReadFeatureTest.java +++ b/googlestorage/src/test/java/ch/cyberduck/core/googlestorage/GoogleStorageReadFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.googlestorage; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.BytecountStreamListener; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -180,7 +181,7 @@ public class GoogleStorageReadFeatureTest extends AbstractGoogleStorageTest { status.setChecksum(new SHA256ChecksumCompute().compute(new ByteArrayInputStream(content), status)); final HttpResponseOutputStream out = new GoogleStorageWriteFeature(session).write(file, status, new DisabledConnectionCallback()); new StreamCopier(new TransferStatus(), new TransferStatus()).transfer(new ByteArrayInputStream(content), out); - assertEquals(0L, new GoogleStorageAttributesFinderFeature(session).find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(initialVersion))).getSize()); + assertEquals(0L, new GoogleStorageAttributesFinderFeature(session).find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(initialVersion))).getSize()); // Read previous version status.setLength(0L); final InputStream in = new GoogleStorageReadFeature(session).read(file, status, new DisabledConnectionCallback()); diff --git a/irods/src/main/java/ch/cyberduck/core/irods/IRODSAttributesFinderFeature.java b/irods/src/main/java/ch/cyberduck/core/irods/IRODSAttributesFinderFeature.java index 8abbc111bd..9837f4290b 100644 --- a/irods/src/main/java/ch/cyberduck/core/irods/IRODSAttributesFinderFeature.java +++ b/irods/src/main/java/ch/cyberduck/core/irods/IRODSAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.irods; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -57,7 +58,7 @@ public class IRODSAttributesFinderFeature implements AttributesFinder, Attribute @Override public PathAttributes toAttributes(final ObjStat stats) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setModificationDate(stats.getModifiedAt().getTime()); attributes.setCreationDate(stats.getCreatedAt().getTime()); attributes.setSize(stats.getObjSize()); diff --git a/irods/src/main/java/ch/cyberduck/core/irods/IRODSListService.java b/irods/src/main/java/ch/cyberduck/core/irods/IRODSListService.java index 9df21070b9..a06b9c37a9 100644 --- a/irods/src/main/java/ch/cyberduck/core/irods/IRODSListService.java +++ b/irods/src/main/java/ch/cyberduck/core/irods/IRODSListService.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.irods; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -61,7 +62,7 @@ public class IRODSListService implements ListService { if(StringUtils.equals(normalized, directory.getAbsolute())) { continue; } - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); final ObjStat stats = fs.getObjStat(file.getAbsolutePath()); attributes.setModificationDate(stats.getModifiedAt().getTime()); attributes.setCreationDate(stats.getCreatedAt().getTime()); diff --git a/manta/src/main/java/ch/cyberduck/core/manta/MantaMoveFeature.java b/manta/src/main/java/ch/cyberduck/core/manta/MantaMoveFeature.java index d8efbf4d72..a7c53f3a5e 100644 --- a/manta/src/main/java/ch/cyberduck/core/manta/MantaMoveFeature.java +++ b/manta/src/main/java/ch/cyberduck/core/manta/MantaMoveFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.manta; import ch.cyberduck.core.ConnectionCallback; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -48,7 +49,7 @@ public class MantaMoveFeature implements Move { try { session.getClient().move(file.getAbsolute(), renamed.getAbsolute()); // Copy original file attributes - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setVault(null)); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null)); } catch(MantaException e) { throw new MantaExceptionMappingService().map("Cannot rename {0}", e, file); diff --git a/manta/src/main/java/ch/cyberduck/core/manta/MantaObjectAttributeAdapter.java b/manta/src/main/java/ch/cyberduck/core/manta/MantaObjectAttributeAdapter.java index 3f2f617c4d..affd0daa18 100644 --- a/manta/src/main/java/ch/cyberduck/core/manta/MantaObjectAttributeAdapter.java +++ b/manta/src/main/java/ch/cyberduck/core/manta/MantaObjectAttributeAdapter.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.manta; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultWebUrlProvider; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.Path; @@ -41,7 +42,7 @@ public final class MantaObjectAttributeAdapter implements AttributesAdapter type = EnumSet.copyOf(DEFAULT_NAME.getType()); - final Path path = new Path(directory, DEFAULT_NAME.getName(), type, new PathAttributes().setFileId(metadata.getId())); + final Path path = new Path(directory, DEFAULT_NAME.getName(), type, new DefaultPathAttributes().setFileId(metadata.getId())); path.setSymlinkTarget( new Path(SITES_NAME, metadata.getSiteCollection().getHostname(), SITES_NAME.getType(), - new PathAttributes().setFileId(metadata.getId()))); + new DefaultPathAttributes().setFileId(metadata.getId()))); return Optional.of(path); } catch(IOException ex) { diff --git a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/GraphAttributesFinderFeature.java b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/GraphAttributesFinderFeature.java index eaa7ef4e0d..ae7f803256 100644 --- a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/GraphAttributesFinderFeature.java +++ b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/GraphAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.onedrive.features; */ import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -93,7 +94,7 @@ public class GraphAttributesFinderFeature implements AttributesFinder, Attribute @Override public PathAttributes toAttributes(final DriveItem.Metadata metadata) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setETag(metadata.getETag()); final File file = metadata.getFile(); if(file != null) { diff --git a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/GroupListService.java b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/GroupListService.java index e7dac7c1c8..c22bd26795 100644 --- a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/GroupListService.java +++ b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/GroupListService.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.onedrive.features.sharepoint; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.onedrive.AbstractListService; @@ -50,7 +51,7 @@ public class GroupListService extends AbstractListService { @Override protected Path toPath(final GroupItem.Metadata metadata, final Path directory) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setFileId(metadata.getId()); return new Path(directory, metadata.getDisplayName(), EnumSet.of(Path.Type.volume, Path.Type.directory, Path.Type.placeholder), attributes); } diff --git a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/SitesListService.java b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/SitesListService.java index 53f591f5b4..a728596658 100644 --- a/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/SitesListService.java +++ b/onedrive/src/main/java/ch/cyberduck/core/onedrive/features/sharepoint/SitesListService.java @@ -1,6 +1,7 @@ package ch.cyberduck.core.onedrive.features.sharepoint; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.NullFilter; import ch.cyberduck.core.Path; @@ -117,7 +118,7 @@ public class SitesListService extends AbstractListService { @Override protected Path toPath(final Site.Metadata metadata, final Path directory) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setFileId(metadata.getId()); attributes.setDisplayname(metadata.getDisplayName()); attributes.setLink(new DescriptiveUrl(metadata.getWebUrl())); diff --git a/onedrive/src/test/java/ch/cyberduck/core/onedrive/OneDriveVersioningFeatureTest.java b/onedrive/src/test/java/ch/cyberduck/core/onedrive/OneDriveVersioningFeatureTest.java index e9d590372d..4a9daf57e0 100644 --- a/onedrive/src/test/java/ch/cyberduck/core/onedrive/OneDriveVersioningFeatureTest.java +++ b/onedrive/src/test/java/ch/cyberduck/core/onedrive/OneDriveVersioningFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.onedrive; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledPasswordCallback; @@ -72,7 +73,7 @@ public class OneDriveVersioningFeatureTest extends AbstractOneDriveTest { } assertEquals(test.attributes().getFileId(), new GraphAttributesFinderFeature(session, fileid).find(test).getFileId()); assertEquals(0, feature.list(test, new DisabledListProgressListener()).size()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); status.setLength(content.length); diff --git a/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointSessionTest.java b/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointSessionTest.java index 015488c3d1..6e313f60a3 100644 --- a/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointSessionTest.java +++ b/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointSessionTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.onedrive; */ import ch.cyberduck.core.AbstractPath; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Host; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -77,7 +78,7 @@ public class SharepointSessionTest { @Test public void testContainerEquality() { final Path source = new Path("/Default/Drives/Docs", EnumSet.of(Path.Type.directory)) - .withAttributes(new PathAttributes() + .withAttributes(new DefaultPathAttributes() .setFileId("File Id")); final Path target = new Path("/Default/Drives/Docs", EnumSet.of(Path.Type.directory)); final GraphSession.ContainerItem sourceItem = session.getContainer(source); diff --git a/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointVersioningFeatureTest.java b/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointVersioningFeatureTest.java index 54516bcd17..b982d4d00c 100644 --- a/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointVersioningFeatureTest.java +++ b/onedrive/src/test/java/ch/cyberduck/core/onedrive/SharepointVersioningFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.onedrive; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledPasswordCallback; @@ -74,7 +75,7 @@ public class SharepointVersioningFeatureTest extends AbstractSharepointTest { } assertEquals(test.attributes().getFileId(), new GraphAttributesFinderFeature(session, fileid).find(test).getFileId()); assertEquals(0, feature.list(test, new DisabledListProgressListener()).size()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); assertNotNull(initialAttributes.getVersionId()); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftAttributesFinderFeature.java b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftAttributesFinderFeature.java index da32ca6ce6..af0deaafb4 100644 --- a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftAttributesFinderFeature.java +++ b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftAttributesFinderFeature.java @@ -20,6 +20,7 @@ package ch.cyberduck.core.openstack; import ch.cyberduck.core.CancellingListProgressListener; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathContainerService; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -78,7 +79,7 @@ public class SwiftAttributesFinderFeature implements AttributesFinder, Attribute if(containerService.isContainer(file)) { final ContainerInfo info = session.getClient().getContainerInfo(region, containerService.getContainer(file).getName()); - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(info.getTotalSize()); attributes.setRegion(info.getRegion().getRegionId()); return attributes; @@ -112,7 +113,7 @@ public class SwiftAttributesFinderFeature implements AttributesFinder, Attribute // Try to find pending large file upload final Write.Append append = new SwiftLargeObjectUploadFeature(session, regionService).append(file, new TransferStatus()); if(append.append) { - return new PathAttributes().setSize(append.offset); + return new DefaultPathAttributes().setSize(append.offset); } throw e; } @@ -140,7 +141,7 @@ public class SwiftAttributesFinderFeature implements AttributesFinder, Attribute @Override public PathAttributes toAttributes(final StorageObject object) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); if(StringUtils.isNotBlank(object.getMd5sum())) { // For manifest files, the ETag in the response for a GET or HEAD on the manifest file is the MD5 sum of // the concatenated string of ETags for each of the segments in the manifest. @@ -166,7 +167,7 @@ public class SwiftAttributesFinderFeature implements AttributesFinder, Attribute } public PathAttributes toAttributes(final ObjectMetadata metadata) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(Long.parseLong(metadata.getContentLength())); final String lastModified = metadata.getLastModified(); try { diff --git a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftContainerListService.java b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftContainerListService.java index 8fc6e05978..1b0cc4d48a 100644 --- a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftContainerListService.java +++ b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftContainerListService.java @@ -20,6 +20,7 @@ package ch.cyberduck.core.openstack; import ch.cyberduck.core.AttributedList; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -73,7 +74,7 @@ public class SwiftContainerListService implements RootListService { do { chunk = client.listContainers(r, limit, marker); for(final Container f : chunk) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setRegion(f.getRegion().getRegionId()); containers.add(new Path(String.format("/%s", f.getName()), EnumSet.of(Path.Type.volume, Path.Type.directory), attributes)); diff --git a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftLargeObjectCopyFeature.java b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftLargeObjectCopyFeature.java index bd095c5df5..c7aa006efa 100644 --- a/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftLargeObjectCopyFeature.java +++ b/openstack/src/main/java/ch/cyberduck/core/openstack/SwiftLargeObjectCopyFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.openstack; import ch.cyberduck.core.ConnectionCallback; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathContainerService; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; @@ -127,7 +128,7 @@ public class SwiftLargeObjectCopyFeature implements Copy { catch(IOException e) { throw new DefaultIOExceptionMappingService().map("Cannot copy {0}", e, source); } - final PathAttributes attributes = new PathAttributes(source.attributes()); + final PathAttributes attributes = new DefaultPathAttributes(source.attributes()); attributes.setChecksum(new Checksum(HashAlgorithm.md5, stored.getMd5sum())); return new Path(target).withAttributes(attributes); } diff --git a/osx/src/main/java/ch/cyberduck/ui/cocoa/datasource/BrowserTableDataSource.java b/osx/src/main/java/ch/cyberduck/ui/cocoa/datasource/BrowserTableDataSource.java index 5c6b29fc90..6ed721ad3f 100644 --- a/osx/src/main/java/ch/cyberduck/ui/cocoa/datasource/BrowserTableDataSource.java +++ b/osx/src/main/java/ch/cyberduck/ui/cocoa/datasource/BrowserTableDataSource.java @@ -29,20 +29,7 @@ import ch.cyberduck.binding.foundation.NSFileManager; import ch.cyberduck.binding.foundation.NSMutableArray; import ch.cyberduck.binding.foundation.NSObject; import ch.cyberduck.binding.foundation.NSURL; -import ch.cyberduck.core.AbstractHostCollection; -import ch.cyberduck.core.Acl; -import ch.cyberduck.core.AttributedList; -import ch.cyberduck.core.Cache; -import ch.cyberduck.core.Host; -import ch.cyberduck.core.HostParser; -import ch.cyberduck.core.Local; -import ch.cyberduck.core.LocalFactory; -import ch.cyberduck.core.LocaleFactory; -import ch.cyberduck.core.Path; -import ch.cyberduck.core.PathAttributes; -import ch.cyberduck.core.Permission; -import ch.cyberduck.core.Scheme; -import ch.cyberduck.core.UserDateFormatterFactory; +import ch.cyberduck.core.*; import ch.cyberduck.core.cache.LRUCache; import ch.cyberduck.core.date.AbstractUserDateFormatter; import ch.cyberduck.core.exception.AccessDeniedException; @@ -198,7 +185,7 @@ public abstract class BrowserTableDataSource extends ProxyController implements log.debug("Set new value {} for item {}", value, item); if(identifier.equals(BrowserColumn.filename.name())) { if(StringUtils.isNotBlank(value.toString()) && !item.getName().equals(value.toString())) { - final Path renamed = new Path(item.getParent(), value.toString(), item.getType(), new PathAttributes(item.attributes()).setVersionId(null)); + final Path renamed = new Path(item.getParent(), value.toString(), item.getType(), new DefaultPathAttributes(item.attributes()).setVersionId(null)); new MoveController(controller).rename(item, renamed); } } diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesAdapter.java b/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesAdapter.java index de4f690841..831a94a4a9 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesAdapter.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesAdapter.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.s3; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Host; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.features.AttributesAdapter; @@ -44,7 +45,7 @@ public class S3AttributesAdapter implements AttributesAdapter { @Override public PathAttributes toAttributes(final StorageObject object) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(object.getContentLength()); final Date lastmodified = object.getLastModifiedDate(); if(lastmodified != null) { diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesFinderFeature.java b/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesFinderFeature.java index 5413d9116f..8e0599ae8a 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesFinderFeature.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3AttributesFinderFeature.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.CancellingListProgressListener; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -56,7 +57,7 @@ public class S3AttributesFinderFeature implements AttributesFinder { return PathAttributes.EMPTY; } if(containerService.isContainer(file)) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); log.debug("Read location for bucket {}", file); attributes.setRegion(new S3LocationFeature(session, session.getClient().getRegionEndpointCache()).getLocation(file).getIdentifier()); return attributes; @@ -64,7 +65,7 @@ public class S3AttributesFinderFeature implements AttributesFinder { if(file.getType().contains(Path.Type.upload)) { final Write.Append append = new S3MultipartUploadService(session, acl).append(file, new TransferStatus()); if(append.append) { - return new PathAttributes().setSize(append.offset); + return new DefaultPathAttributes().setSize(append.offset); } throw new NotfoundException(file.getAbsolute()); } @@ -80,7 +81,7 @@ public class S3AttributesFinderFeature implements AttributesFinder { case 405: log.debug("Mark file {} as delete marker", file); // Only DELETE method is allowed for delete markers - attr = new PathAttributes(); + attr = new DefaultPathAttributes(); attr.setTrashed(true); return attr; } @@ -131,7 +132,7 @@ public class S3AttributesFinderFeature implements AttributesFinder { if(HostPreferencesFactory.get(session.getHost()).getBoolean("s3.upload.multipart.lookup")) { final Write.Append append = new S3MultipartUploadService(session, acl).append(file, new TransferStatus()); if(append.append) { - return new PathAttributes().setSize(append.offset); + return new DefaultPathAttributes().setSize(append.offset); } } } diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3BucketListService.java b/s3/src/main/java/ch/cyberduck/core/s3/S3BucketListService.java index bff3a9249b..ac75201f3f 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3BucketListService.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3BucketListService.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -55,7 +56,7 @@ public class S3BucketListService implements RootListService { final AttributedList buckets = new AttributedList<>(); // List all buckets owned for(StorageBucket b : session.getClient().listAllBuckets()) { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); final Path bucket = new Path(PathNormalizer.normalize(b.getName()), EnumSet.of(Path.Type.volume, Path.Type.directory), attr); if(b.getOwner() != null) { // Null if the owner is not available diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3CopyFeature.java b/s3/src/main/java/ch/cyberduck/core/s3/S3CopyFeature.java index 8729b12e01..f6b91f4a27 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3CopyFeature.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3CopyFeature.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; import ch.cyberduck.core.Acl; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.LocaleFactory; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -88,7 +89,7 @@ public class S3CopyFeature implements Copy { destination.setBucketName(bucket.isRoot() ? StringUtils.EMPTY : bucket.getName()); destination.replaceAllMetadata(new HashMap<>(new S3MetadataFeature(session, acl).getMetadata(source))); final CopyResult result = this.copy(source, destination, status, listener); - return new Path(target).withAttributes(new PathAttributes(source.attributes()) + return new Path(target).withAttributes(new DefaultPathAttributes(source.attributes()) .setVersionId(HostPreferencesFactory.get(session.getHost()).getBoolean("s3.listing.versioning.enable") ? result.versionId : null) .setETag(StringUtils.remove(result.etag, '"'))); } diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3ListService.java b/s3/src/main/java/ch/cyberduck/core/s3/S3ListService.java index e3136708cf..f9e5eb275f 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3ListService.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3ListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -94,7 +95,7 @@ public class S3ListService implements ListService { if(HostPreferencesFactory.get(session.getHost()).getBoolean("s3.upload.multipart.lookup")) { try { for(MultipartUpload upload : new S3DefaultMultipartService(session).find(directory)) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setHidden(true); attributes.setVersionId(upload.getUploadId()); attributes.setModificationDate(upload.getInitiatedDate().getTime()); diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3MoveFeature.java b/s3/src/main/java/ch/cyberduck/core/s3/S3MoveFeature.java index 64ff0bfba5..0983c33173 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3MoveFeature.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3MoveFeature.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.PathContainerService; @@ -84,7 +85,7 @@ public class S3MoveFeature implements Move { try { target = proxy.copy(source, renamed, status, connectionCallback, new DisabledStreamListener()); // Copy source path and nullify version id to add a delete marker - delete.delete(Collections.singletonMap(new Path(source).withAttributes(new PathAttributes(source.attributes()).setVersionId(null)), status), + delete.delete(Collections.singletonMap(new Path(source).withAttributes(new DefaultPathAttributes(source.attributes()).setVersionId(null)), status), connectionCallback, callback); } catch(NotfoundException e) { diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3ObjectListService.java b/s3/src/main/java/ch/cyberduck/core/s3/S3ObjectListService.java index badff165e6..00ffdee702 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3ObjectListService.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3ObjectListService.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -124,7 +125,7 @@ public class S3ObjectListService extends S3AbstractListService implements ListSe continue; } final Path f; - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setRegion(bucket.attributes().getRegion()); if(null == delimiter) { f = new Path(String.format("%s/%s", bucket.getAbsolute(), key), diff --git a/s3/src/main/java/ch/cyberduck/core/s3/S3VersionedObjectListService.java b/s3/src/main/java/ch/cyberduck/core/s3/S3VersionedObjectListService.java index 39388ad1d2..d62b1a13fd 100644 --- a/s3/src/main/java/ch/cyberduck/core/s3/S3VersionedObjectListService.java +++ b/s3/src/main/java/ch/cyberduck/core/s3/S3VersionedObjectListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.s3; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -114,7 +115,7 @@ public class S3VersionedObjectListService extends S3AbstractListService implemen hasDirectoryPlaceholder = true; continue; } - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setVersionId(marker.getVersionId()); if(!StringUtils.equals(lastKey, key)) { // Reset revision for next file @@ -218,7 +219,7 @@ public class S3VersionedObjectListService extends S3AbstractListService implemen return pool.execute(new BackgroundExceptionCallable() { @Override public Path call() throws BackgroundException { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setRegion(bucket.attributes().getRegion()); final String key = StringUtils.removeEnd(prefix, String.valueOf(Path.DELIMITER)); try { diff --git a/s3/src/test/java/ch/cyberduck/core/cryptomator/S3VersioningFeatureTest.java b/s3/src/test/java/ch/cyberduck/core/cryptomator/S3VersioningFeatureTest.java index 1b41ddf177..1e1a523501 100644 --- a/s3/src/test/java/ch/cyberduck/core/cryptomator/S3VersioningFeatureTest.java +++ b/s3/src/test/java/ch/cyberduck/core/cryptomator/S3VersioningFeatureTest.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.cryptomator; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -78,7 +79,7 @@ public class S3VersioningFeatureTest extends AbstractS3Test { final AttributesFinder f = cryptomator.getFeature(session, AttributesFinder.class, new S3AttributesFinderFeature(session, acl)); final Path test = new CryptoTouchFeature<>(session, new S3TouchFeature(session, acl), cryptomator).touch( new CryptoWriteFeature<>(session, new S3WriteFeature(session, new S3AccessControlListFeature(session)), cryptomator), new Path(vault, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus()); - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final String initialVersion = test.attributes().getVersionId(); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/s3/src/test/java/ch/cyberduck/core/s3/S3MultipartUploadServiceTest.java b/s3/src/test/java/ch/cyberduck/core/s3/S3MultipartUploadServiceTest.java index 31b94f0ddc..12277fd673 100644 --- a/s3/src/test/java/ch/cyberduck/core/s3/S3MultipartUploadServiceTest.java +++ b/s3/src/test/java/ch/cyberduck/core/s3/S3MultipartUploadServiceTest.java @@ -3,6 +3,7 @@ package ch.cyberduck.core.s3; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.BytecountStreamListener; import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -342,7 +343,7 @@ public class S3MultipartUploadServiceTest extends AbstractS3Test { public void testSize() throws Exception { final S3AccessControlListFeature acl = new S3AccessControlListFeature(session); final S3MultipartUploadService feature = new S3MultipartUploadService(session, acl, 5 * 1024L * 1024L, 5); - final Write.Append append = feature.append(new Path("/p", EnumSet.of(Path.Type.file)), new TransferStatus().setLength(0L).setRemote(new PathAttributes().setSize(3L))); + final Write.Append append = feature.append(new Path("/p", EnumSet.of(Path.Type.file)), new TransferStatus().setLength(0L).setRemote(new DefaultPathAttributes().setSize(3L))); assertFalse(append.append); assertEquals(0L, append.offset, 0L); } diff --git a/s3/src/test/java/ch/cyberduck/core/s3/S3TouchFeatureTest.java b/s3/src/test/java/ch/cyberduck/core/s3/S3TouchFeatureTest.java index b5c8ec7564..59d9adc919 100644 --- a/s3/src/test/java/ch/cyberduck/core/s3/S3TouchFeatureTest.java +++ b/s3/src/test/java/ch/cyberduck/core/s3/S3TouchFeatureTest.java @@ -1,6 +1,7 @@ package ch.cyberduck.core.s3; import ch.cyberduck.core.AsciiRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -107,23 +108,23 @@ public class S3TouchFeatureTest extends AbstractS3Test { assertTrue(new S3FindFeature(session, acl).find(file)); assertTrue(new DefaultFindFeature(session).find(file)); assertTrue(new DefaultFindFeature(session).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version1)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version1)))); assertTrue(new DefaultFindFeature(session).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version2)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version2)))); assertTrue(new S3FindFeature(session, acl).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version1)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version1)))); assertTrue(new S3FindFeature(session, acl).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version2)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version2)))); new S3DefaultDeleteFeature(session, acl).delete(Collections.singletonList(new Path(file).withAttributes(PathAttributes.EMPTY)), new DisabledLoginCallback(), new Delete.DisabledCallback()); // Versioned files are not deleted but with delete marker added assertTrue(new DefaultFindFeature(session).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version1)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version1)))); assertTrue(new DefaultFindFeature(session).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version2)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version2)))); assertTrue(new S3FindFeature(session, acl).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version1)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version1)))); assertTrue(new S3FindFeature(session, acl).find(new Path(file.getParent(), file.getName(), file.getType(), - new PathAttributes(file.attributes()).setVersionId(version2)))); + new DefaultPathAttributes(file.attributes()).setVersionId(version2)))); } @Test(expected = AccessDeniedException.class) diff --git a/s3/src/test/java/ch/cyberduck/core/s3/S3VersionedObjectListServiceTest.java b/s3/src/test/java/ch/cyberduck/core/s3/S3VersionedObjectListServiceTest.java index cd553d1767..da6c22adda 100644 --- a/s3/src/test/java/ch/cyberduck/core/s3/S3VersionedObjectListServiceTest.java +++ b/s3/src/test/java/ch/cyberduck/core/s3/S3VersionedObjectListServiceTest.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.s3; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AsciiRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathPredicate; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; @@ -191,7 +192,7 @@ public class S3VersionedObjectListServiceTest extends AbstractS3Test { assertEquals(1, versions.size()); assertEquals(versions.get(0), list.get(1)); new S3DefaultDeleteFeature(session, acl).delete(Arrays.asList( - new Path(file).withAttributes(new PathAttributes().setVersionId("null")), + new Path(file).withAttributes(new DefaultPathAttributes().setVersionId("null")), new Path(file).withAttributes(new DefaultAttributesFinderFeature(session).find(file)), bucket), new DisabledLoginCallback(), new Delete.DisabledCallback()); } diff --git a/s3/src/test/java/ch/cyberduck/core/s3/S3VersioningFeatureTest.java b/s3/src/test/java/ch/cyberduck/core/s3/S3VersioningFeatureTest.java index ced7b566ce..37ff29c9ff 100644 --- a/s3/src/test/java/ch/cyberduck/core/s3/S3VersioningFeatureTest.java +++ b/s3/src/test/java/ch/cyberduck/core/s3/S3VersioningFeatureTest.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.s3; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledListProgressListener; import ch.cyberduck.core.DisabledLoginCallback; @@ -100,7 +101,7 @@ public class S3VersioningFeatureTest extends AbstractS3Test { final HttpResponseOutputStream out = writer.write(ignored, status, new DisabledConnectionCallback()); new StreamCopier(status, status).transfer(new ByteArrayInputStream(content), out); } - final PathAttributes initialAttributes = new PathAttributes(test.attributes()); + final PathAttributes initialAttributes = new DefaultPathAttributes(test.attributes()); final String initialVersion = test.attributes().getVersionId(); final byte[] content = RandomUtils.nextBytes(32769); final TransferStatus status = new TransferStatus(); diff --git a/s3/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java b/s3/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java index 7ef3df9552..1ccd932a20 100644 --- a/s3/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java +++ b/s3/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.shared; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.CachingAttributesFinderFeature; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.ListProgressListener; @@ -108,19 +109,19 @@ public class CachingAttributesFinderFeatureTest extends AbstractS3Test { final HttpResponseOutputStream out = new S3WriteFeature(session, acl).write(file, status, new DisabledConnectionCallback()); IOUtils.copy(new ByteArrayInputStream(content), out); out.close(); - assertEquals(initialVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(initialVersion))).getVersionId()); + assertEquals(initialVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(initialVersion))).getVersionId()); final String newVersion = ((S3Object) out.getStatus()).getVersionId(); try { - f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(newVersion))); + f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(newVersion))); fail(); } catch(NotfoundException e) { // Expected } cache.clear(); - assertEquals(newVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); + assertEquals(newVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); assertEquals(newVersion, f.find(file.withAttributes(PathAttributes.EMPTY)).getVersionId()); - assertNotEquals(initialVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); + assertNotEquals(initialVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); assertEquals(new S3AttributesAdapter(session.getHost()).toAttributes(out.getStatus()).getVersionId(), f.find(file).getVersionId()); new S3DefaultDeleteFeature(session, acl).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); } diff --git a/s3/src/test/java/ch/cyberduck/core/shared/DefaultAttributesFinderFeatureTest.java b/s3/src/test/java/ch/cyberduck/core/shared/DefaultAttributesFinderFeatureTest.java index 2bdc027a96..164e3ea706 100644 --- a/s3/src/test/java/ch/cyberduck/core/shared/DefaultAttributesFinderFeatureTest.java +++ b/s3/src/test/java/ch/cyberduck/core/shared/DefaultAttributesFinderFeatureTest.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.shared; */ import ch.cyberduck.core.AlphanumericRandomStringService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledConnectionCallback; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.Path; @@ -85,10 +86,10 @@ public class DefaultAttributesFinderFeatureTest extends AbstractS3Test { final HttpResponseOutputStream out = new S3WriteFeature(session, acl).write(file, status, new DisabledConnectionCallback()); IOUtils.copy(new ByteArrayInputStream(content), out); out.close(); - assertEquals(initialVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(initialVersion))).getVersionId()); + assertEquals(initialVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(initialVersion))).getVersionId()); final String newVersion = ((S3Object) out.getStatus()).getVersionId(); - assertEquals(newVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); - assertNotEquals(initialVersion, f.find(file.withAttributes(new PathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); + assertEquals(newVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); + assertNotEquals(initialVersion, f.find(file.withAttributes(new DefaultPathAttributes(file.attributes()).setVersionId(newVersion))).getVersionId()); assertEquals(new S3AttributesAdapter(session.getHost()).toAttributes(out.getStatus()).getVersionId(), f.find(file).getVersionId()); new S3DefaultDeleteFeature(session, acl).delete(Collections.singletonList(file), new DisabledLoginCallback(), new Delete.DisabledCallback()); } diff --git a/smb/src/main/java/ch/cyberduck/core/smb/SMBAttributesFinderFeature.java b/smb/src/main/java/ch/cyberduck/core/smb/SMBAttributesFinderFeature.java index d408039342..adc8ddae20 100644 --- a/smb/src/main/java/ch/cyberduck/core/smb/SMBAttributesFinderFeature.java +++ b/smb/src/main/java/ch/cyberduck/core/smb/SMBAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.smb; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -45,7 +46,7 @@ public class SMBAttributesFinderFeature implements AttributesFinder, AttributesA try { if(new SMBPathContainerService(session).isContainer(file)) { final ShareInfo shareInformation = share.get().getShareInformation(); - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); final long used = shareInformation.getTotalSpace() - shareInformation.getFreeSpace(); attributes.setSize(used); attributes.setQuota(new Quota.Space(used, shareInformation.getFreeSpace())); @@ -72,7 +73,7 @@ public class SMBAttributesFinderFeature implements AttributesFinder, AttributesA @Override public PathAttributes toAttributes(final FileAllInformation model) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setAccessedDate(model.getBasicInformation().getLastAccessTime().toEpochMillis()); attributes.setModificationDate(model.getBasicInformation().getLastWriteTime().toEpochMillis()); attributes.setCreationDate(model.getBasicInformation().getCreationTime().toEpochMillis()); diff --git a/smb/src/main/java/ch/cyberduck/core/smb/SMBListService.java b/smb/src/main/java/ch/cyberduck/core/smb/SMBListService.java index 74027f0601..4a1f7e65fe 100644 --- a/smb/src/main/java/ch/cyberduck/core/smb/SMBListService.java +++ b/smb/src/main/java/ch/cyberduck/core/smb/SMBListService.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.smb; */ import ch.cyberduck.core.AttributedList; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.ListService; import ch.cyberduck.core.Path; @@ -74,7 +75,7 @@ public class SMBListService implements ListService { else { type.add(Path.Type.file); } - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setAccessedDate(f.getLastAccessTime().toEpochMillis()); attr.setModificationDate(f.getLastWriteTime().toEpochMillis()); attr.setCreationDate(f.getCreationTime().toEpochMillis()); diff --git a/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraAttributesFinderFeature.java b/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraAttributesFinderFeature.java index 2092c7ae00..4bb530263c 100644 --- a/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraAttributesFinderFeature.java +++ b/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraAttributesFinderFeature.java @@ -16,6 +16,7 @@ package ch.cyberduck.core.spectra; */ import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -80,7 +81,7 @@ public class SpectraAttributesFinderFeature implements AttributesFinder, Attribu @Override public PathAttributes toAttributes(final HeadObjectResponse object) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); attributes.setSize(object.getObjectSize()); final Map metadata = new HashMap<>(); for(String key : object.getMetadata().keys()) { diff --git a/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraObjectListService.java b/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraObjectListService.java index 65316a7666..ea9f2661f0 100644 --- a/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraObjectListService.java +++ b/spectra/src/main/java/ch/cyberduck/core/spectra/SpectraObjectListService.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.spectra; import ch.cyberduck.core.AttributedList; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -122,7 +123,7 @@ public class SpectraObjectListService extends S3AbstractListService { if(new Path(bucket, key, EnumSet.of(Path.Type.directory)).equals(directory)) { continue; } - objects.add(new Path(directory, PathNormalizer.name(key), EnumSet.of(Path.Type.directory, Path.Type.placeholder), new PathAttributes())); + objects.add(new Path(directory, PathNormalizer.name(key), EnumSet.of(Path.Type.directory, Path.Type.placeholder), new DefaultPathAttributes())); } marker = response.getListBucketResult().getNextMarker(); listener.chunk(directory, objects); @@ -145,7 +146,7 @@ public class SpectraObjectListService extends S3AbstractListService { @NotNull private PathAttributes toAttributes(final Contents object) { - final PathAttributes attr = new PathAttributes(); + final PathAttributes attr = new DefaultPathAttributes(); attr.setETag(object.getETag()); attr.setModificationDate(object.getLastModified().getTime()); attr.setOwner(object.getOwner().getDisplayName()); diff --git a/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPAttributesFinderFeature.java b/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPAttributesFinderFeature.java index 9ca1cc77c4..876b0118ae 100644 --- a/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPAttributesFinderFeature.java +++ b/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPAttributesFinderFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.sftp; * Bug fixes, suggestions and comments should be sent to feedback@cyberduck.ch */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -87,7 +88,7 @@ public class SFTPAttributesFinderFeature implements AttributesFinder, Attributes @Override public PathAttributes toAttributes(final FileAttributes stat) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); switch(stat.getType()) { case REGULAR: case UNKNOWN: diff --git a/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPMoveFeature.java b/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPMoveFeature.java index de5bd0f399..ddf45ddaf4 100644 --- a/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPMoveFeature.java +++ b/ssh/src/main/java/ch/cyberduck/core/sftp/SFTPMoveFeature.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.sftp; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.exception.BackgroundException; @@ -47,7 +48,7 @@ public class SFTPMoveFeature implements Move { session.sftp().rename(file.getAbsolute(), renamed.getAbsolute(), status.isExists() ? new HashSet<>(Arrays.asList(RenameFlags.OVERWRITE, RenameFlags.NATIVE)) : Collections.singleton(RenameFlags.NATIVE)); // Copy original file attributes - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setVault(null)); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null)); } catch(IOException e) { throw new SFTPExceptionMappingService().map("Cannot rename {0}", e, file); diff --git a/ssh/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java b/ssh/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java index 472e68fa5a..0eaf36eeb8 100644 --- a/ssh/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java +++ b/ssh/src/test/java/ch/cyberduck/core/shared/CachingAttributesFinderFeatureTest.java @@ -3,6 +3,7 @@ package ch.cyberduck.core.shared; import ch.cyberduck.core.AlphanumericRandomStringService; import ch.cyberduck.core.Attributes; import ch.cyberduck.core.CachingAttributesFinderFeature; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DisabledLoginCallback; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -77,7 +78,7 @@ public class CachingAttributesFinderFeatureTest extends AbstractSFTPTest { // Expected } cache.invalidate(workdir); - final PathAttributes newAttr = new PathAttributes(); + final PathAttributes newAttr = new DefaultPathAttributes(); assertSame(newAttr, new CachingAttributesFinderFeature(session, cache, new AttributesFinder() { @Override public PathAttributes find(final Path file, final ListProgressListener listener) { diff --git a/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateAttributesFinderFeature.java b/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateAttributesFinderFeature.java index bf51396e5d..9e64cc6ac2 100644 --- a/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateAttributesFinderFeature.java +++ b/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.storegate; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DefaultPathContainerService; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; @@ -67,7 +68,7 @@ public class StoregateAttributesFinderFeature implements AttributesFinder, Attri @Override public PathAttributes toAttributes(final File f) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); if(0 != f.getModified().getMillis()) { attrs.setModificationDate(f.getModified().getMillis()); } @@ -117,7 +118,7 @@ public class StoregateAttributesFinderFeature implements AttributesFinder, Attri } public PathAttributes toAttributes(final RootFolder f) { - final PathAttributes attrs = new PathAttributes(); + final PathAttributes attrs = new DefaultPathAttributes(); if(0 != f.getModified().getMillis()) { attrs.setModificationDate(f.getModified().getMillis()); } diff --git a/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateMoveFeature.java b/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateMoveFeature.java index 213bd29496..1c9eb66522 100644 --- a/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateMoveFeature.java +++ b/storegate/src/main/java/ch/cyberduck/core/storegate/StoregateMoveFeature.java @@ -17,6 +17,7 @@ package ch.cyberduck.core.storegate; import ch.cyberduck.core.ConnectionCallback; import ch.cyberduck.core.DefaultIOExceptionMappingService; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; import ch.cyberduck.core.exception.BackgroundException; @@ -72,7 +73,7 @@ public class StoregateMoveFeature implements Move { try { switch(response.getStatusLine().getStatusCode()) { case HttpStatus.SC_NO_CONTENT: - final PathAttributes attr = new PathAttributes(file.attributes()); + final PathAttributes attr = new DefaultPathAttributes(file.attributes()); fileid.cache(file, null); fileid.cache(renamed, attr.getFileId()); return new Path(renamed).withAttributes(attr); diff --git a/webdav/src/main/java/ch/cyberduck/core/dav/DAVAttributesFinderFeature.java b/webdav/src/main/java/ch/cyberduck/core/dav/DAVAttributesFinderFeature.java index ffe1f68be7..a2fd3c6360 100644 --- a/webdav/src/main/java/ch/cyberduck/core/dav/DAVAttributesFinderFeature.java +++ b/webdav/src/main/java/ch/cyberduck/core/dav/DAVAttributesFinderFeature.java @@ -15,6 +15,7 @@ package ch.cyberduck.core.dav; * GNU General Public License for more details. */ +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.ListProgressListener; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -110,7 +111,7 @@ public class DAVAttributesFinderFeature implements AttributesFinder, AttributesA protected PathAttributes head(final Path file) throws IOException { final Map headers = session.getClient().execute( new HttpHead(new DAVPathEncoder().encode(file)), new HeadersResponseHandler()); - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); try { attributes.setModificationDate(rfc1123.parse(headers.get(HttpHeaders.LAST_MODIFIED)).getTime()); } @@ -143,7 +144,7 @@ public class DAVAttributesFinderFeature implements AttributesFinder, AttributesA @Override public PathAttributes toAttributes(final DavResource resource) { - final PathAttributes attributes = new PathAttributes(); + final PathAttributes attributes = new DefaultPathAttributes(); final Map properties = resource.getCustomPropsNS(); if(null != properties && properties.containsKey(DAVTimestampFeature.LAST_MODIFIED_CUSTOM_NAMESPACE)) { final String value = properties.get(DAVTimestampFeature.LAST_MODIFIED_CUSTOM_NAMESPACE); diff --git a/webdav/src/main/java/ch/cyberduck/core/dav/DAVCopyFeature.java b/webdav/src/main/java/ch/cyberduck/core/dav/DAVCopyFeature.java index 516bb71e44..951199ca75 100644 --- a/webdav/src/main/java/ch/cyberduck/core/dav/DAVCopyFeature.java +++ b/webdav/src/main/java/ch/cyberduck/core/dav/DAVCopyFeature.java @@ -18,6 +18,7 @@ package ch.cyberduck.core.dav; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -59,7 +60,7 @@ public class DAVCopyFeature implements Copy { session.getClient().copy(new DAVPathEncoder().encode(source), target, status.isExists()); } listener.sent(status.getLength()); - return new Path(copy).withAttributes(new PathAttributes(source.attributes()).setLockId(null)); + return new Path(copy).withAttributes(new DefaultPathAttributes(source.attributes()).setLockId(null)); } catch(SardineException e) { throw new DAVExceptionMappingService().map("Cannot copy {0}", e, source); diff --git a/webdav/src/main/java/ch/cyberduck/core/dav/DAVMoveFeature.java b/webdav/src/main/java/ch/cyberduck/core/dav/DAVMoveFeature.java index bdd8072f60..5a3f5a610a 100644 --- a/webdav/src/main/java/ch/cyberduck/core/dav/DAVMoveFeature.java +++ b/webdav/src/main/java/ch/cyberduck/core/dav/DAVMoveFeature.java @@ -19,6 +19,7 @@ package ch.cyberduck.core.dav; */ import ch.cyberduck.core.ConnectionCallback; +import ch.cyberduck.core.DefaultPathAttributes; import ch.cyberduck.core.DescriptiveUrl; import ch.cyberduck.core.Path; import ch.cyberduck.core.PathAttributes; @@ -62,7 +63,7 @@ public class DAVMoveFeature implements Move { status.isExists()); } // Copy original file attributes - return new Path(renamed).withAttributes(new PathAttributes(file.attributes()).setVault(null).setLockId(null)); + return new Path(renamed).withAttributes(new DefaultPathAttributes(file.attributes()).setVault(null).setLockId(null)); } catch(SardineException e) { throw new DAVExceptionMappingService().map("Cannot rename {0}", e, file); diff --git a/windows/src/main/csharp/ch/cyberduck/ui/controller/BrowserController.cs b/windows/src/main/csharp/ch/cyberduck/ui/controller/BrowserController.cs index b1fe476cc5..15a18ec9cd 100644 --- a/windows/src/main/csharp/ch/cyberduck/ui/controller/BrowserController.cs +++ b/windows/src/main/csharp/ch/cyberduck/ui/controller/BrowserController.cs @@ -1687,7 +1687,7 @@ namespace Ch.Cyberduck.Ui.Controller for (int i = 0; i < _pasteboard.size(); i++) { Path next = (Path)_pasteboard.get(i); - Path renamed = new Path(parent, next.getName(), next.getType(), new PathAttributes(next.attributes())); + Path renamed = new Path(parent, next.getName(), next.getType(), new DefaultPathAttributes(next.attributes())); files.Add(next, renamed); } _pasteboard.clear();