RubySelectionParser.java

/*******************************************************************************
 * Copyright (c) 2005, 2016 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 *******************************************************************************/
package org.eclipse.dltk.ruby.internal.core.codeassist;

import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;

// import antlr.ANTLRException;

public class RubySelectionParser extends RubyAssistParser {

	@Override
	public void handleNotInElement(ASTNode node, int position) {
	}

	@Override
	public void parseBlockStatements(ASTNode node, ASTNode inNode, int position) {
		// /**
		// * This is possible function completion.
		// */
		// if (node instanceof TclStatement) {
		// TclStatement statement = (TclStatement) node;
		// List expressions = statement.getExpressions();
		// int len = expressions.size();
		// boolean first = false;
		// ASTNode completionNode = null;
		// String completionToken = null;
		// for (int i = 0; i < len; ++i) {
		// ASTNode n = (ASTNode) expressions.get(i);
		// if (n.sourceStart() <= position && n.sourceEnd() >= position) {
		// if (i == 0) {
		// first = true;
		// }
		// completionNode = n;
		// }
		// }
		// if (completionNode instanceof SimpleReference) {
		// completionToken = ((SimpleReference) completionNode).getName();
		// if( completionToken.indexOf("[") != -1 ) {
		// processInnerExecuteExpression(inNode, position,
		// completionNode, completionToken);
		// }
		// }
		// // Map Variable
		// if( completionToken != null && completionToken.indexOf('(') != -1 ) {
		// if (position < completionNode.sourceStart() +
		// completionToken.indexOf('(')) {
		// completionToken = completionToken.substring(0,
		// completionToken.indexOf('(') );
		// } else {
		// completionToken =
		// completionToken.substring(completionToken.indexOf('(') + 1,
		// completionToken.length() - 1);
		// }
		// }
		// if (completionNode instanceof TclBlockExpression) {
		// TclBlockExpression block = (TclBlockExpression) completionNode;
		// //try {
		// List s = block.parseBlock();
		// if (s != null) {
		// int slen = s.size();
		// for (int u = 0; u < slen; ++u) {
		// ASTNode n = (ASTNode) s.get(u);
		// if (n != null && n.sourceStart() <= position && n.sourceEnd() >=
		// position) {
		// parseBlockStatements(n, inNode, position);
		// }
		// }
		// }
		// handleNotInElement(inNode, position);
		// /*} catch (ANTLRException e) {
		// if (DLTKCore.DEBUG_PARSER)
		// e.printStackTrace();
		// }*/
		// }
		// if (completionNode instanceof StringLiteral) {
		// int pos = position - completionNode.sourceStart();
		//				
		// String content = ((StringLiteral)completionNode).getValue();
		// if( content.indexOf("[") != -1 ) {
		// processInnerExecuteExpression(inNode, position,
		// completionNode, content);
		// }
		//				
		// SimpleReference tok =
		// TclParseUtils.findVariableFromString((StringLiteral) completionNode,
		// pos);
		// if (tok != null) {
		// this.assistNodeParent = inNode;
		// ASTNode nde = new SelectionOnVariable(tok.getName(), tok, node,
		// inNode);
		// if( nde != null ) {
		// throw new SelectionNodeFound(nde);
		// }
		// }
		// }
		// if (completionNode instanceof TclExecuteExpression) {
		// TclExecuteExpression expr = (TclExecuteExpression) completionNode;
		// List exprs = expr.parseExpression();
		// for (int i = 0; i < exprs.size(); ++i) {
		// ASTNode n = (ASTNode) exprs.get(i);
		// if (n.sourceStart() <= position && n.sourceEnd() >= position) {
		// parseBlockStatements(n, expr, position);
		// }
		// }
		// handleNotInElement(expr, position);
		// }
		// String var = TclParseUtils.returnVariableCheck(statement, position);
		// if (( completionToken != null && completionToken.startsWith("$") ) ||
		// var != null ) {
		// this.assistNodeParent = inNode;
		// if( var != null ) {
		// // ASTNode nde = new SelectionOnVariable("$" + var, statement, node,
		// inNode);
		// // throw new SelectionNodeFound(nde);
		// ASTNode nde = new SelectionOnAST(statement);
		// throw new SelectionNodeFound(nde);
		// }
		// else {
		// ASTNode nde = new SelectionOnVariable(completionToken,
		// completionNode, node, inNode);
		// throw new SelectionNodeFound(nde);
		// }
		// } else {
		// if( completionToken != null && completionNode != null ) {
		// ASTNode nde = new SelectionOnKeywordOrFunction(completionToken,
		// completionNode, node);
		// this.assistNodeParent = inNode;
		// throw new SelectionNodeFound(nde);
		// }
		// }
		// } else if (node instanceof MethodDeclaration) {
		// MethodDeclaration method = (MethodDeclaration) node;
		// List statements = method.getStatements();
		// boolean inStatement = false;
		// if (method.getNameStart() <= position && method.getNameEnd() >=
		// position) {
		// ASTNode nde = new SelectionOnAST(method);
		// this.assistNodeParent = inNode;
		// throw new SelectionNodeFound(nde);
		// }
		// if (statements != null) {
		// int length = statements.size();
		// for (int i = 0; i < length; i++) {
		// ASTNode nde = (ASTNode) statements.get(i);
		// if (nde.sourceStart() <= position && nde.sourceEnd() >= position) {
		// inStatement = true;
		// parseBlockStatements(nde, method, position);
		// }
		// }
		// }
		// if (!inStatement) {
		// this.handleNotInElement(method, position);
		// }
		// }
	}

	@Override
	public ModuleDeclaration getModule() {
		return module;
	}
}