javaclass 0.0.3 → 0.0.4

data/lib/javaclass/classpath/jar_classpath.rb

@@ -1,32 +1,51 @@
-require 'zip/zipfilesystem'
+require 'fileutils'
+require 'javaclass/gems/zip_file'
+require 'javaclass/classpath/temporary_unpacker'
+require 'javaclass/classpath/file_classpath'
+require 'javaclass/java_language'
 require 'javaclass/java_name'
 
 module JavaClass
-  module Classpath 
-    
-    # Abstraction of a ZIP or JAR on the CLASSPATH. 
+
+  # Activate temporary unpacking of all JARs. This speeds up loading of classes later. 
+  def self.unpack_jars!(flag=:unpack)
+    @@unpack_jars = flag
+  end
+
+  # Return +true+ if JARs should be temporarily unpacked
+  def self.unpack_jars?
+    defined?(@@unpack_jars) && @@unpack_jars
+  end
+
+  module Classpath
+
+    # Abstraction of a ZIP or JAR on the CLASSPATH. May return additional classpath 
+    # elements for referenced libs. This is a leaf in the classpath tree.
     # Author::   Peter Kofler
-    class JarClasspath
+    class JarClasspath < FileClasspath
+
+      # Check if the _file_ is a valid location for a jar classpath.
+      def self.valid_location?(file)
+        FileTest.exist?(file) && FileTest.file?(file) && FileTest.size(file) > 0 && file =~ /\.jar$|\.zip$/
+      end
       
-      # Return the list of classnames found in this _jarfile_ . 
+      # Create a classpath with this _jarfile_ .
       def initialize(jarfile)
-        @jarfile = jarfile
-        raise IOError, "jarfile #{@jarfile} not found" if !FileTest.exist? @jarfile
-        raise "#{@jarfile} is no file" if !FileTest.file? @jarfile
-        @classes = list_classes.collect { |cl| cl.to_javaname }
-        @manifest =
-        begin
-          Zip::ZipFile.open(@jarfile) { |zipfile| zipfile.file.read("META-INF/MANIFEST.MF") }
-        rescue
-          nil
+        super(jarfile)
+        unless JarClasspath::valid_location?(jarfile)
+          raise IOError, "jarfile #{jarfile} not found/no file"
         end
+        @jarfile = jarfile
+        init_classes
+        @manifest = JavaClass::Gems::ZipFile.new(@jarfile).read('META-INF/MANIFEST.MF')
+        setup_cache if JavaClass.unpack_jars?
       end
       
-      # Return if the given classpath element is a jar.
+      # Return +true+ as this classpath element is a jar. Zip files return +false+ as well.
       def jar?
         @manifest != nil
       end
-      
+
       # Return list of additional classpath elements defined in the manifest of this jarfile.
       def additional_classpath
         if @manifest
@@ -40,61 +59,81 @@ module JavaClass
           []
         end
       end
-      
-      # Return the list of class names found in this jar.
-      def names
-        @classes.dup
+
+      # Return the list of class names found in this jar. An additional block is used as _filter_ on class names.
+      def names(&filter)
+        if block_given?
+          @class_names.find_all { |n| filter.call(n) }
+        else
+          @class_names.dup
+        end
       end
-      
+
       # Return if _classname_ is included in this jar.
       def includes?(classname)
-        @classes.include?(normalize(classname))
+        @class_lookup[to_key(classname).file_name]
       end
-      
+
       # Load the binary data of the file name or class name _classname_ from this jar.
       def load_binary(classname)
-        raise "class #{classname} not found in #{@jarfile}" unless includes?(classname)
-        Zip::ZipFile.open(@jarfile) do |zipfile|
-          zipfile.file.read(normalize(classname))
+        key = to_key(classname)
+        if JavaClass.unpack_jars?
+          @delegate.load_binary(key)
+        else
+          unless includes?(key)
+            raise ClassNotFoundError.new(key, @jarfile)
+          end
+          JavaClass::Gems::ZipFile.new(@jarfile).read(key).freeze
         end
       end
-      
+
       # Return the number of classes in this jar.
       def count
-        @classes.size
-      end
-      
-      def to_s
-        @jarfile
-      end
-      
-      def ==(other)
-        other.class == JarClasspath && other.to_s == self.to_s
+        @class_names.size
       end
-      
-      private 
-      
-      # Return the list of classnames (in fact file names) found in this jarfile. 
+
+      private
+
+      # Return the list of classnames (in fact file names) found in this jarfile.
       def list_classes
         list = []
-        Zip::ZipFile.foreach(@jarfile) do |entry|
+        JavaClass::Gems::ZipFile.new(@jarfile).entries do |entry|
           name = entry.name
-          next unless entry.file? and name =~ /\.class$/ # class file
-          list << name 
+          next unless entry.file? and name =~ JavaLanguage::CLASS_REGEX # class file
+          list << name
         end
-        list.sort
+        list
+      end
+
+      # Set up the class names.
+      def init_classes
+        @class_names = list_classes.
+          reject { |n| n =~ /package-info\.class$/ }.
+          find_all { |n| valid_java_name?(n) }.
+          sort.
+          collect { |cl| JavaClassFileName.new(cl) } 
+        pairs = @class_names.map { |name| [name.file_name, 1] }.flatten
+        @class_lookup = Hash[ *pairs ] # file_name (String) => anything
       end
       
-      # Normalize the file name or class name _classname_ to be a file name in the jar.
-      def normalize(classname)
-        if classname !~ /\.class$/
-          classname.gsub(/\./,'/') + '.class'
+      def valid_java_name?(name)
+        if JavaClassFileName.valid?(name) 
+          true
         else
-          classname
+          warn("skipping invalid class file name #{name} in classpath #{@jarfile}") 
+          false
         end
       end
       
+      # Set up the temporary unpacking. This sets the delegate field for future use.
+      def setup_cache
+        unpacker = TemporaryUnpacker.new(@jarfile)
+        unpacker.create_temporary_folder
+        unpacker.unpack!
+        @delegate = FolderClasspath.new(unpacker.folder)
+      end
+
     end
-    
+
   end
-end
+end

data/lib/javaclass/classpath/java_home_classpath.rb

@@ -1,40 +1,51 @@
 require 'javaclass/classpath/jar_classpath'
 
 module JavaClass
-  module Classpath 
-    
-    # Abstraction of the Java boot CLASSPATH. May return additional classpath elements for endorsed libs. 
+  module Classpath
+
+    # Abstraction of the Java boot CLASSPATH. May return additional classpath 
+    # elements for endorsed libs. This is a leaf in the classpath tree.
     # Author::   Peter Kofler
     class JavaHomeClasspath < JarClasspath
+
+      RT_JAR = 'rt.jar'
       
-      # Return the list of classnames found in this _javahome_ . 
+      # Create a classpath from this _javahome_ directory.
       def initialize(javahome)
-        if FileTest.exist? rtjar=File.join(javahome, 'lib', 'rt.jar')
+        if exist?(rtjar=File.join(javahome, 'lib', RT_JAR))
+          super(rtjar)
+        elsif exist?(rtjar=File.join(javahome, 'jre', 'lib', RT_JAR))
           super(rtjar)
-        elsif FileTest.exist? rtjar=File.join(javahome, 'jre', 'lib', 'rt.jar')
+        elsif exist?(rtjar=File.join(javahome, 'lib', 'classes.zip')) # Java 1.1 home with lib/classes.zip
           super(rtjar)
         else
-          raise IOError, "rt.jar not found in java home #{javahome}"
+          raise IOError, "#{RT_JAR} not found in java home #{javahome}"
         end
         @lib = File.dirname(rtjar)
       end
-      
+
       # Return list of additional classpath elements, e.g. endorsed libs found in this Java Home.
       def additional_classpath
         list = super
-        
-        if FileTest.exist? ext=File.join(@lib, 'ext') 
+
+        if FileTest.exist? ext=File.join(@lib, 'ext')
           current = Dir.getwd
           Dir.chdir ext
-          
+
           list += Dir['*.jar'].collect { |jar| File.join(ext, jar) }
-          
+
           Dir.chdir current
         end
         list
       end
+
+      private
+      
+      def exist?(file)
+        FileTest.exist?(file) && FileTest.file?(file)
+      end
       
     end
-    
+
   end
 end

data/lib/javaclass/classpath/maven_classpath.rb

@@ -0,0 +1,44 @@
+require 'javaclass/classpath/composite_classpath'
+
+module JavaClass
+  module Classpath
+    
+    # A Maven folder structure aware classpath. Maven submodules are supported.
+    # Author::   Peter Kofler
+    class MavenClasspath < CompositeClasspath
+     
+      POM_XML = 'pom.xml'
+      
+      # Check if the _file_ is a valid location for a Maven classpath.
+      def self.valid_location?(file)
+        FileTest.exist?(file) && FileTest.directory?(file) && FileTest.exist?(File.join(file, POM_XML))
+      end
+
+      # Create a classpath for a Maven base project _folder_ 
+      def initialize(folder)
+        unless MavenClasspath::valid_location?(folder)
+          raise IOError, "folder #{folder} not a Maven project"
+        end
+        pom = File.join(folder, POM_XML)
+        super(pom)
+        add_if_exist(File.join(folder, 'target/classes'))
+        add_if_exist(File.join(folder, 'target/test-classes'))
+
+        # look for submodules
+        Dir.entries(folder).each do |dir|
+          next if dir =~ /^(?:\.|\.\.|src|target|pom.xml|\.settings)$/
+          folder = File.join(folder, dir)
+          add_element(MavenClasspath.new(folder)) if MavenClasspath::valid_location?(folder)
+        end
+      end
+
+      private
+
+      def add_if_exist(folder)
+        add_file_name(folder) if FileTest.exist?(folder) && FileTest.directory?(folder)
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classpath/temporary_unpacker.rb

@@ -0,0 +1,111 @@
+require 'fileutils'
+require 'javaclass/gems/zip_file'
+require 'javaclass/java_language'
+
+module JavaClass
+  module Classpath
+
+    # Unpack a JAR (ZIP) into a temporary folder.
+    # Author::   Peter Kofler
+    class TemporaryUnpacker
+      
+      # Command templates for external too like 7zip or zip.
+      COMMANDS = [
+        # 7zip 9.20
+        '7za x -bd -o<folder> -y <jar> 2>&1',
+        # Unzip 5.42
+        'unzip -o -qq <jar> -d <folder> 2>&1',
+        # WinZip 8.1
+        'WinZip32.exe -min -e -o <jar> <folder>',
+      ]
+
+      # The temporary folder. This folder will be deleted after Ruby shuts down.
+      attr_reader :folder
+
+      # Set the given _jarfile_ to unpack.
+      def initialize(jarfile)
+        @jarfile = jarfile
+
+        if !defined?(@@unpack_strategies)
+          # use unzip first, fallback by hand
+          @@unpack_strategies = COMMANDS.map{ |c| Proc.new{ |jar, folder| TemporaryUnpacker::unpack_shell(c, jar, folder) } } + 
+                                [ Proc.new{ |jar, folder| TemporaryUnpacker::unpack_ruby(jar, folder) } ]
+        end
+      end
+
+      # Create the temporary folder where it will be unpacked to.
+      def create_temporary_folder
+        folder = File.join(find_temp_folder, "temp_#{File.basename(@jarfile)}_#{Time.now.to_i.to_s}")
+        FileUtils.mkdir_p(folder)
+        at_exit { FileUtils.rm_r(folder) }
+        @folder = folder
+      end
+
+      # Unpack the given jar file.
+      def unpack!
+        unless defined?(@folder) && @folder
+          raise IOError, 'no temporary folder created'
+        end
+          
+        # Find the first working strategy and keep it
+        if ! @@unpack_strategies.first.call(@jarfile, @folder)
+          warn("Dropping unpacker for #{@jarfile}. Install 7zip or unzip!")
+          @@unpack_strategies.delete_at(0)
+          if @@unpack_strategies.empty?
+            raise 'no suitable unpack strategy found'
+          end
+          unpack!
+        end
+      end
+
+      # Return the temp folder if a variable is set, else returm /tmp.
+      def find_temp_folder
+        TemporaryUnpacker::escape_folder(
+        if ENV['TEMP']
+          ENV['TEMP'] # Windows
+        elsif ENV['TMP']
+          ENV['TMP']
+        else
+          '/tmp'
+        end
+        )
+      end
+
+      private
+
+      # Escape _folder_ if it contains blanks.
+      def self.escape_folder(folder)
+        if folder =~ / / then "\"#{folder}\"" else folder end
+      end
+
+      # Unpack _jarfile_ into _folder_ using external executeable using the _command_ string. Return +true+ for success.
+      def self.unpack_shell(command, jarfile, folder)
+        begin
+          `#{command.gsub(/<folder>/, escape_folder(folder)).gsub(/<jar>/, escape_folder(jarfile))}`
+          $?.to_i == 0
+        rescue
+          false
+        end
+      end
+
+      # Unpack _jarfile_ into _folder_ using Ruby's Rubyzip gem. This is very slow. Return +true+ for success.
+      def self.unpack_ruby(jarfile, folder)
+        # warn('unpacking with slow ruby unpacker')
+        zip_file = JavaClass::Gems::ZipFile.new(jarfile)
+        zip_file.entries do |entry|
+          name = entry.name
+          next unless entry.file? and name =~ JavaLanguage::CLASS_REGEX # class file
+
+          f_path = File.join(folder, entry.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          unless File.exist?(f_path)
+            File.open(f_path, 'wb') { |file| file.write(zip_file.read(name)) } 
+          end
+        end
+        true
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classpath/tracking_classpath.rb

@@ -0,0 +1,144 @@
+require 'delegate'
+require 'javaclass/classpath/composite_classpath'
+
+module JavaClass
+  module Classpath
+
+    # A delegator classpath that tracks which classes have been accessed. For an example see
+    # {how to find (un)referenced JARs}[link:/files/lib/generated/examples/find_referenced_modules_txt.html]. 
+    # Author::          Peter Kofler
+    class TrackingClasspath < SimpleDelegator
+
+      # Create a tracked instance of the _classpath_ .
+      def initialize(classpath)
+        unless classpath.respond_to?(:load_binary) || classpath.respond_to?(:load)  
+          raise ArgumentError, "wrong type of delegatee #{classpath.class}"
+        end
+        @classpath = classpath
+        reset_access
+        super(classpath)
+      end
+
+      # Returns the wrapped classpath element (+self+) of this decorated classpath.
+      def elements
+        if [FolderClasspath, JarClasspath].include?(@classpath.class)
+          [self]
+        else
+          @classpath.elements
+        end
+      end
+      
+      # Reset all prior marked access.
+      def reset_access
+        @accessed = Hash.new(0) # class_file (JavaClassFileName) => cnt
+      end
+      
+      # Load the binary and mark the _classname_ as accessed.
+      def load_binary(classname)
+        key = to_key(classname)
+        mark_accessed(key)
+        @classpath.load_binary(key)
+      end
+
+      # Read and disassemble the given class _classname_ and mark as accessed.
+      def load(classname)
+        key = to_key(classname)
+        mark_accessed(key)
+        @classpath.load(key)
+      end
+      
+      # Mark the _classname_ as accessed. Return the number of accesses so far.
+      def mark_accessed(classname)
+        key = to_key(classname)
+        
+        if @classpath.includes?(key)
+          
+          # hash keys need to be frozen to keep state
+          if !@accessed.include?(key)
+            key = key.freeze 
+          end
+    
+          @accessed[key] += 1
+        else
+          nil
+        end
+      end
+      
+      # Was the _classname_ accessed then return the count? If _classname_ is +nil+ then check if any class was accessed.
+      def accessed(classname=nil)
+        if classname
+          key = to_key(classname)
+          @accessed[key] 
+        else
+          @accessed.values.inject(0) {|s,e| s + e }
+        end
+      end
+
+      # Return the classnames of all accessed classes. This is a list of frozen JavaClassFileName.      
+      def all_accessed
+        @accessed.keys.sort
+      end
+      
+      private
+      
+      def to_key(classname)
+        classname.to_javaname.to_class_file
+      end
+      
+    end
+
+    class CompositeClasspath 
+
+      # Wrap the _elem_ classpath with a new TrackingClasspath and add it to the list of elements.
+      alias __old__add_element__ add_element 
+      
+      def add_element(elem)
+        unless @elements.find { |cpe| cpe == elem }
+          if [FolderClasspath, JarClasspath].include?(elem.class)
+            __old__add_element__(TrackingClasspath.new(elem))
+          else
+            __old__add_element__(elem)
+          end
+        end 
+      end
+
+      # Reset all prior marked access in child elements. (See TrackingClasspath)
+      def reset_access
+        @elements.each { |e| e.reset_access }
+      end
+            
+      # Mark the _classname_ as accessed. Return the number of accesses so far. (See TrackingClasspath)
+      def mark_accessed(classname)
+        key = to_key(classname)
+        found = find_element_for(key)
+        if found 
+          found.mark_accessed(key) 
+        else 
+          nil 
+        end
+      end
+
+      # Was the _classname_ accessed then return the count? If _classname_ is +nil+ 
+      # then check if any class was accessed. (See TrackingClasspath)
+      def accessed(classname=nil)
+        if classname
+          key = to_key(classname)
+          found = find_element_for(key)
+          if found then found.accessed(key) else 0 end 
+        else
+          @elements.inject(0) do |s,e| 
+            accessed = e.accessed
+            if accessed then s + accessed else s end
+          end
+        end
+      end
+
+      # Return the classnames of all accessed classes in child elements. (See TrackingClasspath)    
+      def all_accessed
+        @elements.map { |cp| cp.all_accessed }.flatten.sort
+      end
+
+    end
+    
+  end
+end

data/lib/javaclass/classscanner/ideas.txt

@@ -0,0 +1,3 @@
+=== Class Analysis (working on a single class) 
+
+ * count outgoing references (usage) per method, similar to general imported types

data/lib/javaclass/classscanner/imported_types.rb

@@ -0,0 +1,29 @@
+require 'delegate'
+
+module JavaClass
+  module ClassScanner
+
+    # Add analysis for imported types to ClassFile::JavaClassHeader.
+    # Author::          Peter Kofler
+    class ImportedTypes < SimpleDelegator
+
+      # Decorate JavaClassHeader _header_ to add imported types lazy scanner.
+      def initialize(header)
+        super(header)
+        @imported_types = nil
+      end
+
+      # Determine the imported types of this class and return their names. This does not contain the name if this class itself.
+      def imported_types
+        @imported_types ||= references.used_classes.collect { |c| c.class_name.to_classname }.sort
+      end
+
+      # Determine the imported types of this class which are not from the JDK. This are all imported_types - all jdk types.
+      def imported_3rd_party_types
+        imported_types.reject { |name| name.in_jdk? }
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classscanner/scanners.rb

@@ -0,0 +1,29 @@
+require 'javaclass/classscanner/imported_types'
+
+module JavaClass
+  
+  # The module ClassScanner is for separating namespaces. It contains various
+  # decorators that scan and analyse single class files and provide additional
+  # information about the class, e.g. Cyclomatic Complexity. For analysis across
+  # whole code bases ("classpaths") see module Analyse. 
+  # Author::          Peter Kofler
+  module ClassScanner
+    
+    # ClassScanner factory methods to create different kind of scanner decorators.
+    # Author::          Peter Kofler
+    module Scanners
+  
+      # Scan parsed _header_ for (selected) _features_ . This ties together all scanners.
+      def analyse(header, features=:all)
+        # later add feature selection if needed, argument determines delegators, :none, :some, :all
+        ImportedTypes.new(
+          header
+        )
+      end
+
+      alias :decorate analyse
+      
+    end
+
+  end
+end

data/lib/javaclass/delegate_directive.rb

@@ -0,0 +1,15 @@
+# Delegation directives.
+# Author::          Peter Kofler
+module DelegateDirective # :nodoc:
+  
+  # Directive to create a delegating method _method_name_ to the result of my own method _delegate_ without arguments.
+  def delegate(method_name, delegate)
+    self.module_eval("def #{method_name}(*obj) #{delegate}.#{method_name}(*obj) end")
+  end
+
+  # Directive to create a delegating method _method_name_ to the field _field_name_ .
+  def delegate_field(method_name, field_name)
+    self.module_eval("def #{method_name}(*obj) @#{field_name}.#{method_name}(*obj) end")
+  end
+
+end

data/lib/javaclass/dsl/caching_classpath.rb

@@ -0,0 +1,38 @@
+require 'delegate'
+
+module JavaClass
+  module Dsl
+
+    # A delegator classpath that caches loaded class files in a map by full qualified class names.
+    # Author::          Peter Kofler
+    class CachingClasspath < SimpleDelegator
+
+      # Create a cached instance of the _classpath_ (a LoadingClasspath).
+      def initialize(classpath)
+        unless classpath.respond_to? :load 
+          raise ArgumentError, "wrong type of delegatee #{classpath.class}"
+        end
+        @classpath = classpath
+        @cache = Hash.new # full_name (String) => ClassEntryHeader
+        super(classpath)
+      end
+
+      # Ask the cache for the _classname_ and return it. Else delegate loading.
+      def load(classname)
+        key = classname.to_javaname.full_name
+        if !@cache.include?(key)
+          @cache[key] = @classpath.load(classname)
+        end
+        @cache[key]
+      end
+
+      # Load _listed_ or all classes. Duplicate method to use the cache of decorator.
+      def values(listed=nil, &filter)
+        listed ||= names(&filter)
+        listed.collect { |name| load(name) }
+      end
+      
+    end
+
+  end
+end