Add more tests

clean up and more tests

Author: czf

RedditSharp/Reddit.cs

@@ -5,7 +5,9 @@
 using System.Linq;
 using System.Security.Authentication;
 using System.Threading.Tasks;
+using RedditSharp.Search;
 using DefaultWebAgent = RedditSharp.WebAgent;
+using System.Linq.Expressions;
 
 namespace RedditSharp
 {
@@ -37,6 +39,19 @@ public class Reddit
         private const string GetLiveEventUrl = "https://www.reddit.com/live/{0}/about";
 
         #endregion
+        private IAdvancedSearchFormatter _searchFormatter;
+        private IAdvancedSearchFormatter SearchFormatter
+        {
+            get
+            {
+                if(_searchFormatter == null)
+                {
+                    _searchFormatter = new DefaultSearchFormatter();
+                }
+                return _searchFormatter;
+            }
+            set => _searchFormatter = value;
+        }
 
         #region Properties
         internal IWebAgent WebAgent { get; set; }
@@ -382,6 +397,15 @@ public Listing<T> Search<T>(string query, Sorting sortE = Sorting.Relevance, Tim
             return Listing<T>.Create(this.WebAgent, string.Format(SearchUrl, query, sort, time), max, 100);
         }
 
+        public Listing<Post> AdvancedSearch(Expression<Func<AdvancedSearchFilter, bool>> searchFilter, Sorting sortE = Sorting.Relevance, TimeSorting timeE = TimeSorting.All)
+        {
+            string query = SearchFormatter.Format(searchFilter);
+            string sort = sortE.ToString().ToLower();
+            string time = timeE.ToString().ToLower();
+            string final = string.Format(SearchUrl, query, sort, time);
+            return new Listing<Post>(this,final,WebAgent);
+        }
+
         /// <summary>
         /// Return a <see cref="Listing{T}"/> of items matching search with a given time period.
         /// </summary>

RedditSharp/Search/DefaultSearchFormatter.cs

@@ -8,9 +8,14 @@
 
 namespace RedditSharp.Search
 {
-    public class DefaultSearchFormatter : ISearchFormatter
+    public class DefaultSearchFormatter : IAdvancedSearchFormatter
     {
-        string ISearchFormatter.Format(Expression<Func<AdvancedSearchFilter, bool>> search)
+        #region Constants
+        private const string BOOL_PROPERTY_PREFIX = "Is";
+        #endregion Constants
+
+
+        string IAdvancedSearchFormatter.Format(Expression<Func<AdvancedSearchFilter, bool>> search)
         {
             Expression expression = null;
             Stack<Expression> expressionStack = new Stack<Expression>();
@@ -33,30 +38,39 @@ string ISearchFormatter.Format(Expression<Func<AdvancedSearchFilter, bool>> sear
                     case ConstantExpression constantExpresssion:
                         searchStack.Push(ConstantExpressionHelper(constantExpresssion));
                         break;
+                    case MethodCallExpression methodCallExpression:
+                        searchStack.Push(MethodCallExpressionHelper(methodCallExpression));
+                        break;
                     default:
                         throw new NotImplementedException(expression.ToString());
                 }
             }
 
             Stack<string> compoundSearchStack = new Stack<string>();
-            while(formatInfoStack.Count >0)
+            while (formatInfoStack.Count > 0)
             {
                 FormatInfo current = formatInfoStack.Pop();
                 string[] formatParameters = new string[current.ParameterCount];
                 int currentCount = current.ParameterCount;
-                while(currentCount > 0)
+                while (currentCount > 0)
                 {
-                    formatParameters[formatParameters.Length - currentCount] = current.IsCompound  ? compoundSearchStack.Pop() : searchStack.Pop();
+                    formatParameters[formatParameters.Length - currentCount] = current.IsCompound ? compoundSearchStack.Pop() : searchStack.Pop();
                     currentCount--;
                 }
-               
+
                 compoundSearchStack.Push(string.Format(current.Pattern, formatParameters));
-                
+
             }
 
             return compoundSearchStack.Pop();
         }
 
+        private string MethodCallExpressionHelper(MethodCallExpression expression)
+        {
+            var o = InvokeGetExpression(expression);
+            return o.ToString();
+        }
+
         private string ConstantExpressionHelper(ConstantExpression constantExpresssion)
         {
             return constantExpresssion.ToString().Replace("\"","");
@@ -79,29 +93,23 @@ private void BinaryExpressionHelper(BinaryExpression expression, Stack<Expressio
                 expressionStack.Push(expression.Left);
             }
 
-
             if (expression.NodeType != ExpressionType.Equal)
             {
                 formatInfoStack.Push(expression.ToFormatInfo());
-                //searchStack.Push("NOT(+{0}+)");
             }
-            
-
         }
 
 
         private void UnaryExpressionHelper(UnaryExpression expression, Stack<Expression> expressionStack,Stack<FormatInfo> formatInfoStack)
         {
-            formatInfoStack.Push( expression.ToFormatInfo());
+            formatInfoStack.Push(expression.ToFormatInfo());
             expressionStack.Push(expression.Operand);
-            //return expressionOperator;
         }
 
         private void MemberExpressionHelper(MemberExpression expression, Stack<string> searchStack, Stack<FormatInfo> formatInfoStack)
         {
             MemberInfo member = expression.Member;
 
-
             if (member.DeclaringType == typeof(AdvancedSearchFilter))
             {
                 string result = member.Name.Replace(BOOL_PROPERTY_PREFIX, string.Empty).ToLower();
@@ -110,7 +118,6 @@ private void MemberExpressionHelper(MemberExpression expression, Stack<string> s
                 if (expression.Type == typeof(bool))
                 {
                     searchStack.Push("1");
-                    
                 }
             }
             else
@@ -130,30 +137,6 @@ private static object InvokeGetExpression(Expression expression)
             return getter();
         }
 
-
-
-
-        private const string BOOL_PROPERTY_PREFIX = "Is";
-
-
-        private static readonly List<ExpressionType> conditionalTypes = new List<ExpressionType>()
-        {
-            ExpressionType.AndAlso,
-            ExpressionType.And,
-            ExpressionType.OrElse,
-            ExpressionType.Or
-        };
-
-        private static readonly List<ExpressionType> evaluateExpressions = new List<ExpressionType>()
-        {
-            ExpressionType.Add,
-            ExpressionType.Subtract,
-            ExpressionType.Multiply,
-            ExpressionType.Divide,
-            ExpressionType.Coalesce,
-            ExpressionType.Conditional
-        };
-
         private static bool IsAdvancedSearchMemberExpression(Expression expression)
         {
             MemberExpression memberExpression = expression as MemberExpression;
@@ -180,28 +163,4 @@ public FormatInfo(string pattern, int parameterCount = 0, bool isCompound = fals
             internal static FormatInfo MemberAccess = new FormatInfo("{1}:{0}", 2);
         }
     }
-
-    public static class Extensions
-    {
-        internal static DefaultSearchFormatter.FormatInfo ToFormatInfo(this Expression expression)
-        {
-            ExpressionType? type = expression?.NodeType;
-            switch (type)
-            {
-                case ExpressionType.Not:
-                case ExpressionType.NotEqual:
-                    return DefaultSearchFormatter.FormatInfo.Not;
-                case ExpressionType.Equal:
-                    throw new NotImplementedException("Currently not supporting Equal expression.");
-                case ExpressionType.AndAlso:
-                    return DefaultSearchFormatter.FormatInfo.AndAlso;
-                case ExpressionType.MemberAccess:
-                    return DefaultSearchFormatter.FormatInfo.MemberAccess;
-                case ExpressionType.OrElse:
-                    return DefaultSearchFormatter.FormatInfo.OrElse;
-            }
-            throw new NotImplementedException($"{type.ToString()} is not implemented.");
-        }
-
-    }
 }

RedditSharp/Search/ISearchFormatter.cs renamed to RedditSharp/Search/IAdvancedSearchFormatter.cs

@@ -5,14 +5,14 @@
 
 namespace RedditSharp.Search
 {
-    public interface ISearchFormatter
+    public interface IAdvancedSearchFormatter
     {
 
         /// <summary>
-        /// 
+        /// use an expression to create a search for reddit
         /// </summary>
         /// <param name="search"></param>
-        /// <returns></returns>
+        /// <returns>the string representing the search expression in reddits search format</returns>
         /// <remarks>
         /// has to be Expression Func https://michael-mckenna.com/func-t-vs-expression-func-t-in-linq/
         /// </remarks>

RedditSharp/Search/SearchExpressionExtentions.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Linq.Expressions;
+
+namespace RedditSharp.Search
+{
+    public static class SearchExtensions
+    {
+        internal static DefaultSearchFormatter.FormatInfo ToFormatInfo(this Expression expression)
+        {
+            ExpressionType? type = expression?.NodeType;
+            switch (type)
+            {
+                case ExpressionType.Not:
+                case ExpressionType.NotEqual:
+                    return DefaultSearchFormatter.FormatInfo.Not;
+                case ExpressionType.Equal:
+                    throw new NotImplementedException("Currently not supporting Equal expression.");
+                case ExpressionType.AndAlso:
+                    return DefaultSearchFormatter.FormatInfo.AndAlso;
+                case ExpressionType.MemberAccess:
+                    return DefaultSearchFormatter.FormatInfo.MemberAccess;
+                case ExpressionType.OrElse:
+                    return DefaultSearchFormatter.FormatInfo.OrElse;
+            }
+            throw new NotImplementedException($"{type.ToString()} is not implemented.");
+        }
+
+    }
+}