javaclass 0.4.1 → 0.4.2

data/examples/generate_class_lists.rb

@@ -22,8 +22,8 @@ JDK_CONFIG = Struct.new(:version, :label, :paths)
 # 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(0, '1.0.2',    [PROGRAMS + '\jdk1.0.2\lib']),
+  JDK_CONFIG.new(1, '1.1.8-09', [PROGRAMS + '\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']),
@@ -31,6 +31,7 @@ JDKS = [
   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']),
   JDK_CONFIG.new(8, '1.8.0',    [PROGRAMS + '\jdk1.8.0_25\jre\lib', PROGRAMS + '\jdk1.8.0_25\lib\dt.jar']),
+  JDK_CONFIG.new(9, '9.0.4',    [PROGRAMS + '\open_jdk9.0.4-1\jmods', PROGRAMS + '\open_jdk9.0.4-1\lib\jrt-fs.jar']),
 ]
 #++
 # configuration for some JDKs
@@ -39,16 +40,22 @@ JDKS = [
 # 1) create a JavaClass::ClassList::JarSearcher
 JavaClass.unpack_jars!(:unpack)
 searcher = JavaClass::ClassList::JarSearcher.new
+searcher.skip_inner_classes = false
+searcher.skip_package_classes = true
 
 # 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/]
+searcher.filters = %w[sun/ sunw/ com/oracle/ com/sun/ netscape/ com/rsa/ 
+         quicktime/ com/apple/mrj/macos/carbon/ org/jcp/xml/dsig/internal/
+         oracle/jrockit/ jdk/internal/ jdk/nashorn/internal/
+         jdk/dynalink/internal/ jdk/incubator/http.internal/ jdk/javadoc/internal/ jdk/tools/jlink/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]
+# oracle/jrockit/ jdk/internal/ jdk/nashorn/internal/ [8]
+# jdk/dynalink/internal/ jdk/incubator/http.internal/ jdk/javadoc/internal/ jdk/tools/jlink/internal/ [9]
 
 Dir.mkdir './ClassLists' unless File.exist? './ClassLists'
 #++
@@ -73,14 +80,14 @@ JDKS.each do |conf|
 
   # 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}_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 } }
+  File.open("#{basename}_all_public_classes.txt", "w") { |f| f.print list.plain_class_list { |c| c.public? }.join() }
+  File.open("#{basename}_new_public_classes.txt", "w") { |f| f.print list.plain_class_list { |c| c.public? and c.version.first == conf.version }.join() }
 
   baseversion = conf.label.gsub(/\.|-.+$/, '')
-  File.open("./fullClassList#{baseversion}.txt", "w") { |f| f.print list.full_class_list }
+  File.open("./fullClassList#{baseversion}.txt", "w") { |f| f.print list.full_class_list.join() }
 
   puts "processed #{conf.label}"
 end

data/history.txt

@@ -1,12 +1,23 @@
+=== 0.4.2 16/09/2020
+
+* fix license text and name
+* tested with GitHub actions for Ruby 2.1 to 2.7
+* fix some warnings shown by Ruby 2.1
+* moved code to GitHub
+* added outer class name for inner classes
+* added new constant pool tags and access modifier for Java 9
+* added method handle and invoke dynamic constant pool tags for Java 8
+* parse class attributes: source file and inner classes
+
 === 0.4.1 30/05/2015
 
 * make compatible with Ruby 2.0
 * upgrade rubyzip to 1.x (still supports 0.x as well)
 * moved code to Bitbucket, moved API doc to code-cop.org
-* Cloudbees dropped support for Ruby 1.8.6 and 1.8.7 - not testet there anymore
+* Cloudbees dropped support for Ruby 1.8.6 and 1.8.7 - not tested there any more
 * add plain class Node for dependency graph
 * add dependency graph and classpath (module/component/plugin) implementation
-* add Maven artefact to generate classpath from group/name/version
+* add Maven artifact to generate classpath from group/name/version
 * change version number from micro to minor which more proper reflects code
 * fix some warnings shown by Ruby 1.9.1
 
@@ -14,7 +25,7 @@
 
 * convert examples to RDOC using example_task
 * added transitive dependency trees from references
-* patched the rubyzip for invalid flags found in some JARs
+* patched the rubyzip gem for invalid flags found in some JARs
 * add some examples
 * fixed generate_class_lists.rb
 * finish first version of DSL with loading/values
@@ -37,7 +48,7 @@
 * integrated ClassList from another project as first analyser
 * 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.
+* moved classes into sub modules for classpath, class file, etc.
 * migrated to Google Code and Mercurial repository
 * added access flag $1000
 * added references to used classes

data/javaclass.gemspec

@@ -1,17 +1,18 @@
 GEM_NAME = 'javaclass'
-HG_PROJECT = "#{GEM_NAME}-rb"
+GIT_PROJECT = "#{GEM_NAME}-rb"
 
 Gem::Specification.new do |s|
-  s.version = '0.4.1'
+  s.version = '0.4.2'
   s.name = GEM_NAME
-  s.rubyforge_project = 'javaclass' # old, just redirects
+  s.rubyforge_project = 'javaclass' if s.respond_to? :rubyforge_project=
+  # Gem::Specification#rubyforge_project= is deprecated with no replacement in 2.7
   s.summary = 'Java class files parser and disassembler for Ruby'
   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 = "https://bitbucket.org/pkofler/#{HG_PROJECT}"
+  s.license = 'BSD-2-Clause'
+  s.homepage = "https://github.com/codecop/#{GIT_PROJECT}"
   s.author = 'Peter Kofler'
   s.email = 'peter dot kofler at code minus cop dot org'
-  s.date = Time::gm(2015, 5, 30) # set current date for release
+  s.date = Time::gm(2020, 9, 16) # set current date for release
 
   s.files = Dir.glob('*.txt') + Dir.glob('{lib,test,examples}/**/*') + ['javaclass.gemspec', 'Rakefile'] + Dir.glob('rake_*.rb') + Dir.glob('dev/*_task.rb')
   s.test_files = Dir.glob('test/**/test_*.rb')
@@ -20,12 +21,13 @@ Gem::Specification.new do |s|
   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.3')
+  # s.add_development_dependency('rake', '>= 0.8.3')
   # s.add_development_dependency('rcov', '>= 0.8.1.2')
   # s.add_development_dependency('saikuro', '>= 1.2.1')
   # s.add_development_dependency('ZenTest', '>= 4.4.0')
 
-  s.has_rdoc = true
+  s.has_rdoc = true if s.respond_to? :has_rdoc=
+  # Gem::Specification#has_rdoc= is deprecated with no replacement in 2.6
   s.extra_rdoc_files = Dir.glob('*.txt')
   s.rdoc_options << '--title' << "#{s.name}-#{s.version} Documentation" <<
                     '--main' << 'Readme.txt'

data/lib/generated/examples/chart_class_dependencies.txt

@@ -0,0 +1,35 @@
+# Example usage of JavaClass::Dependencies::Graph: Iterate all classes of a 
+# classpath and construct the Java dependency graph.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dsl/mixin'
+#  require 'javaclass/dependencies/graph'
+#  require 'javaclass/dependencies/class_node'
+#  require 'javaclass/dependencies/yaml_serializer'
+#  require 'javaclass/dependencies/graphml_serializer'
+#  
+# 1) create the classpath of a given location
+#  cp = classpath(location)
+#  
+#  dependencies = JavaClass::Dependencies::Graph.new
+#  
+# 2) iterate all classes of the classpath
+#  cp.values.each do |clazz|
+#    next unless clazz.access_flags.public?
+#  
+# 3) add a JavaClass::Dependencies::ClassNode for each class to the graph 
+#    dependencies.add(JavaClass::Dependencies::ClassNode.new(clazz))
+#  end
+#  
+# 4) resolve all dependencies of all nodes in the graph. Now each class (Node) has a dependency to
+# all imported classes (Nodes).
+#  dependencies.resolve_dependencies
+#  puts "#{dependencies.to_a.size} classes loaded" 
+#  
+# 5) save the result in various formats, e.g. GraphML or YAML, skipping outgoing edges information
+#  JavaClass::Dependencies::GraphmlSerializer.new(:edges => :no_text).save('class_dependencies', dependencies)
+#  JavaClass::Dependencies::YamlSerializer.new(:outgoing => :none).save('class_dependencies', dependencies)

data/lib/generated/examples/chart_module_dependencies.txt

@@ -0,0 +1,43 @@
+# Example usage of JavaClass::Dependencies::Graph: Iterate all folders of a root folder.
+# Load each component separately and construct the dependency graph.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dsl/mixin'
+#  require 'javaclass/dependencies/graph'
+#  require 'javaclass/dependencies/classpath_node'
+#  require 'javaclass/dependencies/yaml_serializer'
+#  require 'javaclass/dependencies/graphml_serializer'
+#  
+# 1) define the location of the plugins
+#  location = 'C:\Eclipse\workspace'
+#  
+#  plugins = JavaClass::Dependencies::Graph.new
+#  
+# 2) iterate all plugins of a workspace location
+#  Dir.new(location).each do |folder|
+#    path = File.join(location, folder)
+#    next unless FileTest.directory? path
+#  
+#    classes = File.join(path, 'bin')
+#    next unless FileTest.exist?(classes)
+#  
+# 3) create a classpath for each plugin
+#    cp = classpath(classes)
+#    next if cp.count == 0
+#  
+# 4) add a JavaClass::Dependencies::Node for that plugin to the graph 
+#    plugins.add(JavaClass::Dependencies::ClasspathNode.new(folder, cp))
+#  end
+#  
+# 5) resolve all dependencies of all nodes in the graph
+#  plugins.resolve_dependencies
+#  puts "#{plugins.to_a.size} plugins loaded" 
+#  
+# 6) save the result in various formats, e.g. GraphML or YAML
+#  JavaClass::Dependencies::GraphmlSerializer.new.save('plugin_dependencies', plugins)
+#  JavaClass::Dependencies::YamlSerializer.new.save('plugin_dependencies', plugins)
+#  JavaClass::Dependencies::YamlSerializer.new(:outgoing => :summary).save('plugin_dependencies_summary', plugins)

data/lib/generated/examples/check_interface_names.txt

@@ -0,0 +1,36 @@
+# Example usage of classpath and class files: Scan all classes of an workspace.
+# Find all interfaces, print their names and find all which are prefixed with 'I'.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.       
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dsl/mixin'
+#  
+# 1) define the location of the project and a package you are interrested
+#  location = 'C:\Eclipse\workspace'
+#  package = 'com.biz.app'
+#  
+# e.g. add an Eclipse classpath variable to find external dependencies.
+#  Eclipse.add_variable('KOR_HOME', location)
+#  
+# 2) create the 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 on classpath"
+#  
+# 3) filter the classes to analyse, using JavaClass::JavaQualifiedName methods
+#  to_analyse = cp.names { |classname| classname.same_or_subpackage_of?(package) }
+#  puts "#{to_analyse.size} classes matched #{package}"
+#  
+# 4) load all selected classes, parse into JavaClass::ClassFile, find all interfaces and collect their qualified names
+#  names = cp.values(to_analyse).
+#             find_all { |clazz| clazz.interface? }.
+#             collect { |clazz| clazz.to_classname }
+#  puts "#{names.size} interfaces found:\n  #{names.sort.join("\n  ")}"
+#  
+# 5) print all qualified names have a simple namee staring with an I
+#  inames = names.find_all { |classname| classname.simple_name =~ /^I[A-Z][a-z]/ }
+#  puts "#{inames.size} interfaces start with I:\n  #{inames.join("\n  ")}"

data/lib/generated/examples/count_classes_in_modules.txt

@@ -0,0 +1,31 @@
+# Example usage of classpath (JavaClass::Classpath): Scan all classpaths (e.g. modules)
+# of an an Eclipse "workspace". A workspace is a folder containing several Eclipse
+# projects, e.g. JavaClass::Classpath::EclipseClasspath. Report the number of found
+# classes per module.
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.       
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/classpath/factory'
+#  include JavaClass::Classpath::Factory
+# The require/include above just imports what is needed, but usually one would require the whole 
+# JavaClass::Dsl::Mixin for conveniance, e.g. require 'javaclass/dsl/mixin'. 
+#  
+# 1) define the location of the project
+#  location = 'C:\Eclipse\workspace'
+#  
+# 2) create a JavaClass::Classpath::CompositeClasspath of the complete workspace, which will contain many classpath elements.
+#  cp = workspace(location)
+#  puts "#{cp.elements.size} classpaths found under the workspace #{location}"
+#  
+# 3a) find all empty elements by querying the classpath elements
+#  empty = cp.elements.find_all { |clp| clp.count == 0 }
+#  puts "\n#{empty.size} empty modules found:\n  #{empty.join("\n  ")}"
+#  
+# 3b) or print the list of each element with its class count
+#  puts "library (module path): number of contained classes"
+#  puts cp.elements.map { |clp| [clp.to_s, clp.count] }.
+#                   sort { |a,b| a[1] <=> b[1] }.
+#                   map { |e| "  #{e[0]}: #{e[1]}" }

data/lib/generated/examples/cumulative_dependencies.txt

@@ -0,0 +1,28 @@
+# Example usage of the featuress of JavaClass::Analyse::TransitiveDependencies
+# to collect all transitive dependencies of a certain class or a whole package
+# (Cumulative Component Dependencies).
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2009, Peter Kofler.       
+# License::         {BSD License}[link:/files/license_txt.html]
+# See::             Another example how to {list all imported types}[link:/files/lib/generated/examples/find_all_imported_types_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dsl/mixin'
+#  
+# 1) create the classpath of the given workspace
+#  cp = workspace(location)
+#  puts "#{cp.count} classes found on classpath"
+#  
+# define a filter to limit all operations to the classes we are interested in
+#  filter = Proc.new { |classname| classname.same_or_subpackage_of?(package) }
+#  
+# 2a) collect all transitive dependencies of a single class into an AdderTree 
+#  dependencies = cp.transitive_dependency_tree(start_class.to_javaname, &filter)
+#  puts "#{dependencies.size} classes in transitive dependency graph of class #{start_class}"
+#  dependencies.debug_print
+#  
+# 2b) or collect all transitive dependencies of a whole package
+#  dependencies = cp.transitive_dependencies_package(start_class.to_javaname.package, &filter)
+#  puts "#{dependencies.size} classes in transitive dependency graph of package #{start_class.to_javaname.package}"
+#  dependencies.debug_print

data/lib/generated/examples/find_all_imported_types.txt

@@ -0,0 +1,38 @@
+# 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
+#  
+#  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_types_with_numbers = cp.used_types_map
+#  imported_classnames = imported_types_with_numbers.keys
+#  
+# 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 ; 0 = hardcoded'
+#  used_classnames = (imported_classnames + hardcoded_classnames).uniq.sort  - prod_classnames
+# puts used_classnames
+#  used_classnames.each do |name|
+#    puts "#{name} ; #{imported_types_with_numbers[name]}"
+#  end
+#  
+# 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/lib/generated/examples/find_incoming_dependency_graph.txt

@@ -0,0 +1,73 @@
+# Example usage of dependency graph: Invert the graph and see incoming dependencies of a module.
+# After getting all classes of a module, use previously generated dependency graph to iterate 
+# all incoming edges. Then either report all incoming edges as CSV or find all private/inner
+# classes of the module. Works with an existing dependency graph, 
+# e.g. created by {chart module dependencies example}[link:/files/lib/generated/examples/chart_module_dependencies_txt.html].
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2012, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dsl/mixin'
+#  require 'javaclass/classpath/tracking_classpath'
+#  require 'javaclass/dependencies/edge'
+#  require 'javaclass/dependencies/yaml_serializer'
+#  
+# 1) create a classpath of the main model  plugin
+#  Plugin_name = 'org.codecop.model'
+#  cp = classpath(File.join(location, Plugin_name, 'bin'))
+#  classes = cp.names
+#  puts "#{classes.count} classes found in main plugin"
+#  cp.reset_access
+#  
+# 2) load a dependency Graph containing the model
+#  plugins = JavaClass::Dependencies::YamlSerializer.new.load('plugin_dependencies')
+#  
+# used to strip beginning of full qualified names
+#  def strip(name)
+#    name.sub(/^org\.codecop\./, '*.')
+#  end
+#  
+# 3) mark all accessed classes in model plugin using the dependency graph
+#  plugins.each_node do |plugin|
+#    next if plugin.name == Plugin_name
+#    plugin.each_edge do |dep, edge|
+#      next unless dep.name == Plugin_name
+#      cp.mark_accessed(edge.target)
+#    end
+#  end
+#  
+#  plugins.each_node do |plugin|
+#    plugin.each_dependency_provider do |dep, dependencies|
+#      plugin.dependencies[dep] = dependencies.map { |edge| 
+#        # replace class edges by package edges
+#        # JavaClass::Dependencies::Edge.new(edge.source.to_javaname.package, edge.target.to_javaname.package)
+#  
+#        # replace class edges with source plugin, target package
+#        # JavaClass::Dependencies::Edge.new(plugin.name, edge.target.to_javaname.package)
+#  
+#        # replace source edges with source plugin
+#        JavaClass::Dependencies::Edge.new(plugin.name, edge.target)
+#      }.uniq.sort
+#    end
+#  end
+#  
+# 4) report all incoming dependencies (edges) for further Excel analysis 
+#  plugins.each_node do |plugin|
+#    next if plugin.name == Plugin_name
+#    plugin.each_edge do |dep, edge|
+#      next unless dep.name == Plugin_name
+#      puts "#{strip(edge.target)};#{strip(plugin.name)};#{strip(edge.source)}"
+#    end
+#  end
+#  
+# 5) report unused classes in model from outside
+#  unused_classes = classes.
+#      find_all { |clazz| cp.accessed(clazz) == 0 }.
+#      reject { |clazz| clazz =~ /\$.*$/ }
+#  report = unused_classes.map { |clazz| "#{clazz.to_classname}" }.uniq
+#  puts "#{report.size} private classes found:"
+#  report.each do |clazz|
+#    puts "#{strip(clazz)};(internal);NA"
+#  end  

data/lib/generated/examples/find_layers_of_modules.txt

@@ -0,0 +1,70 @@
+# Example usage of dependency graph: Organize the nodes into layers 
+# depending on their dependencies. Works with an existing dependency graph, 
+# e.g. created by {chart module dependencies example}[link:/files/lib/generated/examples/chart_module_dependencies_txt.html].
+# Author::          Peter Kofler
+# Copyright::       Copyright (c) 2012, Peter Kofler.
+# License::         {BSD License}[link:/files/license_txt.html]
+#
+# === Steps
+#  
+#  require 'javaclass/dependencies/yaml_serializer'
+#  
+# 1) load dependency graph 
+#  plugins = JavaClass::Dependencies::YamlSerializer.new.load('plugin_dependencies')
+#  components = plugins.to_a
+#  
+#  @layerOfComponents = []
+#  
+# 2) find modules without any dependencies, these are the first/bottom 
+#  first_elements = components.find_all { |c| c.dependencies.size == 0 }.sort
+#  @layerOfComponents << first_elements
+#  components = components - first_elements
+#  
+#  def has_all_deps_satisfied?(component)
+#    already_sorted_dependencies = @layerOfComponents.flatten
+#    component.dependencies.keys.find { |dependency|
+#      !already_sorted_dependencies.include?(dependency)
+#    } == nil
+#  end
+#  
+#  while components.size > 0
+#    cycle = true
+#  
+#    # 3) for each component, check if all dependencies are satisfied combined layers below
+#    components.each do |component|
+#  
+#      if has_all_deps_satisfied?(component)
+#        components -= [component]
+#  
+#        # 4) if yes, walk up the dependencies until highest/lowest possible
+#        index = @layerOfComponents.size - 1
+#        while (component.dependencies.keys.find { |dependency| @layerOfComponents[index].include?(dependency) } == nil)
+#          index = index -1
+#        end
+#        index = index + 1 # take next
+#  
+#        # and add to the layers
+#        if index == @layerOfComponents.size
+#          @layerOfComponents[index] = []
+#        end
+#        @layerOfComponents[index] << component
+#  
+#        puts "added #{component}"
+#        cycle = false
+#        break
+#      end
+#  
+#    end
+#    
+#    if cycle
+#      warn "cycle in #{components.join(', ')}, can't continue with layering"
+#      break
+#    end
+#  end
+#  
+# 5) output the found layering
+#  (1..@layerOfComponents.size).each do |i|
+#    layer = @layerOfComponents[i-1].sort
+#    puts "#{i} " + layer.join(', ')
+#  end
+#