/**
* Copyright (c) 2011 Cloudsmith Inc. and other contributors, as listed below.
* 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
*
* Contributors:
* Cloudsmith
*
*/
package org.cloudsmith.geppetto.ruby.jrubyparser;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.jrubyparser.ast.ArrayNode;
import org.jrubyparser.ast.CallNode;
import org.jrubyparser.ast.FCallNode;
import org.jrubyparser.ast.HashNode;
import org.jrubyparser.ast.ListNode;
import org.jrubyparser.ast.NewlineNode;
import org.jrubyparser.ast.Node;
import org.jrubyparser.ast.NodeType;
import com.google.common.base.Joiner;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
* Finds Rakefile task creations in a parsed ruby AST. An instance of this class can be reused,
* but it is not threadsafe.
*
* TODO: text from CallFinder - change this
*
* Calls are found using a FQN - i.e. a sequence of module/receiver names, where
* the last name segment is the name of the function. The search will find
* function calls irrespective of call type (e.g. a FCallNode (where receiver is
* implied), or CallNode where receiver is explicit. All FQN names are appended
* to the current scope - i.e. if a call is made to X::Y::foo() in module A, it
* will be found by a search of A::X::Y::foo().
*
* TODO: global references are not handled - i.e. if a call to ::X::Y::foo() is
* made inside module A, it will be recognized (in error) as A::X::Y::foo() -
* also see {@link ConstEvaluator}.
*/
public class RubyRakefileTaskFinder {
/**
* Keeps track of where processing is in the node model.
*/
private LinkedList<Object> stack = null;
/**
* Keeps track of the scope name.
*/
private LinkedList<Object> nameStack = null;
/**
* The wanted FQN
*/
// private List<String> qualifiedName = null;
private List<String> cucumberTask = Lists.newArrayList("Cucumber", "Rake", "Task");
private List<String> rspecTask = Lists.newArrayList("RSpec", "Core", "RakeTask");
/**
* An evaluator of constant ruby expressions
*/
private ConstEvaluator constEvaluator = new ConstEvaluator();
// public List<GenericCallNode> findCalls(Node root, String... qualifiedName) {
// if(qualifiedName.length < 1)
// throw new IllegalArgumentException("qualifiedName can not be empty");
//
// this.stack = Lists.newLinkedList();
// this.nameStack = Lists.newLinkedList();
//
// this.qualifiedName = Lists.reverse(Lists.newArrayList(qualifiedName));
//
// // TODO: make this return more than one
// return findTaskInternal(root, false);
// }
private String lastDesc;
public Map<String, String> findTasks(Node root) {
// use a linked map to get entries in the order they are added
Map<String, String> resultMap = Maps.newLinkedHashMap();
this.stack = Lists.newLinkedList();
this.nameStack = Lists.newLinkedList();
// this.qualifiedName = Lists.reverse(Lists.newArrayList(qualifiedName));
if(root != null)
findTasksInternal(root, resultMap);
return resultMap;
}
private void findTasksInternal(Node root, Map<String, String> resultMap) {
SEARCH: {
switch(root.getNodeType()) {
case MODULENODE:
lastDesc = ""; // not valid now
break SEARCH; // don't know what to do when user declares a module
case CLASSNODE:
lastDesc = ""; // not valid now
// don't know what to do when user declares a class, any calls to
// create tasks could be inside a loop etc. Just impossible to figure out
break SEARCH;
case CALLNODE:
// don't know yet what the calls look like - if they are calls to "do" with
// the interesting part on the left
// or what...
//
// CallNode callNode = (CallNode) root;
if(!processCallNode((CallNode) root, resultMap))
break SEARCH;
break;
// if(!callNode.getName().equals(qualifiedName.get(0)))
// break SEARCH;
// pushNames(constEvaluator.stringList(constEvaluator.eval(callNode.getReceiverNode())));
// if(inWantedScope())
// return Lists.newArrayList(new GenericCallNode(callNode));
// pop(root); // clear the pushed names
// push(root); // push it again
// break; // continue search inside the function
case FCALLNODE:
// Don't know what the interesting calls look like
if(!processFCallNode((FCallNode) root, resultMap))
break SEARCH;
break;
// FCallNode fcallNode = (FCallNode) root;
// if(!fcallNode.getName().equals(qualifiedName.get(0)))
// break SEARCH;
// if(inWantedScope())
// return Lists.newArrayList(new GenericCallNode(fcallNode));
// break; // continue search inside the function
default:
break;
}
for(Node n : root.childNodes()) {
if(n.getNodeType() == NodeType.NEWLINENODE)
n = ((NewlineNode) n).getNextNode();
findTasksInternal(n, resultMap);
}
} // SEARCH
}
/**
* If the argsNode is an Array with a Hash, then return the node for the first key (the name).
* This construct is found for input task :foo => 'dependson', or :foo => ['depdendson', 'andonthis']
*
* @param argsNode
* @return
*/
private Node getTaskNameNodeFromArgNode(Node argsNode) {
if(argsNode instanceof ArrayNode) {
ArrayNode arrayNode = (ArrayNode) argsNode;
if(arrayNode.size() > 0) {
Node a = arrayNode.get(0);
if(a instanceof HashNode) {
HashNode argsHash = (HashNode) a;
ListNode listNode = argsHash.getListNode();
if(listNode.size() > 0)
argsNode = listNode.get(0);
}
}
}
return argsNode;
}
/**
* If in the exact scope, or if scope is an outer scope of the wanted scope.
*
* @return true if wanted or outer scope of wanted
*/
/*
private boolean inCompatibleScope() {
// if an inner module of the wanted module is found
// i.e. we find module a::b::c::d(::_)* when we are looking for
// a::b::c::FUNC
//
if(nameStack.size() >= qualifiedName.size())
return false; // will not be found in this module - it is out of
// scope
// the module's name is shorter than wanted, does it match so far?
// i.e. we find module a::b when we are looking for a::b::c::FUNC
//
int sizeX = qualifiedName.size();
int sizeY = nameStack.size();
try {
return qualifiedName.subList(sizeX - sizeY, sizeX).equals(nameStack)
? true
: false;
}
catch(IndexOutOfBoundsException e) {
return false;
}
}*/
/**
* Returns true if the current scope is the wanted scope.
*
* @return
*/
/*
private boolean inWantedScope() {
// we are in wanted scope if all segments (except the function name)
// match.
try {
return qualifiedName.subList(1, qualifiedName.size()).equals(nameStack)
? true
: false;
}
catch(IndexOutOfBoundsException e) {
return false;
}
}*/
/**
* Pops the stack until we are the previous scope.
*
* @param n
*/
private void pop(Node n) {
while(stack.peek() != n) {
Object x = stack.pop();
if(x instanceof String)
popName();
}
stack.pop();
}
/**
* Pops a name of the namestack - should not be called without also managing
* the scope stack.
*/
private void popName() {
nameStack.pop();
}
/**
* @param root
* @return
*/
private boolean processCallNode(CallNode root, Map<String, String> resultMap) {
String mName = root.getName();
try {
if(mName.equals("new")) {
List<String> receiver = constEvaluator.stringList(constEvaluator.eval(root.getReceiver()));
boolean isRspec = receiver.equals(rspecTask);
boolean isCucumber = !isRspec && receiver.equals(cucumberTask);
if(isRspec || isCucumber) {
// recognized as a task
Node argsNode = getTaskNameNodeFromArgNode(root.getArgs());
List<String> nameList = constEvaluator.stringList(constEvaluator.eval(argsNode));
if(nameList.size() < 1) {
if(isRspec)
nameList = Lists.newArrayList("spec");
else
nameList = Lists.newArrayList("cucumber");
}
String taskName = Joiner.on(":").join(Iterables.concat(Lists.reverse(nameStack), nameList));
resultMap.put(taskName, lastDesc);
// System.err.println("Added task: " + taskName + " with description: " + lastDesc);
lastDesc = ""; // consumed
}
}
}
catch(RuntimeException e) {
// Failed to handle some constant evaluation - not sure what, should not fail, could be
// caused by faulty ruby code (syntax errors etc.) causing a strange model.
// Should be handled elsewhere.
return false;
}
return false;
}
/**
* @param root
* @return
*/
private boolean processFCallNode(FCallNode root, Map<String, String> resultMap) {
final String fName = root.getName();
if(fName.equals("namespace")) {
// System.err.println("Found NAMESPACE (Fcall)");
// push the name on the nameStack
// this is the argument to the namespace function
push(root);
pushNames(constEvaluator.stringList(constEvaluator.eval(root.getArgs())));
for(Node n : root.childNodes()) {
if(n.getNodeType() == NodeType.NEWLINENODE)
n = ((NewlineNode) n).getNextNode();
findTasksInternal(n, resultMap);
}
pop(root);
}
else if(fName.equals("task")) {
// System.err.println("Found TASK (Fcall)");
// argument is the name of the task
// prepend with name parts from namespaces
// pick up lastDesc
Node argsNode = getTaskNameNodeFromArgNode(root.getArgs());
String taskName = Joiner.on(":").join(
Iterables.concat(Lists.reverse(nameStack), constEvaluator.stringList(constEvaluator.eval(argsNode))));
resultMap.put(taskName, lastDesc);
// System.err.println("Added task: " + taskName + " with description: " + lastDesc);
lastDesc = ""; // consumed
}
else if(fName.equals("desc")) {
// argument is the description
lastDesc = Joiner.on("").join(constEvaluator.stringList(constEvaluator.eval(root.getArgs())));
}
else {
lastDesc = ""; // consume, not valid any more
}
return false;
}
/**
* Push node so we know where we are in scope.
*
* @param n
*/
private void push(Node n) {
stack.push(n);
}
/**
* Pushes a name onto the name stack (and the scope stack, as we need to
* discard the names when leaving a named scope).
*
* @param name
*/
private void pushName(String name) {
stack.push(name);
nameStack.push(name);
}
/**
* Convenience for pushing 0-n names in a list. Same as call {@link #pushName(String)} for each.
*
* @param names
*/
private void pushNames(List<String> names) {
for(String name : names)
pushName(name);
}
}