def _MatchTextField()

in src/google/appengine/api/search/stub/document_matcher.py [0:0]
48 lines of code
19 McCabe index (conditional complexity)

  def _MatchTextField(self, field, match, document):
    """Check if a textual field matches a query tree node."""

    if match.getType() == QueryParser.FUZZY:
      return self._MatchTextField(field, match.getChild(0), document)

    if match.getType() == QueryParser.VALUE:
      if query_parser.IsPhrase(match):
        return self._MatchPhrase(field, match, document)

      normalized_query = self._parser.Normalize(
          query_parser.GetQueryNodeText(match), field.value.type)
      normalized_text_field = self._parser.Normalize(field.value.string_value,
                                                     field.value.type)


      if field.value.type == document_pb2.FieldValue.ATOM:
        return normalized_query == normalized_text_field

      if field.value.type == document_pb2.FieldValue.UNTOKENIZED_PREFIX:
        return normalized_text_field.startswith(normalized_query)

      query_tokens = self._parser.TokenizeText(
          query_parser.GetQueryNodeText(match))


      if not query_tokens:
        return True




      if len(query_tokens) > 1:
        def QueryNode(token):
          token_text = self._parser.Normalize(token.chars, field.value.type)
          return query_parser.CreateQueryNode(token_text, QueryParser.TEXT)
        return all(self._MatchTextField(field, QueryNode(token), document)
                   for token in query_tokens)

      token_text = self._parser.Normalize(query_tokens[0].chars,
                                          field.value.type)
      matching_docids = [
          post.doc_id
          for post in self._PostingsForFieldToken(field.name, token_text)
      ]
      return document.id in matching_docids

    def ExtractGlobalEq(node):
      op = node.getType()
      if ((op == QueryParser.EQ or op == QueryParser.HAS) and
          len(node.children) >= 2):
        if node.children[0].getType() == QueryParser.GLOBAL:
          return node.children[1]
      return node

    if match.getType() == QueryParser.CONJUNCTION:
      return all(self._MatchTextField(field, ExtractGlobalEq(child), document)
                 for child in match.children)

    if match.getType() == QueryParser.DISJUNCTION:
      return any(self._MatchTextField(field, ExtractGlobalEq(child), document)
                 for child in match.children)

    if match.getType() == QueryParser.NEGATION:
      raise ExpressionTreeException('Unable to compare \"' + field.name +
                                    '\" with negation')


    return False