Ignore:
Timestamp:
2008-08-09T22:06:40+02:00 (16 years ago)
Author:
stoecker
Message:

Continued TagChecker development. Some other cleanups and fixed. Validator now requires recent josm version

Location:
applications/editors/josm/plugins/validator
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r9269 r9598  
    44import java.util.Map.Entry;
    55
     6import java.awt.event.MouseEvent;
     7
    68import javax.swing.JTree;
     9import javax.swing.ToolTipManager;
    710import javax.swing.tree.*;
    811
    912import org.openstreetmap.josm.plugins.validator.util.Bag;
     13import org.openstreetmap.josm.plugins.validator.util.MultipleNameVisitor;
    1014
    1115/**
    … …  
    1620 * @author frsantos
    1721 */
     22
    1823public class ErrorTreePanel extends JTree
    1924{
    20     /** Serializable ID */
    21     private static final long serialVersionUID = 2952292777351992696L;
    22 
    23     /**
    24     * The validation data.
    25     */
     25        /** Serializable ID */
     26        private static final long serialVersionUID = 2952292777351992696L;
     27
     28        /**
     29        * The validation data.
     30        */
    2631        protected DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
    2732
    28     /** The list of errors shown in the tree */
    29     private List<TestError> errors;
    30     /**
    31      * Constructor
    32      * @param errors The list of errors
    33      */
    34     public ErrorTreePanel(List<TestError> errors)
    35     {
    36         this.setModel(treeModel);
     33        /** The list of errors shown in the tree */
     34        private List<TestError> errors;
     35        /**
     36         * Constructor
     37         * @param errors The list of errors
     38         */
     39        public ErrorTreePanel(List<TestError> errors)
     40        {
     41                ToolTipManager.sharedInstance().registerComponent(this);
     42                this.setModel(treeModel);
    3743                this.setRootVisible(false);
    3844                this.setShowsRootHandles(true);
    … …  
    4147                this.setCellRenderer(new ErrorTreeRenderer());
    4248                this.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
    43         setErrorList(errors);
    44     }
    45 
    46     /**
    47      * Constructor
    48      */
    49     public ErrorTreePanel()
    50     {
    51         this(null);
    52     }
    53    
    54     @Override
    55     public void setVisible(boolean v)
    56     {
     49                setErrorList(errors);
     50                }
     51
     52        public String getToolTipText(MouseEvent e) {
     53                String res = null;
     54                TreePath path = getPathForLocation(e.getX(), e.getY());
     55                if (path != null)
     56                {
     57                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
     58                        Object nodeInfo = node.getUserObject();
     59
     60                        if (nodeInfo instanceof TestError)
     61                        {
     62                                TestError error = (TestError)nodeInfo;
     63                                MultipleNameVisitor v = new MultipleNameVisitor();
     64                                v.visit(error.getPrimitives());
     65                                res = "<html>" + v.getText() + "<br>" + error.getMessage();
     66                                String d = error.getDescription();
     67                                if(d != null)
     68                                        res += "<br>" + d;
     69                                res += "</html>";
     70                        }
     71                        else
     72                                res = node.toString();
     73                }
     74                return res;
     75        }
     76
     77        /** Constructor */
     78        public ErrorTreePanel()
     79        {
     80                this(null);
     81        }
     82
     83        @Override
     84        public void setVisible(boolean v)
     85        {
    5786                if (v)
    5887                        buildTree();
    … …  
    6190                super.setVisible(v);
    6291        }
    63    
    64    
     92
    6593        /**
    6694         * Builds the errors tree
    6795         */
    68         public void buildTree() 
     96        public void buildTree()
    6997        {
    7098                DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode();
    … …  
    76104                }
    77105
    78         // Remember the currently expanded rows
    79         Set<Object> oldSelectedRows = new HashSet<Object>();
    80         Enumeration<TreePath> expanded = getExpandedDescendants( new TreePath(getRoot()) );
    81         if( expanded != null )
    82         {
    83             while( expanded.hasMoreElements() )
    84             {
    85                 TreePath path = expanded.nextElement();
    86                 DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
    87                 Object userObject = node.getUserObject();
    88                 if( userObject instanceof Severity )
    89                     oldSelectedRows.add(userObject);
    90                 else if (userObject instanceof String)
    91                 {
    92                     String msg = (String)userObject;
    93                     msg = msg.substring(0, msg.lastIndexOf(" ("));
    94                     oldSelectedRows.add(msg);
    95                 }
    96             }
    97         }
    98        
     106                // Remember the currently expanded rows
     107                Set<Object> oldSelectedRows = new HashSet<Object>();
     108                Enumeration<TreePath> expanded = getExpandedDescendants( new TreePath(getRoot()) );
     109                if( expanded != null )
     110                {
     111                        while( expanded.hasMoreElements() )
     112                        {
     113                                TreePath path = expanded.nextElement();
     114                                DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
     115                                Object userObject = node.getUserObject();
     116                                if( userObject instanceof Severity )
     117                                        oldSelectedRows.add(userObject);
     118                                else if (userObject instanceof String)
     119                                {
     120                                        String msg = (String)userObject;
     121                                        msg = msg.substring(0, msg.lastIndexOf(" ("));
     122                                        oldSelectedRows.add(msg);
     123                                }
     124                        }
     125                }
     126
    99127                Map<Severity, Bag<String, TestError>> errorTree = new HashMap<Severity, Bag<String, TestError>>();
    100128                for(Severity s : Severity.values())
    … …  
    102130                        errorTree.put(s, new Bag<String, TestError>(20));
    103131                }
    104                
     132
    105133                for(TestError e : errors)
    106134                {
    107135                        errorTree.get(e.getSeverity()).add(e.getMessage(), e);
    108136                }
    109                
    110         List<TreePath> expandedPaths = new ArrayList<TreePath>();
     137
     138                List<TreePath> expandedPaths = new ArrayList<TreePath>();
    111139                for(Severity s : Severity.values())
    112140                {
    113                         Bag<String,     TestError> severityErrors = errorTree.get(s);
     141                        Bag<String, TestError> severityErrors = errorTree.get(s);
    114142                        if( severityErrors.isEmpty() )
    115143                                continue;
    116                        
     144
    117145                        // Severity node
    118146                        DefaultMutableTreeNode severityNode = new DefaultMutableTreeNode(s);
    119147                        rootNode.add(severityNode);
    120            
     148
    121149                        if( oldSelectedRows.contains(s))
    122                 expandedPaths.add( new TreePath( new Object[] {rootNode, severityNode} ) );
    123            
     150                                expandedPaths.add( new TreePath( new Object[] {rootNode, severityNode} ) );
     151
    124152                        for(Entry<String, List<TestError>> msgErrors : severityErrors.entrySet()  )
    125153                        {
    … …  
    130158                                severityNode.add(messageNode);
    131159
    132                 if( oldSelectedRows.contains(msgErrors.getKey()))
    133                     expandedPaths.add( new TreePath( new Object[] {rootNode, severityNode, messageNode} ) );
    134                
     160                                if( oldSelectedRows.contains(msgErrors.getKey()))
     161                                        expandedPaths.add( new TreePath( new Object[] {rootNode, severityNode, messageNode} ) );
     162
    135163                                for (TestError error : errors)
    136164                                {
    … …  
    142170                }
    143171
    144         treeModel.setRoot(rootNode);
    145         for( TreePath path : expandedPaths)
    146         {
    147             this.expandPath(path);
    148         }
    149         }
    150 
    151     /**
    152     * Sets the errors list used by a data layer
    153     * @param errors The error list that is used by a data layer
    154     */
    155     public void setErrorList(List<TestError> errors)
    156     {
    157         this.errors = errors;
    158         if( isVisible() )
    159                 buildTree();
    160     }
     172                treeModel.setRoot(rootNode);
     173                for( TreePath path : expandedPaths)
     174                {
     175                        this.expandPath(path);
     176                }
     177        }
     178
     179        /**
     180        * Sets the errors list used by a data layer
     181        * @param errors The error list that is used by a data layer
     182        */
     183        public void setErrorList(List<TestError> errors)
     184        {
     185                this.errors = errors;
     186                if( isVisible() )
     187                        buildTree();
     188        }
    161189
    162190        /**
    … …  
    195223        }
    196224
    197     /**
    198     * Expands all tree
    199     */
    200     @SuppressWarnings("unchecked")
    201     public void expandAll()
    202     {
    203         DefaultMutableTreeNode root = getRoot();
    204        
    205         int row = 0;
    206         Enumeration<DefaultMutableTreeNode> children = root.breadthFirstEnumeration();
    207         while( children.hasMoreElements() )
    208         {
    209             children.nextElement();
    210             expandRow(row++);
    211         }
    212     }
    213    
    214     /**
    215      * Returns the root node model.
    216     * @return The root node model
    217     */
    218     public DefaultMutableTreeNode getRoot()
    219     {
    220         return (DefaultMutableTreeNode) treeModel.getRoot();
    221     }
     225        /**
     226        * Expands all tree
     227        */
     228        @SuppressWarnings("unchecked")
     229        public void expandAll()
     230        {
     231                DefaultMutableTreeNode root = getRoot();
     232
     233                int row = 0;
     234                Enumeration<DefaultMutableTreeNode> children = root.breadthFirstEnumeration();
     235                while( children.hasMoreElements() )
     236                {
     237                        children.nextElement();
     238                        expandRow(row++);
     239                }
     240        }
     241
     242        /**
     243         * Returns the root node model.
     244        * @return The root node model
     245        */
     246        public DefaultMutableTreeNode getRoot()
     247        {
     248                return (DefaultMutableTreeNode) treeModel.getRoot();
     249        }
    222250}

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

    r2453 r9598  
    1414 * @author frsantos
    1515 */
    16 public class ErrorTreeRenderer extends DefaultTreeCellRenderer 
     16public class ErrorTreeRenderer extends DefaultTreeCellRenderer
    1717{
    18     /** Serializable ID */
    19     private static final long serialVersionUID = 5567632718124640198L;
     18        /** Serializable ID */
     19        private static final long serialVersionUID = 5567632718124640198L;
    2020
    21     @Override
     21        @Override
    2222        public Component getTreeCellRendererComponent(JTree tree, Object value,
    2323                        boolean selected, boolean expanded, boolean leaf, int row,
    … …  
    2727               
    2828                DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
    29                 Object nodeInfo = node.getUserObject();         
    30                
    31                 if (nodeInfo instanceof Severity) 
     29                Object nodeInfo = node.getUserObject();
     30
     31                if (nodeInfo instanceof Severity)
    3232                {
    3333                        Severity s = (Severity)nodeInfo;
    3434                        setIcon(ImageProvider.get("data", s.getIcon()));
    3535                }
    36                 else if (nodeInfo instanceof TestError) 
     36                else if (nodeInfo instanceof TestError)
    3737                {
    3838                        TestError error = (TestError)nodeInfo;

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

    r9270 r9598  
    2424        /** The error message */
    2525        private String message;
     26        /** Deeper error description */
     27        private String description;
    2628        /** The affected primitives */
    2729        private List<? extends OsmPrimitive> primitives;
    … …  
    3537        private boolean selected;
    3638       
    37         public TestError(Test tester, Severity severity, String message,
     39        /**
     40         * Constructors
     41         * @param tester The tester
     42         * @param severity The severity of this error
     43         * @param message The error message
     44         * @param primitive The affected primitive
     45         * @param primitives The affected primitives
     46         * @param internalCode The internal code
     47         */
     48        public TestError(Test tester, Severity severity, String message, String description,
    3849                        List<? extends OsmPrimitive> primitives, List<?> highlighted) {
    3950                this.tester = tester;
    4051                this.severity = severity;
    4152                this.message = message;
     53                this.description = description;
    4254                this.primitives = primitives;
    4355                this.highlighted = highlighted;
    4456        }
    45 
    46         /**
    47          * Constructor
    48          * @param tester The tester
    49          * @param severity The severity of this error
    50          * @param message The error message
    51          * @param primitives The affected primitives
    52          */
     57        public TestError(Test tester, Severity severity, String message, List<? extends OsmPrimitive> primitives, List<?> highlighted)
     58        {
     59                this(tester, severity, message, null, primitives, highlighted);
     60        }
     61        public TestError(Test tester, Severity severity, String message, String description, List<? extends OsmPrimitive> primitives)
     62        {
     63                this(tester, severity, message, description, primitives, primitives);
     64        }
    5365        public TestError(Test tester, Severity severity, String message, List<? extends OsmPrimitive> primitives)
    5466        {
    55                 this(tester, severity, message, primitives, primitives);
    56         }
    57        
    58         /**
    59          * Constructor
    60          * @param tester The tester
    61          * @param severity The severity of this error
    62          * @param message The error message
    63          * @param primitive The affected primitive
    64          */
     67                this(tester, severity, message, null, primitives, primitives);
     68        }
    6569        public TestError(Test tester, Severity severity, String message, OsmPrimitive primitive)
    6670        {
    67                 this(tester, severity, message, Collections.singletonList(primitive));
    68         }
    69        
    70         /**
    71          * Constructor
    72          * @param tester The tester
    73          * @param severity The severity of this error
    74          * @param message The error message
    75          * @param primitive The affected primitive
    76          * @param internalCode The internal code
    77          */
     71                this(tester, severity, message, null, Collections.singletonList(primitive), Collections.singletonList(primitive));
     72        }
     73        public TestError(Test tester, Severity severity, String message, String description, OsmPrimitive primitive)
     74        {
     75                this(tester, severity, message, description, Collections.singletonList(primitive));
     76        }
    7877        public TestError(Test tester, Severity severity, String message, OsmPrimitive primitive, int internalCode)
    7978        {
    80                 this(tester, severity, message, primitive);
     79                this(tester, severity, message, null, primitive);
    8180                this.internalCode = internalCode;
    8281        }
    83        
     82        public TestError(Test tester, Severity severity, String message, String description, OsmPrimitive primitive, int internalCode)
     83        {
     84                this(tester, severity, message, description, primitive);
     85                this.internalCode = internalCode;
     86        }
     87
    8488        /**
    8589         * Gets the error message
    8690         * @return the error message
    8791         */
    88         public String getMessage() 
     92        public String getMessage()
    8993        {
    9094                return message;
    9195        }
    92        
     96
     97        /**
     98         * Gets the error message
     99         * @return the error description
     100         */
     101        public String getDescription()
     102        {
     103                return description;
     104        }
     105
    93106        /**
    94107         * Sets the error message

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

    r9561 r9598  
    261261    }
    262262
    263         public void actionPerformed(ActionEvent e) 
     263        public void actionPerformed(ActionEvent e)
    264264        {
    265265                String actionCommand = e.getActionCommand();
    266                 if( actionCommand.equals("select"))
     266                if( actionCommand.equals("Select"))
    267267                        setSelectedItems();
    268                 else if( actionCommand.equals("validate"))
     268                else if( actionCommand.equals("Validate"))
    269269                        plugin.validateAction.actionPerformed(e);
    270                 else if( actionCommand.equals("fix"))
     270                else if( actionCommand.equals("Fix"))
    271271                        fixErrors(e);
    272                 else if( actionCommand.equals("ignore"))
     272                else if( actionCommand.equals("Ignore"))
    273273                        ignoreErrors(e);
    274274        }

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

    r9561 r9598  
    7070                                        else if (ws.way.get("railway") != null)
    7171                                                railway++;
    72                                         if (OsmUtils.getOsmBoolean(ws.way.get("area")))
     72                                        Boolean ar = OsmUtils.getOsmBoolean(ws.way.get("area"));
     73                                        if (ar != null && ar)
    7374                                                area++;
    7475                                        if (ws.way.get("landuse") != null || ws.way.get("natural") != null

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

    r9561 r9598  
    194194                                else if(tagcheckerfile)
    195195                                {
    196                                         CheckerData d = new CheckerData();
    197                                         String err = d.getData(line);
    198 
    199                                         if(err == null)
    200                                                 checkerData.add(d);
    201                                         else
    202                                                 System.err.println("Invalid tagchecker line - "+err+":" + line);
     196                                        if(line.length() > 0)
     197                                        {
     198                                                CheckerData d = new CheckerData();
     199                                                String err = d.getData(line);
     200
     201                                                if(err == null)
     202                                                        checkerData.add(d);
     203                                                else
     204                                                        System.err.println("Invalid tagchecker line - "+err+":" + line);
     205                                        }
    203206                                }
    204207                                else if( line.charAt(0) == '+' )
    … …  
    286289                        if( checkValues && (value==null || value.trim().length() == 0) && !withErrors.contains(p, "EV"))
    287290                        {
    288                                 errors.add( new TestError(this, Severity.WARNING, tr("Tags with empty values"), p, EMPTY_VALUES) );
     291                                errors.add( new TestError(this, Severity.WARNING, tr("Tags with empty values"), tr("Key ''{0}'' invalid.", key), p, EMPTY_VALUES) );
    289292                                withErrors.add(p, "EV");
    290293                        }
    291294                        if( checkKeys && spellCheckKeyData.containsKey(key) && !withErrors.contains(p, "IPK"))
    292295                        {
    293                                 errors.add( new TestError(this, Severity.WARNING, tr("Invalid property key ''{0}''", key), p, INVALID_KEY) );
     296                                errors.add( new TestError(this, Severity.WARNING, tr("Invalid property key"), tr("Key ''{0}'' invalid.", key), p, INVALID_KEY) );
    294297                                withErrors.add(p, "IPK");
    295298                        }
    296299                        if( checkKeys && key.indexOf(" ") >= 0 && !withErrors.contains(p, "IPK"))
    297300                        {
    298                                 errors.add( new TestError(this, Severity.WARNING, tr("Invalid white space in property key ''{0}''", key), p, INVALID_KEY) );
     301                                errors.add( new TestError(this, Severity.WARNING, tr("Invalid white space in property key"), tr("Key ''{0}'' invalid.", key), p, INVALID_KEY) );
    299302                                withErrors.add(p, "IPK");
    300303                        }
    301304                        if( checkValues && value != null && (value.startsWith(" ") || value.endsWith(" ")) && !withErrors.contains(p, "SPACE"))
    302305                        {
    303                                 errors.add( new TestError(this, Severity.OTHER, tr("Property values start or end with white space"), p, INVALID_SPACE) );
     306                                errors.add( new TestError(this, Severity.OTHER, tr("Property values start or end with white space"), tr("Key ''{0}'' invalid.", key), p, INVALID_SPACE) );
    304307                                withErrors.add(p, "SPACE");
    305308                        }
    … …  
    309312                                if( values != null && !values.contains(prop.getValue()) && !withErrors.contains(p, "UPV"))
    310313                                {
    311                                         errors.add( new TestError(this, Severity.OTHER, tr("Unknown property values"), p, INVALID_VALUE) );
     314                                        errors.add( new TestError(this, Severity.OTHER, tr("Unknown property values"), tr("Key ''{0}'' invalid.", key), p, INVALID_VALUE) );
    312315                                        withErrors.add(p, "UPV");
    313316                                }

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

    r9111 r9598  
    129129                                List<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
    130130                                primitives.add(w);
    131                                 errors.add(new TestError(this, Severity.WARNING, tr("Unclosed way: {0}",type), primitives));
     131                                errors.add(new TestError(this, Severity.WARNING, tr("Unclosed way"), type, primitives));
    132132                                _errorWays.add(w,w);
    133133                        }

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

    r8691 r9598  
    3434        {
    3535                String multipleName = null;
     36                String multiplePluralClassname = null;
    3637                String firstName = null;
    3738                boolean initializedname = false;
    … …  
    5657                        osm.visit(this);
    5758                        if (multipleClassname == null)
     59                        {
    5860                                multipleClassname = className;
     61                                multiplePluralClassname = classNamePlural;
     62                        }
    5963                        else if (!multipleClassname.equals(className))
     64                        {
    6065                                multipleClassname = "object";
     66                                multiplePluralClassname = trn("object", "objects", 2);
     67                        }
    6168                }
    62                
     69
    6370                if( size == 1 )
    6471                        displayName = name;
    6572                else if(multipleName != null)
    66                         displayName = size + " " + trn(multipleClassname, multipleClassname + "s", size) + ": " + multipleName;
     73                        displayName = size + " " + trn(multipleClassname, multiplePluralClassname, size) + ": " + multipleName;
    6774                else if(firstName != null)
    68                         displayName = size + " " + trn(multipleClassname, multipleClassname + "s", size) + ": " + tr("{0}, ...", firstName);
     75                        displayName = size + " " + trn(multipleClassname, multiplePluralClassname, size) + ": " + tr("{0}, ...", firstName);
    6976                else
    70                         displayName = size + " " + trn(multipleClassname, multipleClassname + "s", size);
     77                        displayName = size + " " + trn(multipleClassname, multiplePluralClassname, size);
    7178        }
    7279
    7380        @Override
    74         public JLabel toLabel() 
     81        public JLabel toLabel()
    7582        {
    7683                return new JLabel(getText(), getIcon(), JLabel.HORIZONTAL);
    7784        }
    78        
     85
    7986        /**
    8087         * Gets the name of the items

  • applications/editors/josm/plugins/validator/tagchecker.cfg

    r9269 r9598  
    2222# with and logical and (&&).
    2323#
     24# The comment at the end of a rule is displayed in validator
     25#
    2426# Empty lines and space signs are ignored
    2527
    26 node : bridge == *
    27 node : highway == tertiary
    28 node : highway == secondary
    29 way  : highway == secondary && ref != *
    30 way  : highway == tertiary && ref != *
     28node : bridge == *                                         # bridge tag on a node
     29node : highway == tertiary                                 # wrong highway tag on a node
     30node : highway == secondary                                # wrong highway tag on a node
     31way  : highway == secondary && ref != *                    # highway without a reference
     32way  : highway == tertiary && ref != *                     # highway without a reference
Note: See TracChangeset for help on using the changeset viewer.