def apply(self, document): """Replace the current line with the populated template. IN: document: <IDocument> The edited document. OUT: None. """ self.vars['newline'] = PyAction.getDelimiter(document) sNewCode = self.template % self.vars # Move to insert point: iStartLineOffset = self.selection.getLineOffset() iEndLineOffset = iStartLineOffset + len(self.current_line) self.editor.setSelection(iEndLineOffset, 0) self.selection = PySelection(self.editor) # Replace the old code with the new assignment expression: self.selection.replaceLineContentsToSelection(sNewCode) #mark the value so that the user can change it selection = PySelection(self.editor) absoluteCursorOffset = selection.getAbsoluteCursorOffset() val = self.vars['value'] self.editor.selectAndReveal(absoluteCursorOffset - len(val), len(val))
def CheckCase1(self, types): doc = '''class A(object): # line 0 def m1(self): #line 2 pass def m2(self): #line 5 pass ''' from org.eclipse.jface.text import Document from org.python.pydev.core.docutils import PySelection doc = Document(doc) self._selection = PySelection(doc, 1, 0) context = Context(doc) self.assertEqual(['A'], types['current_class'].resolveAll(context)) self.assertEqual([''], types['current_method'].resolveAll(context)) self.assertEqual(['A'], types['current_qualified_scope'].resolveAll(context)) self.assertEqual(['A'], types['prev_class_or_method'].resolveAll(context)) self.assertEqual(['m1'], types['next_class_or_method'].resolveAll(context)) self.assertEqual(['object'], types['superclass'].resolveAll(context))
def _CreateSelection(context): ''' Created method so that it can be mocked on tests. ''' from org.python.pydev.core.docutils import PySelection selection = PySelection(context.getDocument(), context.getStart()) return selection
def run(self): #gotten here (and not in the class resolution as before) because we want it to be resolved #when we execute it, and not when setting it oSelection = PySelection(self.editor) oDocument = self.editor.getDocument() if not self.isScriptApplicable(oSelection): return None oParamInfo = oSelection.getInsideParentesisToks(True) lsParams = list(oParamInfo.o1) # Determine insert point: iClosingParOffset = oParamInfo.o2 iClosingParLine = oSelection.getLineOfOffset(iClosingParOffset) iInsertAfterLine = iClosingParLine sIndent = self._indent( oSelection) + PyAction.getStaticIndentationString(self.editor) parsingUtils = ParsingUtils.create(oDocument) # Is there a docstring? In that case we need to skip past it. sDocstrFirstLine = oSelection.getLine(iClosingParLine + 1) sDocstrStart = sDocstrFirstLine.strip()[:2] if sDocstrStart and (sDocstrStart[0] in ['"', "'"] or sDocstrStart in ['r"', "r'"]): iDocstrLine = iClosingParLine + 1 iDocstrLineOffset = oSelection.getLineOffset(iDocstrLine) li = [sDocstrFirstLine.find(s) for s in ['"', "'"]] iDocstrStartCol = min([i for i in li if i >= 0]) iDocstrStart = iDocstrLineOffset + iDocstrStartCol iDocstrEnd = parsingUtils.eatLiterals(None, iDocstrStart) iInsertAfterLine = oSelection.getLineOfOffset(iDocstrEnd) sIndent = PySelection.getIndentationFromLine(sDocstrFirstLine) # Workaround for bug in PySelection.addLine() in # pydev < v1.0.6. Inserting at the last line in the file # would raise an exception if the line wasn't newline # terminated. iDocLength = oDocument.getLength() iLastLine = oSelection.getLineOfOffset(iDocLength) sLastChar = str(parsingUtils.charAt(iDocLength - 1)) if (iInsertAfterLine == iLastLine and not self.getNewLineDelim().endswith(sLastChar)): oDocument.replace(iDocLength, 0, self.getNewLineDelim()) line = oSelection.getLine(iInsertAfterLine + 1) if line.strip() == 'pass': oSelection.deleteLine(iInsertAfterLine + 1) # Assemble assignment lines and insert them into the document: sAssignments = self._assignmentLines(lsParams, sIndent) oSelection.addLine(sAssignments, iInsertAfterLine) # Leave cursor at the last char of the new lines. iNewOffset = oSelection.getLineOffset(iInsertAfterLine + 1) + len(sAssignments) self.editor.setSelection(iNewOffset, 0) del oSelection
def check(self, initial_doc, final_doc): from org.eclipse.jface.text import Document #@UnresolvedImport from org.python.pydev.core.docutils import PySelection from assign_params_to_attributes_action import AssignToAttribsOfSelf doc = Document(initial_doc) editor = TestEditor(doc, PySelection(doc, 1, 2)) assign_to_attribs_of_self = AssignToAttribsOfSelf(editor) assign_to_attribs_of_self.run() self.assertEqual(final_doc, doc.get())
def run(self): sel = PySelection(editor) txt = sel.getSelectedText() splitted = re.split('\\.|\\ ', txt) new_text = '.'.join( [x for x in splitted if x not in ('from', 'import')]) new_text = splitted[-1] + ' = ' + '\'' + new_text + '\'' doc = sel.getDoc() sel = sel.getTextSelection() doc.replace(sel.getOffset(), sel.getLength(), new_text)
def run(self): sel = PySelection(editor) txt = sel.getSelectedText() delimiter = sel.getEndLineDelim() indent = sel.getIndentationFromLine() splitted = SplitTextInCommas(txt) doc = sel.getDoc() sel = sel.getTextSelection() doc.replace(sel.getOffset(), sel.getLength(), (delimiter + indent).join([x.strip() + ', ' for x in splitted]))
def run(self): import tempfile import os try: ps = PySelection(editor) doc = ps.getDoc() startLine = ps.getStartLineIndex() p1 = tempfile.mktemp() p2 = tempfile.mktemp() f1 = FileWriter(p1) formatAll = False if ps.getTextSelection().getLength() == 0: # format all. c = doc.get() f1.write(c) formatAll = True else: # format selection. #c = ps.getSelectedText() #f1.write(ps.getSelectedText()) print("Format selected text is not supported yet.") f1.write("") # A kind of solution is to insert a special comment in # front and end of selection text, pythontidy it, and # extract text according that comment. f1.close() os.system('PythonTidy.py "%s" "%s"' % (p1, p2)) f2 = open(p2, "r") result = f2.read() f2.close() os.remove(p1) os.remove(p2) if startLine >= doc.getNumberOfLines(): startLine = doc.getNumberOfLines() - 1 if formatAll: doc.set(result) else: #doc.replace(doc.getLineOffset(startLine), 0, result) pass sel = TextSelection(doc, doc.getLineOffset(startLine), 0) self.getTextEditor().getSelectionProvider().setSelection(sel) except java.lang.Exception as e: self.beep(e)
def __init__(self): self.selection = PySelection(editor) self.document = editor.getDocument() self.offset = self.selection.getAbsoluteCursorOffset() self.currentLineNo = self.selection.getLineOfOffset(self.offset) self.docDelimiter = self.selection.getDelimiter(self.document) self.currentLine = self.selection.getLine(self.currentLineNo) self.pattern = r'''(\s*#\s*|\s*"""\s*|''' \ + r"""\s*'''\s*|""" \ + r'''\s*"\s*|''' \ + r"""\s*'\s*|\s*)""" self.compiledRe = re.compile(self.pattern) self.leadingString, self.mainText = \ self._splitLine(self.currentLine) self.offsetOfOriginalParagraph = 0 self.lengthOfOriginalParagraph = 0 self.numberOfLinesInDocument = self.document.getNumberOfLines()
def CheckCase2(self, types): from org.eclipse.jface.text import Document from org.python.pydev.core.docutils import PySelection doc = '''class A(object ''' doc = Document(doc) self._selection = PySelection(doc, 1, 0) context = Context(doc) self.assertEqual(['A'], types['current_class'].resolveAll(context)) self.assertEqual([''], types['current_method'].resolveAll(context)) self.assertEqual(['A'], types['current_qualified_scope'].resolveAll(context)) self.assertEqual(['A'], types['prev_class_or_method'].resolveAll(context)) self.assertEqual([''], types['next_class_or_method'].resolveAll(context)) self.assertEqual([''], types['superclass'].resolveAll(context)) doc = '''class A(object, obj, foo) ''' doc = Document(doc) self._selection = PySelection(doc, 1, 0) context = Context(doc) self.assertEqual(['A'], types['current_class'].resolveAll(context)) self.assertEqual([''], types['current_method'].resolveAll(context)) self.assertEqual(['A'], types['current_qualified_scope'].resolveAll(context)) self.assertEqual(['A'], types['prev_class_or_method'].resolveAll(context)) self.assertEqual([''], types['next_class_or_method'].resolveAll(context)) self.assertEqual(['object', 'obj', 'foo'], types['superclass'].resolveAll(context)) doc = '''class A(object, #comment obj, foo) ''' doc = Document(doc) self._selection = PySelection(doc, 1, 0) context = Context(doc) self.assertEqual(['A'], types['current_class'].resolveAll(context)) self.assertEqual([''], types['current_method'].resolveAll(context)) self.assertEqual(['A'], types['current_qualified_scope'].resolveAll(context)) self.assertEqual(['A'], types['prev_class_or_method'].resolveAll(context)) self.assertEqual([''], types['next_class_or_method'].resolveAll(context)) self.assertEqual(['object', 'obj', 'foo'], types['superclass'].resolveAll(context))
def GetMethodArg(idocument): ''' This is an older version of the GetMethodArg2 function. After figuring out how to parse a document using the pydev parsers rewrote the method parsing functions. This will get deleted once I am comfortable that the the GetMethodArg2 is working well. :param idocument: an idocument object containing the entire module that was created for this method. :type idocument: org.python.pydev.editor.codecompletion.templates.PyDocumentTemplateContext :returns: a formatted docstring template for the method on which this function was called :rtype: string ''' # TODO: parse the method looking for the return type from org.python.pydev.parser.jython.ast import FunctionDef from org.python.pydev.parser.fastparser import FastParser from org.python.pydev.core.docutils import PySelection # 1 - get the current document doc = idocument.getDocument() # 2 - get a selection object for the current line selection = PySelection(idocument.getDocument(), idocument.getStart()) startLineNumber = doc.getLineOfOffset(idocument.getStart()) startLineContents = selection.getLine(startLineNumber) startIndentation = selection.getIndentationFromLine(startLineContents) print 'the line is', startLineNumber print 'contents is', startLineContents # 3 - create a parser object with the hierarchy of methods, classes etc to which the current line belongs parser = FastParser.parseToKnowGloballyAccessiblePath( idocument.getDocument(), selection.getStartLineIndex()) if parser: # only continuing if the parser found a method definition. print 'parser', parser print 'begin line', parser[0].beginLine print 'rettype', type(parser) print 'start is', idocument.getStart() from java.util import Collections Collections.reverse(parser) # 4 - iterate through the parser object for stmt in parser: print 'stmt', stmt print type(stmt) # 5 - if the parser contains a method definition if isinstance(stmt, FunctionDef): # 6 - get the line number for the method definition print 'method line', stmt.beginLine functionDefinitionStmt = selection.getLine(stmt.beginLine-1) print 'defstatement:', functionDefinitionStmt print 'woke up' afterLine = stmt.beginLine - 1 # listOfStringLines = [] string2Add = prepOutputMethodString(startIndentation, functionDefinitionStmt) #selection.addLine( indentationString + string2Add, stmt.beginLine - 1) offset = doc.getLineInformation(afterLine + 1).getOffset(); print 'offset 1 - ', offset if doc.getNumberOfLines() > stmt.beginLine - 1: offset = doc.getLineInformation(afterLine + 1).getOffset(); print 'offset 2 - ', offset else: offset = doc.getLineInformation(afterLine).getOffset() print 'offset 2 - ', offset #doc.replace(offset, 0, string2Add) # inserting into the doc immediately after the method is # not working, instead will return the doc string return string2Add #selection.addLine( indentationString + string2Add, stmt.beginLine - 1) #offset = doc.getLineInformation(afterLine + 1).getOffset(); #selection = PySelection(idocument.getDocument(), idocument.getStart()) #offset = doc.getLineInformation(stmt.beginLine).getOffset() #print 'offset is now ',offset #print 'on line number', selection.getLineNumber() #args = NodeUtils.getNodeArgs(stmt) #print 'args are', args #print '.getRepresentationString' , NodeUtils.getRepresentationString(stmt) #print 'full rep string:', NodeUtils.getFullRepresentationString(stmt) #return NodeUtils.getRepresentationString(stmt) # if nothing was found then return null. return ""
def getFuncArgs(idocument, beginLine): ''' This method recieves a document object and the start lines of a function definition who's args we want to retrieve. It then creates an AST parsed document structure, which gets worked through until a method is found that occurs on the same line as the beginLine that was sent as an arg to this method. Once this is found it searches for the args in that method and also whether the method has return value. It then sends this information to prepOutputMethodString2 method that will convert this into a nicely formatted docstring. :param idocument: input context object :type idocument: org.python.pydev.editor.codecompletion.templates.PyDocumentTemplateContext :param beginLine: the integer that the function starts on. :type beginLine: int :returns: a sphinx restructured text docstring template for method from which the method was called. :rtype: string ''' print 'getClassArgs called' # from org.python.pydev.core.docutils import PySelection from org.python.pydev.parser import PyParser from org.python.pydev.parser.visitors import NodeUtils from org.python.pydev.core.docutils import PySelection doc = idocument.getDocument() # creating a parser object. The 12 is a constant that # defines python syntax. See org.python.pydev.core.IGrammarVersionProvider # different numbers are: # 2.4 10 # 2.5 11 # 2.6 12 # 2.7 13 # etc... grammarVersion = idocument.getGrammarVersion() print 'grammarVersion:', grammarVersion parseInfoObj = PyParser.ParserInfo(doc, grammarVersion) # parsign the document into the different node types # from the root node you can access all elements of the # doc. (hierarchical parser) # nodes is a Tuple object of type: # com.aptana.shared_core.structure.Tuple nodes = PyParser.reparseDocument(parseInfoObj) print 'node type:', nodes.getClass().getName() # nodes.01 contains SimpleNode #x = nodes.o1 #print 'xtype ', x.getClass().getName() # getting the document body body = NodeUtils.getBody(nodes.ast) print 'body', body # getting the function that starts on the line: begtinLine funcDef = searchFuncs(body, beginLine) print 'funcDef', funcDef argList = parseFunc(funcDef) returnState = hasReturn(funcDef) #doc = idocument.getDocument() # doc = idocument.getDocument() # 2 - get a selection object for the current line selection = PySelection(idocument.getDocument(), idocument.getStart()) startLineNumber = doc.getLineOfOffset(idocument.getStart()) startLineContents = selection.getLine(startLineNumber) indentation = selection.getIndentationFromLine(startLineContents) docString = prepOutputMethodString2(indentation, argList, returnState) print 'return: ', returnState return docString