eric: comparison src/eric7/Utilities/ClassBrowsers/protoclbr.py

-:e9e7eca7efee
+:bf71ee032bb4
 import Utilities
 import Utilities.ClassBrowsers as ClassBrowsers
 from . import ClbrBaseClasses
 SUPPORTED_TYPES = [ClassBrowsers.PROTO_SOURCE]
 _getnext = re.compile(
 r"""
 (?P<String>
 " [^"\\\n]* (?: \\. [^"\\\n]*)* "
 )
 )
 |   (?P<End>
 [ \t]* } [ \t]* ;?
 )""",
-re.VERBOSE | re.DOTALL | re.MULTILINE).search
+re.VERBOSE | re.DOTALL | re.MULTILINE,
+).search
 # function to replace comments
 _commentsub = re.compile(r"""//[^\n]*\n|//[^\n]*$""").sub
 # function to normalize whitespace
 _normalize = re.compile(r"""[ \t]{2,}""").sub
-_modules = {}                           # cache of modules we've seen
+_modules = {}  # cache of modules we've seen
 class VisibilityMixin(ClbrBaseClasses.ClbrVisibilityMixinBase):
 """
 Mixin class implementing the notion of visibility.
 """
 def __init__(self):
 """
 Constructor
 """
 self.setPublic()
 class Message(ClbrBaseClasses.Module, VisibilityMixin):
 """
 Class to represent a ProtoBuf Message.
 """
 def __init__(self, module, name, file, lineno):
 """
 Constructor
 @param module name of the module containing this message
 @type str
 @param name name of this message
 @type str
 @param file filename containing this message
 class Enum(ClbrBaseClasses.Enum, VisibilityMixin):
 """
 Class to represent a ProtoBuf Enum.
 """
 def __init__(self, module, name, file, lineno):
 """
 Constructor
 @param module name of the module containing this enum
 @type str
 @param name name of this enum
 @type str
 @param file filename containing this enum
 class Service(ClbrBaseClasses.Class, VisibilityMixin):
 """
 Class to represent a ProtoBuf Service.
 """
 def __init__(self, module, name, file, lineno):
 """
 Constructor
 @param module name of the module containing this service
 @type str
 @param name name of this service
 @type str
 @param file filename containing this service
 @type str
 @param lineno linenumber of the service definition
 @type int
 """
-ClbrBaseClasses.Class.__init__(self, module, name, None, file,
+ClbrBaseClasses.Class.__init__(self, module, name, None, file, lineno)
-lineno)
 VisibilityMixin.__init__(self)
 class ServiceMethod(ClbrBaseClasses.Function, VisibilityMixin):
 """
 Class to represent a ProtoBuf Service Method.
 """
 def __init__(self, name, file, lineno, signature, returns):
 """
 Constructor
 @param name name of this service method
 @type str
 @param file filename containing this service method
 @type str
 @param lineno linenumber of the service method definition
 @param signature parameter list of the service method
 @type str
 @param returns return type of the service method
 @type str
 """
-ClbrBaseClasses.Function.__init__(self, None, name, file, lineno,
+ClbrBaseClasses.Function.__init__(
-signature,
+self,
-annotation="-> {0}".format(returns))
+None,
+name,
+file,
+lineno,
+signature,
+annotation="-> {0}".format(returns),
+)
 VisibilityMixin.__init__(self)
 def readmodule_ex(module, path=None):
 """
 @type list of str
 @return the resulting dictionary
 @rtype dict
 """
 global _modules
 if module in _modules:
 # we've seen this file before...
 return _modules[module]
 # search the path for the file
 src = Utilities.readEncodedFile(file)[0]
 except (UnicodeError, OSError):
 # can't do anything with this module
 _modules[module] = {}
 return {}
 _modules[module] = scan(src, file, module)
 return _modules[module]
 def scan(src, file, module):
 """
 Public method to scan the given source text.
 @param src source text to be scanned
 @type str
 @param file file name associated with the source text
 @type str
 @param module module name associated with the source text
 @type str
 @return dictionary containing the extracted data
 @rtype dict
 """
 def calculateEndline(lineno, lines):
 """
 Function to calculate the end line.
 @param lineno line number to start at (one based)
 @type int
 @param lines list of source lines
 @type list of str
 @return end line (one based)
 # found a matching brace
 return lineno + 1
 else:
 # nothing found
 return -1
 # convert eol markers the Python style
 src = src.replace("\r\n", "\n").replace("\r", "\n")
 srcLines = src.splitlines()
 dictionary = {}
 if m.start("Method") >= 0:
 # found a method definition or function
 thisindent = indent
 meth_name = m.group("MethodName")
 meth_sig = m.group("MethodSignature")
-meth_sig = meth_sig and meth_sig.replace('\\\n', '') or ''
+meth_sig = meth_sig and meth_sig.replace("\\\n", "") or ""
-meth_sig = _commentsub('', meth_sig)
+meth_sig = _commentsub("", meth_sig)
-meth_sig = _normalize(' ', meth_sig)
+meth_sig = _normalize(" ", meth_sig)
 meth_return = m.group("MethodReturn")
-meth_return = meth_return and meth_return.replace('\\\n', '') or ''
+meth_return = meth_return and meth_return.replace("\\\n", "") or ""
-meth_return = _commentsub('', meth_return)
+meth_return = _commentsub("", meth_return)
-meth_return = _normalize(' ', meth_return)
+meth_return = _normalize(" ", meth_return)
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 # close all interfaces/modules indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 del classstack[-1]
 if classstack:
 # it's an interface/module method
 cur_class = classstack[-1][0]
 if isinstance(cur_class, Service):
 # it's a method
-f = ServiceMethod(meth_name, file, lineno, meth_sig,
+f = ServiceMethod(meth_name, file, lineno, meth_sig, meth_return)
-meth_return)
 cur_class._addmethod(meth_name, f)
 # else it's a nested def
 else:
 f = None
 else:
 elif m.start("Message") >= 0:
 # we found a message definition
 thisindent = indent
 indent += 1
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 message_name = m.group("MessageName")
 # close all messages/services indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 del classstack[-1]
 thisindent = indent
 indent += 1
 # close all messages/services indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 del classstack[-1]
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 enum_name = m.group("EnumName")
 # remember this Enum
 cur_class = Enum(module, enum_name, file, lineno)
 endline = calculateEndline(lineno, srcLines)
 thisindent = indent
 indent += 1
 # close all messages/services indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 del classstack[-1]
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 service_name = m.group("ServiceName")
 # remember this Service
 cur_class = Service(module, service_name, file, lineno)
 endline = calculateEndline(lineno, srcLines)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Utilities/ClassBrowsers/protoclbr.py

src/eric7/Utilities/ClassBrowsers/protoclbr.py