New upstream version 0.18.0+dfsg1

1 files changed, 42 insertions, 80 deletions

diff --git a/searx/query.py b/searx/query.py
index e8b57d4..422cd57 100644
--- a/searx/query.py
+++ b/searx/query.py
@@ -17,23 +17,19 @@ along with searx. If not, see < http://www.gnu.org/licenses/ >.
 (C) 2014 by Thomas Pointhuber, <thomas.pointhuber@gmx.at>
 '''
 
-from searx.languages import language_codes
-from searx.engines import (
-    categories, engines, engine_shortcuts
-)
 import re
-import sys
-
-if sys.version_info[0] == 3:
-    unicode = str
 
-VALID_LANGUAGE_CODE = re.compile(r'^[a-z]{2,3}(-[a-zA-Z]{2})?$')
+from searx.languages import language_codes
+from searx.engines import categories, engines, engine_shortcuts
+from searx.search import EngineRef
+from searx.webutils import VALID_LANGUAGE_CODE
 
 
-class RawTextQuery(object):
+class RawTextQuery:
     """parse raw text query (the value from the html input)"""
 
     def __init__(self, query, disabled_engines):
+        assert isinstance(query, str)
         self.query = query
         self.disabled_engines = []
 
@@ -41,34 +37,28 @@ class RawTextQuery(object):
             self.disabled_engines = disabled_engines
 
         self.query_parts = []
-        self.engines = []
+        self.user_query_parts = []
+        self.enginerefs = []
         self.languages = []
         self.timeout_limit = None
         self.external_bang = None
         self.specific = False
+        self._parse_query()
 
     # parse query, if tags are set, which
     # change the search engine or search-language
-    def parse_query(self):
+    def _parse_query(self):
         self.query_parts = []
 
         # split query, including whitespaces
-        raw_query_parts = re.split(r'(\s+)' if isinstance(self.query, str) else b'(\s+)', self.query)
-
-        parse_next = True
+        raw_query_parts = re.split(r'(\s+)', self.query)
 
         for query_part in raw_query_parts:
-            if not parse_next:
-                self.query_parts[-1] += query_part
-                continue
-
-            parse_next = False
+            searx_query_part = False
 
             # part does only contain spaces, skip
             if query_part.isspace()\
                or query_part == '':
-                parse_next = True
-                self.query_parts.append(query_part)
                 continue
 
             # this force the timeout
@@ -81,7 +71,7 @@ class RawTextQuery(object):
                     else:
                         # 100 or above, the unit is the millisecond ( <850 = 850 milliseconds timeout )
                         self.timeout_limit = raw_timeout_limit / 1000.0
-                    parse_next = True
+                    searx_query_part = True
                 except ValueError:
                     # error not reported to the user
                     pass
@@ -93,7 +83,7 @@ class RawTextQuery(object):
                 # check if any language-code is equal with
                 # declared language-codes
                 for lc in language_codes:
-                    lang_id, lang_name, country, english_name = map(unicode.lower, lc)
+                    lang_id, lang_name, country, english_name = map(str.lower, lc)
 
                     # if correct language-code is found
                     # set it as new search-language
@@ -102,15 +92,15 @@ class RawTextQuery(object):
                         or lang == english_name
                         or lang.replace('-', ' ') == country)\
                        and lang not in self.languages:
-                            parse_next = True
-                            lang_parts = lang_id.split('-')
-                            if len(lang_parts) == 2:
-                                self.languages.append(lang_parts[0] + '-' + lang_parts[1].upper())
-                            else:
-                                self.languages.append(lang_id)
-                            # to ensure best match (first match is not necessarily the best one)
-                            if lang == lang_id:
-                                break
+                        searx_query_part = True
+                        lang_parts = lang_id.split('-')
+                        if len(lang_parts) == 2:
+                            self.languages.append(lang_parts[0] + '-' + lang_parts[1].upper())
+                        else:
+                            self.languages.append(lang_id)
+                        # to ensure best match (first match is not necessarily the best one)
+                        if lang == lang_id:
+                            break
 
                 # user may set a valid, yet not selectable language
                 if VALID_LANGUAGE_CODE.match(lang):
@@ -119,12 +109,12 @@ class RawTextQuery(object):
                         lang = lang_parts[0].lower() + '-' + lang_parts[1].upper()
                     if lang not in self.languages:
                         self.languages.append(lang)
-                        parse_next = True
+                        searx_query_part = True
 
             # external bang
             if query_part[0:2] == "!!":
                 self.external_bang = query_part[2:]
-                parse_next = True
+                searx_query_part = True
                 continue
             # this force a engine or category
             if query_part[0] == '!' or query_part[0] == '?':
@@ -132,69 +122,41 @@ class RawTextQuery(object):
 
                 # check if prefix is equal with engine shortcut
                 if prefix in engine_shortcuts:
-                    parse_next = True
+                    searx_query_part = True
                     engine_name = engine_shortcuts[prefix]
                     if engine_name in engines:
-                        self.engines.append({'category': 'none',
-                                             'name': engine_name,
-                                             'from_bang': True})
+                        self.enginerefs.append(EngineRef(engine_name, 'none', True))
 
                 # check if prefix is equal with engine name
                 elif prefix in engines:
-                    parse_next = True
-                    self.engines.append({'category': 'none',
-                                         'name': prefix,
-                                         'from_bang': True})
+                    searx_query_part = True
+                    self.enginerefs.append(EngineRef(prefix, 'none', True))
 
                 # check if prefix is equal with categorie name
                 elif prefix in categories:
                     # using all engines for that search, which
                     # are declared under that categorie name
-                    parse_next = True
-                    self.engines.extend({'category': prefix,
-                                         'name': engine.name}
-                                        for engine in categories[prefix]
-                                        if (engine.name, prefix) not in self.disabled_engines)
+                    searx_query_part = True
+                    self.enginerefs.extend(EngineRef(engine.name, prefix)
+                                           for engine in categories[prefix]
+                                           if (engine.name, prefix) not in self.disabled_engines)
 
             if query_part[0] == '!':
                 self.specific = True
 
             # append query part to query_part list
-            self.query_parts.append(query_part)
+            if searx_query_part:
+                self.query_parts.append(query_part)
+            else:
+                self.user_query_parts.append(query_part)
 
-    def changeSearchQuery(self, search_query):
-        if len(self.query_parts):
-            self.query_parts[-1] = search_query
-        else:
-            self.query_parts.append(search_query)
+    def changeQuery(self, query):
+        self.user_query_parts = query.strip().split()
         return self
 
-    def getSearchQuery(self):
-        if len(self.query_parts):
-            return self.query_parts[-1]
-        else:
-            return ''
+    def getQuery(self):
+        return ' '.join(self.user_query_parts)
 
     def getFullQuery(self):
         # get full querry including whitespaces
-        return u''.join(self.query_parts)
-
-
-class SearchQuery(object):
-    """container for all the search parameters (query, language, etc...)"""
-
-    def __init__(self, query, engines, categories, lang, safesearch, pageno, time_range,
-                 timeout_limit=None, preferences=None, external_bang=None):
-        self.query = query.encode('utf-8')
-        self.engines = engines
-        self.categories = categories
-        self.lang = lang
-        self.safesearch = safesearch
-        self.pageno = pageno
-        self.time_range = None if time_range in ('', 'None', None) else time_range
-        self.timeout_limit = timeout_limit
-        self.preferences = preferences
-        self.external_bang = external_bang
-
-    def __str__(self):
-        return str(self.query) + ";" + str(self.engines)
+        return '{0} {1}'.format(''.join(self.query_parts), self.getQuery()).strip()