Beispiel #1
0
        public static void CopyWithIgnores(DirectoryInfo source, DirectoryInfo target, IgnoreList ignores)
        {
            if (source is null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            if (target is null)
            {
                throw new ArgumentNullException(nameof(target));
            }

            if (ignores is null)
            {
                throw new ArgumentNullException(nameof(ignores));
            }

            foreach (var dir in source.GetDirectories().Where(d => !ignores.IsIgnored(d)))
            {
                CopyWithIgnores(dir, target.CreateSubdirectory(dir.Name), ignores);
            }

            foreach (var file in source.GetFiles().Where(f => !ignores.IsIgnored(f)))
            {
                file.CopyTo(Path.Combine(target.FullName, file.Name));
            }
        }
Beispiel #2
0
        public void Respect_Rule_Overrides()
        {
            var list = new IgnoreList(new string[] { "*.txt", "!sub1/*.txt", "sub1/README2.txt" });

            Assert.IsTrue(list.IsIgnored("README1.txt", true));
            Assert.IsFalse(list.IsIgnored("sub1/README1.txt", true));
            Assert.IsTrue(list.IsIgnored("sub1/README2.txt", true));
        }
        public void Add_Rules_From_File()
        {
            var ignoreList = new IgnoreList(new string[] { "README.txt" });

            ignoreList.AddRules(_basePath + @"\loadfromfile.gitignore");
            Assert.IsTrue(ignoreList.IsIgnored("README.txt", true));
            Assert.IsFalse(ignoreList.IsIgnored("test.jpg", true));
            Assert.IsTrue(ignoreList.IsIgnored("test.cs", true));
        }
        public void Ignore_After_Dynamic_Remove()
        {
            var ignoreList = new IgnoreList(new List <string> {
                "README1.txt", "README2.txt", "README3.txt", "README4.txt"
            });

            ignoreList.RemoveRule("README2.txt");
            Assert.IsTrue(ignoreList.IsIgnored("README1.txt", true));
            Assert.IsFalse(ignoreList.IsIgnored("README2.txt", true));
            Assert.IsTrue(ignoreList.IsIgnored("README3.txt", true));
            Assert.IsTrue(ignoreList.IsIgnored("README4.txt", true));
        }
        public static void CopyWithIgnores(DirectoryInfo source, DirectoryInfo target, IgnoreList ignores)
        {
            foreach (DirectoryInfo dir in source.GetDirectories().Where(d => !ignores.IsIgnored(d)))
            {
                CopyWithIgnores(dir, target.CreateSubdirectory(dir.Name), ignores);
            }

            foreach (FileInfo file in source.GetFiles().Where(f => !ignores.IsIgnored(f)))
            {
                file.CopyTo(Path.Combine(target.FullName, file.Name));
            }
        }
Beispiel #6
0
        public void File_Rule_Line_Numbers_ToString()
        {
            var log = new IgnoreLog();

            var list = new IgnoreList(new string[] { "*.cs" });

            list.AddRules(_basePath + "/multiplematch.gitignore");

            var paths = new List <string> {
                "test/test1.cs", "test/test2.cs"
            };

            paths.ForEach(path => list.IsIgnored(path, true, log));

            const string expectedResult = @"test/test1.cs
    IGNORED by *.cs
    INCLUDED by !test/*.cs (line 3)
    IGNORED by test/test*.cs (line 4)

test/test2.cs
    IGNORED by *.cs
    INCLUDED by !test/*.cs (line 3)
    IGNORED by test/test*.cs (line 4)
    INCLUDED by !test/test2.cs (line 6)";

            Assert.IsTrue(log.ToString() == expectedResult);
        }
Beispiel #7
0
        public void Log_ToString()
        {
            var log = new IgnoreLog();

            var list = new IgnoreList(new string[] { "one/", "two/", "!one/two/" });

            var paths = new List <string> {
                "one", "one/two", "two"
            };

            paths.ForEach(path => list.IsIgnored(path, true, log));

            const string expectedResult = @"one
    IGNORED by one/

one/two
    IGNORED by one/
    IGNORED by two/
    INCLUDED by !one/two/

two
    IGNORED by two/";

            Assert.IsTrue(log.ToString() == expectedResult);
        }
        protected virtual void OnMethod(RunnerEventArgs e)
        {
            OnEvent(AnalyzeMethod, e);

            foreach (IMethodRule rule in method_rules)
            {
                defectCountBeforeCheck = Defects.Count;
                // stop if we reach the user defined defect limit
                if (defectCountBeforeCheck >= DefectsLimit)
                {
                    break;
                }

                // ignore if the visibility does not match user selection
                ApplicabilityScope scope = rule.ApplicabilityScope;
                if ((scope != ApplicabilityScope.All) && !VisibilityCheck(scope, e.CurrentMethod.IsVisible()))
                {
                    continue;
                }

                // ignore the rule on some user defined methods
                if (IgnoreList.IsIgnored(rule, e.CurrentMethod))
                {
                    continue;
                }

                currentRule = rule;
                rule.CheckMethod(e.CurrentMethod);
            }
        }
Beispiel #9
0
        public void Ignore_After_Dynamic_Add()
        {
            var list = new IgnoreList(new List <string> {
                "README1.txt"
            });

            list.AddRule("README2.txt");
            list.AddRules(new List <string> {
                "README3.txt", "README4.txt"
            });

            Assert.IsTrue(list.IsIgnored("README1.txt", true));
            Assert.IsTrue(list.IsIgnored("README2.txt", true));
            Assert.IsTrue(list.IsIgnored("README3.txt", true));
            Assert.IsTrue(list.IsIgnored("README4.txt", true));
        }
        public void DirectoryInfo_Match()
        {
            var directory = new DirectoryInfo(_basePath + @"\test");
            var list      = new IgnoreList(new string[] { "test" });

            Assert.IsTrue(list.IsIgnored(directory));
        }
        public void FileInfo_Match()
        {
            var directory = new DirectoryInfo(_basePath);
            var file      = directory.GetFiles("*.txt")[0];
            var list      = new IgnoreList(new string[] { "test.txt" });

            Assert.IsTrue(list.IsIgnored(file));
        }
 private bool Filter(Severity severity, Confidence confidence, IMetadataTokenProvider location)
 {
     if (!SeverityBitmask.Get(severity) || !ConfidenceBitmask.Get(confidence))
     {
         return(false);
     }
     // for Assembly | Type | Methods we can ignore before executing the rule
     // but for others (e.g. Parameters, Fields...) we can only ignore the results
     return(!IgnoreList.IsIgnored(currentRule, location));
 }
Beispiel #13
0
        public void DirectoryInfo_Match_Log()
        {
            var directory = new DirectoryInfo(_basePath + "/test");
            var list      = new IgnoreList(new string[] { "test" });
            var log       = new IgnoreLog();

            Assert.IsTrue(list.IsIgnored(directory, log));
            Assert.IsTrue(log.Count == 1);
            Assert.IsTrue(log[directory.FullName].Count == 1);
            Assert.IsTrue(log[directory.FullName][0] == "IGNORED by test");
        }
        public void Ignored_Directory_Ignores_All_Children()
        {
            var list = new IgnoreList(new string[] { "ignored/", "!ignored/one/two/" });

            Assert.IsTrue(list.IsIgnored("ignored/test.txt", false));
            Assert.IsTrue(list.IsIgnored("ignored/one/test.txt", false));
            Assert.IsTrue(list.IsIgnored("ignored/two/three.txt", false));
            Assert.IsTrue(list.IsIgnored("ignored/one/two/test.txt", false));
            Assert.IsTrue(list.IsIgnored("ignored/one/two/three/test.txt", false));
            Assert.IsFalse(list.IsIgnored("notignored/test.txt", false));
            Assert.IsFalse(list.IsIgnored("notignored/one/test.txt", false));
            Assert.IsFalse(list.IsIgnored("notignored/one/two/test.txt", false));
        }
        public void Add_Rule_Flags_Respected()
        {
            var directory = new DirectoryInfo(_basePath + @"\TEST");
            var list1     = new IgnoreList(new string[] { "x" });
            var list2     = new IgnoreList(new string[] { "x" });

            list1.AddRule("test");
            list2.AddRule("test", MatchFlags.CASEFOLD);
            Assert.IsFalse(list1.IsIgnored(directory));
            Assert.IsTrue(list2.IsIgnored(directory));
        }
        public void Constructor_Flags_Respected()
        {
            var directory = new DirectoryInfo(_basePath + @"\TEST");
            // Case sensitive list, should not match
            var list1 = new IgnoreList(new string[] { "test" });
            // Case insensitive, should match
            var list2 = new IgnoreList(new string[] { "test" }, MatchFlags.CASEFOLD);

            Assert.IsFalse(list1.IsIgnored(directory));
            Assert.IsTrue(list2.IsIgnored(directory));
        }
Beispiel #17
0
        public void FileInfo_Match_Log()
        {
            var directory = new DirectoryInfo(_basePath);
            var file      = directory.GetFiles("*.txt")[0];
            var list      = new IgnoreList(new string[] { "test.txt" });
            var log       = new IgnoreLog();

            Assert.IsTrue(list.IsIgnored(file, log));
            Assert.IsTrue(log.Count == 1);
            Assert.IsTrue(log[file.FullName].Count == 1);
            Assert.IsTrue(log[file.FullName][0] == "IGNORED by test.txt");
        }
Beispiel #18
0
        public void Log_Matched_Rules()
        {
            var ignoreList = new IgnoreList(new string[] { "*.txt", "*.cs", "!sub1/*.txt", "sub1/README2.txt" });
            var log        = new IgnoreLog();

            ignoreList.IsIgnored("sub1/README2.txt", true, log);
            Assert.IsTrue(log.Count == 1);
            Assert.IsTrue(log["sub1/README2.txt"].Count == 3);
            Assert.IsTrue(log["sub1/README2.txt"][0] == "IGNORED by *.txt");
            Assert.IsTrue(log["sub1/README2.txt"][1] == "INCLUDED by !sub1/*.txt");
            Assert.IsTrue(log["sub1/README2.txt"][2] == "IGNORED by sub1/README2.txt");
        }
Beispiel #19
0
        /// <summary>
        /// Returns a collection of files contained in the specified directory and recursively in sub-directories.
        /// If the directory has a ".pakfilter" file, it will be used to filter which files to find.
        /// The .pakfilter file contains a list of filtering rules with the same syntax as the .gitignore file in Git. However,
        /// contrary to the .gitignore file which is a blacklist, the .pakfilter file is a whitelist.
        /// </summary>
        /// <param name="dir">The directory to find files in</param>
        /// <returns>An array of absolute file paths</returns>
        public static IReadOnlyCollection <string> Find(string dir)
        {
            var files = Directory.GetFiles(dir, "*", SearchOption.AllDirectories);

            if (!HasFilterFile(dir))
            {
                return(files);
            }

            var ignoreList = new IgnoreList(Path.Combine(dir, FilterFileName));

            return(files.Where(file => ignoreList.IsIgnored(file, false)).ToList());
        }
Beispiel #20
0
        private static async Task <ComponentTree> BuildTreeFrom(
            ProjectSettings settings,
            string path,
            IgnoreList ignoreList)
        {
            var directory = new DirectoryInfo(settings.GetRootedPath(path));

            var componentTree = await GetTreeAt(directory, settings);

            var children = (await directory
                            .GetDirectories()
                            .Where(x => !ignoreList.IsIgnored(new DirectoryInfo(settings.GetRelativePath(x.FullName))))
                            .Select(childDirectory => BuildTreeFrom(settings, childDirectory.FullName, ignoreList))
                            .WhenAll())
                           .ToImmutableList();

            return(ComponentTree.WithChildren(componentTree, children));
        }
        public virtual void Report(Defect defect)
        {
            if (defect == null)
            {
                throw new ArgumentNullException("defect");
            }

            if (!Filter(defect.Severity, defect.Confidence, defect.Location))
            {
                return;
            }

            if (IgnoreList.IsIgnored(defect.Rule, defect.Target))
            {
                return;
            }

            defect_list.Add(defect);
        }
        private RuleResult PreCheck(IMetadataTokenProvider obj)
        {
            if (obj == null)
            {
                throw new ArgumentNullException("obj", "Cannot check a null object");
            }

            Reset();
            AssemblyDefinition assembly = obj.GetAssembly();

            if (!Assemblies.Contains(assembly))
            {
                Assemblies.Clear();
                Assemblies.Add(assembly);
                Engines.Build(Assemblies);
            }
            CurrentTarget = obj;

            return(IgnoreList.IsIgnored(CurrentRule, obj) ? RuleResult.DoesNotApply : RuleResult.Success);
        }
        // protected since a higher-level (e.g. GUI) runner might want to override
        // them to update it's user interface
        protected virtual void OnAssembly(RunnerEventArgs e)
        {
            OnEvent(AnalyzeAssembly, e);

            foreach (IAssemblyRule rule in assembly_rules)
            {
                defectCountBeforeCheck = Defects.Count;
                // stop if we reach the user defined defect limit
                if (defectCountBeforeCheck >= DefectsLimit)
                {
                    break;
                }

                // ignore the rule on some user defined assemblies
                if (IgnoreList.IsIgnored(rule, e.CurrentAssembly))
                {
                    continue;
                }

                currentRule = rule;
                rule.CheckAssembly(e.CurrentAssembly);
            }
        }
Beispiel #24
0
 public bool IsIgnored(string path) =>
 !_isInitialized || _ignoreList.IsIgnored(path, PathHelper.IsDirectoryPath(path));
Beispiel #25
0
        public static void OnScriptError(ScriptCore.ScriptProxy proxy, Exception exception)
        {
            try
            {
                using (TestSpan span = new TestSpan(TimeSpanLogger.Bin, "OnScriptError", DebuggingLevel))
                {
                    bool fullReset = true;

                    bool record = !IgnoreList.IsIgnored(exception, out fullReset);

                    IScriptLogic target = null;
                    if (proxy != null)
                    {
                        target = proxy.Target;
                    }

                    StringBuilder noticeText = new StringBuilder();
                    StringBuilder logText    = new StringBuilder();

                    SimUpdate update = target as SimUpdate;
                    if (update != null)
                    {
                        target = update.mSim;
                    }
                    else
                    {
                        AutonomyManager autonomy = target as AutonomyManager;
                        if (autonomy != null)
                        {
                            target = SearchForAutonomy(exception.StackTrace);
                        }
                        else
                        {
                            Services services = target as Services;
                            if (services != null)
                            {
                                target = SearchForAssignedSim(exception.StackTrace);
                            }
                        }
                    }

                    SimDescription targetSim = SearchForSim(exception.StackTrace);
                    if (targetSim != null)
                    {
                        new FixInvisibleTask(targetSim).AddToSimulator();
                    }

                    IGameObject obj = null;

                    if (targetSim != null)
                    {
                        obj = ScriptCoreLogger.Convert(targetSim, noticeText, logText);
                    }
                    else
                    {
                        obj = ScriptCoreLogger.Convert(target, noticeText, logText);
                        if (obj == null)
                        {
                            obj = target as IGameObject;
                        }
                    }

                    ObjectGuid id       = ObjectGuid.InvalidObjectGuid;
                    bool       moonDial = false;
                    if (obj != null)
                    {
                        id = obj.ObjectId;

                        moonDial = obj.GetType() == typeof(Sims3.Gameplay.Objects.Decorations.MoonDial);

                        if (moonDial)
                        {
                            record = false;
                        }
                    }

                    if (record)
                    {
                        ScriptCoreLogger.Append(noticeText, logText, id, ObjectGuid.InvalidObjectGuid, exception, sAlreadyCaught);
                    }

                    /* do not use else if here */
                    if ((proxy != null) && (proxy.Target is RoleManagerTask))
                    {
                        new CheckRoleManagerTask().Perform(proxy.Target as RoleManagerTask, true);
                    }

                    Sim simObj = obj as Sim;
                    if (simObj != null)
                    {
                        try
                        {
                            if (simObj.Household == null)
                            {
                                fullReset = true;
                            }

                            if ((!fullReset) && (proxy != null))
                            {
                                proxy.OnReset();
                            }
                        }
                        catch (Exception e)
                        {
                            Common.Exception(proxy.Target, null, "PartialReset", e);
                            fullReset = true;
                        }

                        if (fullReset)
                        {
                            if (update != null)
                            {
                                try
                                {
                                    Simulator.DestroyObject(update.Proxy.ObjectId);
                                }
                                catch
                                { }
                            }

                            new ResetSimTask(simObj);
                            return;
                        }
                    }
                    else if (proxy != null && !moonDial)
                    {
                        proxy.OnReset();
                    }
                }
            }
            catch (Exception e)
            {
                Exception(proxy.Target, e);
            }
        }
Beispiel #26
0
        public void Handle_Non_Relative_Path()
        {
            var list = new IgnoreList(new string[] { "ignored/" });

            Assert.IsTrue(list.IsIgnored("/ignored/test/test.txt", false));
        }