add path and query

1.1

Readme.md

@@ -1,7 +1,7 @@
 ## UriBuilder.Fluent
 [![Coverage Status](https://coveralls.io/repos/github/TerribleDev/UriBuilder.Fluent/badge.svg)](https://coveralls.io/github/TerribleDev/UriBuilder.Fluent) [![Build status](https://ci.appveyor.com/api/projects/status/cp704w3bgaerufxm/branch/master?svg=true)](https://ci.appveyor.com/project/tparnell8/uribuilder-fluent/branch/master)
 
-This places extension methods over System.UriBuilder to help deal with query string parameters, and create more of a fluent interface. Unlike other projects this builds ontop of trusty UriBuilder, and does not use custom Uri generators, or have outside dependencies.
+This places extension methods over System.UriBuilder to help deal with query string parameters, and create more of a fluent interface. Unlike other projects, this NetStandardLibrary compliant package builds ontop of trusty UriBuilder, does not use custom Uri generators, or have outside dependencies. Unit tests continue to be a first class citizen!
 
 This lets you do things like
 
@@ -29,7 +29,22 @@ new UriBuilder("https://awesome.com/yo)
     .WithParameter("id", "5")
     .ToString();
 
+```
+result: `https://awesome.com/yo?id=5`
 
+you can even pass a dictionary of parameters
+
+```csharp
+            var dictionary = new Dictionary<string, string>()
+            {
+                ["yo"] = "dawg"
+            };
+            new UriBuilder("http://awesome.com")
+                    .WithParameter(dictionary);
+            http://awesome.com/?yo=dawg
 
 ```
-result: `https://awesome.com/yo?id=5`
+
+## Getting started
+
+Just install the nuget package `install-package UriBuilder.Fluent` and thats it. The extension methods should be available to you!

src/UriBuilder.Fluent.UnitTests/ExtensionTests.cs

@@ -35,6 +35,17 @@ namespace FluentUriBuilder.Tests
                     .WithParameter("awesome", "yodawg");
             Assert.Equal("http://awesome.com/?awesome=yodawg", url.Uri.ToString());
         }
+        
+        [Fact]
+        public void PathAndQuery()
+        {
+            var url = new UriBuilder().WithPathSegment("/awesome/v1/").WithParameter("awesome", "cool").PathAndQuery();
+            Assert.Equal("/awesome/v1/?awesome=cool", url);
+            url = new UriBuilder().WithPathSegment("/awesome/v1").WithParameter("awesome", "cool").PathAndQuery();
+            Assert.Equal("/awesome/v1?awesome=cool", url);
+            url = new UriBuilder().WithPathSegment("/awesome/v1").PathAndQuery();
+            Assert.Equal("/awesome/v1", url);
+        }
 
         [Fact]
         public void TestAddParameterArray()
@@ -97,6 +108,16 @@ namespace FluentUriBuilder.Tests
             Assert.Equal(url.Host, "yodawg.com");
         }
 
+        [Fact]
+        public void AddParamWithNoValue()
+        {
+            var url = new UriBuilder("http://awesome.com")
+                    .WithParameter("awesome", "yodawg")
+                    .WithParameter("fun", null)
+                    .WithParameter("cool", string.Empty);
+            Assert.Equal("http://awesome.com/?awesome=yodawg&fun&cool", url.Uri.ToString());
+        }
+
         [Fact]
         public void TestAddTwoUrlParameters()
         {
@@ -106,5 +127,19 @@ namespace FluentUriBuilder.Tests
                     .WithParameter("supgf", "no22");
             Assert.Equal("http://awesome.com/?awesome=yodawg&supg=no2&supgf=no22", url.Uri.ToString());
         }
+
+        [Fact]
+        public void AddDictOfParams()
+        {
+            var dictionary = new Dictionary<string, string>()
+            {
+                ["yo"] = "dawg",
+                ["troll"] = "toll",
+                ["hammer"] = string.Empty
+            };
+            var url = new UriBuilder("http://awesome.com")
+                    .WithParameter(dictionary);
+            Assert.Equal("http://awesome.com/?yo=dawg&troll=toll&hammer", url.Uri.ToString());
+        }
     }
 }

src/UriBuilder.Fluent.UnitTests/ThrowsTests.cs

@@ -16,6 +16,7 @@ namespace FluentUriBuilder.Tests
             Assert.Throws<ArgumentNullException>(() => tstObj.WithPathSegment(null));
             Assert.Throws<ArgumentNullException>(() => tstObj.WithScheme(null));
             Assert.Throws<ArgumentNullException>(() => tstObj.WithHost(null));
+            Assert.Throws<ArgumentNullException>(() => tstObj.WithParameter(parameterDictionary: null));
             Assert.Throws<ArgumentOutOfRangeException>(() => tstObj.WithPort(-1));
         }
     }

src/UriBuilder.Fluent.UnitTests/project.json

@@ -9,7 +9,7 @@
   },
 
   "frameworks": {
-    "net461": {},
+
     "netcoreapp1.0": {
       "dependencies": {
         "Microsoft.NETCore.App": {

src/UriBuilder.Fluent/TerribleDevUriExtensions.cs

@@ -8,8 +8,39 @@ namespace System
 {
     public static class TerribleDevUriExtensions
     {
+        /// <summary>
+        /// Appends a query string parameter with a key, and many values. Multiple values will be comma seperated. If only 1 value is passed and its null or value, the key will be added to the QS.
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="key"></param>
+        /// <param name="values"></param>
+        /// <returns></returns>
         public static UriBuilder WithParameter(this UriBuilder bld, string key, params string[] values) => bld.WithParameter(key, valuesEnum: values);
 
+        /// <summary>
+        /// Appends query strings from dictionary
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="parameterDictionary"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <returns></returns>
+        public static UriBuilder WithParameter(this UriBuilder bld, IDictionary<string, string> parameterDictionary)
+        {
+            if(parameterDictionary == null) throw new ArgumentNullException(nameof(parameterDictionary));
+            foreach(var item in parameterDictionary)
+            {
+                bld.WithParameter(item.Key, item.Value);
+            }
+            return bld;
+        }
+
+        /// <summary>
+        /// Appends a query string parameter with a key, and many values. Multiple values will be comma seperated. If only 1 value is passed and its null or value, the key will be added to the QS.
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="key"></param>
+        /// <param name="valuesEnum"></param>
+        /// <returns></returns>
         public static UriBuilder WithParameter(this UriBuilder bld, string key, IEnumerable<object> valuesEnum)
         {
             if(string.IsNullOrWhiteSpace(key))
@@ -20,8 +51,7 @@ namespace System
             {
                 valuesEnum = new string[0];
             }
-            var isfirst = string.IsNullOrWhiteSpace(bld.Query);
+            var intitialValue = string.IsNullOrWhiteSpace(bld.Query) ? "" : $"{bld.Query.TrimStart('?')}&";
-            var intitialValue = isfirst ? "" : $"{bld.Query.TrimStart('?')}&";
             var sb = new StringBuilder($"{intitialValue}{key}");
             var validValueHit = false;
             foreach(var value in valuesEnum)
@@ -37,6 +67,13 @@ namespace System
             return bld;
         }
 
+        /// <summary>
+        /// Sets the port to be the port number
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="port"></param>
+        /// <exception cref="ArgumentOutOfRangeException">Throws if port is less than one</exception>
+        /// <returns></returns>
         public static UriBuilder WithPort(this UriBuilder bld, int port)
         {
             if(port < 1) throw new ArgumentOutOfRangeException(nameof(port));
@@ -44,6 +81,13 @@ namespace System
             return bld;
         }
 
+        /// <summary>
+        /// appends a path segment to the path. Can be called multiple times to append multiple segments
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="pathSegment"></param>
+        /// <exception cref="ArgumentNullException">You pass a string as a path segment</exception>
+        /// <returns></returns>
         public static UriBuilder WithPathSegment(this UriBuilder bld, string pathSegment)
         {
             if(string.IsNullOrWhiteSpace(pathSegment))
@@ -51,15 +95,17 @@ namespace System
                 throw new ArgumentNullException(nameof(pathSegment));
             }
             var path = pathSegment.TrimStart('/');
-            if(string.IsNullOrWhiteSpace(bld.Path))
-            {
-                bld.Path = path;
-                return bld;
-            }
             bld.Path = $"{bld.Path.TrimEnd('/')}/{path}";
             return bld;
         }
 
+        /// <summary>
+        /// Sets your Uri Scheme
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="scheme"></param>
+        /// <exception cref="ArgumentNullException">You must pass a scheme</exception>
+        /// <returns></returns>
         public static UriBuilder WithScheme(this UriBuilder bld, string scheme)
         {
             if(string.IsNullOrWhiteSpace(scheme)) throw new ArgumentNullException(nameof(scheme));
@@ -67,6 +113,13 @@ namespace System
             return bld;
         }
 
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="host"></param>
+        /// <exception cref="ArgumentNullException">You must pass a ho0st</exception>
+        /// <returns></returns>
         public static UriBuilder WithHost(this UriBuilder bld, string host)
         {
             if(string.IsNullOrWhiteSpace(host)) throw new ArgumentNullException(nameof(host));
@@ -74,6 +127,17 @@ namespace System
             return bld;
         }
 
+        public static string PathAndQuery(this UriBuilder bld)
+        {
+            return bld.Path + bld.Query;
+        }
+
+        /// <summary>
+        /// Use Https?
+        /// </summary>
+        /// <param name="bld"></param>
+        /// <param name="predicate">default true, if false sets scheme to http</param>
+        /// <returns></returns>
         public static UriBuilder UseHttps(this UriBuilder bld, bool predicate = true)
         {
             bld.Scheme = predicate ? "https" : "http";

src/UriBuilder.Fluent/project.json

@@ -4,9 +4,7 @@
       "owners": [
           "Tommy Parnell"
       ],
-      "repository": {
+      "projectUrl": "https://github.com/TerribleDev/UriBuilder.Fluent",
-          "url":"https://github.com/TerribleDev/UriBuilder.Fluent"
-      },
       "summary": "Fluent extensions for UriBuilder",
       "tags": [
           "Url building",
@@ -16,15 +14,19 @@
           "extension"
       ]
   },
-  "dependencies": {
-    "NETStandard.Library": "1.6.0"
-  },
   "authors": [
       "Tommy Parnell"
   ],
   "frameworks": {
-    "netstandard1.3": {
+    "netstandard1.1": {
+      "imports": "dnxcore50",
+        "dependencies": {
+         "NETStandard.Library": "1.6.0"
+        }
+    },
+    "net40": {
       "imports": "dnxcore50"
-    }
+    },
+    "net45":{}
   }
 }