Ticket #20310: 20310.1.patch

File 20310.1.patch, 15.3 KB (added by taylor.smock, 3 years ago)

Now with options

  • src/org/openstreetmap/josm/actions/OpenFileAction.java

     
    1616import java.util.Arrays;
    1717import java.util.Collection;
    1818import java.util.Collections;
     19import java.util.EnumSet;
    1920import java.util.HashSet;
    2021import java.util.LinkedHashSet;
    2122import java.util.LinkedList;
    2223import java.util.List;
     24import java.util.Objects;
    2325import java.util.Set;
    2426import java.util.concurrent.Future;
    2527import java.util.regex.Matcher;
    2628import java.util.regex.Pattern;
     29import java.util.stream.Stream;
    2730
    2831import javax.swing.JOptionPane;
    2932import javax.swing.SwingUtilities;
    … …  
    3740import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    3841import org.openstreetmap.josm.gui.io.importexport.AllFormatsImporter;
    3942import org.openstreetmap.josm.gui.io.importexport.FileImporter;
     43import org.openstreetmap.josm.gui.io.importexport.Options;
    4044import org.openstreetmap.josm.gui.util.GuiHelper;
    4145import org.openstreetmap.josm.gui.widgets.AbstractFileChooser;
    4246import org.openstreetmap.josm.io.OsmTransferException;
    … …  
    9599     * @since 11986 (return task)
    96100     */
    97101    public static Future<?> openFiles(List<File> fileList) {
    98         return openFiles(fileList, false);
     102        return openFiles(fileList, (Options[]) null);
    99103    }
    100104
    101105    /**
    … …  
    104108     * @param recordHistory {@code true} to save filename in history (default: false)
    105109     * @return the future task
    106110     * @since 11986 (return task)
     111     * @deprecated Since xxx, use {@link OpenFileAction#openFiles(List, Options...)} with {@link Options#RECORD_HISTORY} instead.
    107112     */
     113    @Deprecated
    108114    public static Future<?> openFiles(List<File> fileList, boolean recordHistory) {
     115        Options[] options = recordHistory ? new Options[] {Options.RECORD_HISTORY} : null;
     116        return openFiles(fileList, options);
     117    }
     118
     119    /**
     120     * Open a list of files. The complete list will be passed to batch importers.
     121     * @param fileList A list of files
     122     * @param options The options to use
     123     * @return the future task
     124     * @since xxx ({@link Options})
     125     */
     126    public static Future<?> openFiles(List<File> fileList, Options... options) {
    109127        OpenFileTask task = new OpenFileTask(fileList, null);
    110         task.setRecordHistory(recordHistory);
     128        task.setOptions(options);
    111129        return MainApplication.worker.submit(task);
    112130    }
    113131
    … …  
    121139        private final Set<String> failedAll = new HashSet<>();
    122140        private final FileFilter fileFilter;
    123141        private boolean canceled;
    124         private boolean recordHistory;
     142        private final EnumSet<Options> options = EnumSet.noneOf(Options.class);
    125143
    126144        /**
    127145         * Constructs a new {@code OpenFileTask}.
    … …  
    167185        /**
    168186         * Sets whether to save filename in history (for list of recently opened files).
    169187         * @param recordHistory {@code true} to save filename in history (default: false)
     188         * @deprecated since xxx (use {@link #setOptions} instead).
    170189         */
     190        @Deprecated
    171191        public void setRecordHistory(boolean recordHistory) {
    172             this.recordHistory = recordHistory;
     192            if (recordHistory) {
     193                this.options.add(Options.RECORD_HISTORY);
     194            } else {
     195                this.options.remove(Options.RECORD_HISTORY);
     196            }
    173197        }
    174198
    175199        /**
     200         * Set the options for the task.
     201         * @param options The options to set
     202         * @see Options
     203         */
     204        public void setOptions(Options[] options) {
     205            this.options.clear();
     206            if (options != null) {
     207                Stream.of(options).filter(Objects::nonNull).forEach(this.options::add);
     208            }
     209        }
     210
     211        /**
    176212         * Determines if filename must be saved in history (for list of recently opened files).
    177213         * @return {@code true} if filename must be saved in history
    178214         */
    179215        public boolean isRecordHistory() {
    180             return recordHistory;
     216            return this.options.contains(Options.RECORD_HISTORY);
    181217        }
    182218
     219        /**
     220         * Get the options for this task
     221         * @return A set of options
     222         */
     223        public Set<Options> getOptions() {
     224            return Collections.unmodifiableSet(this.options);
     225        }
     226
    183227        @Override
    184228        protected void cancel() {
    185229            this.canceled = true;
    … …  
    339383                }
    340384            }
    341385
    342             if (recordHistory) {
     386            if (this.options.contains(Options.RECORD_HISTORY)) {
    343387                Collection<String> oldFileHistory = Config.getPref().getList("file-open.history");
    344388                fileHistory.addAll(oldFileHistory);
    345389                // remove the files which failed to load from the list
    … …  
    355399         * @param files data files to import
    356400         */
    357401        public void importData(FileImporter importer, List<File> files) {
     402            importer.setOptions(this.options.toArray(new Options[0]));
    358403            if (importer.isBatchImporter()) {
    359404                if (canceled) return;
    360405                String msg = trn("Opening {0} file...", "Opening {0} files...", files.size(), files.size());
    … …  
    372417                    }
    373418                }
    374419            }
    375             if (recordHistory && !importer.isBatchImporter()) {
     420            if (this.options.contains(Options.RECORD_HISTORY) && !importer.isBatchImporter()) {
    376421                for (File f : files) {
    377422                    try {
    378423                        if (successfullyOpenedFiles.contains(f)) {

  • src/org/openstreetmap/josm/gui/io/importexport/FileImporter.java

     
    55
    66import java.io.File;
    77import java.io.IOException;
     8import java.util.EnumSet;
    89import java.util.List;
     10import java.util.Objects;
     11import java.util.stream.Stream;
    912
    1013import javax.swing.JOptionPane;
    1114
    … …  
    3639
    3740    private boolean enabled;
    3841
     42    protected final EnumSet<Options> options = EnumSet.noneOf(Options.class);
     43
    3944    /**
    4045     * Constructs a new {@code FileImporter} with the given extension file filter.
    4146     * @param filter The extension file filter
    … …  
    190195    public final void setEnabled(boolean enabled) {
    191196        this.enabled = enabled;
    192197    }
     198
     199    /**
     200     * Set the options for the {@code FileImporter}.
     201     * @param options The options to set
     202     * @since xxx
     203     */
     204    public final void setOptions(Options[] options) {
     205        this.options.clear();
     206        if (options != null) {
     207            Stream.of(options).filter(Objects::nonNull).forEach(this.options::add);
     208        }
     209    }
    193210}

  • src/org/openstreetmap/josm/gui/io/importexport/JpgImporter.java

     
    77import java.io.IOException;
    88import java.util.ArrayList;
    99import java.util.Arrays;
     10import java.util.EnumSet;
    1011import java.util.HashSet;
    1112import java.util.List;
    1213import java.util.Set;
     14import java.util.regex.Matcher;
     15import java.util.regex.Pattern;
    1316
    1417import org.openstreetmap.josm.actions.ExtensionFileFilter;
    1518import org.openstreetmap.josm.gui.layer.GpxLayer;
    1619import org.openstreetmap.josm.gui.layer.geoimage.GeoImageLayer;
    1720import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     21import org.openstreetmap.josm.io.CachedFile;
    1822import org.openstreetmap.josm.io.IllegalDataException;
    1923
    2024/**
    … …  
    2226 *
    2327 */
    2428public class JpgImporter extends FileImporter {
     29    /** Check if the filename starts with a borked path ({@link java.io.File#File} drops consecutive {@code /} characters). */
     30    private static final Pattern URL_START_BAD = Pattern.compile("^(https?:/)([^/].*)$");
     31    /** Check for the beginning of a "good" url */
     32    private static final Pattern URL_START_GOOD = Pattern.compile("^https?://.*$");
     33
    2534    private GpxLayer gpx;
    2635
    2736    /**
    … …  
    7382        try {
    7483            List<File> files = new ArrayList<>();
    7584            Set<String> visitedDirs = new HashSet<>();
    76             addRecursiveFiles(files, visitedDirs, sel, progressMonitor.createSubTaskMonitor(1, true));
     85            addRecursiveFiles(this.options, files, visitedDirs, sel, progressMonitor.createSubTaskMonitor(1, true));
    7786
    7887            if (progressMonitor.isCanceled())
    7988                return;
    … …  
    8998
    9099    static void addRecursiveFiles(List<File> files, Set<String> visitedDirs, List<File> sel, ProgressMonitor progressMonitor)
    91100            throws IOException {
     101        addRecursiveFiles(EnumSet.noneOf(Options.class), files, visitedDirs, sel, progressMonitor);
     102    }
    92103
     104    static void addRecursiveFiles(Set<Options> options, List<File> files, Set<String> visitedDirs, List<File> sel,
     105            ProgressMonitor progressMonitor) throws IOException {
     106
    93107        if (progressMonitor.isCanceled())
    94108            return;
    95109
    … …  
    100114                    if (visitedDirs.add(f.getCanonicalPath())) { // Do not loop over symlinks
    101115                        File[] dirFiles = f.listFiles(); // Can be null for some strange directories (like lost+found)
    102116                        if (dirFiles != null) {
    103                             addRecursiveFiles(files, visitedDirs, Arrays.asList(dirFiles), progressMonitor.createSubTaskMonitor(1, true));
     117                            addRecursiveFiles(options, files, visitedDirs, Arrays.asList(dirFiles),
     118                                    progressMonitor.createSubTaskMonitor(1, true));
    104119                        }
    105120                    } else {
    106121                        progressMonitor.worked(1);
    107122                    }
    108123                } else {
    109                     if (FILE_FILTER.accept(f)) {
     124                    /* Check if the path is a web path, and if so, ensure that it is "correct" */
     125                    final String path = f.getPath();
     126                    Matcher matcherBad = URL_START_BAD.matcher(path);
     127                    final String realPath;
     128                    if (matcherBad.matches()) {
     129                        realPath = matcherBad.replaceFirst(matcherBad.group(1) + "/" + matcherBad.group(2));
     130                    } else {
     131                        realPath = path;
     132                    }
     133                    if (URL_START_GOOD.matcher(realPath).matches() && FILE_FILTER.accept(f)
     134                            && options.contains(Options.ALLOW_WEB_RESOURCES)) {
     135                        try (CachedFile cachedFile = new CachedFile(realPath)) {
     136                            files.add(cachedFile.getFile());
     137                        }
     138                    } else if (FILE_FILTER.accept(f)) {
    110139                        files.add(f);
    111140                    }
    112141                    progressMonitor.worked(1);

  • src/org/openstreetmap/josm/gui/io/importexport/Options.java

     
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.gui.io.importexport;
     3
     4/**
     5 * Options for ImportExport classes. Not all ImportExport classes support all options.
     6 * @author Taylor Smock
     7 *
     8 */
     9public enum Options {
     10    /** Allow import/export of web resources */
     11    ALLOW_WEB_RESOURCES,
     12    /** Record history. Primarily used in OpenFileAction */
     13    RECORD_HISTORY
     14}

  • src/org/openstreetmap/josm/io/remotecontrol/PermissionPrefWithDefault.java

     
    2929    /** Open local files */
    3030    public static final PermissionPrefWithDefault OPEN_FILES =
    3131            new PermissionPrefWithDefault("remotecontrol.permission.open-files", false, tr("Open local files"));
     32    /** Open web files */
     33    public static final PermissionPrefWithDefault ALLOW_WEB_RESOURCES =
     34            new PermissionPrefWithDefault("remotecontrol.permission.open-remote-files", false, tr("Open remote files"));
    3235    /** Load imagery layers */
    3336    public static final PermissionPrefWithDefault LOAD_IMAGERY =
    3437            new PermissionPrefWithDefault("remotecontrol.permission.imagery", true, tr("Load imagery layers"));
    … …  
    4447    /** Read protocol version */
    4548    public static final PermissionPrefWithDefault READ_PROTOCOL_VERSION =
    4649            new PermissionPrefWithDefault("remotecontrol.permission.read-protocolversion", true, tr("Read protocol version"));
     50
    4751    /**
    4852     * name of the preference setting to permit the remote operation
    4953     */

  • src/org/openstreetmap/josm/io/remotecontrol/RequestProcessor.java

     
    162162            addRequestHandlerClass(LoadDataHandler.command, LoadDataHandler.class, true);
    163163            addRequestHandlerClass(ImportHandler.command, ImportHandler.class, true);
    164164            addRequestHandlerClass(OpenFileHandler.command, OpenFileHandler.class, true);
     165            PermissionPrefWithDefault.addPermissionPref(PermissionPrefWithDefault.ALLOW_WEB_RESOURCES);
    165166            addRequestHandlerClass(ImageryHandler.command, ImageryHandler.class, true);
    166167            PermissionPrefWithDefault.addPermissionPref(PermissionPrefWithDefault.CHANGE_SELECTION);
    167168            PermissionPrefWithDefault.addPermissionPref(PermissionPrefWithDefault.CHANGE_VIEWPORT);

  • src/org/openstreetmap/josm/io/remotecontrol/handler/OpenFileHandler.java

     
    55
    66import java.io.File;
    77import java.util.Arrays;
     8import java.util.EnumSet;
    89
    910import org.openstreetmap.josm.actions.OpenFileAction;
     11import org.openstreetmap.josm.gui.io.importexport.Options;
    1012import org.openstreetmap.josm.gui.util.GuiHelper;
    1113import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
    1214
    … …  
    4244
    4345    @Override
    4446    protected void handleRequest() throws RequestHandlerErrorException, RequestHandlerBadRequestException {
    45         GuiHelper.runInEDTAndWait(() -> OpenFileAction.openFiles(Arrays.asList(new File(args.get("filename")))));
     47        EnumSet<Options> options = EnumSet.noneOf(Options.class);
     48        if (PermissionPrefWithDefault.ALLOW_WEB_RESOURCES.isAllowed()) {
     49            options.add(Options.ALLOW_WEB_RESOURCES);
     50        }
     51        GuiHelper.runInEDTAndWait(() ->
     52            OpenFileAction.openFiles(Arrays.asList(new File(args.get("filename"))), options.toArray(new Options[0])));
    4653    }
    4754
    4855    @Override