javaclass 0.0.3 → 0.0.4

data/lib/javaclass/classpath/composite_classpath.rb

@@ -1,98 +1,100 @@
 require 'javaclass/classpath/jar_classpath'
 require 'javaclass/classpath/folder_classpath'
+require 'javaclass/classpath/file_classpath'
 
 module JavaClass
-  module Classpath
-    # List of class path elements.
+
+  # The module Classpath is for separating namespaces. It contains the abstraction of classpath to load binary class file data from.
+  # It does not contain references to ClassFile::JavaClassHeader nor does it parse the classes. It just provides the binary data 
+  # (*.class files). A classpath is a composite containing classpath elements, e.g. libraries (JARs), folders, modules. It is low-level. 
+  # For an example see {how to count the number of classes in each module}[link:/files/lib/generated/examples/count_classes_in_modules_txt.html].
+  # Author::          Peter Kofler
+  module Classpath 
+
+    # List of class path elements constructed from a full _CLASSPATH_ variable.
     # Author::   Peter Kofler
-    class CompositeClasspath
-      # Return the list of classnames found in this path.
-      def initialize
+    class CompositeClasspath < FileClasspath
+
+      # Create an empty classpath composite root. The optional _file_ is for
+      # identifying subclasses.
+      def initialize(root='.')
+        super(root)
         @elements = []
       end
 
-      # Return the classpath elements of this path.
+      # Return all the classpath elements (the children) of this path and all child paths.
       def elements
-        @elements.dup
+        # [self] + */ 
+        @elements.map { |cp| cp.elements }.flatten
       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.
+      # Add the _name_ class path which may be a file or a folder to this classpath.
       def add_file_name(name)
-        if FileTest.directory? name
+        if FolderClasspath.valid_location?(name)
           add_element(FolderClasspath.new(name))
-        else
+        elsif JarClasspath.valid_location?(name)
           add_element(JarClasspath.new(name))
+        else
+          warn("tried to add an invalid classpath location #{name}")
         end
       end
 
       # Add the _elem_ classpath element to the list.
       def add_element(elem)
-        @elements << elem unless @elements.find { |cpe| cpe == elem }
+        if elem.count > 0 && !@elements.find { |cpe| cpe == elem }
+          @elements << elem
+        end
         elem.additional_classpath.each do |acpe|
           # referred classpath elements may be missing
-          if FileTest.exist? acpe
-            add_element(JarClasspath.new(acpe)) 
-          end 
+          if JarClasspath.valid_location?(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
+      # Return the list of class names found in this classpath. An additional block is used as _filter_ on class names.
+      def names(&filter)
+        @elements.collect { |e| e.names(&filter) }.flatten.uniq
       end
 
-      # Return if _classname_ is included in this classpath.
+      # Return if _classname_ is included in this classpath. If yes, return the count (usually 1).
       def includes?(classname)
-        @elements.find { |e| e.includes?(classname) } != nil
+        key = to_key(classname)
+        found = find_element_for(key)
+        if found then 1 else nil end
       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)
+        key = to_key(classname)
+        found = find_element_for(key)
+        unless found
+          raise ClassNotFoundError.new(key, to_s)
         end
-        raise "class #{classname} not found in classpath #{to_s}"
+        found.load_binary(key) 
       end
 
-      # Return the number of classes in this jar.
+      # Return the number of classes in this classpath.
       def count
         @elements.inject(0) { |s,e| s + e.count }
       end
 
       def to_s
-        @elements.collect { |e| e.to_s }.join(',')
+        str = super.to_s
+        if str=='.'
+          @elements.collect { |e| e.to_s }.join(',')
+        else
+          str
+        end
       end
 
+      private 
+
+      # Return the matching classpath element for the given _key_
+      def find_element_for(key)
+        @elements.find { |e| e.includes?(key) }
+      end
+      
     end
 
   end

data/lib/javaclass/classpath/convention_classpath.rb

@@ -0,0 +1,38 @@
+require 'javaclass/classpath/folder_classpath'
+require 'javaclass/classpath/jar_classpath'
+
+module JavaClass
+  module Classpath
+
+    # A Java project by naming convention, contains a classes and a lib folder.
+    # Author::   Peter Kofler
+    class ConventionClasspath < FolderClasspath
+
+      CLASSES = 'classes'
+      
+      # Check if the _file_ is a valid location.
+      def self.valid_location?(file)
+        FolderClasspath.valid_location?(file) &&
+        FolderClasspath.valid_location?(File.join(file, CLASSES))
+      end
+
+      # Create a classpath for _folder_ / classes.
+      def initialize(folder)
+        super(File.join(folder, CLASSES))
+        @root = folder
+      end
+
+      # Return list of additional classpath elements defined in the lib folder.
+      def additional_classpath
+        lib = File.join(@root, 'lib')
+        if FolderClasspath.valid_location?(lib)
+          Dir.entries(lib).map { |e| File.join(lib, e) }.find_all { |e| JarClasspath.valid_location?(e) }
+        else
+          []
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/javaclass/classpath/eclipse_classpath.rb

@@ -0,0 +1,74 @@
+require 'javaclass/classpath/composite_classpath'
+
+module JavaClass
+  module Classpath
+
+    # An Eclipse workspace aware classpath.
+    # Author::   Peter Kofler
+    class EclipseClasspath < CompositeClasspath
+
+      DOT_CLASSPATH = '.classpath'
+
+      # Check if the _file_ is a valid location for an Eclipse classpath.
+      def self.valid_location?(file)
+        FileTest.exist?(file) && FileTest.directory?(file) && FileTest.exist?(File.join(file, DOT_CLASSPATH))
+      end
+
+      # Add an Eclipse variable _name_ with _value to look up libraries.
+      def self.add_variable(name, value)
+        @@variables ||= Hash.new
+        @@variables.delete(name)
+        @@variables[name] = value if value
+      end
+
+      # Skip the lib containers if .classpath.
+      def self.skip_lib(flag=:skip)
+        @@skip_lib = flag
+      end
+
+      # Create a classpath for an Eclipse base project in _folder_ where the .classpath is.
+      def initialize(folder)
+        unless EclipseClasspath::valid_location?(folder)
+          raise IOError, "folder #{folder} not an Eclipse project"
+        end
+        dot_classpath = File.join(folder, DOT_CLASSPATH)
+        super(dot_classpath)
+        classpath = IO.readlines(dot_classpath)
+        
+        classpath.find_all { |line| line =~ /kind\s*=\s*"output"/ }.each do |line|
+          if line =~ /path\s*=\s*"([^"]+)"/
+            add_file_name(File.join(folder, $1))
+          end
+        end
+
+        classpath.find_all { |line| line =~ /output\s*=\s*"/ }.each do |line|
+          if line =~ /output\s*=\s*"([^"]+)"/
+            add_file_name(File.join(folder, $1))
+          end
+        end
+        
+        @@skip_lib ||= false
+        unless @@skip_lib
+        
+          classpath.find_all { |line| line =~ /kind\s*=\s*"lib"/ }.each do |line|
+            if line =~ /path\s*=\s*"([^"]+)"/
+              add_file_name(File.join(folder, $1))
+            end
+          end 
+          
+          @@variables ||= Hash.new
+          classpath.find_all { |line| line =~ /kind\s*=\s*"var"/ }.each do |line|
+            if line =~ /path\s*=\s*"([^\/]+)\/([^"]+)"/
+              path = @@variables[$1]
+              add_file_name(File.join(path, $2)) if path
+            end
+          end
+          
+        end
+      
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classpath/factory.rb

@@ -0,0 +1,65 @@
+require 'javaclass/classpath/java_home_classpath'
+require 'javaclass/classpath/composite_classpath'
+require 'javaclass/classpath/maven_classpath'
+require 'javaclass/classpath/eclipse_classpath'
+require 'javaclass/classpath/convention_classpath'
+
+module JavaClass
+  module Classpath
+
+    # Factory methods to create different kind of classpaths.
+    # Author::          Peter Kofler
+    module Factory
+      
+      # Parse the given path variable _path_ and return a chain of class path elements. 
+      # The path variable is separated by : or ; depending on the platform. 
+      # Adds the classpath to the optional _cp_ element else creates a CompositeClasspath.
+      def classpath(path, cp=CompositeClasspath.new)
+        path.split(File::PATH_SEPARATOR).each { |cpe| cp.add_file_name(cpe) } 
+        cp
+      end
+    
+      # Parse and set the system classpath. Needs +JAVA_HOME+ to be set. Uses additional environment 
+      # +CLASSPATH+ if set. Adds the classpath to the optional _cp_ element else creates a CompositeClasspath.
+      def environment_classpath(cp=CompositeClasspath.new)
+        full_classpath(ENV['JAVA_HOME'], ENV['CLASSPATH'], cp)
+      end
+    
+      # Parse the given path variable _path_ and return a chain of class path elements together with _javahome_ if any.
+      def full_classpath(javahome, path=nil, cp=CompositeClasspath.new)
+        cp.add_element(JavaHomeClasspath.new(javahome)) if javahome
+        cp = classpath(path, cp) if path
+        cp
+      end
+      
+      Classpath_types = [EclipseClasspath, MavenClasspath, ConventionClasspath]
+      
+      # Create a classpath from a workspace _basepath_ which contains Eclipse or Maven projects.
+      def workspace(basepath, cp=CompositeClasspath.new)
+        # check for a valid project in this folder
+        Classpath_types.each do |classpath_type|
+          if classpath_type.valid_location?(basepath)
+            cp.add_element(classpath_type.new(basepath))
+            return cp
+          end
+        end
+
+        # check the children as regular workspace
+        Dir.entries(basepath).each do |entry|
+          next if entry == '.' || entry == '..'
+          file = File.join(basepath, entry)
+
+          Classpath_types.each do |classpath_type|
+            if classpath_type.valid_location?(file)
+              cp.add_element(classpath_type.new(file))
+              break
+            end
+          end
+        end if FileTest.directory? basepath
+        cp
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classpath/file_classpath.rb

@@ -0,0 +1,47 @@
+require 'javaclass/classpath/class_not_found_error'
+
+module JavaClass
+  module Classpath
+
+    # Abstract concept of a classpath pointing to a file.
+    # Author::   Peter Kofler
+    class FileClasspath
+
+      # Create a classpath with this _root_ .
+      def initialize(root)
+        @root = root
+      end
+
+      # Return +false+ as this is no jar.
+      def jar?
+        false
+      end
+
+      # Return an empty array.
+      def additional_classpath
+        []
+      end
+
+      def to_s
+        @root.to_s
+      end
+
+      # Equality with _other_ delegated to to_s.
+      def ==(other)
+        other.class == self.class && other.to_s == self.to_s
+      end
+
+      # Return the classpath elements of this (composite) classpath      
+      def elements
+        [self]
+      end
+
+      # Return the key for the access of this class file named _classname_ .      
+      def to_key(classname)
+        classname.to_javaname.to_class_file
+      end
+      
+    end
+
+  end
+end

data/lib/javaclass/classpath/folder_classpath.rb

@@ -1,55 +1,55 @@
+require 'javaclass/classpath/file_classpath'
+require 'javaclass/java_language'
 require 'javaclass/java_name'
 
 module JavaClass
-  module Classpath # :nodoc:
-    # Abstraction of a folder on the CLASSPATH.
+  module Classpath
+
+    # Abstraction of a folder on the CLASSPATH. This is a leaf in the classpath tree.
     # 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
+    class FolderClasspath < FileClasspath
 
-      # Return false.
-      def jar?
-        false
+      # Check if the _file_ is a valid location for a folder classpath.
+      def self.valid_location?(file)
+        FileTest.exist?(file) && FileTest.directory?(file) 
       end
-
-      # Return an empty array.
-      def additional_classpath
-        []
+      
+      # Create a classpath with this _folder_ .
+      def initialize(folder)
+        super(folder)
+        unless FolderClasspath::valid_location?(folder)
+          raise IOError, "folder #{folder} not found/no folder"
+        end
+        @folder = folder
+        init_classes
       end
-
-      # Return the list of class names found in this folder.
-      def names
-        @classes.dup
+      
+      # Return the list of class names found in this folder. 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 folder.
       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.
+      # Load the binary data of the file name or class name _classname_ from this folder.
       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 }
+        key = to_key(classname)
+        unless includes?(key)
+          raise ClassNotFoundError.new(key, @folder)
+        end
+        File.open(File.join(@folder, key), 'rb') { |io| io.read.freeze }
       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
+        @class_names.size
       end
 
       private
@@ -60,23 +60,21 @@ module JavaClass
         begin
           Dir.chdir @folder
 
-          list = Dir['**/*.class']
+          list = Dir["**/*#{JavaLanguage::CLASS}"]
 
         ensure
           Dir.chdir current
         end
-        list.sort
+        list
       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
+      # Set up the class names.
+      def init_classes
+        @class_names = list_classes.sort.reject { |n| n =~ /package-info\.class$/ }.collect { |cl| JavaClassFileName.new(cl) } 
+        pairs = @class_names.map { |name| [name.file_name, 1] }.flatten
+        @class_lookup = Hash[ *pairs ] # file_name (String) => anything
       end
-
+      
     end
 
   end