javaclass 0.0.2 → 0.0.3

data/lib/javaclass/classpath/port_ClassPathEntry.java

@@ -0,0 +1,202 @@
+package at.kugel.tool.classes;
+
+// Kugel's "Java Code & Tools Library", Copyright (c) 1999-2004, Theossos Comp Group
+import java.io.File;
+import java.lang.reflect.Modifier;
+import java.util.zip.ZipEntry;
+
+/**
+ * An entry of a class in the classpath. This contains the reference to the fully qualified name and where to find it.
+ * @author Kugel, <i>Theossos Comp Group</i>
+ * @version 1.00 - 13.03.2004
+ * @since JDK1.2
+ */
+public final class ClassPathEntry implements Comparable<ClassPathEntry>
+{
+
+   public static final String CLASS_EXTENSION = ".class";
+
+   /** Value to be set by factory if we want to check for public or all classes. */
+   static boolean checkForPublic = true;
+
+   public final String className;
+   public final String packageName;
+   public final File origin;
+   public final boolean isInner;
+   /** Ternary value. 0 = not checked, 1 = yes, -1 = no. */
+   public final int isPublic;
+
+   private boolean duplicated;
+
+   public ClassPathEntry(String pClassName, String pPackageName, File pOrigin)
+   {
+      className = pClassName;
+      packageName = pPackageName.intern();
+      origin = pOrigin;
+      isInner = (pClassName.indexOf('$') > -1);
+
+      int ip = 0;
+      if (checkForPublic)
+      {
+         try
+         {
+            // classloader does NOT resolve classes, i.e. no static thingies are run...
+            if ((ClassLoader.getSystemClassLoader().loadClass(toString()).getModifiers() & Modifier.PUBLIC) > 0)
+            {
+               ip = 1;
+            }
+            else
+            {
+               ip = -1;
+            }
+         }
+         catch (final ClassNotFoundException ex)
+         {
+            ip = 0;
+         }
+         catch (final LinkageError ex)
+         {
+            // ex.printStackTrace();
+            // may be NoClassDefFoundError or ClassFormatError (if references to other),
+            // or SecurityEx
+            ip = 0;
+            System.err.println("WARNING: could not load " + toString() + " (" + ex.toString() + ")");
+         }
+      }
+      isPublic = ip;
+
+      // System.out.println("found " + packageName + "." + className + " in " + pOrigin);
+   }
+
+   @Override
+   public boolean equals(Object obj)
+   {
+      if (!(obj instanceof ClassPathEntry))
+      {
+         return false;
+      }
+
+      final ClassPathEntry ce = (ClassPathEntry) obj;
+      return ce.className.equals(className) && ce.packageName.equals(packageName);
+   }
+
+   @Override
+   public int hashCode()
+   {
+      return className.hashCode() ^ packageName.hashCode();
+   }
+
+   @Override
+   public final String toString()
+   {
+      if (packageName.length() == 0)
+      {
+         return className;
+      }
+      return packageName + '.' + className;
+   }
+
+   public int compareTo(ClassPathEntry o)
+   {
+      return toString().compareTo(o.toString());
+   }
+
+   // --- static ---
+
+   private static ClassPathEntry create(String pClass, String pPackage, File pOrigin)
+   {
+      return new ClassPathEntry(pClass, pPackage, pOrigin);
+   }
+
+   static ClassPathEntry createFromClassFile(File pClassPathBase, File pClassInFileSystem)
+   {
+      final String baseDirectory = pClassPathBase.getPath();
+      final String fullName = pClassInFileSystem.getPath().substring(baseDirectory.length());
+
+      // get the path
+      String path;
+      final int i = fullName.lastIndexOf(File.separatorChar);
+      if (i > -1)
+      {
+         path = fullName.substring(0, i).replace(File.separatorChar, '.');
+      }
+      else
+      {
+         path = "";
+      }
+
+      // get the name
+      String name;
+      if (i > -1)
+      {
+         name = fullName.substring(i + 1);
+      }
+      else
+      {
+         throw new IllegalArgumentException("no classname in entry: " + fullName);
+      }
+
+      if (name.endsWith(CLASS_EXTENSION))
+      {
+         name = name.substring(0, name.length() - 6);
+      }
+      else
+      {
+         throw new IllegalArgumentException("no classs file: " + fullName);
+      }
+
+      return create(name, path, pClassInFileSystem);
+   }
+
+   static ClassPathEntry createFromZipEntry(File pZipFile, ZipEntry pClassInZip)
+   {
+      final char ZIP_PATH_CHAR = '/';
+
+      final String fullName = pClassInZip.getName();
+
+      // get the path
+      String path;
+      final int i = fullName.lastIndexOf(ZIP_PATH_CHAR);
+      if (i > -1)
+      {
+         path = fullName.substring(0, i).replace(ZIP_PATH_CHAR, '.');
+      }
+      else
+      {
+         path = "";
+      }
+
+      // get the name
+      String name;
+      if (i > -1)
+      {
+         name = fullName.substring(i + 1);
+      }
+      else
+      {
+         name = fullName;
+      }
+
+      if (name.endsWith(CLASS_EXTENSION))
+      {
+         name = name.substring(0, name.length() - 6);
+      }
+      else
+      {
+         throw new IllegalArgumentException("no class file: " + fullName);
+      }
+
+      return create(name, path, pZipFile);
+   }
+
+   public boolean isDuplicated()
+   {
+      return duplicated;
+   }
+
+   public void setDuplicated(boolean b)
+   {
+      duplicated = b;
+   }
+
+}

data/lib/javaclass/classpath/port_ClassPathEntryFactory.java

@@ -0,0 +1,311 @@
+package at.kugel.tool.classes;
+
+// Kugel's "Java Code & Tools Library", Copyright (c) 1999-2004, Theossos Comp Group
+import java.io.File;
+import java.io.IOException;
+import java.security.InvalidParameterException;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import at.kugel.util.io.WildcardSearch;
+
+/**
+ * Factory to get the CPEs (Class Path Entries) from a system path, given path or archive.
+ * @author Kugel, <i>Theossos Comp Group</i>
+ * @version 1.00 - 13.03.2004
+ */
+public final class ClassPathEntryFactory
+{
+
+   /**
+    * 0 = no output, 1 = system path, 2 = archives and directories, 3 = statistics, 5 = duplicates.
+    */
+   private final int debugLevel = 3;
+
+   private static final String CLASS_EXTENSION = ClassPathEntry.CLASS_EXTENSION;
+   private boolean dropInnerClasses = true;
+   private boolean dropPackageClasses = true;
+
+   private long numberEntries;
+   private long numberDuplicatedEntries;
+
+   private void resetStatistics()
+   {
+      numberEntries = 0;
+      numberDuplicatedEntries = 0;
+   }
+
+   private void printStatistics()
+   {
+      if (dropPackageClasses)
+      {
+
+         System.out.println("   Found " + numberEntries + " new and " + numberDuplicatedEntries + " duplicated public classes");
+
+      }
+      else
+      {
+
+         System.out.println("   Found " + numberEntries + " new and " + numberDuplicatedEntries + " duplicated classes");
+
+      }
+   }
+
+   private void addEntryToList(final ClassPathEntry cpe, List<ClassPathEntry> pClassList2Add)
+   {
+      if (dropInnerClasses && cpe.isInner)
+      {
+         return;
+      }
+      if (dropPackageClasses && cpe.isPublic == -1)
+      {
+         return;
+      }
+
+      if (!pClassList2Add.contains(cpe))
+      {
+         numberEntries++;
+         pClassList2Add.add(cpe);
+
+      }
+      else
+      {
+
+         numberDuplicatedEntries++;
+
+         if (debugLevel >= 5)
+         {
+            final int i = pClassList2Add.indexOf(cpe);
+            final ClassPathEntry duplicated = pClassList2Add.get(i);
+            duplicated.setDuplicated(true);
+            System.out.println("   Duplicate class: " + cpe + " in " + duplicated.origin + " and " + cpe.origin);
+         }
+      }
+   }
+
+   public void readAllClassesFromDirectory(File pClassPathBase, List<ClassPathEntry> pClassList2Add)
+   {
+      if (debugLevel >= 2)
+      {
+         System.out.println(" * Reading classes from directory " + pClassPathBase);
+         resetStatistics();
+      }
+
+      final Vector<File> foundElements = new Vector<File>();
+
+      WildcardSearch.getFiles(pClassPathBase.getPath() + File.separatorChar + "*" + CLASS_EXTENSION, true, foundElements);
+      for (final File file : foundElements)
+      {
+         final ClassPathEntry cpe = ClassPathEntry.createFromClassFile(pClassPathBase, file);
+
+         addEntryToList(cpe, pClassList2Add);
+      }
+
+      foundElements.removeAllElements();
+
+      if (debugLevel >= 3)
+      {
+         printStatistics();
+      }
+   }
+
+   public void readAllClassesFromZip(File pZipFile, List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      if (debugLevel >= 2)
+      {
+         System.out.println(" * Reading classes from archive " + pZipFile);
+         resetStatistics();
+      }
+
+      final ZipFile zf = new ZipFile(pZipFile);
+      for (final Enumeration<? extends ZipEntry> en = zf.entries(); en.hasMoreElements();)
+      {
+         final ZipEntry entry = en.nextElement();
+
+         if (entry.getName().endsWith(CLASS_EXTENSION))
+         {
+            final ClassPathEntry cpe = ClassPathEntry.createFromZipEntry(pZipFile, entry);
+            addEntryToList(cpe, pClassList2Add);
+         }
+
+      }
+
+      if (debugLevel >= 3)
+      {
+         printStatistics();
+      }
+   }
+
+   public void readAllZipsFromDirectory(File pClassPathBase, List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      if (debugLevel >= 2)
+      {
+         System.out.println(" * Reading jars from directory " + pClassPathBase);
+         resetStatistics();
+      }
+
+      final Vector<File> foundElements = new Vector<File>();
+
+      WildcardSearch.getFiles(pClassPathBase.getPath() + File.separatorChar + "*.jar", true, foundElements);
+      for (final File entry : foundElements)
+      {
+         readAllClassesFromZip(entry, pClassList2Add);
+      }
+      foundElements.removeAllElements();
+
+      WildcardSearch.getFiles(pClassPathBase.getPath() + File.separatorChar + "*.zip", true, foundElements);
+      for (final File entry : foundElements)
+      {
+         readAllClassesFromZip(entry, pClassList2Add);
+      }
+      foundElements.removeAllElements();
+   }
+
+   public void readAllFromClassPath(String pPath, List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      final StringTokenizer pathTokenizer = new StringTokenizer(pPath, File.pathSeparator);
+      while (pathTokenizer.hasMoreTokens())
+      {
+         final String path = pathTokenizer.nextToken();
+
+         if (path.endsWith(".zip") || path.endsWith(".jar"))
+         {
+            final File zipFile = new File(path);
+            if (zipFile.exists() && zipFile.isFile() && zipFile.canRead())
+            {
+               readAllClassesFromZip(zipFile, pClassList2Add);
+            }
+            else
+            {
+               if (debugLevel >= 2)
+               {
+                  System.out.println("WARNING: archive " + path + " from classpath not found");
+               }
+            }
+
+         }
+         else
+         {
+
+            final File directoryFile = new File(path);
+            if (directoryFile.exists() && directoryFile.isDirectory())
+            {
+               readAllClassesFromDirectory(directoryFile, pClassList2Add);
+            }
+            else
+            {
+               if (debugLevel >= 2)
+               {
+                  System.out.println("WARNING: directory " + path + " from classpath not found");
+               }
+            }
+
+         }
+      }
+   }
+
+   private void readAllFromSystemClassPath(String name, List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      final String p = System.getProperty(name);
+
+      if (debugLevel >= 1)
+      {
+         System.out.println("Working on path " + name + " (" + p + ")");
+      }
+
+      if (p != null && p.length() > 0)
+      {
+         if (name.endsWith(".dirs"))
+         {
+            readAllZipsFromDirectory(new File(p), pClassList2Add);
+
+         }
+         else if (name.endsWith(".path"))
+         {
+            readAllFromClassPath(p, pClassList2Add);
+
+         }
+         else
+         {
+            throw new InvalidParameterException("no path or directory system property given");
+         }
+      }
+   }
+
+   public void readAllFromSystemClassPaths(List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      readAllFromSystemClassPath("sun.boot.class.path", pClassList2Add);
+      readAllFromSystemClassPath("java.endorsed.dirs", pClassList2Add);
+      readAllFromSystemClassPath("java.ext.dirs", pClassList2Add);
+      readAllFromSystemClassPath("java.class.path", pClassList2Add);
+   }
+
+   public void readAllFromUserClassPaths(String p, List<ClassPathEntry> pClassList2Add) throws IOException
+   {
+      if (debugLevel >= 1)
+      {
+         System.out.println("Working on user input (" + p + ")");
+      }
+
+      final File userFile = new File(p);
+      if (p.indexOf(File.pathSeparator) > -1)
+      {
+         // this is a pathlist
+         readAllFromClassPath(p, pClassList2Add);
+
+      }
+      else if (userFile.isDirectory())
+      {
+         // may be a WEB-INF clone - read all zips and jars
+         readAllZipsFromDirectory(userFile, pClassList2Add);
+         // but also may be a single class list
+         readAllClassesFromDirectory(userFile, pClassList2Add);
+
+      }
+      else
+      {
+         // must be a file - a zip
+         readAllClassesFromZip(userFile, pClassList2Add);
+      }
+
+   }
+
+   public boolean isDropInnerClasses()
+   {
+      return dropInnerClasses;
+   }
+
+   public void setDropInnerClasses(boolean b)
+   {
+      dropInnerClasses = b;
+   }
+
+   public boolean isDropPackageClasses()
+   {
+      return dropPackageClasses;
+   }
+
+   public void setDropPackageClasses(boolean b)
+   {
+      dropPackageClasses = b;
+   }
+
+   // /** Just for testing. */
+   // public static void main(String[] args) throws IOException
+   // {
+   // final ClassPathEntryFactory fac = new ClassPathEntryFactory();
+   // final List<ClassPathEntry> list = new ArrayList<ClassPathEntry>();
+   //
+   // System.out.println("*** reading ***");
+   // fac.readAllFromSystemClassPaths(list);
+   // System.out.println("*** sorting ***");
+   // Collections.sort(list);
+   //
+   // System.out.println("found " + list.size() + " classes.");
+   // }
+
+}

data/lib/javaclass/classpath/port_DirectoryRepository.java

@@ -0,0 +1,24 @@
+/**
+ * Abstraction of a place where to find the physical class files for a given full class name. This must also configure
+ * the <code>org.apache.bcel.Repository</code> to use the right repository for BCEL automatic class loading, i.e. for
+ * interfaces.
+ */
+
+
+   public List<String> getAllClassNames(boolean skipInnerClasses)
+   {
+      final List<String> result = new ArrayList<String>();
+
+      for (final String name : filesInRepository.keySet())
+      {
+         if (skipInnerClasses && name.indexOf('$') != -1)
+         {
+            continue;
+         }
+         result.add(name);
+      }
+
+      Collections.sort(result);
+      return result;
+   }
+

data/lib/javaclass/java_name.rb

@@ -0,0 +1,90 @@
+module JavaClass
+  
+  # Special string with methods to work with Java class or package names.
+  # Author::          Peter Kofler
+  class JavaName < String
+    
+    # Return the package name of a classname or the superpackage of a package. Return an empty String if default package.
+    attr_reader :package
+    
+    # Return the simple name of this class or package.
+    attr_reader :simple_name
+    # Full normalized class name of this class.
+    attr_reader :full_name
+    
+    def initialize(string)
+      super string
+      @full_name = string.gsub(/\/|\\/,'.').sub(/\.(class|java|".*|<.*)?$/, '')
+      
+      matches = @full_name.scan(/^(.+)\.([A-Z][^.]*)$/)[0]
+      if matches
+        @package = matches[0].to_javaname
+        @simple_name = matches[1].to_javaname
+      elsif @full_name =~ /^[A-Z][^.]*$/
+        # simple name
+        @package = ''
+        @simple_name = self
+      else
+        # only package
+        @package = self
+        @simple_name = ''
+      end
+    end
+    
+    # Return +true+ if this class is in same or in a subpackage of the given Java _packages_ or
+    # if this package is same or a subpackage (with .).
+    def same_or_subpackage_of?(packages)
+      packages.find {|pkg| @package == pkg } != nil || subpackage_of?(packages)
+    end
+    
+    # Return +true+ if this class is in a subpackage of the given Java _packages_ .
+    def subpackage_of?(packages)
+      packages.find {|pkg| @package =~ /^#{Regexp.escape(pkg)}\./ } != nil
+    end
+    
+    def to_javaname
+      self
+    end
+
+    # Return the full classname of this class, e.g. <code>java.lang.Object</code>.
+    def to_classname
+      @full_name.to_javaname
+    end
+    
+    # Return the VM name of this class, e.g. <code>java/lang/Object</code>.
+    def to_jvmname
+      (@full_name.gsub(/\./, '/')).to_javaname
+    end
+    
+    # Return the Java source file name of this class, e.g. <code>java/lang/Object.java</code>.
+    def to_java_file
+      (to_jvmname + '.java').to_javaname
+    end
+    
+    # Return the Java class file name of this class, e.g. <code>java/lang/Object.class</code>.
+    def to_class_file
+      (to_jvmname + '.class').to_javaname
+    end
+    
+    # Split the simple name at the camel case boundary _pos_ and return two parts. _pos_ may
+    # be < 0 for counting backwards.
+    def split_simple_name(pos)
+      parts = @simple_name.scan(/([A-Z][^A-Z]+)/).flatten
+      pos = parts.size + pos +1 if pos < 0
+      return ['', @simple_name] if pos <= 0
+      return [@simple_name, ''] if pos >= parts.size
+      [parts[0...pos].join, parts[pos..-1].join]
+    end
+  end
+  
+end
+
+class String
+  
+  # Convert a Java classname or Java class filename to JavaClass::JavaName instance. 
+  # If it's a pathname then it must be relative to the classpath.
+  def to_javaname
+    JavaClass::JavaName.new(self)
+  end
+  
+end

data/lib/javaclass/metric/ccd.rb

@@ -0,0 +1,68 @@
+# add the lib to the load path
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+
+# TODO cleanup this code fragment and make a proper class 
+
+require 'javaclass'
+include JavaClass
+
+def process_class(name, already=[], intend=0)
+  file_name = 'C:\JavaDev\classes\\' + name.gsub(/\./,'\\') + '.class'
+  return if !FileTest.exist? file_name
+  # p file_name
+  clazz = JavaClass.parse(file_name)
+  # p clazz
+  puts " "*intend + clazz.this_class
+  
+  imported = clazz.references.used_classes.collect { |c| c.to_s }.sort
+  new_used = imported - already
+  already << new_used
+  already.flatten!
+  new_used.find_all { |c| c =~ /at\/spardat\// }.each do |c|
+    process_class(c, already, intend+1)
+  end
+end
+
+def process_package(folder, already=[], intend=0)
+  file_name = 'C:\JavaDev\classes\\' + folder.gsub(/\./,'\\')
+  cwd = Dir.getwd
+  Dir.chdir file_name
+  files = Dir['*']
+  files.each do |c|
+    if c =~ /\.class$/
+      process_class(folder + '.' + c[/^[^.]+/], already, intend)
+    elsif FileTest.directory? c
+      puts " "*intend+ '-----'
+      process_package(folder + '.' + c, already, intend)
+    end
+  end
+  Dir.chdir cwd
+end
+
+# total = []
+# #process_class('at/spardat/krimiaps/service/client/service/impl/ClientSmeSearchServiceImpl', total)
+# #process_class('at/spardat/krimiaps/service/client/service/impl/ClientPrivateSearchServiceImpl', total)
+#
+# # --- common
+# #process_package('at.spardat.krimicee.common', total) #
+# #process_package('at.spardat.krimiaps.common', total) # -> 79 ok
+# #process_package('at.spardat.common', total) # 146, in sich, koennte nach common
+# #process_package('at.spardat.integrator', total) #
+# # DatabaseAwareComponent -> ganze DB
+# #process_package('at.spardat.krimicee.util', total)
+# # ItoTestApsSchema -> ganze DB
+# # process_package('at.spardat.krimicee.lib', total)
+# # KrimiLock -> ganze DB
+#
+# #process_package('at.spardat.krimicee.dom', total)
+# #process_package('at.spardat.krimicee.db', total)
+# # KrimiLoanService, PrintHelper ->
+# #process_package('at.spardat.krimicee.dao', total)
+# #process_package('at.spardat.krimicee.dao', total)
+# #process_package('at.spardat.krimicee.entity', total)
+# #process_package('at.spardat.krimicee.entity', total)
+# #process_package('at.spardat.krimicee.eo', total)
+# #process_package('at.spardat.krimicee.sql', total)
+# #process_package('at.spardat.krimicee.model', total) # 1647
+#
+# puts total.size