package net.bitpot.railways.utils;

import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiNamedElement;
import com.intellij.psi.stubs.StubIndex;
import com.intellij.psi.util.PsiElementFilter;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.ruby.rails.model.RailsApp;
import org.jetbrains.plugins.ruby.rails.model.RailsController;
import org.jetbrains.plugins.ruby.ruby.lang.psi.RPsiElement;
import org.jetbrains.plugins.ruby.ruby.lang.psi.RubyProjectAndLibrariesScope;
import org.jetbrains.plugins.ruby.ruby.lang.psi.RubyPsiUtil;
import org.jetbrains.plugins.ruby.ruby.lang.psi.controlStructures.classes.RClass;
import org.jetbrains.plugins.ruby.ruby.lang.psi.controlStructures.methods.RMethod;
import org.jetbrains.plugins.ruby.ruby.lang.psi.controlStructures.modules.RModule;
import org.jetbrains.plugins.ruby.ruby.lang.psi.controlStructures.names.RSuperClass;
import org.jetbrains.plugins.ruby.ruby.lang.psi.holders.RContainer;
import org.jetbrains.plugins.ruby.ruby.lang.psi.indexes.RubyClassModuleNameIndex;
import org.jetbrains.plugins.ruby.ruby.lang.psi.methodCall.RCall;
import org.jetbrains.plugins.ruby.utils.NamingConventions;

import java.util.Collection;

 * Class that contains helper methods for working with PSI elements.
 * Created by Basil Gren on 11/27/14.
public class RailwaysPsiUtils {

     * Searches for controller in application and libraries.
     * @param app Rails app for the current module
     * @param qualifiedClassName Full class name with modules, ex. "Devise::SessionsController"
     * @return Found RClass object or null if nothing is found.
    public static RClass findControllerClass(RailsApp app, String qualifiedClassName) {
        if ((app == null) || qualifiedClassName.isEmpty())
            return null;

        // Lookup in application controllers
        RailsController ctrl = app.findController(qualifiedClassName);
        if (ctrl != null)
            return ctrl.getRClass();

        // If controller is not found among application classes, proceed with
        // global class lookup
        RContainer cont = findClassOrModule(qualifiedClassName,
        return cont instanceof RClass ? (RClass)cont : null;

     * Searched for method implementation recursively in current class and all
     * included modules, then if not found, in parent class and all included
     * modules, etc.
     * @param app Rails app.
     * @param ctrlClass Class in which method implementation will be searched for.
     * @param methodName Name of the method to find.
     * @return RMethod object of null.
    public static RMethod findControllerMethod(RailsApp app,
                                               @NotNull RClass ctrlClass,
                                               @NotNull String methodName) {
        RClass currentClass = ctrlClass;

        while (true) {
            RMethod method = RubyPsiUtil.getMethodWithPossibleZeroArgsByName(currentClass, methodName);
            if (method != null)
                return method;

            method = findMethodInClassModules(currentClass, methodName);
            if (method != null)
                return method;

            // Search in parent classes
            RSuperClass psiParentRef = currentClass.getPsiSuperClass();
            if ((psiParentRef == null) || (psiParentRef.getName() == null))
                return null;

            currentClass = findControllerClass(app, psiParentRef.getName());
            if (currentClass == null)
                return null;

     * Performs search of specified class or module in IDE indexes.
     * @param qualifiedName Full name of specified class or module controller
     *                      (with parent modules, ex. Devise::SessionsController)
     * @param project Current project.
     * @return RClass object, RModule object or null.
    public static RContainer findClassOrModule(@NotNull String qualifiedName,
                                               @NotNull Project project) {
        // Search should be performed using only class name, without modules.
        // For example, if we have Devise::SessionsController, we should search
        // for only 'SessionsController'
        String[] classPath = qualifiedName.split("::");
        String className = classPath[classPath.length - 1];

        Collection items = findClassesAndModules(className, project);

        for (Object item: items) {
            String name = null;

            if (item instanceof RClass)
                name = ((RClass)item).getQualifiedName();
            else if (item instanceof RModule)
                name = ((RModule)item).getQualifiedName();

            // Perform case insensitive comparison to avoid mess with acronyms.
            if (qualifiedName.equalsIgnoreCase(name))
                return (RContainer)item;

        return null;

     * Finds specified ruby class or module in IDE index.
     * @param name Name of class or module to search for. This should be a name
     *             without any modules, so if we wand to find
     *             Devise::SessionsController, we should pass only
     *             SessionsController here.
     * @param project Current project.
     * @return Collection of PSI elements which match specified name.
    public static Collection findClassesAndModules(String name, Project project) {
        GlobalSearchScope scope = new RubyProjectAndLibrariesScope(project);

        // StubIndex.getElements was introduced in 134.231 build (RubyMine 6.3)
        return StubIndex.getElements(RubyClassModuleNameIndex.KEY,
                name, project, scope, RContainer.class);

    public static String getControllerClassNameByShortName(String shortName) {
        return StringUtil.join(getControllerClassPathByShortName(shortName), "::");

    public static String[] getControllerClassPathByShortName(String shortName) {
        // Process namespaces
        String[] classPath = (shortName + "_controller").split("/");
        for(int i = 0; i < classPath.length; i++)
            classPath[i] = NamingConventions.toCamelCase(classPath[i]);

        return classPath;

     * Filter that selects only 'include Module::Name' expressions.
    private final static PsiElementFilter INCLUDE_MODULE_FILTER = psiElement ->
            (psiElement instanceof RCall) &&

     * Performs search in all modules that are included in specified class. So
     * if ruby-class contains explicit includes:
     *     include Admin::MyModule
     *     include Concerns::Logging
     * the specified methodName will be searched in both modules in order
     * of their declaration.
     * @param ctrlClass Class to look for modules.
     * @param methodName Method name to search within modules of specified ruby
     *                   class
     * @return First method which name matches methodName
    private static RMethod findMethodInClassModules(RClass ctrlClass, String methodName) {
        PsiElement[] elements = PsiTreeUtil.collectElements(ctrlClass,

        // Iterate from the end of the list as next included module can override
        // same-named methods of previously included module.
        int i = elements.length;
        while (--i >= 0) {
            RCall includeMethodCall = (RCall)elements[i];

            RPsiElement moduleNameArg = includeMethodCall.getArguments().get(0);
            if (moduleNameArg == null)

            RContainer cont = findClassOrModule(moduleNameArg.getText(),

            if (cont instanceof RModule)
                return RubyPsiUtil.getMethodWithPossibleZeroArgsByName(cont, methodName);

        return null;

    public static void logPsiParentChain(PsiElement elem) {
        while (elem != null) {
            if (elem instanceof PsiNamedElement) {
                System.out.println(elem.getClass().getName() + " --> Name: " + ((PsiNamedElement)elem).getName());

                if (elem instanceof RClass)
                    System.out.println(" ----- Class qualified name: " + ((RClass)elem).getQualifiedName());

            } else
                System.out.println(elem.getClass().getName() + " --> No name");

            elem = elem.getParent();