JavaImport.java

  1. /* $Id$
  2.  *****************************************************************************
  3.  * Copyright (c) 2009-2013 Contributors - see below
  4.  * All rights reserved. This program and the accompanying materials
  5.  * are made available under the terms of the Eclipse Public License v1.0
  6.  * which accompanies this distribution, and is available at
  7.  * http://www.eclipse.org/legal/epl-v10.html
  8.  *
  9.  * Contributors:
  10.  *    thn
  11.  *****************************************************************************
  12.  *
  13.  * Some portions of this file was previously release using the BSD License:
  14.  */

  16. // Copyright (c) 1996-2008 The Regents of the University of California. All
  17. // Rights Reserved. Permission to use, copy, modify, and distribute this
  18. // software and its documentation without fee, and without a written
  19. // agreement is hereby granted, provided that the above copyright notice
  20. // and this paragraph appear in all copies.  This software program and
  21. // documentation are copyrighted by The Regents of the University of
  22. // California. The software program and documentation are supplied "AS
  23. // IS", without any accompanying services from The Regents. The Regents
  24. // does not warrant that the operation of the program will be
  25. // uninterrupted or error-free. The end-user understands that the program
  26. // was developed for research purposes and is advised not to rely
  27. // exclusively on the program for any reason.  IN NO EVENT SHALL THE
  28. // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
  29. // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
  30. // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  31. // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
  32. // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
  33. // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  34. // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
  35. // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
  36. // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
  37. // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

  39. package org.argouml.language.java.reveng;

  41. import java.io.File;
  42. import java.io.FileInputStream;
  43. import java.io.IOException;
  44. import java.io.InputStreamReader;
  45. import java.io.PrintWriter;
  46. import java.io.StringWriter;
  47. import java.io.UnsupportedEncodingException;
  48. import java.net.MalformedURLException;
  49. import java.net.URL;
  50. import java.util.Collection;
  51. import java.util.HashSet;
  52. import java.util.List;
  53. import java.util.logging.Level;
  54. import java.util.logging.Logger;

  56. import org.antlr.runtime.ANTLRReaderStream;
  57. import org.antlr.runtime.CommonTokenStream;
  58. import org.argouml.i18n.Translator;
  59. import org.argouml.kernel.Project;
  60. import org.argouml.language.java.JavaModuleGlobals;
  61. import org.argouml.model.IllegalModelElementConnectionException;
  62. import org.argouml.moduleloader.ModuleInterface;
  63. import org.argouml.profile.Profile;
  64. import org.argouml.taskmgmt.ProgressMonitor;
  65. import org.argouml.uml.reveng.FileImportUtils;
  66. import org.argouml.uml.reveng.ImportClassLoader;
  67. import org.argouml.uml.reveng.ImportInterface;
  68. import org.argouml.uml.reveng.ImportSettings;
  69. import org.argouml.uml.reveng.ImporterManager;
  70. import org.argouml.uml.reveng.SettingsTypes;
  71. import org.argouml.uml.util.ModelUtil;
  72. import org.argouml.util.SuffixFilter;

  74. /**
  75.  * This is the main class for Java reverse engineering. It's based on the Antlr
  76.  * Java example.
  77.  * 
  78.  * @author Andreas Rueckert <a_rueckert@gmx.net>
  79.  */
  80. public class JavaImport implements ModuleInterface, ImportInterface {

  82.     /** Logger. */
  83.     private static final Logger LOG =
  84.         Logger.getLogger(JavaImport.class.getName());

  86.     /**
  87.      * Java profile model.
  88.      */
  89.     private Profile javaProfile = null;

  91.     /**
  92.      * New model elements that were added
  93.      */
  94.     private Collection<Object> newElements;

  96.     /*
  97.      * @see org.argouml.uml.reveng.ImportInterface#parseFiles(org.argouml.kernel.Project,
  98.      *      java.util.Collection, org.argouml.uml.reveng.ImportSettings,
  99.      *      org.argouml.application.api.ProgressMonitor)
  100.      */
  101.     public Collection parseFiles(Project p, Collection<File> files,
  102.             ImportSettings settings, ProgressMonitor monitor)
  103.         throws ImportException {

  105.         JavaImportSettings.getInstance().saveSettings();
  106.         updateImportClassloader();
  107.         newElements = new HashSet<Object>();
  108.         monitor.updateMainTask(Translator.localize("dialog.import.pass1"));

  110.         // get the Java profile from project, if available
  111.         javaProfile = getJavaProfile(p);

  113.         try {
  114.             if ((settings.getImportLevel() 
  115.                     == ImportSettings.DETAIL_CLASSIFIER_FEATURE)
  116.                 || settings.getImportLevel() == ImportSettings.DETAIL_FULL) {
  117.                 monitor.setMaximumProgress(files.size() * 2);
  118.                 doImportPass(p, files, settings, monitor, 0, 0);
  119.                 if (!monitor.isCanceled()) {
  120.                     monitor.updateMainTask(Translator
  121.                             .localize("dialog.import.pass2"));
  122.                     doImportPass(p, files, settings, monitor, files.size(), 1);
  123.                 }
  124.             } else {
  125.                 monitor.setMaximumProgress(files.size() * 2);
  126.                 doImportPass(p, files, settings, monitor, 0, 0);
  127.             }
  128.             
  129.             ModelUtil.generatePackageDependencies(p);
  130.         } catch (IllegalModelElementConnectionException e) {
  131.         } finally {
  132.             //this prevents parse problems to be displayed, so I disabled it:
  133.             // --thn
  134.             //monitor.close();
  135.         }
  136.         return newElements;
  137.     }

  139.     private void doImportPass(Project p, Collection<File> files,
  140.             ImportSettings settings, ProgressMonitor monitor, int startCount,
  141.             int pass) {

  143.         int count = startCount;
  144.         for (File file : files) {
  145.             if (monitor.isCanceled()) {
  146.                 monitor.updateSubTask(Translator
  147.                         .localize("dialog.import.cancelled"));
  148.                 return;
  149.             }
  150.             try {
  151.                 parseFile(p, file, settings, pass);
  152.             } catch (Exception e) {
  153.                 StringWriter sw = new StringWriter();
  154.                 PrintWriter pw = new java.io.PrintWriter(sw);
  155.                 e.printStackTrace(pw);
  156.                 monitor.notifyMessage(
  157.                     Translator.localize(
  158.                             "dialog.title.import-problems"), //$NON-NLS-1$
  159.                     Translator.localize("label.import-problems"), //$NON-NLS-1$
  160.                     sw.toString());
  161.                 if (monitor.isCanceled()) {
  162.                     break;
  163.                 }
  164.             }
  165.             monitor.updateProgress(count++);
  166.             monitor.updateSubTask(Translator.localize(
  167.                     "dialog.import.parsingAction", 
  168.                     new Object[] { 
  169.                         file.getAbsolutePath() 
  170.                     }));
  171.         }
  172.     }

  174.     /**
  175.      * Do a single import pass of a single file.
  176.      * 
  177.      * @param p the project
  178.      * @param f the source file
  179.      * @param settings the user provided import settings
  180.      * @param pass current import pass - 0 = single pass, 1 = pass 1 of 2, 2 =
  181.      *                pass 2 of 2
  182.      */
  183.     private void parseFile(Project p, File f, ImportSettings settings, int pass)
  184.         throws ImportException {

  186.         try {
  187.             // Create a scanner that reads from the input stream
  188.             String encoding = settings.getInputSourceEncoding();
  189.             FileInputStream in = new FileInputStream(f);
  190.             InputStreamReader isr;
  191.             try {
  192.                 isr = new InputStreamReader(in, encoding);
  193.             } catch (UnsupportedEncodingException e) {
  194.                 // fall back to default encoding
  195.                 isr = new InputStreamReader(in);
  196.             }
  197.             JavaLexer lexer = new JavaLexer(new ANTLRReaderStream(isr));

  199.             // Create a parser that reads from the scanner
  200.             JavaParser parser = new JavaParser(new CommonTokenStream(lexer));

  202.             // Pass == 0 means single pass recognition
  203.             int parserMode = JavaParser.MODE_IMPORT_PASS1
  204.                     | JavaParser.MODE_IMPORT_PASS2;
  205.             if (pass == 0) {
  206.                 parserMode = JavaParser.MODE_IMPORT_PASS1;
  207.             } else if (pass == 1) {
  208.                 parserMode = JavaParser.MODE_IMPORT_PASS2;
  209.             }
  210.             parser.setParserMode(parserMode);

  212.             // Create a modeller for the parser
  213.             Modeller modeller = new Modeller(
  214.                     p.getUserDefinedModelList().get(0), javaProfile,
  215.                     JavaImportSettings.getInstance().isAttributeSelected(),
  216.                     JavaImportSettings.getInstance().isDatatypeSelected(), f
  217.                             .getName());

  219.             // Print the name of the current file, so we can associate
  220.             // exceptions to the file.
  221.             LOG.info("Parsing " + f.getAbsolutePath());

  223.             // Calculate the import level
  224.             int level = 0;
  225.             int importlevel = settings.getImportLevel();
  226.             if (importlevel == ImportSettings.DETAIL_CLASSIFIER_FEATURE) {
  227.                 level = 1;
  228.             } else if (importlevel == ImportSettings.DETAIL_FULL) {
  229.                 // full level only needed for the second pass
  230.                 level = (pass == 0) ? 0 : 2;
  231.             }
  232.             modeller.setAttribute("level", Integer.valueOf(level));

  234.             try {
  235.                 // start parsing at the compilationUnit rule
  236.                 parser.compilationUnit(modeller, lexer);
  237.             } catch (Exception e) {
  238.                 String errorString = buildErrorString(f);
  239.                 LOG.log(Level.SEVERE, 
  240.                         e.getClass().getName() + errorString,
  241.                         e);
  242.                 throw new ImportException(errorString, e);
  243.             } finally {
  244.                 newElements.addAll(modeller.getNewElements());
  245.                 in.close();
  246.             }
  247.         } catch (IOException e) {
  248.             throw new ImportException(buildErrorString(f), e);
  249.         }
  250.     }

  252.     private String buildErrorString(File f) {
  253.         String path = "";
  254.         try {
  255.             path = f.getCanonicalPath();
  256.         } catch (IOException e) {
  257.             // Just ignore - we'll use the simple file name
  258.             LOG.log(Level.FINEST,
  259.                     "Cannot get the Canonical Path, using name without path",
  260.                     e);
  261.         }
  262.         return "Exception in file: " + path + " " + f.getName();
  263.     }

  265.     /*
  266.      * @see org.argouml.uml.reveng.ImportInterface#getSuffixFilters()
  267.      */
  268.     public SuffixFilter[] getSuffixFilters() {
  269.         SuffixFilter[] result = {
  270.             new SuffixFilter("java", 
  271.                     Translator.localize("java.filefilter.java")),
  272.         };
  273.         return result;
  274.     }

  276.     /*
  277.      * @see org.argouml.uml.reveng.ImportInterface#isParseable(java.io.File)
  278.      */
  279.     public boolean isParseable(File file) {
  280.         return FileImportUtils.matchesSuffix(file, getSuffixFilters());
  281.     }

  283.     /*
  284.      * @see org.argouml.moduleloader.ModuleInterface#getName()
  285.      */
  286.     public String getName() {
  287.         return "Java";
  288.     }

  290.     /*
  291.      * @see org.argouml.moduleloader.ModuleInterface#getInfo(int)
  292.      */
  293.     public String getInfo(int type) {
  294.         switch (type) {
  295.         case DESCRIPTION:
  296.             return "Java import from Java files.";
  297.         case AUTHOR:
  298.             return JavaModuleGlobals.MODULE_AUTHOR;
  299.         case VERSION:
  300.             return JavaModuleGlobals.MODULE_VERSION;
  301.         case ModuleInterface.DOWNLOADSITE:
  302.             return JavaModuleGlobals.MODULE_DOWNLOADSITE;
  303.         default:
  304.             return null;
  305.         }
  306.     }

  308.     /*
  309.      * @see org.argouml.moduleloader.ModuleInterface#disable()
  310.      */
  311.     public boolean disable() {
  312.         // We are permanently enabled
  313.         return false;
  314.     }

  316.     /*
  317.      * @see org.argouml.moduleloader.ModuleInterface#enable()
  318.      */
  319.     public boolean enable() {
  320.         ImporterManager.getInstance().addImporter(this);
  321.         return true;
  322.     }

  324.     /*
  325.      * @see org.argouml.uml.reveng.ImportInterface#getImportSettings()
  326.      */
  327.     public List<SettingsTypes.Setting> getImportSettings() {
  328.         return JavaImportSettings.getInstance().getImportSettings();
  329.     }

  331.     private void updateImportClassloader() {
  332.         List<String> pathList = JavaImportSettings.getInstance().getPathList();
  333.         URL[] urls = new URL[pathList.size()];

  335.         int i = 0;
  336.         for (String path : pathList) {
  337.             try {
  338.                 urls[i++] = new File(path).toURI().toURL();
  339.             } catch (MalformedURLException e) {
  340.                 LOG.severe("Bad path in classpath " + path);
  341.             }
  342.         }

  344.         try {
  345.             ImportClassLoader.getInstance(urls);
  346.             ImportClassLoader.getInstance().saveUserPath();
  347.         } catch (MalformedURLException e) {
  348.             LOG.log(Level.FINEST, "Bad path in classpaths", e);
  349.         }
  350.     }

  352.     /**
  353.      * Get the Java profile from project, if available.
  354.      * 
  355.      * @param p the project
  356.      * @return the Java profile
  357.      */
  358.     private Profile getJavaProfile(Project p) {
  359.         for (Profile profile : p.getProfileConfiguration().getProfiles()) {
  360.             if ("Java".equals(profile.getDisplayName())) {
  361.                 return profile;
  362.             }
  363.         }
  364.         return null;
  365.     }
  366. }
Created with JaCoCo 0.8.5.201910111838