Inspect

import java.awt.image.ReplicateScaleFilter;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;


import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.body.EnumDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.Parameter;
import com.github.javaparser.ast.comments.Comment;

public class Inspect {
	/*
	 * Returns the List of Methods contained in a Compilation Unit
	 * @return List of Methods contained in the Compilation unit
	 * @param CompilationUnit the Compilation Unit to analyze
	 *
	 * */
	public static String ExtractMethods(CompilationUnit CompilationUnit)
	{
		String resultat ="";
		List<MethodDeclaration> ListOfMethods= CompilationUnit.findAll(MethodDeclaration.class);
		List<ConstructorDeclaration> ListOfConstructors = CompilationUnit.findAll(ConstructorDeclaration.class);
		for(ConstructorDeclaration constructor : ListOfConstructors)
		{
			resultat+="Constucteur :\n";
			if(constructor.getParameters().size()>0)
			{
				resultat +="  Parametres : \n";
				for (Parameter parameter : constructor.getParameters()) {
					resultat +="    * "+parameter.getNameAsString()+" de type : "+parameter.getTypeAsString()+"\n";
				}
			}
			else resultat+="  Sans parametres.\n";
			resultat+="\n";
		}
		for (MethodDeclaration method : ListOfMethods) {
				resultat +="Méthode '"+method.getNameAsString()+"'\n";
				resultat +="  Type de retour : "+method.getTypeAsString()+"\n";
			if(method.getParameters().size()>0)
			{
				resultat +="  Parametres : \n";
				for (Parameter parameter : method.getParameters()) {
					resultat +="    * "+parameter.getNameAsString()+" de type : "+parameter.getTypeAsString()+"\n";
				}
			}
			else resultat+="  Sans parametres.\n";
			resultat +="\n";
		}
		return resultat;
	}
	public static void getAttributes(CompilationUnit cu) {

	     JavaParser.getStaticConfiguration().setAttributeComments(false);
	     System.out.println("==> Liste des attributs.\n");
	     /*Stream resultAtt = (ArrayList) */cu.findAll(FieldDeclaration.class).stream()
	                .filter(f -> f.isPublic() || f.isPrivate() || f.isStatic() || f.isFinal()|| f.isProtected() )
	              .forEach(f -> System.out.println(f.getVariable(0)));
//	                .collect(Collectors.toList());
//	     FieldDeclaration f = new FieldDeclaration();
//
//	     System.out.println("==> Liste des attributes.");
//	        for (int i = 0; i < resultAtt.size(); i++) {
//	            System.out.println(resultAtt.get(i));
//	        }
	 }


	 public static void getVariables(CompilationUnit cu) {

	     JavaParser.getStaticConfiguration().setAttributeComments(false);

	     ArrayList resultVar =(ArrayList)  cu.findAll(FieldDeclaration.class).stream()
	                .filter(f -> !f.isPublic() && !f.isPrivate() && !f.isStatic() && !f.isFinal() && !f.isProtected() )
	               // .forEach(f -> System.out.println("Les variables " + f ));
	               .collect(Collectors.toList());


	                System.out.println("==> Liste des variables.");
	                for (int i = 0; i < resultVar.size(); i++) {

	                    System.out.println(resultVar.get(i));
	                }


	 }
	 public static void nameClass(CompilationUnit cu){
	        cu.findAll(ClassOrInterfaceDeclaration.class)
	                .stream()
	                .filter(c -> !c.isEnumDeclaration()
	                        && !c.isInterface()
	                        && !c.isAbstract())
	                .forEach(c -> {
	                    String name = c.getNameAsString();
	                    System.out.println("Class-name : " + name);
	                });
	    }

	    public static void methodClass(CompilationUnit cu){
	        cu.findAll(ClassOrInterfaceDeclaration.class)
	                .forEach(c -> {
	                    if(c.isPublic()) { System.out.println("Class-encaps : " + "public");}
	                    if(c.isPrivate())  { System.out.println("Class-encaps : " + "private"); }
	                    if(c.isProtected())  { System.out.println("Class-encaps : " + "protected"); }
	                });
	    }

	    public static void nameClassAbstract(CompilationUnit cu){
	        cu.findAll(ClassOrInterfaceDeclaration.class)
	                .stream()
	                .filter(c -> !c.isInterface()
	                        && c.isAbstract()
	                        && !c.isEnumDeclaration())
	                .forEach(c -> {
	                    String name = c.getNameAsString();
	                    System.out.println("Class-abstract-name : " + name);
	                });
	    }

	    public static void nameClassInterface(CompilationUnit cu){
	        cu.findAll(ClassOrInterfaceDeclaration.class)
	                .stream()
	                .filter(c -> c.isInterface()
	                        && !c.isAbstract()
	                        && !c.isEnumDeclaration())
	                .forEach(c -> {
	                    String name = c.getNameAsString();
	                    System.out.println("Class-interface-name : " + name);
	                });
	    }

	    public static void nameClassEnum(CompilationUnit cu){
	        cu.findAll(EnumDeclaration.class)
	                .stream()
	                .filter(c -> c.isEnumDeclaration())
	                .forEach(c -> {
	                    String name = c.getNameAsString();
	                    System.out.println("Class-enum-name : " + name);
	                });
	    }

	    public static void typeClassInterfaceOrAbstract(CompilationUnit cu){
	        cu.findAll(ClassOrInterfaceDeclaration.class)
	                .forEach(c -> {
	                    if(c.isInterface()) { System.out.println("Class-type : " + "Interface");}
	                    if(c.isAbstract())  { System.out.println("Class-type : " + "Abstract"); }
	                });
	    }

	    public static void typeClassEnum(CompilationUnit cu){
	        cu.findAll(EnumDeclaration.class)
	                .forEach(c -> {
	                    if(c.isEnumDeclaration())
	                    { System.out.println("Class-type : " + "Enum"); }
	                });
	    }
	    public static void getClasse(CompilationUnit cu) {
	        nameClassAbstract(cu);
	        nameClassInterface(cu);
	        nameClassEnum(cu);
	        nameClass(cu);
	        methodClass(cu);
	        typeClassInterfaceOrAbstract(cu);
	        typeClassEnum(cu);
	    }
	    public  static void getComment(CompilationUnit cu) {

			String[] ss=null;

		     List<Comment> listC=cu.getAllContainedComments();

		     for(Comment c:listC) {

		       ss = c.getContent().split("\n");
		       String result="";
		       for(String com : ss)
		       {
		    	   result+=com;
		       }
		       System.out.println(result);

		    }
	    }

	public static void main(String[] args) throws FileNotFoundException  {
		Inspect i = new Inspect();
		//JavaParser.getStaticConfiguration().setAttributeComments(false);
		CompilationUnit cu = JavaParser.parse(new File("MyTestClass.java"));
		System.out.println("=> Classe \n");
		getClasse(cu);
		System.out.println("\n");
		System.out.println("--------------------------- \n");
		System.out.println("==> Liste des attributs. \n");
		System.out.println(ExtractMethods(cu));
		System.out.println("--------------------------- \n");
		getAttributes(cu);
		System.out.println("--------------------------- \n");
		getVariables(cu);
		System.out.println("\n");
		System.out.println("--------------------------- \n");
		System.out.println("==> Liste des Commentaires. \n");
		getComment(cu);
	}
}