javaclass 0.0.4 → 0.4.1

data/lib/javaclass/classpath/tracking_classpath.rb

@@ -22,6 +22,7 @@ module JavaClass
       # Returns the wrapped classpath element (+self+) of this decorated classpath.
       def elements
         if [FolderClasspath, JarClasspath].include?(@classpath.class)
+          # TODO check for any subclass of FileClasspath instead
           [self]
         else
           @classpath.elements
@@ -90,11 +91,12 @@ module JavaClass
     class CompositeClasspath 
 
       # Wrap the _elem_ classpath with a new TrackingClasspath and add it to the list of elements.
-      alias __old__add_element__ add_element 
+      alias :__old__add_element__ :add_element unless method_defined?('__old__add_element__') 
       
       def add_element(elem)
         unless @elements.find { |cpe| cpe == elem }
           if [FolderClasspath, JarClasspath].include?(elem.class)
+            # TODO check for any subclass of FileClasspath instead -> fail a test with ConventionClasspath and Tracker
             __old__add_element__(TrackingClasspath.new(elem))
           else
             __old__add_element__(elem)

data/lib/javaclass/dependencies/class_node.rb

@@ -0,0 +1,36 @@
+require 'javaclass/dependencies/node'
+require 'javaclass/dependencies/edge'
+
+module JavaClass
+  module Dependencies
+    
+    # A concrete Node which contains a ClassFile and its dependencies.
+    # This models a Node as a Java class.
+    # Author::          Peter Kofler
+    class ClassNode < Node
+    
+      def initialize(java_class)
+        super(java_class.to_classname)
+        @java_class = java_class
+      end
+
+      # Iterate on a list of Edge dependencies this node has.
+      def outgoing_dependencies
+        @java_class.imported_3rd_party_types.each do |import|
+            yield Edge.new(@java_class.to_classname, import.to_classname)
+        end
+        # later iterate all types/fields/methods and create an edge from the method to the target type.
+        # So Edges make sense and multiplicity in dependencies is possible. 
+      end
+      
+      # Does this Node satisfy the dependency to _class_name_ ?
+      def satisfies?(class_name)
+        @java_class.to_classname == class_name.to_classname
+        # later class name will be a full qualified class#method or field name.
+      end
+
+    end
+    # TODO add tests
+
+  end
+end

data/lib/javaclass/dependencies/classpath_node.rb

@@ -0,0 +1,37 @@
+require 'javaclass/dependencies/node'
+require 'javaclass/dependencies/edge'
+
+module JavaClass
+  module Dependencies
+    
+    # A concrete Node which contains a Classpath and its dependencies.
+    # This models a Node as a component, maybe an Eclipse plugin, a Maven module or a library. 
+    # Dependencies (Edge) contain all references imported by any class of this component.  
+    # Author::          Peter Kofler
+    class ClasspathNode < Node
+    
+      def initialize(name, classpath)
+        super(name, classpath.count)
+        @classpath = classpath
+      end
+
+      # Iterate on a list of Edge dependencies this node has.
+      def outgoing_dependencies
+        @classpath.values.each do |clazz|
+          clazz.imported_3rd_party_types.each do |import|
+            unless satisfies?(import) 
+              yield Edge.new(clazz.to_classname, import)
+            end
+          end
+        end
+      end
+      
+      # Does this Node satisfy the dependency _dependency_name_ .
+      def satisfies?(dependency_name)
+        @classpath.includes?(dependency_name)
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/dependencies/edge.rb

@@ -0,0 +1,41 @@
+module JavaClass
+  module Dependencies
+    
+    # An edge in the Graph of dependencies. An edge knows it's source and destination details.
+    # Author::          Peter Kofler
+    class Edge
+
+      attr_reader :source
+      attr_reader :target
+      
+      def initialize(source, target)
+        @source = source
+        @target = target
+      end
+
+      def to_s
+        "#{@target} (#{@source})"
+      end
+
+      def ==(other)
+        @source == other.source && @target == other.target 
+      end
+
+      alias eql? ==
+
+      def hash
+        [@source, @target].hash
+      end
+                  
+      def <=>(other)
+        res = @target <=> other.target
+        if res == 0
+          res = @source <=> other.source
+        end
+        res 
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/dependencies/graph.rb

@@ -0,0 +1,53 @@
+module JavaClass
+  
+  # The module Dependencies is for separating namespaces. It contains logic 
+  # to analyse and structure general directed dependency graphs. A set of 
+  # dependencies build a Graph which can be analysed.
+  # Author::          Peter Kofler
+  module Dependencies
+   
+    # A graph contains a list of Node
+    # Author::          Peter Kofler
+    class Graph
+
+      def initialize
+        @nodes = []
+      end
+
+      # Add a _node_ to this graph.
+      def add(node)
+        @nodes << node
+      end
+
+      def to_a
+        @nodes.dup
+      end
+
+      # Iterates all nodes and fills the dependency fields of the Node.
+      def resolve_dependencies
+        @nodes.each do |node|
+          puts "processing #{node}"
+
+          node.outgoing_dependencies do |dependency|
+            providers = nodes_satisfying(dependency.target)
+            node.add_dependency(dependency, providers)
+          end
+          
+          node.dependencies.values.each { |vals| vals.sort! }
+        end
+      end
+      
+      # Find the nodes that satisfy the given _dependency_
+      def nodes_satisfying(dependency)
+        @nodes.find_all { |n| n.satisfies?(dependency) }
+      end      
+
+      # Iterate all nodes in this Graph and call _block_ for each Node 
+      def each_node(&block)
+        @nodes.each { |node| block.call(node) }
+      end      
+      
+    end
+
+  end
+end

data/lib/javaclass/dependencies/graphml_serializer.rb

@@ -0,0 +1,102 @@
+require 'rexml/document'
+
+module JavaClass
+  module Dependencies
+
+    # Serializes a Graph of Node to GraphML (XML). 
+    # To see the graph, use yED, http://www.yworks.com/en/products_yed_about.html to  
+    # * load the graphml file. 
+    # * Then select all nodes and apply Tools/Fit Node to Label.
+    # * Finally apply the Layout/Hierarchical or maybe Layout/Organic/Smart.
+    # Author::          Peter Kofler
+    class GraphmlSerializer
+      include REXML
+
+      # Create a serializer with _options_ hash:
+      # edges:: how to chart edge labes, either :no_text or :with_counts 
+      def initialize(options = { :edges => :with_counts })
+        @options = options
+      end
+
+      # Save the _graph_ to _filename_ .
+      def save(filename, graph)
+        File.open(filename + '.graphml', 'w') do |f|
+          doc = graph_to_xml(graph)
+          doc.write(out_string = '', 2)
+          f.print out_string
+        end
+      end
+
+      # Return an XML document of the GraphML serialized _graph_ .
+      def graph_to_xml(graph)
+        doc = create_xml_doc
+        container = add_graph_element(doc)
+        graph.to_a.each { |node| add_node_as_xml(container, node) }
+        doc
+      end
+
+      private
+      
+      def create_xml_doc
+        REXML::Document.new
+      end
+      
+      def add_graph_element(doc)
+        root = doc.add_element('graphml', 
+          'xmlns' => 'http://graphml.graphdrawing.org/xmlns',  
+          'xmlns:y' => 'http://www.yworks.com/xml/graphml')
+        root.add_element('key', 'id' => 'n1', 'for' => 'node', 'yfiles.type' => 'nodegraphics')
+        root.add_element('key', 'id' => 'e1', 'for' => 'edge', 'yfiles.type' => 'edgegraphics')
+        
+        root.add_element('graph', 'edgedefault' => 'directed')
+      end
+      
+      public
+            
+      # Add the _node_ as XML to the _container_ .
+      def add_node_as_xml(container, node)
+        add_node_element(container, node)
+    
+        node.dependencies.keys.each do |dep|
+          add_edge_element(container, node, dep)
+        end
+      end
+  
+      private
+      
+      def add_node_element(container, node)
+        elem = container.add_element('node', 'id' => node.name)
+        elem.add_element('data', 'key' => 'n1').
+          add_element('y:ShapeNode').
+            add_element('y:NodeLabel').
+              add_text(node.to_s)
+      end
+  
+      def add_edge_element(container, node, dep)
+        edge = container.add_element('edge')
+        edge.add_attribute('id', node.name + '.' + dep.name)
+        edge.add_attribute('source', node.name)
+        edge.add_attribute('target', dep.name)
+        
+        add_edge_label(edge, node.dependencies[dep])
+      end
+      
+      def add_edge_label(edge, dependencies_2_dep)
+        if @options[:edges] == :with_counts
+          number_total_dependencies = dependencies_2_dep.size.to_s
+          number_unique_dependencies = dependencies_2_dep.collect { |d| d.target }.uniq.size.to_s
+          edge.add_element('data', 'key' => 'e1').
+            add_element('y:PolyLineEdge').
+              add_element('y:EdgeLabel').
+                add_text("#{number_total_dependencies} (#{number_unique_dependencies})")
+        elsif @options[:edges] == :no_text
+          # do nothing
+        else
+          raise "unknown option for edge labels #{@options[:edges]}"
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/javaclass/dependencies/node.rb

@@ -0,0 +1,82 @@
+module JavaClass
+  module Dependencies
+    
+    # A node in a Graph of dependencies. A node contains a map of dependencies (Edge) to other nodes.
+    # Author::          Peter Kofler
+    class Node
+
+      attr_reader :name
+      attr_reader :size
+      attr_reader :dependencies
+      ### attr_reader :incoming
+    
+      def initialize(name, size=0)
+        @name = name
+        @size = size
+        @dependencies = Hash.new([])
+        ### @incoming = Hash.new([])
+      end
+
+      def to_s
+        if @size > 0
+          "#{@name} (#{@size.to_s})"
+        else
+          @name
+        end
+      end
+      
+      def ==(other)
+        other.respond_to?(:name) && @name == other.name
+      end
+      
+      def hash
+        @name.hash
+      end
+      
+      def <=>(other)
+        @name <=> other.name 
+      end
+
+      # Add a _dependency_ Edge for a list of _provider_ Node. 
+      def add_dependency(dependency, providers)
+        if providers.size == 0
+          # external dependency, skip this
+        elsif providers.size == 1
+          # add dependency to this provider
+          provider = providers[0]
+          # unless @dependencies[provider].include? dependency
+          @dependencies[provider] = @dependencies[provider] + [dependency]
+          ### provider.incoming[self] = provider.incoming[self] + [dependency]
+          # end
+        else
+          warn "dependency to \"#{dependency}\" found more than once: #{providers.join(', ')}"
+        end
+      end
+
+      # Add a list _dependencies_ of _provider_ . 
+      def add_dependencies(dependencies, providers)
+        dependencies.each do |dependency|
+          add_dependency(dependency, providers)
+        end
+      end
+
+      # Iterate all providers of dependencies of this Node and call _block_ for each provider with its list of dependencies (Edge). 
+      def each_dependency_provider(&block)
+        @dependencies.keys.each do |provider|
+          block.call(provider, @dependencies[provider])
+        end
+      end
+
+      # Iterate all dependencies of this Node and call _block_ for each provider with each of its dependencies. 
+      def each_edge(&block)
+        each_dependency_provider do |provider, edges|
+          edges.each do |edge|
+            block.call(provider, edge)
+          end
+        end
+      end
+            
+    end
+
+  end
+end

data/lib/javaclass/dependencies/yaml_serializer.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+require 'javaclass/dependencies/edge'
+require 'javaclass/dependencies/node'
+require 'javaclass/dependencies/graph'
+
+module JavaClass
+  module Dependencies
+    
+    # Serializes a Graph of Nodes to YAML.
+    # Author::          Peter Kofler
+    class YamlSerializer
+      
+      # Create a serializer with _options_ hash:
+      # outgoing:: how to persist outgoing dependencies, either :detailed, :summary or :none 
+      def initialize(options = {:outgoing => :detailed })
+        @options = options
+      end
+      
+      # Exists a YAML serialized _graph_ ? 
+      def has_yaml?(filename)
+        File.exist? yaml_file(filename)
+      end
+      
+      # Save the _graph_ to YAML _filename_ .
+      def save(filename, graph)
+        File.open(yaml_file(filename), 'w') { |f| f.print graph_to_yaml(graph) }
+      end
+
+      # Return a String of the YAML serialized _graph_ .
+      def graph_to_yaml(graph)
+        "---\n" +
+        graph.to_a.map { |node| node_to_yaml(node) }.join("\n")
+      end
+
+      # Return a String of the YAML serialized _node_ .
+      def node_to_yaml(node)
+        node.name + ":\n" +
+        node.dependencies.keys.map { |dep|
+          '  ' + dep.name + dependencies_to_yaml(node.dependencies[dep])
+        }.join("\n")
+      end
+
+      private
+
+      def yaml_file(filename)
+        filename + '.yaml'
+      end
+            
+      def dependencies_to_yaml(dependencies)
+        if @options[:outgoing] == :detailed 
+          ":\n" + dependencies.map { |dep| "    - #{dep.source}->#{dep.target}" }.join("\n")
+        elsif @options[:outgoing] == :summary
+          ":\n" + dependencies.map { |dep| dep.target }.uniq.sort.map { |dep| "    - #{dep}" }.join("\n")
+        elsif @options[:outgoing] == :none
+          ''
+        else
+          raise "unknown option for outgoing dependencies #{@options[:outgoing]}"
+        end
+      end
+      
+      def node_with(name)
+        node = @nodes_by_name[name]
+        if node
+          node
+        else
+          @nodes_by_name[name] = Node.new(name)
+        end
+      end
+
+      public
+
+      # Load the Graph from YAML _filename_ .
+      def load(filename)
+        yaml = File.open(yaml_file(filename)) { |f| YAML.load(f) }
+        # TODO support compressed yaml files, e.g. inside zip
+        yaml_to_graph(yaml)
+      end
+      
+      # Return a Graph from the YAML data _yaml_ .
+      def yaml_to_graph(yaml)
+        graph = Graph.new
+        @nodes_by_name = {}
+
+        yaml.keys.each do |name|
+          node = node_with(name)
+          graph.add(node)
+
+          dependency_map = yaml[name] || {}
+          dependency_map.keys.each do |dependency_name|
+            depending_node = node_with(dependency_name)
+            dependencies = dependency_map[dependency_name].collect { |d| Edge.new(*d.split(/->/)) }
+            node.add_dependencies(dependencies, [depending_node])
+          end
+        end
+        
+        @nodes_by_name = {}
+        graph
+      end
+
+    end
+
+  end
+end