예제 #1
0
        private static List <string> ProcessComplexItems(IEnumerable <string> directories, PathSegment wildcard,
                                                         Regex regularExpression)
        {
            List <string> newItems = new List <string>();
            int           indexOfComplexWildcard =
                wildcard.Value.IndexOf(PathConstants.ANY_PATH_WILDCARD, StringComparison.OrdinalIgnoreCase);
            bool   hasSimpleStart = false;
            string simpleStart    = string.Empty;

            if (indexOfComplexWildcard > 0)
            {
                hasSimpleStart = true;
                simpleStart    = wildcard.Value.Substring(0, indexOfComplexWildcard) +
                                 PathConstants.WILDCARD_ANY_CHARACTER;
            }

            foreach (string directory in directories)
            {
                IEnumerable <string> subItems = hasSimpleStart
                    ? TexoDirectory.GetFileSystemEntries(directory, PathConstants.SEARCH_TERM_ALL, simpleStart)
                    : TexoDirectory.GetFileSystemEntries(directory, PathConstants.SEARCH_TERM_ALL,
                                                         SearchOption.AllDirectories);

                newItems.AddRange(subItems.Where(item => regularExpression.IsMatch(item)));
            }

            return(newItems);
        }
예제 #2
0
        public IImmutableList <string> GetTopDirectories()
        {
            var result = ImmutableList <string> .Empty.ToBuilder();

            Stack <string> directories = new Stack <string>();

            directories.Push(GetFixedPrefixPath());

            while (directories.Count > 0)
            {
                string directory = directories.Pop();

                foreach (string subDirectory in TexoDirectory.GetDirectories(directory))
                {
                    if (regularExpression.IsMatch(subDirectory))
                    {
                        result.Add(subDirectory);
                    }
                    else
                    {
                        directories.Push(subDirectory);
                    }
                }
            }

            return(result.ToImmutable());
        }
예제 #3
0
        public IImmutableList <string> GetFilesFromDirectories(string searchPattern, SearchOption options)
        {
            var result = ImmutableList <string> .Empty.ToBuilder();

            IEnumerable <string> directories =
                options == SearchOption.AllDirectories
                    ? GetTopDirectories()
                    : GetDirectories();


            foreach (string directory in directories)
            {
                result.AddRange(TexoDirectory.GetFiles(directory, searchPattern, options));
            }

            return(result.ToImmutable());
        }
예제 #4
0
        private List <string> ProcessItems(List <string> directories)
        {
            int wildcardIndex = GetFirstWildcardOrLastIndex();
            int lastIndex     = GetLastIndex();

            while (true)
            {
                PathSegment wildcard = Segments[wildcardIndex];

                if (wildcard.WildcardType == PathSegment.WildcardTypeEnum.Complex)
                {
                    return(ProcessComplexItems(directories, wildcard, regularExpression));
                }

                if (wildcardIndex == lastIndex)
                {
                    return(ProcessLeafItems(directories, wildcard));
                }

                List <string> newDirectories = new List <string>();

                foreach (string directory in directories)
                {
                    if (wildcard.WildcardType == PathSegment.WildcardTypeEnum.Simple)
                    {
                        newDirectories.AddRange(TexoDirectory.GetDirectories(directory, wildcard.Value,
                                                                             SearchOption.TopDirectoryOnly));
                    }
                    else
                    {
                        string newDirectory = System.IO.Path.Combine(directory, wildcard.Value);

                        if (Directory.Exists(newDirectory))
                        {
                            newDirectories.Add(newDirectory);
                        }
                    }
                }

                directories = newDirectories;
                wildcardIndex++;
            }
        }