javaclass 0.0.3 → 0.0.4

data/examples/find_all_imported_types.rb

@@ -0,0 +1,44 @@
+# Example usage of the class analysis featuress of JavaClass::ClassScanner and JavaClass::Analyse. 
+# After defining a classpath, use dependency analysis to find all used classes of a codebase. 
+# This code uses in turn the method <i>imported_3rd_party_types</i> of 
+# JavaClass::ClassScanner::ImportedTypes to find all imported classes.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+
+#--
+# add the lib of this gem to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), 'corpus')
+
+location = Corpus[:Lib]
+prod_location = File.join(location, '..', 'classes')
+test_location = File.join(location, 'classes')
+conf_location = location
+#++
+require 'javaclass/dsl/mixin'
+
+# 1) create the classpath of production classes
+cp = classpath(prod_location)
+
+# 2) remember all types defined on this classpath from JavaClass::Analyse::Dependencies 
+prod_classnames = cp.types
+
+# 3) collect all dependencies of all classes defined there
+imported_classnames = cp.used_types
+
+# 4) also collect all classes referenced from config files, defined in JavaClass::JavaNameScanner
+hardcoded_classnames = scan_config_for_3rd_party_class_names(conf_location)
+
+# 5) now we know all classes imported/used by production classes
+puts '---------- used 3rd party types in production'
+used_classnames = (imported_classnames + hardcoded_classnames).uniq.sort  - prod_classnames
+puts used_classnames
+
+# 6) do the same for test classes, at least org.junit.* should show up here
+test_cp = classpath(test_location)
+puts '---------- used 3rd party types only in tests'
+test_classes = test_cp.external_types - prod_classnames - used_classnames
+puts test_classes

data/examples/find_referenced_modules.rb

@@ -0,0 +1,53 @@
+# Example usage of JavaClass::Classpath and JavaClass::Classpath::TrackingClasspath: 
+# Use the classes of one module and mark all their dependencies. Then find all modules 
+# which were not referenced. This list contains *potential* unused libraries (modules). 
+# Note that the libraries may still be used by reflection or internal from other libraries.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+
+#--
+# add the lib of this gem to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), 'corpus')
+
+location = Corpus[:HBD]
+location = Corpus[:RCP]
+location = Corpus[:BIA]
+
+main_location = File.join(location, 'classes')
+test_location = File.join(location, 'test-classes')
+#++
+require 'javaclass/dsl/mixin'
+
+# 1) create a classpath of the main module(s) under test
+main_classpath = classpath("#{main_location};#{test_location}")
+puts "#{main_classpath.count} classes found in main classpath:"
+puts "  #{main_classpath.elements.join("\n  ")}"
+
+# 2) mix in JavaClass::Classpath::TrackingClasspath before creating any new classpaths
+require 'javaclass/classpath/tracking_classpath'
+
+# 3) create the (tracking) composite classpath of the given workspace
+cp = workspace(location)
+puts "#{cp.elements.size} classpaths found under the workspace #{location}"
+puts "  #{cp.elements.join("\n  ")}"
+puts "#{cp.count} classes found in classpaths"
+
+# 4) mark all their referenced types as accessed in the workspace
+puts 'mapping referenced classes... (can take several minutes)'
+cp.reset_access
+main_classpath.external_types.each { |clazz| cp.mark_accessed(clazz) }
+puts 'referenced classes mapped'
+
+# 5a) now find non accessed modules/libraries (i.e. classpath elements)
+unused = cp.elements.find_all { |clp| clp.jar? && clp.accessed == 0 }
+puts "\n#{unused.size} unused modules found:\n  #{unused.join("\n  ")}"
+
+# 5b) or print the list of classpath elements (e.g. JARs) with their access
+puts "\nlibrary (module path): number of accessed classes"
+puts cp.elements.map { |clp| [clp.to_s, clp.accessed] }.
+                 sort { |a,b| a[1] <=> b[1] }.
+                 map { |e| "  #{e[0]}: #{e[1]}" }

data/examples/find_unreferenced_classes.rb

@@ -0,0 +1,65 @@
+# Advanced example usage of JavaClass::Classpath::TrackingClasspath. Load all 
+# classes of an Eclipse workspace. Then mark all referenced classes. In the end 
+# report remaining classes as unreferenced. This lists *potential* unused classes. 
+# Note that the classes may still be used by reflection.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+
+#--
+# add the lib of this gem to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), 'corpus')
+
+location = Corpus[:RCP]
+package1 = 'com.ibm.arc.sdm'
+package2 = 'pricingTool'
+#++
+require 'javaclass/dsl/mixin'
+require 'javaclass/classpath/tracking_classpath'
+
+# speed up loading by skipping non source file classpaths
+Eclipse.skip_lib
+
+# 1) create the (tracking) composite classpath of the given workspace
+cp = workspace(location)
+puts "#{cp.elements.size} classpaths found under the workspace #{location}:"
+puts "  #{cp.elements.join("\n  ")}"
+
+# create a filter to limit all operations to the classes of two base packages
+filter = Proc.new { |clazz| clazz.same_or_subpackage_of?(package1) || 
+                            clazz.same_or_subpackage_of?(package2) }
+
+# 2) load all classes in the given packages
+puts 'loading all *filtered* classes... (can take several minutes)'
+classes = cp.values(&filter)
+puts "#{classes.size} classes loaded from classpaths"
+
+# 3) mark all referenced types in the given packages as accessed
+cp.reset_access
+classes.map { |clazz| clazz.imported_types }.
+        flatten.
+        find_all(&filter).
+        each { |classname| cp.mark_accessed(classname) }
+puts '*filtered* classes mapped'
+
+# 4) also mark all classes referenced from config files (e.g. hardcoded class names)
+hardcoded_classnames = scan_config_for_3rd_party_class_names(location).find_all(&filter)
+puts "#{hardcoded_classnames.size} classes references found in configs"
+hardcoded_classnames.each { |classname| cp.mark_accessed(classname) }
+puts 'hardcoded classes mapped'
+
+# 5) mark unit tests (all classes ending in Test) on the test projects (classpath elements ending in .test)
+test_projects = cp.elements.find_all { |cpe| cpe.to_s =~ /\.test\// }
+test_projects.each do |project|
+  project.names { |classname| classname =~ /Test(?:Case|Suite|s)?\.class/ }.
+          each { |classname| project.mark_accessed(classname) }
+end
+puts 'test classes mapped'
+
+# 6) find non accessed classes in specific packages and report them
+unused_classes = classes.find_all { |clazz| cp.accessed(clazz) == 0 }
+report = unused_classes.map { |clazz| "#{clazz.to_classname}" }
+puts "#{report.size} unused classes found:\n  #{report.join("\n  ")}"

data/examples/generate_class_lists.rb

@@ -1,61 +1,85 @@
+# Generate a JavaClass::ClassList, which contains all class 
+# names with version numbers when introduced. The list is created 
+# iterating all JDKs, opening the RT.jars and loading all classes.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Usage
+
+#--
+# add the lib of this gem to the load path
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'javaclass/classlist/list'
+#++
 require 'javaclass/classlist/jar_searcher'
-
-# Generate the full class lists starting from a saved one.
-# Author::          Peter Kofler
-puts "create full class lists for JDKs (by search and open class)"
+require 'javaclass/classpath/jar_classpath'
+require 'javaclass/classlist/list'
 
 # Struct to keep configuration what kind of JDK classes should be searched and added.
 JDK_CONFIG = Struct.new(:version, :label, :paths)
-# Define information about JDK to process one after another.
+
+#--
+# Windows 7 configuration for 32bit Sun/Oracle JVMs
+PROGRAMS = 'C:\Program Files (x86)\Java'
 JDKS = [
-  JDK_CONFIG.new(0, "1.0.2",    ['E:\Develop\Java\Compiler\jdk1.0.2\lib']),
-  JDK_CONFIG.new(1, "1.1.8-09", ['E:\Develop\Java\Compiler\jdk1.1.8\lib', 'E:\Develop\Java\JDK-1.1\Library\swing-1.1.1\lib']),
-  JDK_CONFIG.new(2, "1.2.2-13", ['C:\Programme\Java\jdk1.2.2_13\jre\lib', 'C:\Programme\Java\jdk1.2.2_13\lib\dt.jar']),
-  JDK_CONFIG.new(3, "1.3.1-08", ['C:\Programme\Java\jdk1.3.1_08\jre\lib', 'C:\Programme\Java\jdk1.3.1_08\lib\dt.jar']),
-  JDK_CONFIG.new(4, "1.4.2-03", ['C:\Programme\Java\jdk1.4.2_03\jre\lib', 'C:\Programme\Java\jdk1.4.2_03\lib\dt.jar']),
-  JDK_CONFIG.new(5, "1.5.0-07", ['C:\Programme\Java\jdk1.5.0_07\jre\lib', 'C:\Programme\Java\jdk1.5.0_07\lib\dt.jar']),
-  JDK_CONFIG.new(6, "1.6.0-11", ['C:\Programme\Java\jdk1.6.0_21\jre\lib', 'C:\Programme\Java\jdk1.6.0_21\lib\dt.jar']),
-  #JDK_CONFIG.new(7, "1.7.0-xx", ['C:\Programme\Java\jdk1.7.0_xx\jre\lib']),
+  JDK_CONFIG.new(0, '1.0.2',    ['E:\Develop\Java\Compiler\jdk1.0.2\lib']),
+  JDK_CONFIG.new(1, '1.1.8-09', ['E:\Develop\Java\Compiler\jdk1.1.8\lib', 'E:\Develop\Java\JDK-1.1\Library\swing-1.1.1\lib']),
+  JDK_CONFIG.new(2, '1.2.2-13', [PROGRAMS + '\jdk1.2.2_13\jre\lib', PROGRAMS + '\jdk1.2.2_13\lib\dt.jar']),
+  JDK_CONFIG.new(3, '1.3.1-08', [PROGRAMS + '\jdk1.3.1_08\jre\lib', PROGRAMS + '\jdk1.3.1_08\lib\dt.jar']),
+  JDK_CONFIG.new(4, '1.4.2-03', [PROGRAMS + '\jdk1.4.2_03\jre\lib', PROGRAMS + '\jdk1.4.2_03\lib\dt.jar']),
+  JDK_CONFIG.new(5, '1.5.0-07', [PROGRAMS + '\jdk1.5.0_07\jre\lib', PROGRAMS + '\jdk1.5.0_07\lib\dt.jar']),
+  JDK_CONFIG.new(6, '1.6.0-26', [PROGRAMS + '\jdk1.6.0_26\jre\lib', PROGRAMS + '\jdk1.6.0_26\lib\dt.jar']),
+  JDK_CONFIG.new(7, '1.7.0',    [PROGRAMS + '\jdk1.7.0\jre\lib',    PROGRAMS + '\jdk1.7.0\lib\dt.jar']),
 ]
+#++
+# configuration for some JDKs
+#  JDKS = [ JDK_CONFIG.new(...), ... ]
 
-BASE_NAME = 'fullClassList'
-
-# Create a new list
-@list = JavaClass::ClassList::List.new
-
-# load already good list if we do not start with JDK 1.0
-if JDKS[0].version > 0
-  old_version = JDKS[0].version-1
-  old_class_list_name = Dir["./#{BASE_NAME}?#{old_version}?.txt"].first
-  if FileTest.exist?(old_class_list_name)
-    puts "loading #{old_version}"
-    IO.readlines(old_class_list_name).each {|line| @list.parse_line(line, old_version) }
-  end
-end
+# 1) create a JavaClass::ClassList::JarSearcher
+JavaClass.unpack_jars!(:unpack)
+searcher = JavaClass::ClassList::JarSearcher.new
 
-# init the searcher
-@searcher = JavaClass::ClassList::JarSearcher.new
-@searcher.filters = %w[sun/ sunw/ com/sun/ netscape/ COM/rsa/ quicktime/ com/apple/mrj/macos/carbon/ org/jcp/xml/dsig/internal/]
+# 2) filter out unwanted classes, e.g. vendor classes
+searcher.filters = %w[sun/ sunw/ com/oracle/ com/sun/ netscape/ COM/rsa/ 
+         quicktime/ com/apple/mrj/macos/carbon/ org/jcp/xml/dsig/internal/]
+#--
 # netscape ... applet js security [2]
 # COM/rsa/ ... jsafe [4]
 # quicktime ... quicktime [5]
 # org/jcp/xml/dsig/internal ... xml dsig [6]
+# com/oracle/ ... com.oracle.net.Sdp [7]
+
+Dir.mkdir './ClassLists' unless File.exist? './ClassLists'
+#++
 
-#Dir.mkdir './ClassLists' unless File.exist? './ClassLists'
+# 3) create a new JavaClass::ClassList::List to contain the classes
+list = JavaClass::ClassList::List.new
 
-# Work on all lists defined in +JDK+ and yield the block with the jdk label and the class list.
+#--
+# load an already good list if we do not start with JDK 1.0
+if JDKS[0].version > 0
+  full_class_list_version = JDKS[0].version - 1
+  full_class_list = "fullClassList1#{full_class_list_version}0.txt"
+  IO.readlines(full_class_list).each {|line| list.parse_line(line, full_class_list_version) }
+  puts "loaded full class list #{full_class_list} with versions #{list.version}"
+end
+#++
+
+# Work on all lists defined in +JDKS+, add to the list and write list files.
 JDKS.each do |conf|
-  puts "processing #{conf.version}"
-  conf.paths.each { |p| @list = @searcher.compile_list(conf.version, p, @list) }
-  
-  #basename = "jdk#{conf.label.gsub(/\./, '')}"
-  #File.open("./ClassLists/#{basename}_new_package_classes.txt", "w") { |f| f.print @list.old_access_list.collect{|m| m.sub(/\s.*$/, '')} }
-  #File.open("./ClassLists/#{basename}_all_classes.txt", "w") { |f| f.print @list.plain_class_list }
-  #File.open("./ClassLists/#{basename}_all_public_classes.txt", "w") { |f| f.print @list.plain_class_list { |c| c.public? } }
-  #File.open("./ClassLists/#{basename}_new_public_classes.txt", "w") { |f| f.print @list.plain_class_list { |c| c.public? and c.version.first == conf.version } }
-  
+  # 4) iterate JARs and compile a list
+  conf.paths.each { |p| list = searcher.compile_list(conf.version, p, list) }
+
+  # 5) save various kind of lists
+  basename = "./ClassLists/jdk#{conf.label.gsub(/\./, '')}"
+  File.open("#{basename}_new_package_classes.txt", "w") { |f| f.print list.old_access_list.collect{|m| m.sub(/\s.*$/, '')} }
+  File.open("#{basename}_all_classes.txt", "w") { |f| f.print list.plain_class_list }
+  File.open("#{basename}_all_packages.txt", "w") { |f| f.print list.to_s }
+  File.open("#{basename}_all_public_classes.txt", "w") { |f| f.print list.plain_class_list { |c| c.public? } }
+  File.open("#{basename}_new_public_classes.txt", "w") { |f| f.print list.plain_class_list { |c| c.public? and c.version.first == conf.version } }
+
   baseversion = conf.label.gsub(/\.|-.+$/, '')
-  File.open("./#{BASE_NAME}#{baseversion}.txt", "w") { |f| f.print @list.full_class_list }
+  File.open("./fullClassList#{baseversion}.txt", "w") { |f| f.print list.full_class_list }
+
+  puts "processed #{conf.label}"
 end

data/examples/profiler_scratchpad.rb

@@ -0,0 +1,33 @@
+# :nodoc:
+# Scratchpad script for profiler execution.
+
+require 'ruby-prof'
+
+# add the lib of this gem to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'javaclass/dsl/mixin'
+require File.join(File.dirname(__FILE__), 'corpus')
+
+location = File.join(Corpus[:BIA], 'classes')
+
+# 1) create a classpath of the given workspace
+#RubyProf.start
+cp = classpath(location)
+puts "#{cp.elements.size} classpaths found under the workspace #{location}:\n  #{cp.elements.join("\n  ")}"
+puts "#{cp.count} classes found in classpaths"
+#result = RubyProf.stop
+
+# 2) load all classes
+RubyProf.start
+cp.values
+result = RubyProf.stop
+
+# 3) iterate all constant pool entries
+#RubyProf.start
+# workspace.external_types
+#result = RubyProf.stop
+
+# Print a flat profile to text
+printer = RubyProf::GraphPrinter.new(result)
+# printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT)

data/examples/simple_usage.rb

@@ -0,0 +1,42 @@
+# Example of basic usage of JavaClass to load and inspect class files.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.       
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Usage
+
+#--
+# add the lib of this gem to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+#++
+# 1) require the basic module
+require 'javaclass'
+
+# 2a) load a class directly from the file system
+clazz = JavaClass.load_fs('./test/data/access_flags/AccessFlagsTestPublic.class')
+
+# 2b) or get a class from the system classpath which needs _JAVA_HOME_ to be set
+cp = JavaClass.environment_classpath
+puts cp.includes?('java/lang/String.class') # => 1 (true)
+
+# 2c) or look up the class from some JavaClass::Classpath by its Java qualified name
+cp = JavaClass.classpath('./test/data/access_flags')
+puts cp.includes?('AccessFlagsTestPublic')  # => 1 (true)
+clazz = JavaClass.load_cp('AccessFlagsTestPublic', cp)
+
+# 3) then retrieve low level information about the class
+puts clazz.version                          # => "50.0"
+puts clazz.constant_pool.items[1]           # => "packagename/AccessFlagsTestPublic"
+puts clazz.access_flags.public?             # => true
+puts clazz.access_flags.final?              # => false
+puts clazz.this_class                       # => "packagename/AccessFlagsTestPublic"
+puts clazz.super_class                      # => "java/lang/Object"
+puts clazz.super_class.to_classname         # => "java.lang.Object"
+puts clazz.references.referenced_methods[0] # => "java/lang/Object.<init>:()V"
+puts clazz.interfaces                       # => []
+
+# Returned class names are not just Strings, but JavaClass::JavaQualifiedName
+puts clazz.this_class.to_java_file          # => "packagename/AccessFlagsTestPublic.java"
+puts clazz.this_class.full_name             # => "packagename.AccessFlagsTestPublic"
+puts clazz.this_class.package               # => "packagename"
+puts clazz.this_class.simple_name           # => "AccessFlagsTestPublic"

data/history.txt

@@ -1,9 +1,31 @@
+=== 0.0.4 19/12/2011
+
+* convert examples to RDOC using example_task
+* added transitive dependency trees from references
+* patched the rubyzip for invalid flags found in some JARs
+* add some examples
+* fixed generate_class_lists.rb
+* finish first version of DSL with loading/values
+* added Eclipse project aware classpath
+* added Maven aware classpath
+* added ZipFile abstraction over rubyzip gem
+* added class scanning "framework" and imported types Scanners
+* added CachingClasspath
+* added usage of system 7za/unzip (if available) which unpack much faster
+* added option to unpack JARs for faster access later
+* added support for Java Enum and Annotations
+* added DSL like shortcuts for java.* and javax.* package and class names.
+* added interfaces implemented by the class
+* fixed string ux problem in Ruby 1.9
+* replaced leading 0 in exponent of float/double because of Linux printf
+* split Gemspec from Rakefile as proposed by Yeguda Katz
+
 === 0.0.3 02/10/2010
 
 * integrated ClassList from another project as first analyser
-* add JavaName to all class names that are returned
-* fix links in RDoc, update documentation
-* move classes into submodules for classpath, classfile, etc.
+* added abstraction of Java names to all class names that are returned
+* fixed links in RDoc, update documentation
+* moved classes into submodules for classpath, classfile, etc.
 * migrated to Google Code and Mercurial repository
 * added access flag $1000
 * added references to used classes
@@ -14,10 +36,10 @@
 * refactored code to smaller objects for version and constant pool
 * fixed float and double constant pool items
 * added tests
-* continued implementation with class names and references
+* added implementation with class name and references of a class file
 
 === 0.0.1 01/03/2009
-	
-* initial version extracted from ClassList project
+
+* extracted initial version of javaclass-rb from ClassList project
 * reads the class version and package/public flag of a class
-* understands the constant pool but does not use it
+* understands the constant pool of class file but does not use it

data/javaclass.gemspec

@@ -0,0 +1,31 @@
+GEM_NAME = 'javaclass'
+GOOGLE_PROJECT = "#{GEM_NAME}-rb"
+
+Gem::Specification.new do |s|
+  s.version = '0.0.4'
+  s.name = GEM_NAME
+  s.rubyforge_project = 'javaclass' # old, just redirects
+  s.summary = 'A parser and disassembler for Java class files'
+  s.description = 'Provides access to the package, protected, and public fields and methods of the classes passed to it together with a list of all outgoing references.'
+  s.license = 'BSD'
+  s.homepage = "http://code.google.com/p/#{GOOGLE_PROJECT}/"
+  s.author = 'Peter Kofler'
+  s.email = 'peter dot kofler at code minus cop dot org'
+  s.date = Time::gm(2011, 12, 19)
+
+  s.files = Dir.glob('*.txt') + Dir.glob('{lib,test,examples}/**/*') + ['javaclass.gemspec', 'Rakefile', 'example_task.rb']
+  s.test_files = Dir.glob('test/**/test_*.rb')
+  s.require_path = 'lib'
+  s.add_dependency('rubyzip', '>= 0.9.1')
+  s.required_ruby_version = '>= 1.8.6'
+  s.required_rubygems_version = nil if s.respond_to? :required_rubygems_version=
+  s.platform = Gem::Platform::RUBY
+  s.add_development_dependency('rake', '>= 0.8.4')
+  s.add_development_dependency('rcov', '>= 0.8.1.2')
+  # s.add_development_dependency('ZenTest', '>= 4.4.0')
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = Dir.glob('*.txt')
+  s.rdoc_options << '--title' << "#{s.name}-#{s.version} Documentation" <<
+                    '--main' << 'Readme.txt'
+end

data/lib/javaclass/adder_tree.rb

@@ -0,0 +1,92 @@
+# A node in the AdderTree. 
+# Author::          Peter Kofler
+class AdderTreeNode
+
+  attr_reader :parent
+  attr_reader :data
+
+  def initialize(data, parent)
+    @data = data
+    @parent = parent
+    @children = []
+  end
+
+  def children
+    @children.dup
+  end
+
+  def add(o)
+    node = AdderTreeNode.new(o, self)
+    @children << node
+    node
+  end
+
+  def contain?(o)
+    if @data == o
+      self
+    else
+      @children.find { |child| child.contain?(o) }
+    end
+  end
+
+  def level
+    @parent.level + 1
+  end
+
+  def root
+    @parent.root
+  end
+
+  # Return the number of nodes this this (sub-)tree.
+  def size
+    @children.inject(1) { |sum, child| sum + child.size }
+  end
+
+  def levels
+    ( [1] + @children.map { |child| 1 + child.levels } ).max
+  end
+
+  # Return an array of all children. Each child has its own array. For example
+  #  tree = AdderTree.new(0)
+  #  tree.add(1)
+  #  tree.to_a               # => [0, [1]]
+  def to_a
+    if @children.size > 0
+      sublist = []
+      @children.each { |child| child.to_a.each { |c| sublist << c } } 
+      [data, sublist]
+    else
+      [data]
+    end
+  end
+
+  # Prints the tree to the console. Each level of the tree is intended by a blank.
+  def debug_print
+    puts ' ' * level + data
+    @children.each { |child| child.debug_print }
+  end
+  
+end
+
+# The root node of the adder tree. The "adder tree" is a simple add-only tree. 
+# Once the tree is build it can't be changed. Only new elements can be added. 
+# The tree's main functionality is defined in AdderTreeNode.
+# Author::          Peter Kofler
+class AdderTree < AdderTreeNode
+
+  attr_reader :parent
+  attr_reader :data
+
+  def initialize(data)
+    super(data, nil)
+  end
+
+  def level
+    0
+  end
+
+  def root
+    self
+  end
+
+end

data/lib/javaclass/analyse/dependencies.rb

@@ -0,0 +1,52 @@
+module JavaClass
+
+  # The module Analyse is for separating namespaces. It contains various methods
+  # to analyse classes accross a whole whole code bases (Classpath). The functionality
+  # of all analysers is collected in Dsl::ClasspathAnalysers.
+  # Author::          Peter Kofler
+  module Analyse
+
+    # Analyser to get dependencies of a whole Classpath (to be mixed into Dsl::LoadingClasspath). 
+    # For an example see 
+    # {how to list all imported types}[link:/files/lib/generated/examples/find_all_imported_types_txt.html].
+    # Author::          Peter Kofler
+    module Dependencies
+
+      # Return all types in this classpath. An additional block is used as _filter_ on class names.
+      # Returns a list of JavaQualifiedName. Requires a method _names_ in the base class.
+      def types(&filter)
+        names(&filter).collect { |c| c.to_classname }.sort
+      end
+
+      # Determine all imported types from all classes in this classpath together with count of imports.
+      # An additional block is used as _filter_ on class names. Requires a method _values_ in the base class.
+      def used_types_map(&filter)
+        type_map = Hash.new(0) # class_name (JavaQualifiedName) => cnt
+        values(&filter).collect { |clazz| clazz.imported_3rd_party_types }.flatten.each do |type|
+
+          # hash keys need to be frozen to keep state
+          if !type_map.include?(type)
+            type = type.freeze 
+          end
+
+          type_map[type] += 1
+        end
+        type_map
+      end
+
+      # Determine all imported types from all classes in this classpath.
+      # An additional block is used as _filter_ on class names.
+      def used_types(&filter)
+        used_types_map(&filter).keys.sort
+      end
+      
+      # Determine all foreign imported types from all classes in this classpath.
+      # An additional block is used as _filter_ on class names.
+      def external_types(&filter)
+        used_types(&filter) - types(&filter)
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/{metric/metrics.txt → analyse/ideas.txt}

@@ -1,4 +1,4 @@
-=== Metrics
+=== Metrics/Analysis across a whole classpath
  
  * "metric" if all referencing classes of a class is another package, propose moving it there.
  * "Greed Detector"
@@ -6,7 +6,7 @@
   * which signatures are called how often
   * maybe move current method there?
   * CRSS Metric
-  * CCD
+  * CCD: lazy init, classpath sits inside the analyser and works recursively through all elements
 
  * {Chidamber and Kemerer Java Metrics (ckjm)}[http://www.spinellis.gr/sw/ckjm/]
  * {The CRSS Metric for Package Design Quality}[http://crpit.com/confpapers/CRPITV62Melton2.pdf]

data/lib/javaclass/analyse/transitive_dependencies.rb

@@ -0,0 +1,52 @@
+require 'javaclass/adder_tree'
+
+module JavaClass
+  module Analyse
+
+    # Transitive dependency analysis to be mixed into Dsl::LoadingClasspath. For an example see
+    # {how to get cumulative dependencies of a class}[link:/files/lib/generated/examples/cumulative_dependencies_txt.html].
+    # For plain dependencies of a Classpath see Dependencies. 
+    # Author::          Peter Kofler
+    module TransitiveDependencies
+
+      # Creates the tree of all transitive dependencies of _classname_ where every dependency is only 
+      # listed once at its first occurence. It returns an AdderTree containing all found dependencies.
+      # An additional block is used as _filter_ on class names to work with, e.g. the main classes.
+      # Requires methods <i>includes?</i> and _load_ in the base class.
+      def transitive_dependency_tree(classname, tree=nil, &filter)
+        return if block_given? && !filter.call(classname) 
+        return if tree && tree.root.contain?(classname)
+        
+        if tree
+          tree = tree.add(classname.to_classname)
+        else
+          tree = AdderTree.new(classname.to_classname)
+        end
+
+        if includes?(classname)
+          load(classname).imported_3rd_party_types.each do |classname|
+            transitive_dependency_tree(classname, tree, &filter)
+          end
+        end
+        
+        tree
+      end
+
+      # Creates the tree of all transitive dependencies of the Java _package_ where every dependency is only 
+      # listed once at its first occurence. It returns an AdderTree containing all found dependencies.
+      # An additional block is used as _filter_ on class names to work with, e.g. the main classes.
+      # Requires a method _names_ in the base class.
+      def transitive_dependencies_package(package, &filter)
+        tree = AdderTree.new(package)
+
+        names { |classname| classname.same_or_subpackage_of?(package) }.each do |classname| 
+          transitive_dependency_tree(classname, tree, &filter)
+        end
+        
+        tree
+      end
+      
+    end
+
+  end
+end