Fix getElementsByClassName to support multiple class names, from document (parser), tags (AdvancedTag), or TagCollections.

With tests.

Author: kata198

AdvancedHTMLParser/Parser.py

@@ -379,13 +379,20 @@ def getElementsByClassName(self, className, root='root'):
         '''
             getElementsByClassName - Searches and returns all elements containing a given class name.
 
-                @param className <str> - A one-word class name
+                @param className <str> - One or more space-separated class names
+
                 @param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root' [default], the root of the parsed tree will be used.
         '''
         (root, isFromRoot) = self._handleRootArg(root)
 
         elements = []
 
+        # Generate list of all classnames to match
+        classNames = [x.strip() for x in className.strip().split(' ') if x.strip()]
+
+        # Run through entire tree on the first
+        className = classNames.pop(0)
+
         if isFromRoot is True and className in root.classNames:
             elements.append(root)
 
@@ -397,6 +404,11 @@ def getElementsByClassName(self, className, root='root'):
 
             elements += getElementsByClassName(className, child)
 
+
+        # Check if we need to match against any other names
+        if len(classNames) > 0:
+            elements = [ em for em in elements for matchClassName in classNames  if matchClassName in em.classList ]
+
         return TagCollection(elements)
 
     def getElementsByAttr(self, attrName, attrValue, root='root'):
@@ -1276,8 +1288,11 @@ def getElementsByClassName(self, className, root='root', useIndex=True):
         '''
             getElementsByClassName - Searches and returns all elements containing a given class name.
 
-                @param className <str> - A one-word class name
+
+                @param className <str> - One or more space-separated class names
+
                 @param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root', the root of the parsed tree will be used.
+
                 @param useIndex <bool> If useIndex is True and class names are indexed [see constructor] only the index will be used. Otherwise a full search is performed.
         '''
         (root, isFromRoot) = self._handleRootArg(root)

AdvancedHTMLParser/Tags.py

@@ -1891,15 +1891,27 @@ def getElementsByClassName(self, className):
         '''
             getElementsByClassName - Search children of this tag for tags containing a given class name
 
-            @param className - Class name
+            @param className <str> - One or more space-separated class names
 
             @return - TagCollection of matching elements
         '''
         elements = []
+
+        # Generate list of all classnames to match
+        classNames = [x.strip() for x in className.strip().split(' ') if x.strip()]
+
+        # Run through entire tree on the first
+        className = classNames.pop(0)
+
         for child in self.children:
             if child.hasClass(className) is True:
                 elements.append(child)
             elements += child.getElementsByClassName(className)
+
+        # Check if we need to match against any other names
+        if len(classNames) > 0:
+            elements = [ em for em in elements for matchClassName in classNames  if matchClassName in em.classList ]
+
         return TagCollection(elements)
 
     def getElementsWithAttrValues(self, attrName, attrValues):
@@ -2391,14 +2403,30 @@ def getElementsByClassName(self, className):
         '''
             getElementsByClassName - Get elements within this collection containing a specific class name
 
-            @param className - A single class name
+            @param className <str> - One or more space-separated class names
 
             @return - TagCollection of unique elements within this collection tagged with a specific class name
         '''
         ret = TagCollection()
         if len(self) == 0:
             return ret
-        _cmpFunc = lambda tag : tag.hasClass(className)
+
+        # Check for multiple class names
+        classNames = className.split(' ')
+        if len(classNames) <= 1:
+            # Simple - 1 class name
+            _cmpFunc = lambda tag : tag.hasClass(className)
+        else:
+            # Multiple class names
+            def _cmpFunc(tag):
+                tagClassList = tag.classList
+
+                for cName in classNames:
+                    if cName not in tagClassList:
+                        return False
+
+                return True
+
         for tag in self:
             TagCollection._subset(ret, _cmpFunc, tag)
 

tests/AdvancedHTMLParserTests/test_Attributes.py

@@ -1225,5 +1225,99 @@ def test_getElementsByClassName(self):
         assert len(classDash2Ems) == 1 , 'Expected to find 1 element with class name = "class-dash2" but got %d. %s' %( len(classDash2Ems), repr(classDash2Ems))
 
 
+    def test_getElementsByClassNameMultipleClasses(self):
+        '''
+            test_getElementsByClassNameMultipleClasses -
+
+                This will test that the "getElementsByClassName" method supports a space-separated list of classes in which to match via AND
+        '''
+
+        htmlStr = '''<html><head></head><body>
+
+        <div id="em1" class="outer blue one" name="outerDiv" >
+
+            <div id="em2" class="inner blue one" >One</div>
+            <div id="em3" class="inner blue two" >Two</div>
+            <div id="em4" class="inner green one" >G One</div>
+        </div>
+    </body>
+</html>
+'''
+
+        document = AdvancedHTMLParser()
+        document.parseStr(htmlStr)
+
+        # Test a regular query, one element
+        oneEms = document.getElementsByClassName('one')
+        oneIds = [ em.id for em in oneEms ]
+
+        assert 'em1' in oneIds , 'Expected to find id="em1" (contains class "one") but did not. Matched: ' + repr(oneIds)
+        assert 'em2' in oneIds , 'Expected to find id="em2" (contains class "one") but did not. Matched: ' + repr(oneIds)
+
+
+        # Test multiple, sequential
+        blueOneEms = document.getElementsByClassName('blue one')
+        blueOneIds = [ em.id for em in blueOneEms ]
+
+        assert 'em1' in blueOneIds , 'Expected to find id="em1" via "blue one" (contains classes "blue" and "one") but did not. Matched: ' + repr(blueOneIds)
+        assert 'em2' in blueOneIds , 'Expected to find id="em2" via "blue one" (contains classes "blue" and "one") but did not. Matched: ' + repr(blueOneIds)
+
+
+        # Test from a tag
+        blueOneEms = document.body.getElementsByClassName('blue one')
+        blueOneIds = [ em.id for em in blueOneEms ]
+        assert 'em1' in blueOneIds , 'Expected to find id="em1" via "blue one" (contains classes "blue" and "one") from a tag but did not. Matched: ' + repr(blueOneIds)
+        assert 'em2' in blueOneIds , 'Expected to find id="em2" via "blue one" (contains classes "blue" and "one") from a tag but did not. Matched: ' + repr(blueOneIds)
+
+
+        # Test from a tag collection
+        divs = document.getElementsByTagName('div')
+        blueOneEms = divs.getElementsByClassName('blue one')
+        blueOneIds = [ em.id for em in blueOneEms ]
+        assert 'em1' in blueOneIds , 'Expected to find id="em1" via "blue one" (contains classes "blue" and "one") through tag collection but did not. Matched: ' + repr(blueOneIds)
+        assert 'em2' in blueOneIds , 'Expected to find id="em2" via "blue one" (contains classes "blue" and "one") through tag collection but did not. Matched: ' + repr(blueOneIds)
+
+
+
+        # Try reverse order
+        oneBlueEms = document.getElementsByClassName('one blue')
+        oneBlueIds = [ em.id for em in oneBlueEms ]
+
+
+        assert 'em1' in oneBlueIds, 'Expected to find id="em1" via "one blue" (contains classes "blue" and "one") but did not. Matched: ' + repr(oneBlueIds)
+        assert 'em2' in oneBlueIds, 'Expected to find id="em2" via "one blue" (contains classes "blue" and "one") but did not. Matched: ' + repr(oneBlueIds)
+
+
+        # Try reverse order from a tag
+        oneBlueEms = document.body.getElementsByClassName('one blue')
+        oneBlueIds = [ em.id for em in oneBlueEms ]
+
+        assert 'em1' in oneBlueIds, 'Expected to find id="em1" via "one blue" (contains classes "blue" and "one") from a tag but did not. Matched: ' + repr(oneBlueIds)
+        assert 'em2' in oneBlueIds, 'Expected to find id="em2" via "one blue" (contains classes "blue" and "one") from a tag but did not. Matched: ' + repr(oneBlueIds)
+
+
+        # Try reverse order from a tagcollection
+        divs = document.getElementsByTagName('div')
+        oneBlueEms = divs.getElementsByClassName('one blue')
+        oneBlueIds = [ em.id for em in oneBlueEms ]
+
+        assert 'em1' in oneBlueIds, 'Expected to find id="em1" via "one blue" (contains classes "blue" and "one") from a tagcollection but did not. Matched: ' + repr(oneBlueIds)
+        assert 'em2' in oneBlueIds, 'Expected to find id="em2" via "one blue" (contains classes "blue" and "one") from a tagcollection but did not. Matched: ' + repr(oneBlueIds)
+
+
+
+        # Try others
+        innerBlueEms = document.getElementsByClassName('inner blue')
+        innerBlueIds = [ em.id for em in innerBlueEms ]
+
+        assert 'em2' in innerBlueIds , 'Expected to find id="em2" via "inner blue" ( contains classes "blue" and "inner") but did not. Matched: ' + repr(innerBlueIds)
+        assert 'em3' in innerBlueIds , 'Expected to find id="em3" via "inner blue" ( contains classes "blue" and "inner") but did not. Matched: ' + repr(innerBlueIds)
+
+        # Now validate on tag collection
+        outerDivNames = document.getElementsByName('outerDiv')
+
+        assert len(outerDivNames) == 1 , 'Expected to find div name="outerDiv" but did not.'
+
+
 if __name__ == '__main__':
     sys.exit(subprocess.Popen('GoodTests.py -n1 "%s" %s' %(sys.argv[0], ' '.join(['"%s"' %(arg.replace('"', '\\"'), ) for arg in sys.argv[1:]]) ), shell=True).wait())