javaclass 0.0.2 → 0.0.3

data/lib/javaclass/classlist/jar_searcher.rb

@@ -0,0 +1,69 @@
+require 'javaclass/classpath/composite_classpath'
+require 'javaclass/classfile/java_class_header'
+
+module JavaClass
+  module ClassList # :nodoc:
+    
+    # Search in zip or jar files for Java class files, check for package access or inner classes and
+    # call back a list of all these.
+    # Author::          Peter Kofler
+    class JarSearcher
+      
+      attr_accessor :skip_inner_classes
+      attr_accessor :skip_package_classes
+      
+      # Create a new searcher.
+      def initialize
+        @skip_inner_classes = true
+        @skip_package_classes = false
+        @package_filters = []
+      end
+      
+      # The given _filters_ will be dropped during searching.
+      # _filters_ contain the beginning of package paths, i.e. <code>com/sun/</code>.
+      def filters=(filters)
+        @package_filters = filters.collect{ |f| /^#{f}/ }
+      end
+      
+      # Return the list of classnames of this list of _classes_ .
+      # Skips inner classes if +skip_inner_classes+ is true.
+      # Skips classes that are in the filtered packages.
+      def filter_classes(classes)
+        classes.find_all do |name|
+          !(@skip_inner_classes && name =~ /\$/) && (@package_filters.find { |filter| name =~ filter } == nil)
+        end
+      end
+      
+      # Return true if the _classfile_ in the given _classpath_ is public. This is expensive because
+      # the jarfile is opened and the _classfile_ is extracted and read.
+      def public?(classpath, classfile)
+        begin
+          header = ClassFile::JavaClassHeader.new(classpath.load_binary(classfile))
+        rescue
+          puts "error #{$1} for class #{classfile} on #{classpath.to_s}"
+          raise
+        end
+        raise "invalid java class #{classfile}" unless header.magic.valid?
+        header.access_flags.accessible?
+      end
+      
+      # Compile the class list for the given _version_ of Java. This searches the _path_ for zips and jars
+      # and adds them to the given _list_ of found classes. _version_ is a number >= 0, e.g. 2 for JDK 1.2.
+      # _list_ must provide a <code>add_class(entry, is_public, version)</code> method.
+      def compile_list(version, path, list)
+        cpe = JavaClass::Classpath::CompositeClasspath.new
+        cpe.find_jars(path)
+        filter_classes(cpe.names).each do |entry|
+          is_public = public?(cpe, entry)
+          next if @skip_package_classes && !is_public
+          list.add_class(entry, is_public, version) if list
+          yield(entry, is_public, version) if block_given?
+        end
+        
+        list
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classlist/list.rb

@@ -0,0 +1,126 @@
+require 'javaclass/java_name'
+require 'javaclass/classlist/package_entry'
+
+module JavaClass
+  module ClassList # :nodoc:
+    
+    # Classes to form a list of JDK classes to find classes which have been added in new releases.
+    # The list of classes. It list contains packages.
+    # Author::          Peter Kofler
+    class List
+      
+      def initialize
+        @packages = {}
+      end
+      
+      # Add a _fileentry_ to the list. The _fileentry_ is the file name of the class in the jar file. _version_ 
+      # is the version of the JDK scanned and is used if the class is new.
+      def add_class(fileentry, is_public, version)
+        class_name = fileentry.to_javaname.to_classname
+        package_name = class_name.package
+        @packages[package_name] = PackageEntry.new(package_name, version) unless @packages.has_key?(package_name)
+        @packages[package_name].add_class(class_name, is_public, version)
+      end
+      
+      # Parse a _line_ from a <code>fullClassList</code> and fill the list again. _maxversion_ is the maximum
+      # max version from the list, i.e. the highest possible value, so we can continue to use it.
+      def parse_line(line, maxversion)
+        class_name, versions = line.scan(/^([^\s]+)\s(?:\[(.*)\]\s)?-\s*$/)[0]
+        
+        # no [], so we have it from always and it is public
+        first_vers = 0
+        last_vers = maxversion
+        is_public = true
+        if versions
+          # extract package access and drop it
+          is_public = (versions !~ /p/)
+          versions = versions.gsub(/p/, '')
+          
+          # \d, \d-\d, only \d, -\d, oder leer
+          if versions =~ /^(\d)$/
+            first_vers = $1.to_i
+          elsif versions =~ /^(\d)-(\d)$/
+            first_vers = $1.to_i
+            last_vers = $2.to_i
+          elsif versions =~ /^(?:bis\s|-)(\d)$/
+            last_vers = $1.to_i
+          elsif versions =~ /^only (\d)$/
+            first_vers = $1.to_i
+            last_vers = $1.to_i
+          else
+            raise "can't match version number #{versions} in line #{line.chomp}" unless versions == ''
+          end
+        end
+        
+        first_vers.upto(last_vers) do |v| 
+          add_class(class_name, is_public, v) 
+        end
+      rescue
+        raise "#{$!} in line #{line.chomp}: class_name=#{class_name}, versions=#{versions}, first_vers=#{first_vers}, last_vers=#{last_vers}, is_public=#{is_public}"
+      end
+      
+      def packages
+        @packages.values.sort
+      end
+      
+      # Return the version list of all packages.
+      def version
+        packages.collect { |p| p.version }.flatten.uniq.sort
+      end
+      
+      # Return the first and last version of this list.
+      def first_last_versions
+        v = version
+        [v.first, v.last]
+      end
+      
+      def to_s
+        packages.collect { |p| p.to_s }.join("\n")
+      end
+      
+      # Return the number of classes in this list.
+      def size
+        @packages.values.inject(0) {|sum, p| sum + p.size }
+      end
+      
+      # The access list is the raw list of all package access classes for one version. It was used to differ
+      # normal classes from hidden classes and was saved in <code>doc/AccessLists/*_p.txt</code>.
+      # This works only if JarSearcher was used with +skip_package_classes+ set to false (default).
+      # If there are more versions loaded, then only the last version is printed. So we get consecutive lists 
+      # of new package access classes with every JDK version.
+      def old_access_list
+        v = first_last_versions
+        packages.collect { |pkg| 
+          pkg.classes.find_all { |c| !c.public? && c.version == [v[1]]}.collect { |c| c.to_full_qualified_s(v[0], v[1]) }
+        }.flatten.sort{|a,b| a.casecmp b }
+      end
+      
+      # The class list is the raw list of all classes for one version without version or package access 
+      # descriptors. It was used to find differences and was saved in <code>doc/ClassLists/*_classes.txt</code>.
+      # This usually was done with JarSearcher set +skip_package_classes+ to false.
+      # If a block is given it is invoked with ClassEntry and should return if to add the class or not. 
+      def plain_class_list
+        packages.collect { |pkg|
+          cls = pkg.classes
+          if block_given?
+            cls = cls.find_all { |c| yield(c) }
+          end
+          cls.collect { |c| c.full_name + "\n" }
+        }.flatten.sort{|a,b| a.casecmp b }
+      end
+      
+      # Create a full class list with version numbers and different versions to compare.
+      # This was the base for classlists and was saved in <code>doc/fullClassList1x.txt</code>.
+      # This usually was done with JarSearcher set +skip_package_classes+ to false and
+      # contained different classlists merged together.
+      def full_class_list
+        v = first_last_versions
+        packages.collect { |pkg| 
+          pkg.classes.collect { |c| c.to_full_qualified_s(v[0], v[1]) }
+        }.flatten.sort{|a,b| a.casecmp b }
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classlist/package_entry.rb

@@ -0,0 +1,87 @@
+require 'javaclass/classlist/class_entry'
+
+module JavaClass
+  module ClassList # :nodoc:
+    
+    # A package in the List.
+    # Author::          Peter Kofler
+    class PackageEntry # ZenTest FULL to find method <=>
+      
+      attr_reader :name
+      # Return the list of versions this package exists. This is the sum of all versions of all classes in the package.
+      attr_reader :version
+      
+      # Create a new package with name _name_ and first version _vers_ which is the version of the first class in the package.
+      def initialize(name, vers=0)
+        @name = name
+        @version = [vers]
+        @classes = {}
+      end
+      
+      def add_class(class_name, is_public, version)
+        @version << version unless @version.include? version
+        @version = @version.sort
+        
+        unless @classes.has_key?(class_name)
+          @classes[class_name] = ClassEntry.new(self, class_name, is_public, version)
+        else
+          @classes[class_name].update(version, is_public)
+        end
+      end
+      
+      # Sorting in packages is: <code>java.lang</code>, other <code>java.*</code>, <code>javax.*</code> and then others.
+      def <=>(other)
+        if @name =~ /^java\.lang$/ and other.name !~ /^java\.lang$/
+          -1
+        elsif @name !~ /^java\.lang$/ and other.name =~ /^java\.lang$/
+          1
+        elsif @name =~ /^java\./ and other.name !~ /^java\./
+          -1
+        elsif @name !~ /^java\./ and other.name =~ /^java\./
+          1
+        elsif @name =~ /^javax\./ and other.name !~ /^javax\./
+          -1
+        elsif @name !~ /^javax\./ and other.name =~ /^javax\./
+          1
+        else
+          @name <=> other.name
+        end
+      end
+      
+      # Return the classes in this package.
+      def classes
+        @classes.values.sort
+      end
+      
+      # Return the number of classes in this package.
+      def size
+        @classes.size
+      end
+      
+      def to_s
+        @name
+      end
+      
+      # Special version of +to_s+ for package shortcut. A package needs _minversion_ and _maxversion_ to
+      # determine if the whole package was dropped. 
+      def to_package_shortcut_s(minversion, maxversion)
+      "#{@name}#{format_version(minversion, maxversion)} - \n" + 
+        classes.collect { |c| c.to_package_shortcut_s }.join
+      end
+      
+      private
+      
+      def format_version(minversion, maxversion)
+        is_newer = @version.first > minversion
+        is_outdated = @version.last < maxversion
+        line = 
+          " [#{ is_newer  ? @version.first.to_s : ''}" +
+          "#{is_outdated ? '-' + @version.last.to_s : ''}" +
+          "]"
+        line.sub(/(\d)-\1/, "only \\1").sub(/ \[\]/, '')
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classpath/classpaths.txt

@@ -0,0 +1,2 @@
+* Java 1.1 Home classpath with lib/classes.zip
+* other classpath abstractions: - WARs and EARs contain JARs and a folder

data/lib/javaclass/classpath/composite_classpath.rb

@@ -0,0 +1,99 @@
+require 'javaclass/classpath/jar_classpath'
+require 'javaclass/classpath/folder_classpath'
+
+module JavaClass
+  module Classpath
+    # List of class path elements.
+    # Author::   Peter Kofler
+    class CompositeClasspath
+      # Return the list of classnames found in this path.
+      def initialize
+        @elements = []
+      end
+
+      # Return the classpath elements of this path.
+      def elements
+        @elements.dup
+      end
+
+      # Search the given _path_ recursievely for zips or jars. Add all found jars to this classpath.
+      def find_jars(path)
+        current = Dir.getwd
+        begin
+          Dir.chdir File.expand_path(path)
+
+          Dir['*'].collect do |name|
+            if FileTest.directory?(name)
+              find_jars(name)
+            elsif name =~ /\.jar$|\.zip$/
+              add_file_name File.expand_path(name)
+            end
+          end
+
+        ensure
+          Dir.chdir current
+        end
+      end
+
+      # Add the _name_ class path file/folder name to the list.
+      def add_file_name(name)
+        if FileTest.directory? name
+          add_element(FolderClasspath.new(name))
+        else
+          add_element(JarClasspath.new(name))
+        end
+      end
+
+      # Add the _elem_ classpath element to the list.
+      def add_element(elem)
+        @elements << elem unless @elements.find { |cpe| cpe == elem }
+        elem.additional_classpath.each do |acpe|
+          # referred classpath elements may be missing
+          if FileTest.exist? acpe
+            add_element(JarClasspath.new(acpe)) 
+          end 
+        end
+      end
+
+      # Return false.
+      def jar?
+        false
+      end
+
+      # Return an empty array.
+      def additional_classpath
+        []
+      end
+
+      # Return the list of class names found in this classpath.
+      def names
+        @elements.collect { |e| e.names }.flatten.uniq
+      end
+
+      # Return if _classname_ is included in this classpath.
+      def includes?(classname)
+        @elements.find { |e| e.includes?(classname) } != nil
+      end
+
+      # Load the binary data of the file name or class name _classname_ from this classpath.
+      def load_binary(classname)
+        found = @elements.find { |e| e.includes?(classname) }
+        if (found)
+          return found.load_binary(classname)
+        end
+        raise "class #{classname} not found in classpath #{to_s}"
+      end
+
+      # Return the number of classes in this jar.
+      def count
+        @elements.inject(0) { |s,e| s + e.count }
+      end
+
+      def to_s
+        @elements.collect { |e| e.to_s }.join(',')
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classpath/folder_classpath.rb

@@ -0,0 +1,83 @@
+require 'javaclass/java_name'
+
+module JavaClass
+  module Classpath # :nodoc:
+    # Abstraction of a folder on the CLASSPATH.
+    # Author::   Peter Kofler
+    class FolderClasspath
+      # Return the list of classnames found in this _folder_ .
+      def initialize(folder)
+        @folder = folder
+        raise IOError, "folder #{@folder} not found" if !FileTest.exist? @folder
+        raise "#{@folder} is no folder" if !FileTest.directory? @folder
+        @classes = list_classes.collect { |cl| cl.to_javaname }
+      end
+
+      # Return false.
+      def jar?
+        false
+      end
+
+      # Return an empty array.
+      def additional_classpath
+        []
+      end
+
+      # Return the list of class names found in this folder.
+      def names
+        @classes.dup
+      end
+
+      # Return if _classname_ is included in this folder.
+      def includes?(classname)
+        @classes.include?(normalize(classname))
+      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 #{@folder}" unless includes?(classname)
+        File.open(File.join(@folder, normalize(classname)), 'rb') {|io| io.read }
+      end
+
+      # Return the number of classes in this folder.
+      def count
+        @classes.size
+      end
+
+      def to_s
+        @folder
+      end
+
+      def ==(other)
+        other.class == FolderClasspath && other.to_s == self.to_s
+      end
+
+      private
+
+      # Return the list of classnames (in fact file names) found in this folder.
+      def list_classes
+        current = Dir.getwd
+        begin
+          Dir.chdir @folder
+
+          list = Dir['**/*.class']
+
+        ensure
+          Dir.chdir current
+        end
+        list.sort
+      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'
+        else
+          classname
+        end
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classpath/jar_classpath.rb

@@ -0,0 +1,100 @@
+require 'zip/zipfilesystem'
+require 'javaclass/java_name'
+
+module JavaClass
+  module Classpath 
+    
+    # Abstraction of a ZIP or JAR on the CLASSPATH. 
+    # Author::   Peter Kofler
+    class JarClasspath
+      
+      # Return the list of classnames found in 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
+        end
+      end
+      
+      # Return if the given classpath element is a jar.
+      def jar?
+        @manifest != nil
+      end
+      
+      # Return list of additional classpath elements defined in the manifest of this jarfile.
+      def additional_classpath
+        if @manifest
+          cp = @manifest.gsub(/\s{4,}/, ' ').scan(/^(.*): (.*)\s*$/).find { |p| p[0] == 'Class-Path' }
+          if cp
+            cp[1].strip.split.collect { |jar| File.join(File.dirname(@jarfile), jar) }
+          else
+            []
+          end
+        else
+          []
+        end
+      end
+      
+      # Return the list of class names found in this jar.
+      def names
+        @classes.dup
+      end
+      
+      # Return if _classname_ is included in this jar.
+      def includes?(classname)
+        @classes.include?(normalize(classname))
+      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))
+        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
+      end
+      
+      private 
+      
+      # Return the list of classnames (in fact file names) found in this jarfile. 
+      def list_classes
+        list = []
+        Zip::ZipFile.foreach(@jarfile) do |entry|
+          name = entry.name
+          next unless entry.file? and name =~ /\.class$/ # class file
+          list << name 
+        end
+        list.sort
+      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'
+        else
+          classname
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classpath/java_home_classpath.rb

@@ -0,0 +1,40 @@
+require 'javaclass/classpath/jar_classpath'
+
+module JavaClass
+  module Classpath 
+    
+    # Abstraction of the Java boot CLASSPATH. May return additional classpath elements for endorsed libs. 
+    # Author::   Peter Kofler
+    class JavaHomeClasspath < JarClasspath
+      
+      # Return the list of classnames found in this _javahome_ . 
+      def initialize(javahome)
+        if FileTest.exist? rtjar=File.join(javahome, 'lib', 'rt.jar')
+          super(rtjar)
+        elsif FileTest.exist? rtjar=File.join(javahome, 'jre', 'lib', 'rt.jar')
+          super(rtjar)
+        else
+          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') 
+          current = Dir.getwd
+          Dir.chdir ext
+          
+          list += Dir['*.jar'].collect { |jar| File.join(ext, jar) }
+          
+          Dir.chdir current
+        end
+        list
+      end
+      
+    end
+    
+  end
+end