Regex zur Suche von "value-losen" Attributen in HTML Tags

[faetzminator]

Hallo zusammen,

Ich suche in XHTML (JSP) Dateien illegale, "alte" HTML Tag Attribute, welche nicht geschlossen werden, als Beispiel

<input type="checkbox" checked/>

nun schrieb ich folgende Regex zum Erkennen dieser (gesplittet zum vereinfachten Erklären?:

<[a-zA-Z0-9:]+[ \\t\\n]+                                      // matcht '<jsp:some '
([a-zA-Z0-9]*([ \\t\\n]*=[ \\t\\n]*\"[^\"]*\")?[ \\t\\n]+)*?  // matcht alle Attribute vor dem gesuchten
([a-zA-Z0-9]+)                                                // matcht das gesuchte Attribut
([ \\t\\n]+[a-zA-Z0-9]*([ \\t\\n]*=[ \\t\\n]*\"[^\"]*\")?)*   // matcht alle Attribute nach dem gesuchten
[ \\t\\n]*/?>                                                 // matcht ' />'

Nun, die Problematik ist, dass wenn ich im "2. Teil" des Regex das ? weglasse, findet er nur das letzte und ansonsten nur das erste Attribut. Ich gehe davon aus, dass Tags mehrere fehlerhafte Attribute haben.
Wie kann ich das Problem lösen?

Gruss, faetzminator

 

[bygones]

Hallo zusammen,

Ich suche in XHTML (JSP) Dateien illegale, "alte" HTML Tag Attribute, welche nicht geschlossen werden, als Beispiel

<input type="checkbox" checked/>

input ist doch damit geschlossen... ich haette jetzt sowas wie

<br>

vermutet ?

 

[faetzminator]

ich will im Dokument alle illegalen Attribute ersetzen, z.B. sollte aus meinem Beispiel folgendes werden

<input type="checkbox" checked="checked"/>

 

[faetzminator]

Hab die Regex noch ein Bisschen angepasst, zur Veranschaulichung:

public class Reg {

    public static String reg(String string) {
        String ret = string;
        while (!(ret = reg_(string)).equals(string)) {
            string = ret;
        }
        return ret;
    }

    public static String reg_(String string) {
        return string.replaceAll("(<[\\d\\w:]+\\s+([\\d\\w]*(\\s*=\\s*\"[^\"]*\")?\\s+)*?)([\\d\\w]+)((\\s+[\\d\\w]*(\\s*=\\s*\"[^\"]*\")?)*\\s*/?>)", "$1$4=\"$4\"$5");
    }
}

mit reg() kann ich das Problem von reg_() umgehen, ist aber mühsam, langsam und unschön.
Hier die JUnit Klasse dazu (mit jenem Testcase, welches fehlschlägt):

import junit.framework.TestCase;

public class RegTest extends TestCase {

    public void testReg() {
        String str1 = "<foo otherfoo test=\"i am word odr not\" kekeke bar=\"baz\" word other=\"other\" other/>";
        String str2 = "<foo otherfoo=\"otherfoo\" test=\"i am word odr not\" kekeke=\"kekeke\" bar=\"baz\" word=\"word\" other=\"other\" other=\"other\"/>";
        assertEquals(str2, Reg.reg(str1));
        assertEquals(str2, Reg.reg_(str1));
    }
}

 

[faetzminator]

Nun habe ich Probleme mit dem replaceAll(), wenn ich z.B.

"<uw:lookup beanName=\"__JSpAlLoCAtiON-REPLACESIGN\"           model=\"__JSpAlLoCAtiON-REPLACESIGN\"           id=\"__JSpAlLoCAtiON-REPLACESIGN\"           labelCancelKey=\"__JSpAlLoCAtiON-REPLACESIGN\"           labelConfirmKey=\"__JSpAlLoCAtiON-REPLACESIGN\"           titleKey=\"__JSpAlLoCAtiON-REPLACESIGN\"           name=\"__JSpAlLoCAtiON-REPLACESIGN\"           onselection=\"__JSpAlLoCAtiON-REPLACESIGN\"/>"

übergebe. Er hängt irgendwie irgendwo rekursiv fest:

[hier noch 100, 200 Stacktraceeinträge von Pattern$*]
Pattern$GroupHead.match(Matcher, int, CharSequence) line: 4022	
Pattern$Loop.matchInit(Matcher, int, CharSequence) line: 4168	
Pattern$Prolog.match(Matcher, int, CharSequence) line: 4105	
Pattern$Curly.match0(Matcher, int, int, CharSequence) line: 3725	
Pattern$Curly.match(Matcher, int, CharSequence) line: 3680	
Pattern$Curly.match0(Matcher, int, int, CharSequence) line: 3718	
Pattern$Curly.match(Matcher, int, CharSequence) line: 3680	
Pattern$Single.match(Matcher, int, CharSequence) line: 3053	
Pattern$GroupHead.match(Matcher, int, CharSequence) line: 4022	
Pattern$Start.match(Matcher, int, CharSequence) line: 2855	
Matcher.find(int, int) line: 736	
Matcher.find() line: 428	
Matcher.replaceAll(String) line: 671	
String.replaceAll(String, String) line: 1340	
Reg.reg_(String) line: 12	
Reg.reg(String) line: 5	
RegTest.testReg() line: 44	
[hier noch die JUnit Calls]

Habe ich den Regex irgendwie "illegal" geschrieben, also was verbotenes gemacht?

 

[faetzminator]

Hab den Regex nochmals angeschaut und stellte fest, dass ich versehentlich zwei Mal auf [\\d\\w]* statt [\\d\\w]+ matchte. Irgendwie löste dies gleich auch mein Rekursionsproblem Nur die while-Schleife brauch ich immer noch, aber mit dem kann ich leben.

"(<[\\d\\w:]+\\s+([\\d\\w]+(\\s*=\\s*\"[^\"]*\")?\\s+)*?)([\\d\\w]+)((\\s+[\\d\\w]+(\\s*=\\s*\"[^\"]*\")?)*\\s*/?>)"

Gruss, faetzminator

 

[bygones]

Hab den Regex nochmals angeschaut und stellte fest, dass ich versehentlich zwei Mal auf [\\d\\w]* statt [\\d\\w]+ matchte. Irgendwie löste dies gleich auch mein Rekursionsproblem Nur die while-Schleife brauch ich immer noch, aber mit dem kann ich leben.

"(<[\\d\\w:]+\\s+([\\d\\w]+(\\s*=\\s*\"[^\"]*\")?\\s+)*?)([\\d\\w]+)((\\s+[\\d\\w]+(\\s*=\\s*\"[^\"]*\")?)*\\s*/?>)"

Gruss, faetzminator

na dann hoff ich mal dass du das nie debuggen oder refactoren musst... bei dem regex

 

[faetzminator]

Wenn du dir meinen ersten Post ansiehst, siehst du, dass er eigentlich ganz einfach und logisch aufgebaut ist Aber klar - das ist natürlich ein Nachteil von Regex.