Fixed Documentation and Code compliance

File_Engine/Compute/WriteToJsonFile.cs

@@ -41,10 +41,11 @@
         /***************************************************/
 
         [Description("Write a JSON-serialised file with the input data or objects.")]
+        [Input("objects", "Objects to write to the file.")]
         [Input("filePath", "Path to the file.")]
         [Input("replace", "If the file exists, you need to set this to true in order to allow overwriting it.")]
         [Input("active", "Boolean used to trigger the function.")]
         public static bool WriteToJsonFile(List<object> objects, string filePath, bool replace = false, bool active = false)
         {
             if (!active || objects == null)
                 return false;

File_Engine/Modify/ChangeDirectory.cs

@@ -38,7 +38,7 @@ public static partial class Modify
         /***************************************************/
 
         [Description("Move a file or directory to a new parent directory.")]
-        [Input("file", "The file (or directory) to move.")]
+        [Input("fileOrDir", "The file or directory to move.")]
         [Input("to", "The new parent Directory.")]
         [Output("The moved file object.")]
         public static IFSContainer ChangeDirectory(this oM.Adapters.File.IFSContainer fileOrDir, oM.Adapters.File.FSDirectory to)

File_Engine/Modify/ProcessFileDirRequest.cs

@@ -40,37 +40,36 @@
         /***************************************************/
 
         [Description("Get the contents of the file as a string, reading from its location.")]
-        [Input("file", "The file to get the contents of.")]
-        [Input("encoding", "The encoding to use to decode the data. If null (default) discovery will be attempted; defaults to UTF-8 if it can't be discovered.")]
-        [Output("The contents of the file.")]
-        public static bool ProcessFileDirRequest(this FileDirRequest fdr, out WildcardPattern wildcardPattern)
+        [Input("fileDirectoryRequest", "The file directory request to process.")]
+        [Output("success", "True if the wildcard pattern is valid.")]
+        public static bool ProcessFileDirRequest(this FileDirRequest fileDirectoryRequest, out WildcardPattern wildcardPattern)
         {
             wildcardPattern = null;
 
-            if (WildcardPattern.ContainsWildcardCharacters(fdr.Location))
+            if (WildcardPattern.ContainsWildcardCharacters(fileDirectoryRequest.Location))
             {
-                if (WildcardPattern.ContainsWildcardCharacters(fdr.Location))
+                if (WildcardPattern.ContainsWildcardCharacters(fileDirectoryRequest.Location))
                 {
-                    string allButLastSegment = fdr.Location.Remove(fdr.Location.Count() - Path.GetFileName(fdr.Location).Count());
+                    string allButLastSegment = fileDirectoryRequest.Location.Remove(fileDirectoryRequest.Location.Count() - Path.GetFileName(fileDirectoryRequest.Location).Count());
                     if (WildcardPattern.ContainsWildcardCharacters(allButLastSegment))
                     {
                         BH.Engine.Base.Compute.RecordError("Wildcards are only allowed in the last segment of the path.");
                         return false;
                     }
                     else
-                        wildcardPattern = new WildcardPattern(Path.GetFileName(fdr.Location));
+                        wildcardPattern = new WildcardPattern(Path.GetFileName(fileDirectoryRequest.Location));
                 }
 
-                if (fdr.IncludeDirectories)
+                if (fileDirectoryRequest.IncludeDirectories)
                 {
                     BH.Engine.Base.Compute.RecordWarning($"The usage of Wildcards is limited to file retrievals: " +
-                        $"\ncannot have `{nameof(FileDirRequest)}.{nameof(fdr.IncludeDirectories)}` set to true while a Wildcard is specified in the path." +
-                        $"\nDefaulting `{nameof(fdr.IncludeDirectories)}` to false and continuing.");
-                    fdr.IncludeDirectories = false;
+                        $"\ncannot have `{nameof(FileDirRequest)}.{nameof(fileDirectoryRequest.IncludeDirectories)}` set to true while a Wildcard is specified in the path." +
+                        $"\nDefaulting `{nameof(fileDirectoryRequest.IncludeDirectories)}` to false and continuing.");
+                    fileDirectoryRequest.IncludeDirectories = false;
                 }
 
-                if (fdr.IncludeFileContents)
-                    BH.Engine.Base.Compute.RecordNote($"Note that `{nameof(fdr.IncludeFileContents)}` works only for BHoM-serialized JSON files.");
+                if (fileDirectoryRequest.IncludeFileContents)
+                    BH.Engine.Base.Compute.RecordNote($"Note that `{nameof(fileDirectoryRequest.IncludeFileContents)}` works only for BHoM-serialized JSON files.");
             }
 
             return true;

File_Engine/Modify/RelativiseUserPath.cs

@@ -41,7 +41,7 @@
         /***************************************************/
 
         [Description("If an user path is specified – e.g. containing `C:/Users/SomeUser` – modifies SomeUser to match the current user.")]
         public static string RelativiseUserPath(string path)
         {
             string relativisedPath = path;
             char separator = '\\';
@@ -63,6 +63,8 @@
             return relativisedPath;
         }
 
+        /***************************************************/
+
         // Get the user folder, in the form of C:\Users\UserName.
         // Written to work also for Windows versions prior to 10.
         private static string GetUserPath()

File_Engine/Modify/Rename.cs

@@ -38,28 +38,46 @@ public static partial class Modify
         /***************************************************/
 
         [Description("Rename a file or directory.")]
-        [Input("file", "The file (or directory) to rename.")]
+        [Input("fileOrDir", "The file or directory to rename.")]
         [Input("name", "The new name.")]
         [Output("The moved file object.")]
+        [PreviousVersion("7.1", "BH.Engine.Adapters.File.Modify.Rename(BH.oM.Adapters.File.FSFile, System.String)")]
+        [PreviousVersion("7.1", "BH.Engine.Adapters.File.Modify.Rename(BH.oM.Adapters.File.FSDirectory, System.String)")]
         public static IFSContainer IRename(this oM.Adapters.File.IFSContainer fileOrDir, string name)
         {
             fileOrDir = BH.Engine.Base.Query.ShallowClone(fileOrDir);
             return Rename(fileOrDir as dynamic, name);
         }
 
+        /***************************************************/
+        /**** Private interface methods                 ****/
         /***************************************************/
 
-        public static IFSContainer Rename(this FSFile file, string name)
+        private static IFSContainer Rename(this FSFile file, string name)
         {
             file.Name = name;
             return file;
         }
 
-        public static IFSContainer Rename(this FSDirectory directory, string name)
+        /***************************************************/
+
+        private static IFSContainer Rename(this FSDirectory directory, string name)
         {
             directory.Name = name;
             return directory;
         }
+
+        /***************************************************/
+        /**** Private interface methods - fallback      ****/
+        /***************************************************/
+
+        private static IFSContainer Rename(this IFSContainer container, string name)
+        {
+            BH.Engine.Base.Compute.RecordError($"Cannot rename FSContainers of type: {container.GetType().FullName}, please provide either an FSFile or FSDirectory object.");
+            return null;
+        }
+
+        /***************************************************/
     }
 }
 

File_Engine/Query/Contents.cs

@@ -40,7 +40,7 @@ public static partial class Query
         [Description("Get the contents of the file as a string, reading from its location.")]
         [Input("file", "The file to get the contents of.")]
         [Input("encoding", "The encoding to use to decode the data. If null (default) discovery will be attempted; defaults to UTF-8 if it can't be discovered.")]
-        [Output("The contents of the file.")]
+        [Output("contents", "The contents of the file.")]
         public static string ContentsAsString(this FSFile file, Encodings encoding = Encodings.FromFile)
         {
             byte[] contents = file.ContentsAsByteArray();
@@ -63,8 +63,8 @@ public static string ContentsAsString(this FSFile file, Encodings encoding = Enc
 
 
         [Description("Get the contents of the file as a byteArray, reading from its location.")]
-        [Input("file", "The file to get the contents of.")]
-        [Output("The contents of the file.")]
+        [Input("bhomFile", "The BHoM file to get the contents of.")]
+        [Output("contents", "The contents of the file.")]
         public static byte[] ContentsAsByteArray(this FSFile bhomFile)
         {
             byte[] contents = null;

File_Engine/Query/FullPath.cs

@@ -41,11 +41,15 @@
 
         [Description("Get the full path. " +
             "If the input is a string path containing wildcard symbols, return only the upper portion of the path that doesn't have any.")]
         public static string IFullPath(this object obj)
         {
             return obj != null ? FullPath(obj as dynamic) ?? "" : "";
         }
 
+        /***************************************************/
+        /**** Private interface methods                 ****/
+        /***************************************************/
+
         private static string FullPath(this IFSInfo baseInfo)
         {
             if (baseInfo.ParentDirectory == null)
@@ -57,11 +61,15 @@
             return baseInfo.ToString();
         }
 
+        /***************************************************/
+
         private static string FullPath(this IResourceRequest fdr)
         {
             return FullPath(fdr.Location);
         }
 
+        /***************************************************/
+
         private static string FullPath(this ILocatableResource fdr)
         {
             if (fdr?.Location == null)
@@ -78,6 +86,8 @@
             return location;
         }
 
+        /***************************************************/
+
         private static string FullPath(this string path)
         {
             if (string.IsNullOrWhiteSpace(path))
@@ -128,7 +138,10 @@
             return null;
         }
 
-        //Fallback
+        /***************************************************/
+        /**** Private interface methods - Fallback      ****/
+        /***************************************************/
+
         private static string FullPath(object fileOrDir)
         {
             BH.Engine.Base.Compute.RecordError($"Can not compute the FullPath for an object of type `{fileOrDir.GetType().Name}`.");

File_Engine/Query/NestingDepth.cs

@@ -38,7 +38,9 @@ public static partial class Query
         /***************************************************/
 
         [Description("Get the nesting depth of the input File or Directory, which is the total number of parent folders.")]
-        public static int NestingDepth(oM.Adapters.File.IFSInfo fileOrDir)
+        [Input("fileOrDir", "The file or directory to get the depth of.")]
+        [Output("count", "The number of parent folders that the file or directory has.")]
+        public static int NestingDepth(this oM.Adapters.File.IFSInfo fileOrDir)
         {
             int count = 0;
             while (fileOrDir.ParentDirectory != null)

File_Engine/Query/PathCombine.cs

@@ -40,15 +40,20 @@ public static partial class Query
         /***************************************************/
 
         [Description("Combines two paths.")]
-        public static string PathCombine(string path1, string path2)
+        [Input("path1", "The left half of the path.")]
+        [Input("path2", "The right half of the path.")]
+        [Output("path", "The combined path.")]
+        public static string PathCombine(this string path1, string path2)
         {
             return Path.Combine(path1, path2);
         }
 
         /***************************************************/
 
         [Description("Combines multiple string paths.")]
-        public static string PathCombine(List<string> paths)
+        [Input("paths", "The list of paths to combine, in order.")]
+        [Output("path", "The combined path.")]
+        public static string PathCombine(this List<string> paths)
         {
             return Path.Combine(paths.ToArray());
         }