beagled/QueryStringParser.cs

   1 //
   2 // QueryStringParser.cs
   3 //
   4 // Copyright (C) 2004-2005 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a
   9 // copy of this software and associated documentation files (the "Software"),
  10 // to deal in the Software without restriction, including without limitation
  11 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12 // and/or sell copies of the Software, and to permit persons to whom the
  13 // Software is furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24 // DEALINGS IN THE SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.Collections;
  29 using System.Text.RegularExpressions;
  30
  31 using Beagle.Util;
  32 using FSQ=Beagle.Daemon.FileSystemQueryable;
  33
  34 namespace Beagle.Daemon {
  35
  36         public class QueryStringParser {
  37
  38                 private QueryStringParser () { } // a static class
  39
  40                 // Returns an ICollection of QueryPart objects.
  41                 static public ICollection Parse (string query_string)
  42                 {
  43
  44                         /* This is our regular Expression Pattern:
  45                          * we expect something like this:
  46                          * -key:"Value String"
  47                          * key:Value
  48                          * or
  49                          * Value
  50                                 ([+-]?)         # Required or Prohibited (optional)
  51                                 (\w+:)?         # Key  (optional)
  52                                 (               # Query Text
  53                                  (\"([^\"]*)\"?)#  quoted
  54                                  |              #  or
  55                                  ([^\s\"]+)     #  unquoted
  56                                 )
  57                                 ";
  58                          */
  59                         string Pattern = "(?<pm>[+-]?) ( (?<key>\\w+) :)? ( (\"(?<quote>[^\"]*)\"?) | (?<unquote>[^\\s\"]+) )";
  60
  61                         Regex r = new Regex (Pattern, RegexOptions.IgnorePatternWhitespace);
  62
  63                         Match m = r.Match (query_string);
  64
  65                         ArrayList parts;
  66                         parts = new ArrayList ();
  67
  68                         ArrayList or_list = null;
  69
  70                         while (m.Success) {
  71
  72                                 QueryPart query_part = MatchToQueryPart (m);
  73
  74                                 if (or_list != null) {
  75                                         or_list.Add (query_part);
  76                                         query_part = null;
  77                                 }
  78
  79                                 Match next = m.NextMatch ();
  80
  81                                 // Trap the OR operator
  82                                 // If the next match is an or, start an or_list
  83                                 // (if we don't have one already) and skip
  84                                 // ahead to the next part.
  85                                 if ( next.Success
  86                                     && (next.Groups ["key"].ToString () == "")
  87                                     && (next.Groups ["unquote"].ToString ().ToUpper () == "OR") ) {
  88
  89                                         if (or_list == null) {
  90                                                 or_list = new ArrayList ();
  91                                                 or_list.Add (query_part);
  92                                         }
  93
  94                                         m = next.NextMatch();
  95                                         continue;
  96                                 }
  97
  98                                 // If we have a non-empty or-list going,
  99                                 // Create the appropriate QueryPart and add it
 100                                 // to the list.
 101                                 if (or_list != null) {
 102
 103                                         QueryPart_Or or_part = new QueryPart_Or ();
 104                                         or_part.Logic = QueryPartLogic.Required;
 105
 106                                         foreach (QueryPart sub_part in or_list)
 107                                                 or_part.Add (sub_part);
 108
 109                                         parts.Add (or_part);
 110                                         or_list = null;
 111                                 }
 112
 113                                 // Add the next text part
 114                                 if (query_part != null)
 115                                         parts.Add (query_part);
 116
 117                                 m=next;
 118                         }
 119
 120                         // If we ended with an or_parts list, do the right thing.
 121                         if (or_list != null) {
 122
 123                                 QueryPart_Or or_part = new QueryPart_Or ();
 124                                 or_part.Logic = QueryPartLogic.Required;
 125
 126                                 foreach (QueryPart sub_part in or_list)
 127                                         or_part.Add (sub_part);
 128                         }
 129
 130                         return parts;
 131                 }
 132
 133                 static private QueryPart StringToQueryPart (string text, bool is_prohibited)
 134                 {
 135                         QueryPart part;
 136
 137                         if (text.IndexOf ('*') != -1) {
 138                                 part = new QueryPart_Wildcard ();
 139                                 ((QueryPart_Wildcard) part).QueryString = text;
 140                         } else {
 141                                 part = new QueryPart_Text ();
 142                                 ((QueryPart_Text) part).Text = text;
 143                         }
 144
 145                         part.Logic = (is_prohibited ? QueryPartLogic.Prohibited : QueryPartLogic.Required);
 146                         return part;
 147                 }
 148
 149                 static private QueryPart MatchToQueryPart (Match m)
 150                 {
 151                         // Looping over all Matches we have got:
 152                         // m.Groups["pm"]       plus or minus sign
 153                         // m.Groups["key"]      keyname
 154                         // m.Groups["quote"]    quoted string
 155                         // m.Groups["unquote"]  unquoted string
 156
 157                         string query = m.ToString ();
 158                         string unquote = m.Groups["unquote"].ToString ();
 159                         string text = m.Groups ["quote"].ToString () + m.Groups ["unquote"].ToString ();        // only one of both is set.
 160                         string key = m.Groups ["key"].ToString ();
 161
 162                         bool IsProhibited = (m.Groups ["pm"].ToString () == "-");
 163
 164
 165                         // check for file extensions
 166                         // if match starts with *. or . and only contains letters we assume it's a file extension
 167                         Regex extension_re = new Regex (@"^\**\.\w*$");
 168
 169                         if (extension_re.Match (text).Success || key.ToLower () == "ext" || key.ToLower () == "extension") {
 170
 171                                 QueryPart_Property query_part = new QueryPart_Property ();
 172
 173                                 query_part.Key = Property.FilenameExtensionPropKey;
 174
 175                                 if (text.StartsWith ("*."))
 176                                         query_part.Value = text.Substring (1).ToLower ();
 177                                 else if (text.StartsWith ("."))
 178                                         query_part.Value = text.ToLower ();
 179                                 else
 180                                         query_part.Value = "." + text.ToLower ();
 181
 182                                 query_part.Type = PropertyType.Keyword;
 183                                 query_part.Logic = (IsProhibited ? QueryPartLogic.Prohibited : QueryPartLogic.Required);
 184
 185                                 Logger.Log.Debug ("Extension query: {0}", query_part.Value);
 186
 187                                 return query_part;
 188                         }
 189
 190                         if (key == "") {
 191
 192                                 Logger.Log.Debug ("Parsed query '{0}' as text_query", text);
 193
 194                                 return StringToQueryPart (text, IsProhibited);
 195                         }
 196
 197                         string prop_string = null;
 198                         bool is_present;
 199                         PropertyType prop_type;
 200
 201                         is_present = PropertyKeywordFu.GetPropertyDetails (key, out prop_string, out prop_type);
 202                         // if key is not present in the mapping, assume the query is a text query
 203                         // i.e. if token is foo:bar and there is no mappable property named foo,
 204                         // assume "foo:bar" as text query
 205                         // FIXME the analyzer changes the text query "foo:bar" to "foo bar"
 206                         // which might not be the right thing to do
 207
 208                         if (!is_present) {
 209
 210                                 Logger.Log.Debug ("Could not find property, parsed query '{0}' as text_query", query);
 211
 212                                 return StringToQueryPart (query, IsProhibited);
 213                         }
 214
 215                         QueryPart_Property query_part_prop = new QueryPart_Property ();
 216                         query_part_prop.Key = prop_string;
 217                         query_part_prop.Value = text;
 218                         query_part_prop.Type = prop_type;
 219                         query_part_prop.Logic = (IsProhibited ? QueryPartLogic.Prohibited : QueryPartLogic.Required);
 220
 221                         Logger.Log.Debug ("Parsed query '"          + query +
 222                                           "' as prop query:key="    + query_part_prop.Key +
 223                                           ", value="                + query_part_prop.Value +
 224                                           " and property type="     + query_part_prop.Type);
 225
 226                         return query_part_prop;
 227                 }
 228         }
 229 }
 230