Changeset 2591 in osm for applications


Ignore:
Timestamp:
2007-04-18T23:56:19+02:00 (18 years ago)
Author:
frsantos
Message:

Automatic fixes

Location:
applications/editors/josm/plugins/validator
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/Test.java

    r2453 r2591  
    11package org.openstreetmap.josm.plugins.validator;
    22
    3 import java.util.*;
     3import java.util.ArrayList;
     4import java.util.Collection;
     5import java.util.List;
    46
    57import javax.swing.JPanel;
    68
     9import org.openstreetmap.josm.command.Command;
    710import org.openstreetmap.josm.data.osm.*;
    811import org.openstreetmap.josm.data.osm.visitor.Visitor;
    … …  
    3033        /** The list of errors */
    3134        protected List<TestError> errors = new ArrayList<TestError>(30);
     35
     36        /** Whether the test is run on a partial selection data */
     37        protected boolean partialSelection;
    3238
    3339        /**
    … …  
    6672                errors = new ArrayList<TestError>(30);
    6773        }
     74
     75        /**
     76         * Flag notifying that this test is run over a partial data selection
     77         * @param partialSelection Whether the test is on a partial selection data
     78         */
     79        public void setPartialSelection(boolean partialSelection)
     80        {
     81                this.partialSelection = partialSelection;
     82        }
    6883       
    6984        /**
    … …  
    92107        for (OsmPrimitive p : selection)
    93108        {
    94             p.visit(this);
     109                if( !p.deleted )
     110                        p.visit(this);
    95111        }
    96112    }
    … …  
    116132        {
    117133        }
     134       
     135        /**
     136         * Fixes the error with the appropiate command
     137         *
     138         * @param testError
     139         * @return The command to fix the error
     140         */
     141        public Command fixError(TestError testError)
     142        {
     143                return null;
     144        }
     145       
     146        /**
     147         * Returns true if the given error can be fixed automatically
     148         *
     149         * @param testError The error to check if can be fixed
     150         * @return true if the error can be fixed
     151         */
     152        public boolean isFixable(TestError testError)
     153        {
     154                return false;
     155        }       
    118156}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/TestError.java

    r2453 r2591  
    44import java.util.List;
    55
     6import org.openstreetmap.josm.command.Command;
    67import org.openstreetmap.josm.data.osm.OsmPrimitive;
    78
    … …  
    1718        private String message;
    1819        /** The affected primitives */
    19         private List<? extends OsmPrimitive> primitives;
     20        private List<OsmPrimitive> primitives;
     21        /** The tester that raised this error */
     22        private Test tester;
     23        /** Internal code used by testers to classify errors */
     24        private int internalCode;
    2025       
    2126        /**
    … …  
    2833        /**
    2934         * Constructor
     35         * @param tester The tester
    3036         * @param severity The severity of this error
    3137         * @param message The error message
    3238         * @param primitives The affected primitives
    3339         */
    34         public TestError(Severity severity, String message, List<? extends OsmPrimitive> primitives)
     40        public TestError(Test tester, Severity severity, String message, List<OsmPrimitive> primitives)
    3541        {
     42                this.tester = tester;
    3643                this.severity = severity;
    3744                this.message = message;
    … …  
    4148        /**
    4249         * Constructor
     50         * @param tester The tester
    4351         * @param severity The severity of this error
    4452         * @param message The error message
    4553         * @param primitive The affected primitive
    4654         */
    47         public TestError(Severity severity, String message, OsmPrimitive primitive)
     55        public TestError(Test tester, Severity severity, String message, OsmPrimitive primitive)
    4856        {
     57                this.tester = tester;
    4958                this.severity = severity;
    5059                this.message = message;
    … …  
    5463               
    5564                this.primitives = primitives;
     65        }
     66       
     67        /**
     68         * Constructor
     69         * @param tester The tester
     70         * @param severity The severity of this error
     71         * @param message The error message
     72         * @param primitive The affected primitive
     73         * @param internalCode The internal code
     74         */
     75        public TestError(Test tester, Severity severity, String message, OsmPrimitive primitive, int internalCode)
     76        {
     77                this(tester, severity, message, primitive);
     78                this.internalCode = internalCode;
    5679        }
    5780       
    … …  
    78101         * @return the list of primitives affected by this error
    79102         */
    80         public List<? extends OsmPrimitive> getPrimitives()
     103        public List<OsmPrimitive> getPrimitives()
    81104        {
    82105                return primitives;
    … …  
    110133                this.severity = severity;
    111134        }
     135
     136        /**
     137         * Gets the tester that raised this error
     138         * @return the tester that raised this error
     139         */
     140        public Test getTester()
     141        {
     142                return tester;
     143        }
     144
     145        /**
     146         * Gets the internal code
     147         * @return the internal code
     148         */
     149        public int getInternalCode()
     150        {
     151                return internalCode;
     152        }
     153
     154       
     155        /**
     156         * Sets the internal code
     157         * @param internalCode The internal code
     158         */
     159        public void setInternalCode(int internalCode)
     160        {
     161                this.internalCode = internalCode;
     162        }
     163       
     164        /**
     165         * Returns true if the error can be fixed automatically
     166         *
     167         * @return true if the error can be fixed
     168         */
     169        public boolean isFixable()
     170        {
     171                return tester != null && tester.isFixable(this);
     172        }
     173       
     174        /**
     175         * Fixes the error with the appropiate command
     176         *
     177         * @return The command to fix the error
     178         */
     179        public Command getFix()
     180        {
     181                if( tester == null )
     182                        return null;
     183               
     184                return tester.fixError(this);
     185        }       
    112186}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ValidateAction.java

    r2453 r2591  
    2424    private static final long serialVersionUID = -2304521273582574603L;
    2525
     26        /** Last selection used to validate */
     27        private Collection<OsmPrimitive> lastSelection;
     28       
    2629    /**
    2730         * Constructor
    … …  
    3437        public void actionPerformed(ActionEvent ev)
    3538        {
     39                doValidate(ev, true);
     40        }
     41       
     42        /**
     43         * Does the validation.
     44         * <p>
     45         * If getSelectedItems is true, the selected items (or all items, if no one
     46         * is selected) are validated. If it is false, last selected items are
     47         * revalidated
     48         *
     49         * @param ev The event
     50         * @param getSelectedItems If selected or last selected items must be validated
     51         */
     52        public void doValidate(ActionEvent ev, boolean getSelectedItems)
     53        {
    3654                OSMValidatorPlugin plugin = OSMValidatorPlugin.getPlugin();
    3755                plugin.errors = new ArrayList<TestError>();
    … …  
    4260                        return;
    4361               
    44                 Collection<OsmPrimitive> selection = Main.ds.getSelected();
    45                 if( selection.isEmpty() )
    46                         selection = Main.ds.allNonDeletedPrimitives();
     62                Collection<OsmPrimitive> selection;
     63                if( getSelectedItems )
     64                {
     65                        selection = Main.ds.getSelected();
     66                        if( selection.isEmpty() )
     67                        {
     68                                selection = Main.ds.allNonDeletedPrimitives();
     69                                lastSelection = null;
     70                        }
     71                        else
     72                        {
     73                                AgregatePrimitivesVisitor v = new AgregatePrimitivesVisitor();
     74                                selection = v.visit(selection);
     75                                lastSelection = selection;
     76                        }
     77                }
    4778                else
    4879                {
    49                         AgregatePrimitivesVisitor v = new AgregatePrimitivesVisitor();
    50                         selection = v.visit(selection);
     80                        if( lastSelection == null )
     81                                selection = Main.ds.allNonDeletedPrimitives();
     82                        else
     83                                selection = lastSelection;
    5184                }
    5285
    5386                for(Test test : tests)
    5487        {
     88                        test.setPartialSelection(lastSelection != null);
    5589                    test.startTest();
    5690                    test.visit(selection);

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ValidatorDialog.java

    r2453 r2591  
    99import java.util.Map.Entry;
    1010
    11 import javax.swing.JPanel;
    12 import javax.swing.JScrollPane;
    13 import javax.swing.JTree;
     11import javax.swing.*;
     12import javax.swing.event.TreeSelectionEvent;
     13import javax.swing.event.TreeSelectionListener;
    1414import javax.swing.tree.*;
    1515
    1616import org.openstreetmap.josm.Main;
     17import org.openstreetmap.josm.command.Command;
     18import org.openstreetmap.josm.command.SequenceCommand;
    1719import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1820import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
    … …  
    4143     */
    4244    protected JTree tree = new JTree(treeModel);
     45
     46    /**
     47     * The fix button
     48     */
     49        private JButton fixButton;
    4350   
    4451
    … …  
    5461                tree.expandRow(0);
    5562                tree.setVisibleRowCount(8);
    56                 tree.addMouseListener(new DblClickWatch());
     63                tree.addMouseListener(new ClickWatch());
     64                tree.addTreeSelectionListener(new SelectionWatch());
    5765                tree.setCellRenderer(new ErrorTreeRenderer());
    5866                tree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
    … …  
    6573        add(buttonPanel, BorderLayout.SOUTH);
    6674        buttonPanel.add(Util.createButton("Validate", "dialogs/refresh", "Validate the data.", this));
     75        add(buttonPanel, BorderLayout.SOUTH);
     76        fixButton = Util.createButton("Fix", "dialogs/fix", "Fix the selected errors.", this);
     77        fixButton.setEnabled(false);
     78        buttonPanel.add(fixButton);
    6779        add(buttonPanel, BorderLayout.SOUTH);
    6880    }
    … …  
    136148        }
    137149       
     150        /**
     151         * Fix selected errors
     152         * @param e
     153         */
     154        @SuppressWarnings("unchecked")
     155        private void fixErrors(ActionEvent e)
     156        {
     157                DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
     158        if( node == null )
     159                return;
     160
     161        Bag<String, Command> commands = new Bag<String, Command>();
     162
     163                Enumeration<DefaultMutableTreeNode> children = node.breadthFirstEnumeration();
     164                while( children.hasMoreElements() )
     165                {
     166                DefaultMutableTreeNode childNode = children.nextElement();
     167                Object nodeInfo = childNode.getUserObject();
     168                if( nodeInfo instanceof TestError)
     169                {
     170                        TestError error = (TestError)nodeInfo;
     171                        Command fixCommand = error.getFix();
     172                        if( fixCommand != null )
     173                        {
     174                                commands.add(error.getMessage(), fixCommand);
     175                        }
     176                }
     177                }
     178               
     179                Command fixCommand = null;
     180                if( commands.size() == 0 )
     181                        return;
     182                else if( commands.size() > 1 )
     183                {
     184                        List<Command> allComands = new ArrayList<Command>(50);
     185                        for( Entry<String, List<Command>> errorType : commands.entrySet())
     186                        {
     187                                String description = errorType.getKey();
     188                                List<Command> errorCommands = errorType.getValue();
     189                                allComands.add( new SequenceCommand("Fix " + description, errorCommands) );
     190                        }
     191                       
     192                        fixCommand = new SequenceCommand("Fix errors", allComands);
     193                }
     194                else
     195                {
     196                        for( Entry<String, List<Command>> errorType : commands.entrySet())
     197                        {
     198                                String description = errorType.getKey();
     199                                List<Command> errorCommands = errorType.getValue();
     200                                fixCommand = new SequenceCommand("Fix " + description, errorCommands);
     201                        }
     202                }
     203               
     204                Main.main.editLayer().add( fixCommand );
     205                Main.map.repaint();
     206                Main.ds.fireSelectionChanged(Main.ds.getSelected());
     207                       
     208        OSMValidatorPlugin.getPlugin().validateAction.doValidate(e, false);
     209        }       
     210       
    138211    /**
    139212     * Sets the selection of the map to the current selected items.
    140213     */
    141214    @SuppressWarnings("unchecked")
    142     public void setSelectedItems()
     215    private void setSelectedItems()
    143216    {
    144217        Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>(40);
    … …  
    160233                }
    161234        }
     235       
    162236        Main.ds.setSelected(sel);
    163237    }
    … …  
    165239        public void actionPerformed(ActionEvent e)
    166240        {
    167                 if( e.getActionCommand().equals("Select"))
     241                String actionCommand = e.getActionCommand();
     242                if( actionCommand.equals("Select"))
    168243                        setSelectedItems();
    169                 else if( e.getActionCommand().equals("Validate"))
     244                else if( actionCommand.equals("Validate"))
    170245                OSMValidatorPlugin.getPlugin().validateAction.actionPerformed(e);
     246                else if( actionCommand.equals("Fix"))
     247                fixErrors(e);
     248        }
     249
     250        /**
     251         * Refresh the error messages display
     252         */
     253        public void refresh()
     254        {
     255                buildTree();
    171256        }
    172257       
    173         /**
    174          * Refresh the error messages display
    175          */
    176         public void refresh()
    177         {
    178                 buildTree();
    179         }
    180        
    181         /**
    182          * Watches for double clicks and from editing or new property, depending on the
    183          * location, the click was.
    184          * @author imi
    185          */
    186         public class DblClickWatch extends MouseAdapter
    187         {
    188         @SuppressWarnings("unchecked")
     258    /**
     259     * Checks for fixes in selected element and, if needed, adds to the sel parameter all selected elements
     260     * @param sel The collection where to add all selected elements
     261     * @param addSelected if true, add all selected elements to collection
     262     * @return whether the selected elements has any fix
     263     */
     264    @SuppressWarnings("unchecked")
     265        private boolean setSelection(Collection<OsmPrimitive> sel, boolean addSelected)
     266        {
     267                boolean hasFixes = false;
     268
     269                DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
     270        if( node == null )
     271                return hasFixes;
     272
     273                Enumeration<DefaultMutableTreeNode> children = node.breadthFirstEnumeration();
     274                while( children.hasMoreElements() )
     275                {
     276                DefaultMutableTreeNode childNode = children.nextElement();
     277                Object nodeInfo = childNode.getUserObject();
     278                if( nodeInfo instanceof TestError)
     279                {
     280                        TestError error = (TestError)nodeInfo;
     281                        hasFixes = hasFixes || error.isFixable();
     282                        if( addSelected )
     283                        {
     284                                sel.addAll( error.getPrimitives() );
     285                        }
     286                }
     287                }
     288               
     289                return hasFixes;
     290        }
     291   
     292        /**
     293         * Watches for clicks.
     294         */
     295        public class ClickWatch extends MouseAdapter
     296        {
    189297        @Override
    190298                public void mouseClicked(MouseEvent e)
    191299                {
    192                         if (e.getClickCount() < 2 || e.getSource() instanceof JScrollPane)
     300                fixButton.setEnabled(false);
     301               
     302                        if(e.getSource() instanceof JScrollPane)
    193303                                return;
    194                         else
     304               
     305                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
     306                if( node == null )
     307                        return;
     308
     309                Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>(40);
     310                        boolean isDblClick = e.getClickCount() > 1;
     311                       
     312                        boolean hasFixes = setSelection(sel, isDblClick);
     313                fixButton.setEnabled(hasFixes);
     314               
     315                if( isDblClick)
    195316                        {
    196                         Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>(40);
    197 
    198                         DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
    199                         Enumeration<DefaultMutableTreeNode> children = node.breadthFirstEnumeration();
    200                         while( children.hasMoreElements() )
    201                         {
    202                                 DefaultMutableTreeNode childNode = children.nextElement();
    203                                 Object nodeInfo = childNode.getUserObject();
    204                                 if( nodeInfo instanceof TestError)
    205                                 {
    206                                         TestError error = (TestError)nodeInfo;
    207                                         sel.addAll( error.getPrimitives() );
    208                                 }
    209                         }
    210317                        Main.ds.setSelected(sel);
    211318                        }
    212319                }
    213320        }
     321       
     322        /**
     323         * Watches for tree selection.
     324         */
     325        public class SelectionWatch implements TreeSelectionListener
     326        {
     327        @SuppressWarnings("unchecked")
     328                public void valueChanged(TreeSelectionEvent e)
     329                {
     330                fixButton.setEnabled(false);
     331               
     332                        if(e.getSource() instanceof JScrollPane)
     333                                return;
     334               
     335                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
     336                if( node == null )
     337                        return;
     338
     339                        boolean hasFixes = setSelection(null, false);
     340                fixButton.setEnabled(hasFixes);
     341                }
     342        }
    214343}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/DuplicateNode.java

    r2453 r2591  
    55import java.util.List;
    66
     7import org.openstreetmap.josm.command.Command;
     8import org.openstreetmap.josm.command.DeleteCommand;
    79import org.openstreetmap.josm.data.coor.LatLon;
    810import org.openstreetmap.josm.data.osm.Node;
     11import org.openstreetmap.josm.data.osm.OsmPrimitive;
    912import org.openstreetmap.josm.plugins.validator.Severity;
    1013import org.openstreetmap.josm.plugins.validator.Test;
    … …  
    1922{
    2023        /** Bag of all nodes */
    21         Bag<LatLon, Node> nodes;
     24        Bag<LatLon, OsmPrimitive> nodes;
    2225       
    2326        /**
    … …  
    3437        public void startTest()
    3538        {
    36                 nodes = new Bag<LatLon, Node>(1000);
     39                nodes = new Bag<LatLon, OsmPrimitive>(1000);
    3740        }
    3841
    … …  
    4043        public void endTest()
    4144        {
    42                 for(List<Node> duplicated : nodes.values() )
     45                for(List<OsmPrimitive> duplicated : nodes.values() )
    4346                {
    4447                        if( duplicated.size() > 1)
    4548                        {
    46                                 errors.add( new TestError(Severity.ERROR, tr("Duplicated nodes"), duplicated) );
     49                                TestError testError = new TestError(this, Severity.ERROR, tr("Duplicated nodes"), duplicated);
     50                                errors.add( testError );
    4751                        }
    4852                }
    … …  
    5559                nodes.add(n.coor, n);
    5660        }
     61       
     62        @Override
     63        public Command fixError(TestError testError)
     64        {
     65                //TODO Which should be the fix?
     66                return new DeleteCommand(testError.getPrimitives());
     67        }
     68       
     69        @Override
     70        public boolean isFixable(TestError testError)
     71        {
     72                return false; //(testError.getTester() instanceof DuplicateNode);
     73        }       
    5774}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/DuplicateSegment.java

    r2453 r2591  
    66
    77import org.openstreetmap.josm.data.coor.LatLon;
     8import org.openstreetmap.josm.data.osm.OsmPrimitive;
    89import org.openstreetmap.josm.data.osm.Segment;
    910import org.openstreetmap.josm.plugins.validator.Severity;
    … …  
    1920{
    2021        /** Bag of all segments */
    21         Bag<CompoundLatLon, Segment> segments;
     22        Bag<CompoundLatLon, OsmPrimitive> segments;
    2223       
    2324        /**
    … …  
    3536        public void startTest()
    3637        {
    37                 segments = new Bag<CompoundLatLon, Segment>(1000);
     38                segments = new Bag<CompoundLatLon, OsmPrimitive>(1000);
    3839        }
    3940
    … …  
    4142        public void endTest()
    4243        {
    43                 for(List<Segment> duplicated : segments.values() )
     44                for(List<OsmPrimitive> duplicated : segments.values() )
    4445                {
    4546                        if( duplicated.size() > 1)
    4647                        {
    47                                 errors.add( new TestError(Severity.ERROR, tr("Duplicated segments"), duplicated) );
     48                                errors.add( new TestError(this, Severity.ERROR, tr("Duplicated segments"), duplicated) );
    4849                        }
    4950                }

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/OrphanSegment.java

    r2453 r2591  
    4343                for(Segment segment : segments )
    4444                {
    45                         errors.add( new TestError(Severity.OTHER, tr("Segments not in a way"), segment) );
     45                        errors.add( new TestError(this, Severity.OTHER, tr("Segments not in a way"), segment) );
    4646                }
    4747                segments = null;

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/SingleNodeSegment.java

    r2453 r2591  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
     5import org.openstreetmap.josm.command.Command;
     6import org.openstreetmap.josm.command.DeleteCommand;
    57import org.openstreetmap.josm.data.osm.Segment;
    68import org.openstreetmap.josm.plugins.validator.Severity;
    … …  
    3133                if( !s.incomplete && s.from.equals(s.to) )
    3234                {
    33                         errors.add( new TestError(Severity.ERROR, tr("Single node segments"), s) );
     35                        errors.add( new TestError(this, Severity.ERROR, tr("Single node segments"), s) );
    3436                }
    3537        }
     38       
     39        @Override
     40        public Command fixError(TestError testError)
     41        {
     42                return new DeleteCommand(testError.getPrimitives());
     43        }
     44       
     45        @Override
     46        public boolean isFixable(TestError testError)
     47        {
     48                return (testError.getTester() instanceof SingleNodeSegment);
     49        }       
    3650}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/SpellCheck.java

    r2453 r2591  
    1313
    1414import org.openstreetmap.josm.Main;
     15import org.openstreetmap.josm.command.ChangePropertyCommand;
     16import org.openstreetmap.josm.command.Command;
     17import org.openstreetmap.josm.command.SequenceCommand;
    1518import org.openstreetmap.josm.data.osm.*;
    1619import org.openstreetmap.josm.gui.annotation.AnnotationPreset;
    … …  
    4548        protected JCheckBox prefCheckValues;
    4649
     50        /** Empty values error */
     51        protected static int EMPTY_VALUES       = 0;
     52        /** Invalid key error */
     53        protected static int INVALID_KEY        = 1;
     54        /** Invalid value error */
     55        protected static int INVALID_VALUE      = 2;
     56       
    4757        /**
    4858         * Constructor
    … …  
    161171                        if( (value==null || value.trim().length() == 0) && !withErrors.contains(p, "EV"))
    162172                        {
    163                                 errors.add( new TestError(Severity.WARNING, tr("Tags with empty value"), p) );
     173                                errors.add( new TestError(this, Severity.WARNING, tr("Tags with empty values"), p, EMPTY_VALUES) );
    164174                                withErrors.add(p, "EV");
    165175                        }
    166176                        if( spellCheckKeyData.containsKey(key) && !withErrors.contains(p, "IPK"))
    167177                        {
    168                                 errors.add( new TestError(Severity.WARNING, tr("Invalid property key"), p) );
     178                                errors.add( new TestError(this, Severity.WARNING, tr("Invalid property keys"), p, INVALID_KEY) );
    169179                                withErrors.add(p, "IPK");
    170180                        }
    … …  
    174184                                if( values != null && !values.contains(prop.getValue()) && !withErrors.contains(p, "UPV"))
    175185                                {
    176                                         errors.add( new TestError(Severity.OTHER, tr("Unknown property value"), p) );
     186                                        errors.add( new TestError(this, Severity.OTHER, tr("Unknown property values"), p, INVALID_VALUE) );
    177187                                        withErrors.add(p, "UPV");
    178188                                }
    … …  
    277287                Main.pref.put(PREF_CHECK_VALUES, prefCheckValues.isSelected());
    278288        }
     289       
     290        @Override
     291        public Command fixError(TestError testError)
     292        {
     293                List<Command> commands = new ArrayList<Command>(50);
     294               
     295                int i = -1;
     296                List<OsmPrimitive> primitives = testError.getPrimitives();
     297                for(OsmPrimitive p : primitives )
     298                {
     299                        i++;
     300                        Map<String, String> tags = p.keys;
     301                        if( tags == null || tags.size() == 0 )
     302                                continue;
     303               
     304                        for(Entry<String, String> prop: tags.entrySet() )
     305                        {
     306                                String key = prop.getKey();
     307                                String value = prop.getValue();
     308                                if( value == null || value.trim().length() == 0 )
     309                                        commands.add( new ChangePropertyCommand(primitives.subList(i, i+1), key, null) );
     310                                else
     311                                {
     312                                        String replacementKey = spellCheckKeyData.get(key);
     313                                        if( replacementKey != null )
     314                                                commands.add( new ChangePropertyKeyCommand(primitives.subList(i, i+1), key, replacementKey) );                                 
     315                                }
     316                        }
     317                }
     318               
     319                return commands.size() > 1 ? new SequenceCommand("Fix properties", commands) : commands.get(0);
     320        }
     321       
     322        @Override
     323        public boolean isFixable(TestError testError)
     324        {
     325                if( testError.getTester() instanceof SpellCheck)
     326                {
     327                        int code = testError.getInternalCode();
     328                        return code == INVALID_KEY || code == EMPTY_VALUES;
     329                }
     330               
     331                return false;
     332        }       
    279333}
    280334       

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/TaggedSegment.java

    r2453 r2591  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.util.Map;
     5import java.util.*;
    66
     7import org.openstreetmap.josm.command.*;
     8import org.openstreetmap.josm.data.osm.OsmPrimitive;
    79import org.openstreetmap.josm.data.osm.Segment;
    810import org.openstreetmap.josm.plugins.validator.Severity;
    … …  
    3537                if( tags == null )
    3638                        return;
     39                tags = new HashMap<String, String>(tags);
     40                for( String tag : allowedTags)
     41                        tags.remove(tag);
    3742               
    38                 int numAllowedTags = 0;
    39                 for( String tag : allowedTags)
    40                         if( tags.containsKey(tag) ) numAllowedTags++;
    41                
    42                 if( tags.size() - numAllowedTags > 0 )
     43                if( tags.size() > 0 )
    4344                {
    44                         errors.add( new TestError(Severity.WARNING, tr("Segments with tags"), s) );
     45                        errors.add( new TestError(this, Severity.WARNING, tr("Segments with tags"), s) );
    4546                }
    4647        }
     48       
     49        @Override
     50        public Command fixError(TestError testError)
     51        {
     52                List<Command> commands = new ArrayList<Command>(50);
     53               
     54                int i = -1;
     55                List<OsmPrimitive> primitives = testError.getPrimitives();
     56                for(OsmPrimitive p : primitives )
     57                {
     58                        i++;
     59                        Map<String, String> tags = p.keys;
     60                        if( tags == null )
     61                                continue;
     62                       
     63                        tags = new HashMap<String, String>(tags);
     64                        for( String tag : allowedTags)
     65                                tags.remove(tag);
     66                       
     67                        if( tags.size() == 0 )
     68                                continue;
     69               
     70                        for(String key : tags.keySet() )
     71                        {
     72                                commands.add( new ChangePropertyCommand(primitives.subList(i, i+1), key, null) );
     73                        }
     74                }
     75               
     76                return commands.size() > 1 ? new SequenceCommand("Remove keys", commands) : commands.get(0);
     77        }
     78       
     79        @Override
     80        public boolean isFixable(TestError testError)
     81        {
     82                return (testError.getTester() instanceof TaggedSegment);
     83        }       
    4784}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/UnorderedWay.java

    r2453 r2591  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
     5import java.util.*;
     6
     7import org.openstreetmap.josm.actions.ReorderAction;
     8import org.openstreetmap.josm.command.*;
     9import org.openstreetmap.josm.data.osm.OsmPrimitive;
    510import org.openstreetmap.josm.data.osm.Segment;
    611import org.openstreetmap.josm.data.osm.Way;
    … …  
    3338                        if( last != null && !last.incomplete && !s.incomplete && !last.to.equals(s.from) )
    3439                        {
    35                                 errors.add( new TestError(Severity.WARNING, tr("Unordered ways"), w) );
     40                                errors.add( new TestError(this, Severity.WARNING, tr("Unordered ways"), w) );
    3641                                break;
    3742                        }
    … …  
    3944                }
    4045        }
     46       
     47        @Override
     48        public Command fixError(TestError testError)
     49        {
     50                List<Command> commands = new ArrayList<Command>(50);
     51               
     52                for(OsmPrimitive p : testError.getPrimitives() )
     53                {
     54                        Way w = (Way)p;
     55                        Way newWay = new Way(w);
     56                        newWay.segments.clear();
     57                        newWay.segments.addAll(ReorderAction.sortSegments(new HashSet<Segment>(w.segments)));
     58                        return new ChangeCommand(p, newWay);
     59                }
     60               
     61                return commands.size() > 1 ? new SequenceCommand("Remove keys", commands) : commands.get(0);
     62        }
     63       
     64        @Override
     65        public boolean isFixable(TestError testError)
     66        {
     67                return (testError.getTester() instanceof UnorderedWay);
     68        }       
    4169}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/UntaggedNode.java

    r2453 r2591  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.util.HashSet;
    6 import java.util.Map;
    7 import java.util.Set;
     5import java.util.*;
    86
     7import org.openstreetmap.josm.Main;
     8import org.openstreetmap.josm.command.Command;
     9import org.openstreetmap.josm.command.DeleteCommand;
    910import org.openstreetmap.josm.data.osm.Node;
     11import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1012import org.openstreetmap.josm.data.osm.Segment;
    1113import org.openstreetmap.josm.plugins.validator.Severity;
    … …  
    1921public class UntaggedNode extends Test
    2022{
    21         /** Tags allowed in a segment */
     23        /** Tags allowed in a node */
    2224        public static String[] allowedTags = new String[] { "created_by" };
    2325       
    2426        /** Bag of all nodes */
    2527        Set<Node> emptyNodes;
    26 
     28       
    2729        /**
    2830         * Constructor
    … …  
    4042        }
    4143       
     44        @Override
     45    public void visit(Collection<OsmPrimitive> selection)
     46    {
     47                // If there is a partial selection, it may be false positives if a
     48                // node is selected, but not the container segment. So, in this
     49                // case, we must visit all segments, selected or not.
     50
     51                for (OsmPrimitive p : selection)
     52        {
     53                if( !p.deleted )
     54                {
     55                        if( !partialSelection || p instanceof Node )
     56                                p.visit(this);
     57                }
     58        }
     59       
     60                if( partialSelection )
     61                {
     62                        for( Segment s : Main.ds.segments)
     63                                visit(s);
     64                }
     65    }
     66   
    4267        @Override
    4368        public void visit(Node n)
    … …  
    7095                for(Node node : emptyNodes)
    7196                {
    72                         errors.add( new TestError(Severity.OTHER, tr("Untagged and unconnected nodes"), node) );
     97                        errors.add( new TestError(this, Severity.OTHER, tr("Untagged and unconnected nodes"), node) );
    7398                }
    7499                emptyNodes = null;
    75100        }
     101       
     102        @Override
     103        public Command fixError(TestError testError)
     104        {
     105                return new DeleteCommand(testError.getPrimitives());
     106        }
     107       
     108        @Override
     109        public boolean isFixable(TestError testError)
     110        {
     111                return (testError.getTester() instanceof UntaggedNode);
     112        }               
    76113}
Note: See TracChangeset for help on using the changeset viewer.