public override string ExplicitLabel(IFuzzyOption item)
        {
            if (item is NamespaceOption namespaceOption)
            {
                return(namespaceOption.value.DisplayName());
            }
            else if (item is TypeOption typeOption)
            {
                return(typeOption.value.DisplayName());
            }
            else if (item is MemberOption memberOption)
            {
                var member = memberOption.value;

                if (member.isInvocable)
                {
                    return($"{member.info.DisplayName(action, expectingBoolean)} ({member.methodBase.DisplayParameterString()})");
                }
                else
                {
                    return(member.info.DisplayName(action, expectingBoolean));
                }
            }

            throw new NotSupportedException();
        }
        public FuzzyOptionNode(IFuzzyOption option)
        {
            Ensure.That(nameof(option)).IsNotNull(option);

            this.option = option;
            children    = new List <FuzzyOptionNode>();
            labelText   = option.label;
        }
        public FuzzyOptionNode(IFuzzyOption option, string label)
        {
            Ensure.That(nameof(option)).IsNotNull(option);

            this.option = option;
            children    = new List <FuzzyOptionNode>();
            labelText   = label ?? string.Empty;
        }
        public override string SearchResultLabel(IFuzzyOption item, string query)
        {
            if (item is MemberOption memberOption)
            {
                return(memberOption.SearchResultLabel(query, action, expectingBoolean));
            }

            return(base.SearchResultLabel(item, query));
        }
Exemple #5
0
        public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
        {
            if (parent is NamespaceOption namespaceOption)
            {
                var @namespace = namespaceOption.value;

                if ([email protected])
                {
                    var childNamespaces = Enumerable.Empty <Namespace>();
                    if (namespacesInNamespace.TryGetValue(@namespace, out var foundNamespaces))
                    {
                        childNamespaces = foundNamespaces;
                    }

                    if (ordered)
                    {
                        childNamespaces = childNamespaces.OrderBy(ns => ns.DisplayName(false));
                    }

                    foreach (var childNamespace in childNamespaces)
                    {
                        yield return(new NamespaceOption(childNamespace, FuzzyOptionMode.Branch));
                    }
                }

                var childTypes = Enumerable.Empty <Type>();
                if (typesInNamespace.TryGetValue(@namespace, out var foundTypes))
                {
                    childTypes = foundTypes;
                }

                if (ordered)
                {
                    childTypes = childTypes.OrderBy(t => t.DisplayName());
                }

                foreach (var type in childTypes)
                {
                    yield return(new TypeOption(type, FuzzyOptionMode.Leaf));
                }
            }
            else if (parent.value == enumsGroup)
            {
                var childTypes = enumTypes.AsEnumerable();

                if (ordered)
                {
                    childTypes = childTypes.OrderBy(t => t.DisplayName());
                }

                foreach (var type in childTypes)
                {
                    yield return(new TypeOption(type, FuzzyOptionMode.Leaf));
                }
            }
        }
 public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
 {
     if (parent is AssetFolderOption folderOption)
     {
         return(Children(folderOption.value));
     }
     else
     {
         return(Enumerable.Empty <IFuzzyOption>());
     }
 }
        public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
        {
            foreach (var extension in extensions)
            {
                var children = (extension is FuzzyOptionTree fot) ? fot.Children(parent, ordered) : extension.Children(parent);

                foreach (var extensionChild in children)
                {
                    yield return(extensionChild);
                }
            }
        }
        public override string SearchResultLabel(IFuzzyOption item, string query)
        {
            foreach (var extension in extensions)
            {
                try
                {
                    var label = extension.SearchResultLabel(item, query);
                    if (label != null)
                    {
                        return(label);
                    }
                }
                catch (NotSupportedException) {}
            }

            return(base.SearchResultLabel(item, query));
        }
Exemple #9
0
        public virtual IEnumerable <IFuzzyOption> SearchableChildren(IFuzzyOption parent)
        {
            if (parent is FuzzyWindow.FavoritesRoot)
            {
                foreach (var favorite in favorites.Where(CanFavorite))
                {
                    yield return(favorite);
                }
            }
            else
            {
                foreach (var child in Children(parent, false))
                {
                    yield return(child);

                    foreach (var grandchild in SearchableChildren(child))
                    {
                        yield return(grandchild);
                    }
                }
            }
        }
Exemple #10
0
        public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
        {
            if (parent is NamespaceOption namespaceOption)
            {
                var @namespace = namespaceOption.value;

                if ([email protected])
                {
                    var childNamespaces = namespaces.Where(ns => ns.Parent == @namespace);

                    if (ordered)
                    {
                        childNamespaces = childNamespaces.OrderBy(ns => ns.DisplayName(false));
                    }

                    foreach (var childNamespace in childNamespaces)
                    {
                        yield return(new NamespaceOption(childNamespace, FuzzyOptionMode.Branch));

                        yield return(new NamespaceOption(childNamespace, FuzzyOptionMode.Leaf));
                    }
                }
            }
        }
Exemple #11
0
 public virtual bool UseExplicitLabel(IFuzzyOption parent, IFuzzyOption item)
 {
     return(false);
 }
Exemple #12
0
 public virtual string SearchResultLabel(IFuzzyOption item, string query)
 {
     return(item.SearchResultLabel(query));
 }
Exemple #13
0
        public virtual IEnumerable <ISearchResult <IFuzzyOption> > SearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
        {
            var options = parent == null?SearchableRoot() : SearchableChildren(parent);

            return(options.OrderableSearchFilter(query, x => x.haystack, cancellation));
        }
Exemple #14
0
 public virtual IEnumerable <IFuzzyOption> OrderedSearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
 {
     return(SearchResults(query, parent, cancellation).OrderByRelevance());
 }
        public override IEnumerable <ISearchResult <IFuzzyOption> > SearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
        {
            foreach (var baseSearchResult in base.SearchResults(query, parent, cancellation))
            {
                yield return(baseSearchResult);
            }

            foreach (var extension in extensions)
            {
                if (extension.searchable)
                {
                    foreach (var extensionSearchResult in extension.SearchResults(query, parent, cancellation))
                    {
                        yield return(extensionSearchResult);
                    }
                }
            }
        }
Exemple #16
0
 public virtual IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered) => Enumerable.Empty <IFuzzyOption>();
 public override IEnumerable <ISearchResult <IFuzzyOption> > SearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
 {
     return(looseAssemblyNames.Select(x => new LooseAssemblyNameOption(x)).OrderableSearchFilter(query, x => x.haystack, cancellation));
 }
 public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
 {
     return(Enumerable.Empty <IFuzzyOption>());
 }
        public override IEnumerable <IFuzzyOption> OrderedSearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
        {
            // Exclude duplicate inherited members, like the high amount of "Destroy()" or "enabled",
            // if their declaring type is also available for search.

            foreach (var memberOption in codebase.members
                     .Cancellable(cancellation)
                     .Select(m => new MemberOption(m))
                     .UnorderedSearchFilter(query, m => m.Haystack(action, expectingBoolean))
                     .Where(m => !m.value.isPseudoInherited || !codebase.types.Contains(m.value.info.DeclaringOrExtendedType()))
                     .OrderBy(m => LudiqCore.Configuration.groupInheritedMembers && m.value.isPseudoInherited)
                     .ThenByDescending(m => SearchUtility.Relevance(query, m.Haystack(action, expectingBoolean))))
            {
                yield return(memberOption);
            }

            foreach (var typeOption in codebase.types
                     .Select(t => new TypeOption(t, FuzzyOptionMode.Branch))
                     .Where(t => !t.value.IsEnum)
                     .OrderedSearchFilter(query, t => t.haystack, cancellation))
            {
                yield return(typeOption);
            }
        }
Exemple #20
0
        public override IEnumerable <ISearchResult <IFuzzyOption> > SearchResults(string query, IFuzzyOption parent, CancellationToken cancellation)
        {
            var children = parent != null
                                ? SearchableChildren(parent)
                                : namespaces.Select(x => (IFuzzyOption) new NamespaceOption(x, FuzzyOptionMode.Branch));

            return(children.OrderableSearchFilter(query, x => x.haystack, cancellation));
        }
Exemple #21
0
 public virtual string ExplicitLabel(IFuzzyOption item)
 {
     throw new NotSupportedException();
 }
Exemple #22
0
 public virtual bool CanFavorite(IFuzzyOption item)
 {
     throw new NotSupportedException();
 }
 public override bool CanFavorite(IFuzzyOption item)
 {
     return(item is MemberOption);
 }
Exemple #24
0
 public IEnumerable <IFuzzyOption> Children(IFuzzyOption parent)
 {
     return(Children(parent, true));
 }
        public override IEnumerable <IFuzzyOption> Children(IFuzzyOption parent, bool ordered)
        {
            if (parent is NamespaceOption namespaceOption)
            {
                var @namespace = namespaceOption.value;

                if ([email protected])
                {
                    var childNamespaces = codebase.members
                                          .Select(m => m.targetType)
                                          .Distinct()
                                          .Where(t => !t.IsEnum)
                                          .Select(t => t.Namespace())
                                          .Distinct()
                                          .Where(ns => ns.Parent == @namespace);

                    if (ordered)
                    {
                        childNamespaces = childNamespaces.OrderBy(ns => ns.DisplayName(false));
                    }

                    foreach (var childNamespace in childNamespaces)
                    {
                        yield return(new NamespaceOption(childNamespace, FuzzyOptionMode.Branch));
                    }
                }

                var childTypes = codebase.members
                                 .Select(m => m.targetType)
                                 .Where(t => !t.IsEnum)
                                 .Distinct()
                                 .Where(t => t.Namespace() == @namespace);

                if (ordered)
                {
                    childTypes = childTypes.OrderBy(t => t.DisplayName());
                }

                foreach (var type in childTypes)
                {
                    yield return(new TypeOption(type, FuzzyOptionMode.Branch));
                }
            }
            else if (parent is TypeOption typeOption)
            {
                var childMembers = codebase.members.Where(m => m.targetType == typeOption.value);

                if (ordered)
                {
                    childMembers = childMembers
                                   .OrderBy(m => LudiqCore.Configuration.groupInheritedMembers && m.isPseudoInherited)
                                   .ThenBy(m => m.info.DisplayName());
                }

                foreach (var member in childMembers)
                {
                    yield return(new MemberOption(member));
                }
            }
            else if (parent is MemberOption)
            {
                yield break;
            }
            else
            {
                throw new NotSupportedException();
            }
        }