DepGraph 0.8.0 → 0.9.0

data/History.txt

@@ -1 +1,19 @@
+0.9.0
 
+* Added dynamic loading of node finders from directory lib/nodefinders.
+ Example:
+   see 'lib/nodefinders/TestNodeFinder.rb' which can be used like this:
+   depgraph -type test
+* Added functionality to exclude the nodes the user is not interested in.
+ Example:
+   depgraph -type ruby_requires -exc "client, server"
+* A transitive reduction can be applied to the graph.
+ Example:
+   depgraph -type csproj -trans
+* Disconnected nodes don't show up anymore.
+* The type of output can be selected by changing the file extension. 
+ Example:
+   depgraph -type test -output test.dot
+* Separated unit tests and integration tests in different folders.
+* Renamed option -dirs to -location
+* Some more refactorings.

data/Manifest.txt

@@ -7,12 +7,13 @@ bin/depgraph
 config/hoe.rb
 config/requirements.rb
 lib/DepGraph/version.rb
-lib/dependable_filter_manager.rb
+lib/dependency_types_manager.rb
 lib/dependency_types.yaml
-lib/dependent.rb
-lib/file_system_dependent_finder.rb
-lib/graph.rb
+lib/node.rb
+lib/file_system_node_finder.rb
+lib/graph_image_creator.rb
 lib/graph_creator.rb
+lib/nodefinders/test_node_finder.rb
 script/destroy
 script/destroy.cmd
 script/generate
@@ -20,16 +21,20 @@ script/generate.cmd
 script/txt2html
 script/txt2html.cmd
 setup.rb
-spec/dependable_filter_manager_spec.rb
-spec/dependent_spec.rb
-spec/depgraph_spec.rb
-spec/file_system_dependent_finder_spec.rb
-spec/graph_creator_spec.rb
-spec/graph_spec.rb
+spec/IntegrationTests/depgraph_spec.rb
+spec/IntegrationTests/file_system_node_finder_spec.rb
+spec/IntegrationTests/graph_creator_spec.rb
+spec/IntegrationTests/graph_image_creator_spec.rb
+spec/UnitTests/dependency_types_manager_spec.rb
+spec/UnitTests/node_spec.rb
+spec/UnitTests/graph_creator_spec.rb
+spec/UnitTests/graph_image_creator_spec.rb
+spec/UnitTests/file_system_node_finder_spec.rb
+spec/integration_spec.opts
 spec/spec.opts
 spec/spec_helper.rb
+spec/unit_spec.opts
 tasks/deployment.rake
 tasks/environment.rake
 tasks/rspec.rake
 tasks/website.rake
-todo.txt

data/bin/depgraph

@@ -16,54 +16,67 @@ rescue LoadError
   exit
 end
 
-require 'dependable_filter_manager'
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
 require 'graph_creator'
 
+
 module CommandLineParameters extend OptiFlagSet
   flag "type" do
-    dependency_types = DepGraph::DependableFilterManager.types    
+    dependency_types = DepGraph::GraphCreator.types    
     description "Type of dependencies to analyze: #{dependency_types.join(', ')}"
     value_in_set dependency_types
   end
   
+  optional_flag "exc" do
+    description "The node names to be excluded.\nUse double quotes and commas for multiple nodes."
+  end
+  
   optional_flag "output" do
-    description "The file name of the image."
+    description "The file name of the graph image."
   end
 
-
   optional_flag "from" do
-    description "Regular expresion that must be met by the dependency source."
+    description "Regular expression that must be met by the dependency source."
   end
   
   optional_flag "to" do
-    description "Regular expresion that must be met by the dependency target."
+    description "Regular expression that must be met by the dependency target."
+  end
+  
+  optional_flag "location" do
+    description "A string defining the place where the nodes to analyse are found.\nThis are directories for most dependency types.\n
+Use double quotes and commas for more than one directory."
   end
   
-  optional_flag "dirs" do
-    description "Directories to traverse for dependency files. Use double quotes and commas for more than one directory."
+  optional_switch_flag "trans" do
+    description "Applies a transitive reduction to the graph"
   end
   
   usage_flag "h","help","?"
-
   
   and_process!
 end 
 
 type = CommandLineParameters.flags.type
 output = CommandLineParameters.flags.output || 'dependency_graph.png'
-dirs = CommandLineParameters.flags.dirs || '.'
+location = CommandLineParameters.flags.location || '.'
 from = CommandLineParameters.flags.from if CommandLineParameters.flags.from?
 to = CommandLineParameters.flags.to if CommandLineParameters.flags.to?
+exc = CommandLineParameters.flags.exc || ''
+trans = CommandLineParameters.flags.trans?
 
 puts "Creating #{type} dependency graph. Please wait..."
 
 dep_grapher = DepGraph::GraphCreator.new(type)
-dep_grapher.dirs = dirs.split(',')
-dep_grapher.from= from
+dep_grapher.location = location.split(',')
+dep_grapher.from = from
 dep_grapher.to = to
+dep_grapher.trans = trans
+dep_grapher.excluded_nodes = exc.split(',')
 
 if dep_grapher.create_image(output)
-  puts "Created #{output}.\nDone."
+  puts "Done.\nResults in #{output}."
 else
   puts "No dependency graph image created."
 end

data/config/hoe.rb

@@ -1,12 +1,12 @@
 require 'DepGraph/version'
 
 AUTHOR = 'Daniel Cadenas Ni�n'  # can also be an array of Authors
-EMAIL = "depgraph-devel@rubyforge.org"
+EMAIL = "dcadenas@gmail.com"
 DESCRIPTION = "A tool to create dependency graph images from source code directories"
 GEM_NAME = 'DepGraph' # what ppl will type to install your gem
 RUBYFORGE_PROJECT = 'DepGraph' # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
-DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT.downcase}"
 
 @config_file = "~/.rubyforge/user-config.yml"
 @config = nil

data/lib/DepGraph/version.rb

@@ -1,7 +1,7 @@
 module DepGraph #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 8
+    MINOR = 9
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/{dependable_filter_manager.rb → dependency_types_manager.rb}

@@ -1,7 +1,7 @@
 require 'yaml'
 
 module DepGraph
-  class DependableFilterManager
+  class DependencyTypesManager
     def self.dependency_types_file
       File.join(File.dirname(__FILE__), 'dependency_types.yaml')
     end
@@ -16,27 +16,27 @@ module DepGraph
       @@dependable_dependency_types.map {|type, _| type.to_sym}
     end
     
-    def initialize(dependent_type = :anything)
-      @dependent_type = dependent_type.to_s
+    def initialize(node_type = :anything)
+      @node_type = node_type.to_s
     end
     
     def dependable_regexp
-      get_dependent_type_parameters(@dependent_type)['dependable_regexp']
+      get_node_type_parameters(@node_type)['dependable_regexp']
     end
         
     def dependable_regexp_capture_group_index
-      get_dependent_type_parameters(@dependent_type)['capture_group_index']
+      get_node_type_parameters(@node_type)['capture_group_index']
     end
     
     def file_name_pattern
-      get_dependent_type_parameters(@dependent_type)['file_name_pattern']
+      get_node_type_parameters(@node_type)['file_name_pattern']
     end
     
-    def get_dependent_type_parameters(dependent_type)
-      dependent_type_parameters = @@dependable_dependency_types[dependent_type]
+    def get_node_type_parameters(node_type)
+      node_type_parameters = @@dependable_dependency_types[node_type]
       
-      if dependent_type_parameters
-        return dependent_type_parameters
+      if node_type_parameters
+        return node_type_parameters
       else
         return default_parameters = {
           'dependable_regexp' => /.+/,

data/lib/file_system_node_finder.rb

@@ -0,0 +1,60 @@
+require 'node'
+require 'dependency_types_manager'
+
+module DepGraph
+  class FileSystemNodeFinder
+    attr_accessor :dependable_filter, :dependable_filter_capture_group_index, :file_name_pattern
+    attr_writer :location
+    
+    def initialize(node_type)
+      
+      dependable_filter_manager = DependencyTypesManager.new node_type
+      @file_name_pattern = dependable_filter_manager.file_name_pattern
+      @dependable_filter = dependable_filter_manager.dependable_regexp
+      @dependable_filter_capture_group_index = dependable_filter_manager.dependable_regexp_capture_group_index
+      @location = ['.']
+    end 
+    
+    def location=(locs)
+      @location = locs.map {|d| d.strip}
+    end
+    
+    def get_nodes
+      files = []
+      @location.each do |dir|
+        files += Dir.glob(dir.strip + '/**/' + @file_name_pattern)
+      end
+      
+      nodes = []
+      files.each { |file| nodes << create_node_from_file(file) }
+      return nodes
+    end
+    
+    def load_dependencies_from_string(node, dependencies_string)
+      fail 'The dependable finder Regexp was not set' unless @dependable_filter
+
+      dependencies_string.scan(@dependable_filter).each do |matches|
+        dependable = (matches.respond_to? :to_ary) ? matches[@dependable_filter_capture_group_index] : matches
+        node.depends_on(dependable) unless node.depends_on? dependable
+      end
+    end
+    
+    private
+    def create_node_from_file file
+      node = Node.new remove_extension(file)
+      
+      File.open(file) do |f|
+        f.each_line do |line|
+          load_dependencies_from_string(node, line)
+        end
+      end
+      
+      return node
+    end
+    
+    def remove_extension file_path
+      file_extension_regexp = /\.[^\.]+$/
+      return File.basename(file_path).gsub(file_extension_regexp, '')
+    end
+  end
+end

data/lib/graph_creator.rb

@@ -1,85 +1,122 @@
 require 'rubygems'
-require 'dependent'
-require 'graph'
-require 'file_system_dependent_finder'
+require 'node'
+require 'graph_image_creator'
+require 'file_system_node_finder'
+require 'dependency_types_manager'
 
 module DepGraph
   class GraphCreator
-    attr_accessor :dependent_finder 
+    attr_writer :graph_image_creator_class, :from, :to, :node_finder, :trans
     
-    def initialize(dependent_type = :none)
-      @dependent_finder = FileSystemDependentFinder.new(dependent_type)
-      @graph_class = Graph
+    def initialize(node_type = :none)
+      @node_finder = get_node_finder(node_type)
+      @graph_image_creator_class = GraphImageCreator
+      @trans = false
     end
     
-    def graph_class= the_graph_class
-      @graph_class = the_graph_class
+    def self.types
+      node_finders_dir = File.join(File.dirname(__FILE__), 'nodefinders')
+      node_finders = Dir.glob(File.join(node_finders_dir, '*_node_finder.rb'))
+      node_finders = node_finders.map {|nf| nf.gsub(node_finders_dir + '/', '').gsub('_node_finder.rb', '').to_sym}
+      return DependencyTypesManager.types + node_finders
     end
     
-    def dirs=(directories)
-      @dependent_finder.dirs = directories
+    def location=(loc)
+      @node_finder.location = loc
     end
     
-    def from=(from_filter)
-      @from_filter = from_filter
+    def excluded_nodes=(exc)
+      @excluded_nodes = exc.map {|e| e.strip}
     end
     
-    def to=(to_filter)
-      @to_filter = to_filter
+    def create_image(image_file_name = 'dependency_graph.png')
+      create_graph.create_image(image_file_name) 
     end
-
     
     def create_graph
-      nodes = @dependent_finder.get_dependents.uniq
-      return nil if nodes.size < 2
-      
-      dependents = apply_from_filter(nodes)
-      dependents = apply_to_filter(dependents)
-      
-      graph = @graph_class.new
-      
-      dependents.each do |dependent|
-        graph.add_node dependent
+      nodes = @node_finder.get_nodes.uniq
+      nodes = apply_filters(nodes)
+      nodes = remove_disconnected_nodes(nodes)
+
+      graph = @graph_image_creator_class.new            
+      return graph if nodes.size < 2
+
+      nodes.each do |node|
+        graph.add_node(node)
       end
       
-      dependents.each do |dependent|
-        dependent.dependencies.each do |dependable|
-          graph.add_edge(dependent, dependable) if dependents.include? dependable
+      nodes.each do |node|
+        node.dependencies.each do |dependable|
+          graph.add_edge(node, dependable) if nodes.include? dependable
         end
       end
       
+      graph.trans = @trans
+      
       return graph
     end
+
+    private
+    def get_node_finder(node_type)
+      begin
+        begin
+          require "nodefinders/#{node_type.to_s}_node_finder"
+        rescue LoadError
+        end
+        
+        node_finder_class = deep_const_get("DepGraph::NodeFinders::#{camelize(node_type.to_s)}NodeFinder")
+        @node_finder = node_finder_class.new 
+      rescue
+        @node_finder = FileSystemNodeFinder.new(node_type)
+      end
+    end
     
-    def apply_from_filter(nodes)
-      return nodes unless @from_filter
+    def remove_disconnected_nodes(nodes)
+      nodes.select do |node|
+        nodes.any? {|n| n.depends_on?(node) or node.depends_on?(n)}
+      end
+    end
+    
+    def apply_filters(nodes)
+      apply_exclude_filter apply_to_filter(apply_from_filter(nodes))
+    end
+    
+    def apply_exclude_filter(nodes)
+      return nodes unless @excluded_nodes
+      
+      regexps = Regexp.union(*@excluded_nodes)
       
-      selected_dependents = nodes.select do |node|
-        node.name.match(@from_filter) or nodes.any?{|dependent| dependent.name.match(@from_filter) and dependent.depends_on?(node)}
+      nodes.reject do |node|
+        node.name.match(regexps)
       end
+    end
+    
+    def apply_from_filter(nodes)
+      return nodes unless @from
       
-      return selected_dependents
+      nodes.select do |node|
+        node.name.match(@from) or nodes.any?{|n| n.name.match(@from) and n.depends_on?(node)}
+      end
     end
     
     def apply_to_filter(nodes)
-      return nodes unless @to_filter
+      return nodes unless @to
       
-      selected_dependents = nodes.select do |node|
-        node.name.match(@to_filter) or nodes.any?{|dependable| node.depends_on?(dependable) and dependable.name.match(@to_filter)}
+      nodes.select do |node|
+        node.name.match(@to) or node.dependencies.any? {|d| d.name.match(@to)}
       end
-      
-      return selected_dependents
     end
-
     
-    def create_image(image_file_name = 'dependency_graph.png')
-      graph = create_graph
-      
-      if graph
-        return graph.create_image(image_file_name) 
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
       else
-        return false
+        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
       end
     end
+    
+    def deep_const_get str
+      return str.split("::").inject(Object) {|a,b| a.const_get(b) } 
+    end
   end
 end

data/lib/{graph.rb → graph_image_creator.rb}

@@ -2,10 +2,13 @@ require 'rubygems'
 require 'graphviz'
 
 module DepGraph
-  class Graph
+  class GraphImageCreator
+    attr_writer :trans
+    
     def initialize
       @nodes = []
       @edges = []
+      @trans = false
     end
 
     def node_count
@@ -69,21 +72,54 @@ module DepGraph
       unless @output_generation 
         @output_generation = lambda {|nodes, edges, image_file_name|
           #TODO: Could we catch Graphviz errors that the wrapper couldn't catch?        
-          g = GraphViz::new( "G", :use => 'dot', :mode => 'major', :rankdir => 'LR', :concentrate => 'true', :fontname => 'Arial', :file => image_file_name)      
+          g = GraphViz::new( "G", :use => 'dot', :mode => 'major', :rankdir => 'LR', :concentrate => 'true', :fontname => 'Arial')      
 
-        
-          nodes.each do |node|
-            g.add_node(quotify(node))
-          end
-      
-          edges.each do |from, to|
-            g.add_edge(quotify(from), quotify(to))
-          end
-      
-          g.output( :output => "png")
+          load_nodes(g, nodes)        
+          load_edges(g, edges)
+
+          create_output(g, image_file_name)          
+          
           return true
         }
       end
     end
+    
+    def load_nodes(g, nodes)
+      nodes.each do |node|
+        g.add_node(quotify(node))
+      end
+    end
+    
+    def load_edges(g, edges)
+      edges.each do |from, to|
+        g.add_edge(quotify(from), quotify(to))
+      end
+    end
+    
+    def create_output(g, image_file_name)
+      output_type = get_output_type(image_file_name)
+          
+      if @trans
+        begin
+          g.output(:file => 'temp.dot', :output => 'dot')
+          system "tred temp.dot|dot -T#{output_type} > #{image_file_name}"
+        ensure
+          File.delete('temp.dot')
+        end
+      else
+        g.output(:file => image_file_name, :output => output_type)
+      end
+    end
+    
+    def get_output_type(image_file_name)
+      #png is the default output type
+      output_type = 'png'
+
+      image_file_name.scan(/.+\.([^\.]*)$/) do |matches|
+        output_type = matches[0]        
+      end
+      
+      return output_type
+    end
   end
 end

data/lib/node.rb

@@ -0,0 +1,44 @@
+module DepGraph
+
+  #A node knows its dependables
+  class Node
+    include Comparable
+    attr_reader :name
+
+    def initialize(node_uri)
+      fail 'Empty uris are not allowed' if node_uri.empty?
+      @name = node_uri
+      @dependencies = []
+    end
+      
+    def to_str
+      @name
+    end
+    
+    def <=> other_node
+      @name <=> other_node.to_str
+    end
+    
+    def eql? other_node
+      (self <=> other_node) == 0
+    end
+    
+    def hash
+      @name.hash
+    end
+    
+    def depends_on node
+      node = Node.new(node) unless node.respond_to? :name
+      
+      @dependencies << node
+    end
+    
+    def depends_on? node
+      @dependencies.include? node
+    end
+
+    def dependencies
+      @dependencies
+    end
+  end
+end

data/lib/nodefinders/test_node_finder.rb

@@ -0,0 +1,26 @@
+require 'node'
+
+module DepGraph
+  module NodeFinders
+    
+    #This is a simple example of a custom node finder with a hard coded graph.
+    #Note that the file must be named [nodetype]_node_finder.rb containing a class named [Nodetype]NodeFinder
+    #To use this example do: depgraph -type test
+    class TestNodeFinder
+      def location=(loc)
+        #we will ignore location in this example
+      end
+      
+      def get_nodes
+        #let's return a hardcoded graph with 2 nodes and one dependency between them
+        
+        node1 = Node.new('node1')
+        node2 = Node.new('node2')
+        
+        node1.depends_on(node2)
+        
+        return [node1, node2] 
+      end
+    end
+  end
+end