Пример #1
0
        private static bool IsExceptionType(CompletionResult member) {
            switch (member.MemberType) {
                case Interpreter.PythonMemberType.Class:
                    // Classes need further checking
                    break;
                case Interpreter.PythonMemberType.Module:
                case Interpreter.PythonMemberType.Namespace:
                    // Always include modules
                    return true;
                default:
                    // Never include anything else
                    return false;
            }

            if (KnownExceptions.Contains(member.Name)) {
                return true;
            }

            if (member.Name.IndexOf("Exception", StringComparison.CurrentCultureIgnoreCase) >= 0 ||
                member.Name.IndexOf("Error", StringComparison.CurrentCultureIgnoreCase) >= 0) {
                return true;
            }

            return false;
        }
Пример #2
0
 internal static DynamicallyVisibleCompletion PythonCompletion(IGlyphService service, CompletionResult memberResult) {
     return new DynamicallyVisibleCompletion(memberResult.Name, 
         memberResult.Completion, 
         () => memberResult.Documentation, 
         () => service.GetGlyph(memberResult.MemberType.ToGlyphGroup(), StandardGlyphItem.GlyphItemPublic),
         Enum.GetName(typeof(PythonMemberType), memberResult.MemberType)
     );
 }
Пример #3
0
 public PythonLibraryNode(LibraryNode parent, CompletionResult value, IVsHierarchy hierarchy, uint itemId, IList<LibraryNode> children)
     : base(parent, value.Name, value.Name, hierarchy, itemId, GetLibraryNodeType(value, parent), children: children) {
     _value = value;
     bool hasLocation = false;
     foreach (var completion in value.Values) {
         if (completion.locations.Any()) {
             hasLocation = true;
         }
     }
     if (hasLocation) {
         CanGoToSource = true;
     }
 }
Пример #4
0
        private static LibraryNodeType GetLibraryNodeType(CompletionResult value, LibraryNode parent) {
            switch (value.MemberType) {
                case PythonMemberType.Class:
                    return LibraryNodeType.Classes;
                case PythonMemberType.Function:
                    //if (parent is PythonFileLibraryNode) {
                    //    return LibraryNodeType.Classes | LibraryNodeType.Members;
                    //}
                    return LibraryNodeType.Members;
                default:
                    return LibraryNodeType.Members;
            }

        }
Пример #5
0
        private static bool IsDecoratorType(CompletionResult member) {
            switch (member.MemberType) {
                case Interpreter.PythonMemberType.Function:
                case Interpreter.PythonMemberType.Class:
                    // Classes and functions need further checking
                    break;
                case Interpreter.PythonMemberType.Module:
                case Interpreter.PythonMemberType.Namespace:
                    // Always include modules
                    return true;
                default:
                    // Never include anything else
                    return false;
            }

            // TODO: Only include objects that look like decorators
            // This is probably impossible to tell, since a decorator may be
            // called immediately or as part of creating the function. Filtering
            // down to callables that return a callable would work, but if our
            // analysis has failed then items could randomly be missing.
            return true;
        }
Пример #6
0
 internal static DynamicallyVisibleCompletion PythonCompletion(IGlyphService service, CompletionResult memberResult)
 {
     return(new DynamicallyVisibleCompletion(memberResult.Name,
                                             memberResult.Completion,
                                             () => memberResult.Documentation,
                                             () => service.GetGlyph(memberResult.MemberType.ToGlyphGroup(), StandardGlyphItem.GlyphItemPublic),
                                             Enum.GetName(typeof(PythonMemberType), memberResult.MemberType)
                                             ));
 }
Пример #7
0
        internal DynamicallyVisibleCompletion PythonCompletion(IGlyphService service, CompletionResult memberResult)
        {
            var insert = memberResult.Completion;

            if (insert.IndexOf('\t') >= 0 && _view.Options.IsConvertTabsToSpacesEnabled())
            {
                insert = insert.Replace("\t", new string(' ', _view.Options.GetIndentSize()));
            }

            return(new DynamicallyVisibleCompletion(memberResult.Name,
                                                    insert,
                                                    () => memberResult.Documentation,
                                                    () => service.GetGlyph(memberResult.MemberType.ToGlyphGroup(), StandardGlyphItem.GlyphItemPublic),
                                                    Enum.GetName(typeof(PythonMemberType), memberResult.MemberType)
                                                    ));
        }
            public CompletionResult[] GetMemberNames(string text) {
                _completionResultEvent.Reset();
                _memberResults = null;

                using (new StreamLock(this, throwIfDisconnected: false)) {
                    if (_stream == null) {
                        return new CompletionResult[0];
                    }
                    try {
                        _stream.Write(GetMembersCommandBytes);
                        SendString(text);
                    } catch (IOException) {
                        return new CompletionResult[0];
                    }
                }

                if (_completionResultEvent.WaitOne(1000) && _memberResults != null) {
                    var res = new CompletionResult[_memberResults.TypeMembers.Count + _memberResults.InstanceMembers.Count];
                    int i = 0;
                    foreach (var member in _memberResults.TypeMembers) {
                        res[i++] = CreateCompletionResult(member.Key, member.Value);
                    }
                    foreach (var member in _memberResults.InstanceMembers) {
                        res[i++] = CreateCompletionResult(member.Key, member.Value);
                    }

                    _memberResults = null;
                    return res;
                }
                return null;
            }
Пример #9
0
 protected PythonLibraryNode(PythonLibraryNode node, string newFullName) : base(node, newFullName) {
     _value = node._value;
 }
Пример #10
0
 protected PythonLibraryNode(PythonLibraryNode node) : base(node) {
     _value = node._value;
 }