xpath - Implement "contains" function

Author: kata198

AdvancedHTMLParser/xpath/_body.py

@@ -1201,6 +1201,71 @@ def resolveValueFromTag(self, thisTag):
 VALUE_GENERATOR_RES.append( (BEVG_FUNCTION_CONCAT_RE, BodyElementValueGenerator_Function_Concat) )
 
 
+class BodyElementValueGenerator_Function_Contains(BodyElementValueGenerator_Function):
+    '''
+        BodyElementValueGenerator_Function_Contains - BodyElementValueGenerator class implementing contains function
+    '''
+
+    # FUNCTION_MIN_ARGS - Class attribute for the minimum number of args lest there be a parsing error
+    FUNCTION_MIN_ARGS = 2
+
+    # FUNCTION_NAME_STR - Name of the function
+    FUNCTION_NAME_STR = 'contains'
+
+
+    def __init__(self, fnArgElements=None):
+        '''
+            __init__ - Create this object
+        '''
+        BodyElementValueGenerator_Function.__init__(self, fnArgElements)
+
+        # Ensure we are given exactly two arguments
+        fnArgElements = self.fnArgElements
+        if len(fnArgElements) != 2:
+            raise XPathParseError('"contains" function takes exactly two arguments, but got %d.  Args were:  %s' % ( \
+                    len(fnArgElements),
+                    repr(fnArgElements),
+                )
+            )
+
+        self.string1Arg = fnArgElements[0]
+        self.string2Arg = fnArgElements[1]
+
+
+    def resolveValueFromTag(self, thisTag):
+        '''
+            resolveValueFromTag - Test if one string occurs within the other, and return the boolean result
+
+
+                @param thisTag <AdvancedTag> - The tag of interest
+
+
+                @return <BodyElementValue_Boolean> - True if string1 contains string2, otherwise False
+
+
+                @see BodyElementValueGenerator_Function.resolveValueFromTag
+        '''
+
+        string1ValueElement = self.string1Arg.evaluateLevelForTag(thisTag)
+        string2ValueElement = self.string2Arg.evaluateLevelForTag(thisTag)
+
+        try:
+            string1Value = str( string1ValueElement.getValue() )
+        except Exception as e1:
+            raise XPathRuntimeError('Error in contains() - cannot convert first argument to a string! It is %s' %( repr(string1ValueElement.getValue()), ))
+        try:
+            string2Value = str( string2ValueElement.getValue() )
+        except Exception as e2:
+            raise XPathRuntimeError('Error in contains() - cannot convert second argument to a string! It is %s' %( repr(string2ValueElement.getValue()), ))
+
+        containsResult = bool( string2Value in string1Value )
+
+        return BodyElementValue_Boolean(containsResult)
+
+
+BEVG_FUNCTION_CONTAINS_RE = re.compile(r'''^([ \t]*[cC][oO][nN][tT][aA][iI][nN][sS][ \t]*[\(][ \t]*(?P<restOfBody>.+))$''')
+VALUE_GENERATOR_RES.append( (BEVG_FUNCTION_CONTAINS_RE, BodyElementValueGenerator_Function_Contains) )
+
 #############################
 ##        Operations       ##
 #############################

tests/AdvancedHTMLParserTests/test_XPath.py

@@ -393,9 +393,9 @@ def test_xpathLast(self):
             assert lastSpan in results , 'Got a mismatch of results from xpath vs non-xpath. Node  (  %s  ) was found via non-xpath, but not in the xpath set!' %(repr(lastSpan), )
 
 
-    def test_parseOptimizations1(self):
+    def test_xpathParseOptimizations1(self):
         '''
-            test_parseOptimizations1 - Test that we properly optimize xpath strings with values that can be calculated at parse time
+            test_xpathParseOptimizations1 - Test that we properly optimize xpath strings with values that can be calculated at parse time
         '''
 
         bodyElements = parseBodyStringIntoBodyElements('''"hello" || " " || "world" = "hello world"''')
@@ -410,6 +410,43 @@ def test_parseOptimizations1(self):
         assert value is True , 'Expected the calculated BodyElementValue to be <bool> True. Got: <%s> %s' %( type(value).__name__, repr(value))
 
 
+
+    def test_xpathContains(self):
+        '''
+            test_xpathContains - Test the "contains" function
+        '''
+
+        puddingNameSpans = self.parser.getElementsByXPathExpression('//span[ @name = "itemName" and contains( text(), "Pudding" ) ]')
+
+        assert len(puddingNameSpans) == 1 , 'Expected to get one span[name="itemName"] where inner text contains "Pudding", but got %d.  %s' %( len(puddingNameSpans), repr(puddingNameSpans) )
+
+        puddingSpan = puddingNameSpans[0]
+        assert 'Pudding Cups' in puddingSpan.innerText , 'Expected "Pudding Cups" to be in the inner text of the matched pudding item, but it was not. Inner text was: %s' %( repr(puddingSpan.innerText), )
+
+
+        itemsContainingLetterE = self.parser.getElementsByXPathExpression('''//span[(@name = "itemName") and contains( normalize-space(), "e" )]/ancestor::div[@name="items"]''')
+        assert len(itemsContainingLetterE) == 3 , 'Expected to find 3 items which contained lower case "e" , but found %d !  %s' %( len(itemsContainingLetterE), repr(itemsContainingLetterE) )
+
+
+        item1Found = False
+        item2Found = False
+        item3Found = False
+
+        for itemEm in itemsContainingLetterE:
+
+            if itemEm.id == 'item1':
+                item1Found = True
+            elif itemEm.id == 'item2':
+                item2Found = True
+            elif itemEm.id == 'item3':
+                item3Found = True
+
+        assert item1Found is True , 'Expected to find div id="item1" but did not!'
+        assert item2Found is True , 'Expected to find div id="item2" but did not!'
+        assert item3Found is True , 'Expected to find div id="item3" 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())