source/ch/cyberduck/core/Archive.java

   1 package ch.cyberduck.core;
   2
   3 /*
   4  *  Copyright (c) 2008 David Kocher. All rights reserved.
   5  *  http://cyberduck.ch/
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  Bug fixes, suggestions and comments should be sent to:
  18  *  dkocher@cyberduck.ch
  19  */
  20
  21 import ch.cyberduck.core.preferences.Preferences;
  22 import ch.cyberduck.core.preferences.PreferencesFactory;
  23
  24 import org.apache.commons.lang3.StringUtils;
  25 import org.apache.log4j.Logger;
  26
  27 import java.text.MessageFormat;
  28 import java.util.ArrayList;
  29 import java.util.EnumSet;
  30 import java.util.List;
  31 import java.util.Locale;
  32
  33 /**
  34  * Description of an archive format
  35  *
  36  * @version $Id$
  37  */
  38 public abstract class Archive {
  39     private static final Logger log = Logger.getLogger(Archive.class);
  40
  41     private Preferences preferences
  42             = PreferencesFactory.get();
  43
  44     public static final Archive TAR
  45             = new Archive("tar") {
  46         @Override
  47         public String getDescription() {
  48             return LocaleFactory.localizedString("tar archive", "Archive");
  49         }
  50     };
  51
  52     public static final Archive TARGZ
  53             = new Archive("tar.gz") {
  54         @Override
  55         public String getDescription() {
  56             return LocaleFactory.localizedString("gzip compressed tar archive", "Archive");
  57         }
  58
  59         @Override
  60         public String[] getExtensions() {
  61             return new String[]{this.getIdentifier(), "tgz"};
  62         }
  63     };
  64
  65     public static final Archive TARBZ2
  66             = new Archive("tar.bz2") {
  67         @Override
  68         public String getDescription() {
  69             return LocaleFactory.localizedString("bzip2 compressed tar archive", "Archive");
  70         }
  71
  72         @Override
  73         public String[] getExtensions() {
  74             return new String[]{this.getIdentifier(), "tbz", "tbz2"};
  75         }
  76     };
  77
  78     public static final Archive ZIP
  79             = new Archive("zip") {
  80         @Override
  81         public String getDescription() {
  82             return LocaleFactory.localizedString("ZIP archive", "Archive");
  83         }
  84     };
  85
  86     public static final Archive GZIP
  87             = new Archive("gz") {
  88         @Override
  89         public String getDescription() {
  90             return LocaleFactory.localizedString("gzip compressed tar archive", "Archive");
  91         }
  92
  93         @Override
  94         public String[] getExtensions() {
  95             return new String[]{this.getIdentifier(), "gzip"};
  96         }
  97     };
  98
  99     public static final Archive BZ2
 100             = new Archive("bz2") {
 101         @Override
 102         public String getDescription() {
 103             return LocaleFactory.localizedString("bzip2 compressed archive", "Archive");
 104         }
 105
 106         @Override
 107         public String[] getExtensions() {
 108             return new String[]{this.getIdentifier(), "bz", "bzip2"};
 109         }
 110     };
 111
 112     /**
 113      * @return The default archiver set in the Preferences
 114      */
 115     public static Archive getDefault() {
 116         return Archive.forName(PreferencesFactory.get().getProperty("archive.default"));
 117     }
 118
 119     /**
 120      * @return List of archive types
 121      */
 122     public static Archive[] getKnownArchives() {
 123         return new Archive[]{TAR, TARGZ, TARBZ2, ZIP};
 124     }
 125
 126     /**
 127      * Factory
 128      *
 129      * @param name Identifier
 130      * @return Archive description
 131      */
 132     public static Archive forName(final String name) {
 133         if(StringUtils.isNotBlank(name)) {
 134             for(Archive archive : getKnownArchives()) {
 135                 for(String extension : archive.getExtensions()) {
 136                     if(name.toLowerCase(Locale.ROOT).endsWith(extension.toLowerCase(Locale.ROOT))) {
 137                         return archive;
 138                     }
 139                 }
 140             }
 141         }
 142         log.fatal(String.format("Unknown archive %s", name));
 143         return null;
 144     }
 145
 146     /**
 147      * Typical filename extension. The default
 148      */
 149     private String identifier;
 150
 151     /**
 152      * @param extension Filename extension for archive format
 153      */
 154     private Archive(final String extension) {
 155         this.identifier = extension;
 156     }
 157
 158     /**
 159      * @return Known filename extensions for archive format
 160      */
 161     public String[] getExtensions() {
 162         return new String[]{this.getIdentifier()};
 163     }
 164
 165     /**
 166      * @return Archive identifier
 167      */
 168     public String getIdentifier() {
 169         return identifier;
 170     }
 171
 172     public abstract String getDescription();
 173
 174     /**
 175      * @param files Files
 176      * @return Archived path for files
 177      */
 178     public Path getArchive(final List<Path> files) {
 179         if(files.size() == 0) {
 180             return null;
 181         }
 182         if(files.size() == 1) {
 183             return new Path(files.get(0).getParent(),
 184                     String.format("%s.%s", files.get(0).getName(), this.getIdentifier()),
 185                     EnumSet.of(Path.Type.file));
 186         }
 187         return new Path(files.get(0).getParent(),
 188                 String.format("%s.%s", LocaleFactory.localizedString("Archive", "Archive"), this.getIdentifier()),
 189                 EnumSet.of(Path.Type.file));
 190     }
 191
 192     /**
 193      * @param files Files
 194      * @return Expanded filenames
 195      */
 196     public List<Path> getExpanded(final List<Path> files) {
 197         final List<Path> expanded = new ArrayList<Path>();
 198         for(Path file : files) {
 199             expanded.add(new Path(file.getParent(),
 200                     StringUtils.remove(file.getName(), String.format(".%s", this.getIdentifier())), EnumSet.of(Path.Type.file)));
 201         }
 202         return expanded;
 203     }
 204
 205     /**
 206      * @param files Files to archive
 207      * @return Name of archive
 208      */
 209     public String getTitle(final List<Path> files) {
 210         final Path archive = this.getArchive(files);
 211         if(null == archive) {
 212             return this.getIdentifier();
 213         }
 214         return archive.getName();
 215     }
 216
 217     /**
 218      * @param workdir Working directory
 219      * @param files   Files to archive
 220      * @return Archive command
 221      */
 222     public String getCompressCommand(final Path workdir, final List<Path> files) {
 223         final StringBuilder archive = new StringBuilder();
 224         if(files.size() == 1) {
 225             archive.append(this.escape(files.get(0).getAbsolute()));
 226         }
 227         else {
 228             // Use default filename
 229             archive.append(this.escape(files.get(0).getParent().getAbsolute())).append(Path.DELIMITER).append("Archive");
 230         }
 231         final List<String> command = new ArrayList<String>();
 232         for(Path path : files) {
 233             command.add(this.escape(PathRelativizer.relativize(workdir.getAbsolute(), path.getAbsolute())));
 234         }
 235         return MessageFormat.format(preferences.getProperty(String.format("archive.command.create.%s", this.getIdentifier())),
 236                 archive.toString(), StringUtils.join(command, " "), this.escape(workdir.getAbsolute()));
 237     }
 238
 239     /**
 240      * @param path Filename
 241      * @return Unarchive command
 242      */
 243     public String getDecompressCommand(final Path path) {
 244         return MessageFormat.format(preferences.getProperty(String.format("archive.command.expand.%s", this.getIdentifier())),
 245                 this.escape(path.getAbsolute()), this.escape(path.getParent().getAbsolute()));
 246     }
 247
 248     /**
 249      * Escape blank
 250      *
 251      * @param path Filename
 252      * @return Escaped whitespace in path
 253      */
 254     protected String escape(final String path) {
 255         final StringBuilder escaped = new StringBuilder();
 256         for(char c : path.toCharArray()) {
 257             if(StringUtils.isAlphanumeric(String.valueOf(c))
 258                     || c == Path.DELIMITER) {
 259                 escaped.append(c);
 260             }
 261             else {
 262                 escaped.append("\\").append(c);
 263             }
 264         }
 265         return escaped.toString();
 266     }
 267
 268     /**
 269      * @param filename File extension to match with archive format
 270      * @return True if a known file extension for compressed archives
 271      */
 272     public static boolean isArchive(final String filename) {
 273         if(StringUtils.isNotBlank(filename)) {
 274             for(Archive archive : getKnownArchives()) {
 275                 for(String extension : archive.getExtensions()) {
 276                     if(filename.endsWith(extension)) {
 277                         return true;
 278                     }
 279                 }
 280             }
 281         }
 282         return false;
 283     }
 284 }