@Override public long getEndPosition() { if (doc != null) { OffsetRange range = ASTUtils.getRangeFull(node.getNode(), doc); LOG.log(Level.FINEST, "getEndPosition(), end: {0}", range.getEnd()); return (long) range.getEnd(); } return 0; }
public void testValidUseCase_01() throws Exception { AnnotationParsedLine parsedLine = parser.parse("Secure"); assertEquals("Secure", parsedLine.getName()); assertEquals("", parsedLine.getDescription()); Map<OffsetRange, String> types = parsedLine.getTypes(); for (Map.Entry<OffsetRange, String> entry : types.entrySet()) { OffsetRange offsetRange = entry.getKey(); String value = entry.getValue(); assertEquals(0, offsetRange.getStart()); assertEquals(6, offsetRange.getEnd()); assertEquals("Secure", value); } }
private void addFolds( BaseDocument doc, List<? extends ASTElement> elements, Map<String, List<OffsetRange>> folds, List<OffsetRange> codeblocks) throws BadLocationException { for (ASTElement element : elements) { ElementKind kind = element.getKind(); switch (kind) { case FIELD: case METHOD: case CONSTRUCTOR: case CLASS: case MODULE: ASTNode node = element.getNode(); OffsetRange range = ASTUtils.getRangeFull(node, doc); // beware of synthetic elements if ((kind == ElementKind.METHOD && !((MethodNode) node).isSynthetic()) || (kind == ElementKind.CONSTRUCTOR && !((ConstructorNode) node).isSynthetic()) || (kind == ElementKind.FIELD && ((FieldNode) node).getInitialExpression() instanceof ClosureExpression) // Only make nested classes/modules foldable, similar to what the java editor is doing || (range.getStart() > Utilities.getRowStart(doc, range.getStart())) && kind != ElementKind.FIELD) { int start = range.getStart(); // Start the fold at the END of the line behind last non-whitespace, remove curly brace, // if any start = Utilities.getRowLastNonWhite(doc, start); if (start >= 0 && doc.getChars(start, 1)[0] != '{') { start++; } int end = range.getEnd(); if (start != (-1) && end != (-1) && start < end && end <= doc.getLength()) { range = new OffsetRange(start, end); codeblocks.add(range); } } break; } List<? extends ASTElement> children = element.getChildren(); if (children != null && children.size() > 0) { addFolds(doc, children, folds, codeblocks); } } }
public void testValidUseCase_05() throws Exception { AnnotationParsedLine parsedLine = parser.parse("Annotations\\Secure(roles=\"ROLE_USER, ROLE_FOO, ROLE_ADMIN\") \t"); assertEquals("Secure", parsedLine.getName()); assertEquals("(roles=\"ROLE_USER, ROLE_FOO, ROLE_ADMIN\")", parsedLine.getDescription()); Map<OffsetRange, String> types = parsedLine.getTypes(); assertNotNull(types); for (Map.Entry<OffsetRange, String> entry : types.entrySet()) { OffsetRange offsetRange = entry.getKey(); String value = entry.getValue(); assertEquals(0, offsetRange.getStart()); assertEquals(18, offsetRange.getEnd()); assertEquals("Annotations\\Secure", value); } }
public void run(RubyRuleContext context, List<Hint> result) { Node node = context.node; ParserResult info = context.parserResult; IfNode ifNode = (IfNode) node; if (ifNode.getCondition() == null) { // Can happen for this code: // if () // end // (typically while editing) return; } Node body = ifNode.getThenBody(); Node elseNode = ifNode.getElseBody(); if (body != null && elseNode != null) { // Can't convert if-then-else conditionals return; } if (body == null && elseNode == null) { // Can't convert empty conditions return; } // Can't convert if !x/elseif blocks if (ifNode.getElseBody() != null && ifNode.getElseBody().getNodeType() == NodeType.IFNODE) { return; } int start = ifNode.getPosition().getStartOffset(); if (!RubyHints.isNullOrInvisible(body) && ( // Can't convert blocks with multiple statements body.getNodeType() == NodeType.BLOCKNODE || // Already a statement modifier? body.getPosition().getStartOffset() <= start)) { return; } else if (!RubyHints.isNullOrInvisible(elseNode) && (elseNode.getNodeType() == NodeType.BLOCKNODE || elseNode.getPosition().getStartOffset() <= start)) { return; } BaseDocument doc = context.doc; try { int keywordOffset = ConvertIfToUnless.findKeywordOffset(context, ifNode); if (keywordOffset == -1 || keywordOffset > doc.getLength() - 1) { return; } char k = doc.getText(keywordOffset, 1).charAt(0); if (!(k == 'i' || k == 'u')) { return; // Probably ternary operator, ?: } } catch (BadLocationException ble) { Exceptions.printStackTrace(ble); } // If statement that is not already a statement modifier OffsetRange range = AstUtilities.getRange(node); if (RubyUtils.isRhtmlDocument(doc) || RubyUtils.isYamlDocument(doc)) { // Make sure that we're in a single contiguous Ruby section; if not, this won't work range = LexUtilities.getLexerOffsets(info, range); if (range == OffsetRange.NONE) { return; } try { doc.readLock(); TokenHierarchy th = TokenHierarchy.get(doc); TokenSequence ts = th.tokenSequence(); ts.move(range.getStart()); if (!ts.moveNext() && !ts.movePrevious()) { return; } if (ts.offset() + ts.token().length() < range.getEnd()) { return; } } finally { doc.readUnlock(); } } ConvertToModifier fix = new ConvertToModifier(context, ifNode); if (fix.getEditList() == null) { return; } List<HintFix> fixes = Collections.<HintFix>singletonList(fix); String displayName = NbBundle.getMessage(ConvertConditionals.class, "ConvertConditionals"); Hint desc = new Hint(this, displayName, RubyUtils.getFileObject(info), range, fixes, 500); result.add(desc); }
public void run(JsRuleContext context, List<Hint> result) { JsParseResult info = AstUtilities.getParseResult(context.parserResult); Node node = context.node; AstElement element = (AstElement) node.element; if (element == null) { JsParseResult jps = AstUtilities.getParseResult(info); if (jps != null) { jps.getStructure(); element = (AstElement) node.element; if (element == null) { return; } } } if (element.getKind() != ElementKind.METHOD && element.getKind() != ElementKind.CONSTRUCTOR) { return; } if (!(element instanceof FunctionAstElement)) { assert false : element; return; } FunctionAstElement func = (FunctionAstElement) element; Map<String, String> docProps = element.getDocProps(); if (docProps == null || docProps.size() == 0) { return; } // Make sure we actually have some parameters in the doc props boolean found = false; for (String key : docProps.keySet()) { if (!key.startsWith("@")) { found = true; break; } } // Don't complain about functions that don't have any parameters if (!found) { return; } // Make sure every parameter is documented List<String> params = func.getParameters(); List<String> missing = null; List<String> extra = null; for (String param : params) { if (!docProps.containsKey(param)) { if (missing == null) { missing = new ArrayList<String>(); } missing.add(param); } } // TODO - make sure doc props exist even for items without types!! for (String key : docProps.keySet()) { if (key.startsWith("@")) { continue; } if (!params.contains(key)) { if (extra == null) { extra = new ArrayList<String>(); } extra.add(key); } } if (missing != null || extra != null) { String label; if (missing != null && extra != null) { label = NbBundle.getMessage(WrongJsDoc.class, "WrongParamsBoth", missing, extra); } else if (missing != null) { label = NbBundle.getMessage(WrongJsDoc.class, "WrongParamsMissing", missing); } else { assert extra != null; label = NbBundle.getMessage(WrongJsDoc.class, "WrongParamsExtra", extra); } OffsetRange astRange = AstUtilities.getNameRange(node); OffsetRange lexRange = LexUtilities.getLexerOffsets(info, astRange); if (lexRange == OffsetRange.NONE) { return; } if (lexRange.getEnd() < context.doc.getLength()) { try { int startRowEnd = Utilities.getRowEnd(context.doc, lexRange.getStart()); if (startRowEnd < lexRange.getEnd() && startRowEnd > lexRange.getStart()) { lexRange = new OffsetRange(lexRange.getStart(), startRowEnd); } } catch (BadLocationException ex) { Exceptions.printStackTrace(ex); } } List<HintFix> fixList = Collections.<HintFix>singletonList(new MoreInfoFix("wrongjsdoc")); // NOI18N Hint desc = new Hint( this, label, info.getSnapshot().getSource().getFileObject(), lexRange, fixList, 1450); result.add(desc); } }