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

-:e9e7eca7efee
+:bf71ee032bb4
 import Utilities
 import Utilities.ClassBrowsers as ClassBrowsers
 from . import ClbrBaseClasses
 SUPPORTED_TYPES = [ClassBrowsers.RB_SOURCE]
 _getnext = re.compile(
 r"""
 (?P<String>
 =begin .*? =end
 end [ \t]* $
 |
 end \b [^_]
 )
 )""",
-re.VERBOSE | re.DOTALL | re.MULTILINE).search
+re.VERBOSE | re.DOTALL | re.MULTILINE,
+).search
 _commentsub = re.compile(r"""#[^\n]*\n|#[^\n]*$""").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 Class(ClbrBaseClasses.Class, VisibilityMixin):
 """
 Class to represent a Ruby class.
 """
 def __init__(self, module, name, superClasses, file, lineno):
 """
 Constructor
 @param module name of the module containing this class
 @param name name of this class
 @param superClasses list of class names this class is inherited from
 @param file filename containing this class
 @param lineno linenumber of the class definition
 """
-ClbrBaseClasses.Class.__init__(self, module, name, superClasses, file,
+ClbrBaseClasses.Class.__init__(self, module, name, superClasses, file, lineno)
-lineno)
 VisibilityMixin.__init__(self)
 class Module(ClbrBaseClasses.Module, VisibilityMixin):
 """
 Class to represent a Ruby module.
 """
 def __init__(self, module, name, file, lineno):
 """
 Constructor
 @param module name of the module containing this class
 @param name name of this class
 @param file filename containing this class
 @param lineno linenumber of the class definition
 """
 class Function(ClbrBaseClasses.Function, VisibilityMixin):
 """
 Class to represent a Ruby function.
 """
-def __init__(self, module, name, file, lineno, signature='',
-separator=','):
+def __init__(self, module, name, file, lineno, signature="", separator=","):
 """
 Constructor
 @param module name of the module containing this function
 @param name name of this function
 @param file filename containing this class
 @param lineno linenumber of the class definition
 @param signature parameterlist of the method
 @param separator string separating the parameters
 """
-ClbrBaseClasses.Function.__init__(self, module, name, file, lineno,
+ClbrBaseClasses.Function.__init__(
-signature, separator)
+self, module, name, file, lineno, signature, separator
+)
 VisibilityMixin.__init__(self)
 class Attribute(ClbrBaseClasses.Attribute, VisibilityMixin):
 """
 Class to represent a class or module attribute.
 """
 def __init__(self, module, name, file, lineno):
 """
 Constructor
 @param module name of the module containing this class
 @param name name of this class
 @param file filename containing this attribute
 @param lineno linenumber of the class definition
 """
 @param module name of the Ruby file (string)
 @param path path the file should be searched in (list of strings)
 @return the resulting dictionary
 """
 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
 dictionary = {}
 dict_counts = {}
 classstack = []  # stack of (class, indent) pairs
-acstack = []    # stack of (access control, indent) pairs
+acstack = []  # stack of (access control, indent) pairs
 indent = 0
 lineno, last_lineno_pos = 1, 0
 cur_obj = None
 lastGlobalEntry = None
 if m.start("Method") >= 0:
 # found a method definition or function
 thisindent = indent
 indent += 1
 meth_name = (
-m.group("MethodName") or
+m.group("MethodName")
-m.group("MethodName2") or
+or m.group("MethodName2")
-m.group("MethodName3")
+or m.group("MethodName3")
 )
 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)
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
-if meth_name.startswith('self.'):
+if meth_name.startswith("self."):
 meth_name = meth_name[5:]
-elif meth_name.startswith('self::'):
+elif meth_name.startswith("self::"):
 meth_name = meth_name[6:]
 # close all classes/modules indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 if classstack[-1][0] is not None:
 # record the end line
 if classstack:
 # it's a class/module method
 cur_class = classstack[-1][0]
 if isinstance(cur_class, (Class, Module)):
 # it's a method
-f = Function(None, meth_name,
+f = Function(None, meth_name, file, lineno, meth_sig)
-file, lineno, meth_sig)
 cur_class._addmethod(meth_name, f)
 else:
 f = cur_class
 # set access control
 if acstack:
 elif accesscontrol == "public":
 f.setPublic()
 # else it's a nested def
 else:
 # it's a function
-f = Function(module, meth_name,
+f = Function(module, meth_name, file, lineno, meth_sig)
-file, lineno, meth_sig)
 if meth_name in dict_counts:
 dict_counts[meth_name] += 1
-meth_name = "{0}_{1:d}".format(
+meth_name = "{0}_{1:d}".format(meth_name, dict_counts[meth_name])
-meth_name, dict_counts[meth_name])
 else:
 dict_counts[meth_name] = 0
 dictionary[meth_name] = f
 if not classstack:
 if lastGlobalEntry:
 cur_obj.setEndLine(lineno - 1)
 cur_obj = f
 classstack.append((f, thisindent))  # Marker for nested fns
 elif (
-m.start("String") >= 0 or
+m.start("String") >= 0
-m.start("Comment") >= 0 or
+or m.start("Comment") >= 0
-m.start("ClassIgnored") >= 0 or
+or m.start("ClassIgnored") >= 0
-m.start("BeginEnd") >= 0
+or m.start("BeginEnd") >= 0
 ):
 pass
 elif m.start("Class") >= 0:
 # we found a class 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
 # close all classes/modules indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 if classstack[-1][0] is not None:
 # record the end line
 class_name = m.group("ClassName") or m.group("ClassName2")
 inherit = m.group("ClassSupers")
 if inherit:
 # the class inherits from other classes
 inherit = inherit[1:].strip()
-inherit = [_commentsub('', inherit)]
+inherit = [_commentsub("", inherit)]
 # remember this class
-cur_class = Class(module, class_name, inherit,
+cur_class = Class(module, class_name, inherit, file, lineno)
-file, lineno)
 if not classstack:
 if class_name in dictionary:
 cur_class = dictionary[class_name]
 else:
 dictionary[class_name] = cur_class
 elif m.start("Module") >= 0:
 # we found a module 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
 # close all classes/modules indented at least as much
 while classstack and classstack[-1][1] >= thisindent:
 if classstack[-1][0] is not None:
 # record the end line
 if aclist is None:
 index = -1
 while index >= -len(acstack):
 if acstack[index][1] < indent:
 actype = (
-m.group("AccessControlType") or
+m.group("AccessControlType")
-m.group("AccessControlType2").split('_')[0]
+or m.group("AccessControlType2").split("_")[0]
 )
 acstack[index][0] = actype.lower()
 break
 else:
 index -= 1
 else:
 index = -1
 while index >= -len(classstack):
 if (
-classstack[index][0] is not None and
+classstack[index][0] is not None
-not isinstance(classstack[index][0], Function) and
+and not isinstance(classstack[index][0], Function)
-classstack[index][1] < indent
+and classstack[index][1] < indent
 ):
 parent = classstack[index][0]
 actype = (
-m.group("AccessControlType") or
+m.group("AccessControlType")
-m.group("AccessControlType2").split('_')[0]
+or m.group("AccessControlType2").split("_")[0]
 )
 actype = actype.lower()
 for name in aclist.split(","):
-name = name.strip()[1:]   # get rid of leading ':'
+name = name.strip()[1:]  # get rid of leading ':'
 acmeth = parent._getmethod(name)
 if acmeth is None:
 continue
 if actype == "private":
 acmeth.setPrivate()
 break
 else:
 index -= 1
 elif m.start("Attribute") >= 0:
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 index = -1
 while index >= -len(classstack):
 if (
-classstack[index][0] is not None and
+classstack[index][0] is not None
-not isinstance(classstack[index][0], Function) and
+and not isinstance(classstack[index][0], Function)
-classstack[index][1] < indent
+and classstack[index][1] < indent
 ):
-attr = Attribute(
+attr = Attribute(module, m.group("AttributeName"), file, lineno)
-module, m.group("AttributeName"), file, lineno)
 classstack[index][0]._addattribute(attr)
 break
 else:
 index -= 1
 if lastGlobalEntry:
 lastGlobalEntry.setEndLine(lineno - 1)
 lastGlobalEntry = None
 elif m.start("Attr") >= 0:
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 index = -1
 while index >= -len(classstack):
 if (
-classstack[index][0] is not None and
+classstack[index][0] is not None
-not isinstance(classstack[index][0], Function) and
+and not isinstance(classstack[index][0], Function)
-classstack[index][1] < indent
+and classstack[index][1] < indent
 ):
 parent = classstack[index][0]
 if m.group("AttrType") is None:
 nv = m.group("AttrList").split(",")
 if not nv:
 break
-name = nv[0].strip()[1:]    # get rid of leading ':'
+name = nv[0].strip()[1:]  # get rid of leading ':'
 attr = (
-parent._getattribute("@" + name) or
+parent._getattribute("@" + name)
-parent._getattribute("@@" + name) or
+or parent._getattribute("@@" + name)
-Attribute(module, "@" + name, file, lineno)
+or Attribute(module, "@" + name, file, lineno)
 )
 if len(nv) == 1 or nv[1].strip() == "false":
 attr.setProtected()
 elif nv[1].strip() == "true":
 attr.setPublic()
 parent._addattribute(attr)
 else:
 access = m.group("AttrType")
 for name in m.group("AttrList").split(","):
-name = name.strip()[1:]   # get rid of leading ':'
+name = name.strip()[1:]  # get rid of leading ':'
 attr = (
-parent._getattribute("@" + name) or
+parent._getattribute("@" + name)
-parent._getattribute("@@" + name) or
+or parent._getattribute("@@" + name)
-Attribute(module, "@" + name, file, lineno)
+or Attribute(module, "@" + name, file, lineno)
 )
 if access == "_accessor":
 attr.setPublic()
 elif access in ("_reader", "_writer"):
 if attr.isPrivate():
 if classstack:
 # it's a class/module method
 indent = classstack[-1][1]
 else:
 indent = 0
 elif m.start("CodingLine") >= 0:
 # a coding statement
 coding = m.group("Coding")
-lineno += src.count('\n', last_lineno_pos, start)
+lineno += src.count("\n", last_lineno_pos, start)
 last_lineno_pos = start
 if "@@Coding@@" not in dictionary:
 dictionary["@@Coding@@"] = ClbrBaseClasses.Coding(
-module, file, lineno, coding)
+module, file, lineno, coding
+)
 return dictionary

Mercurial Repositories > eric / file comparison

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

src/eric7/Utilities/ClassBrowsers/rbclbr.py