depgraph 0.11.0

data/lib/graph_creator.rb

@@ -0,0 +1,122 @@
+require 'rubygems'
+require 'node'
+require 'graph_image_creator'
+require 'file_system_node_finder'
+require 'dependency_types_manager'
+
+module DepGraph
+  class GraphCreator
+    attr_writer :graph_image_creator_class, :from, :to, :node_finder, :trans
+    
+    def initialize(node_type = :none)
+      @node_finder = get_node_finder(node_type)
+      @graph_image_creator_class = GraphImageCreator
+      @trans = false
+    end
+    
+    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 location=(loc)
+      @node_finder.location = loc
+    end
+    
+    def excluded_nodes=(exc)
+      @excluded_nodes = exc.map {|e| e.strip}
+    end
+    
+    def create_image(image_file_name = 'dependency_graph.png')
+      create_graph.create_image(image_file_name) 
+    end
+    
+    def create_graph
+      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
+      
+      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 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)
+      
+      nodes.reject do |node|
+        node.name.match(regexps)
+      end
+    end
+    
+    def apply_from_filter(nodes)
+      return nodes unless @from
+      
+      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
+      
+      nodes.select do |node|
+        node.name.match(@to) or node.dependencies.any? {|d| d.name.match(@to)}
+      end
+    end
+    
+    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
+        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_image_creator.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+require 'graphviz'
+
+module DepGraph
+  class GraphImageCreator
+    attr_writer :trans
+    
+    def initialize
+      @nodes = []
+      @edges = []
+      @trans = false
+    end
+
+    def node_count
+      @nodes.size
+    end
+    
+    def add_node(node_name)
+      fail 'Node name not specified' if node_name.to_str.empty?
+      @nodes << node_name.to_str
+    end
+    
+    def has_node?(node_name)
+      @nodes.include? node_name
+    end
+
+    def edge_count
+      @edges.size
+    end
+
+    def add_edge(source_node_name, target_node_name)
+      fail "Cannot create a dependency to the unregistered node #{target_node_name}" unless @nodes.include?(target_node_name.to_str)
+      fail "Cannot create a dependency from the unregistered node #{source_node_name}" unless @nodes.include?(source_node_name.to_str) 
+      
+      @edges << [source_node_name.to_str, target_node_name.to_str]
+    end
+    
+    def has_edge?(node1, node2)
+      @edges.include? [node1, node2]
+    end
+    
+    def reset
+      @nodes.clear
+      @edges.clear
+    end
+    
+    def create_image(image_file_name)
+      begin
+        return false if @nodes.size == 0 or @edges.size == 0
+        
+        set_default_output_generation_unless_is_set
+        
+        return @output_generation.call(@nodes, @edges, image_file_name)
+        
+      rescue => e
+        puts e.message
+        puts e.backtrace
+        return false
+      end
+    end
+    
+    def output_generation= output_generation_lambda
+      @output_generation = output_generation_lambda
+    end
+    
+    private
+    def quotify(a_string)
+      '"' + a_string + '"'
+    end
+    
+    def set_default_output_generation_unless_is_set
+      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')      
+
+          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_nodes(quotify(node))
+      end
+    end
+    
+    def load_edges(g, edges)
+      edges.each do |from, to|
+        g.add_edges(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(:dot => 'temp.dot')
+          system "tred temp.dot|dot -T#{output_type} > #{image_file_name}"
+        ensure
+          File.delete('temp.dot')
+        end
+      else
+        g.output(output_type => image_file_name)
+      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/gems_node_finder.rb

@@ -0,0 +1,58 @@
+require 'node'
+
+module DepGraph
+  module NodeFinders
+    class GemsNodeFinder
+      def initialize
+        @spec_directories = Gem::Specification.dirs
+      end
+
+      def location=(loc)
+        @spec_directories = loc
+      end
+
+      def get_nodes
+        require 'rubygems'
+
+        fail 'The gem specification directories were not set' unless @spec_directories and @spec_directories.size > 0
+
+        nodes = {}
+        @spec_directories.each do |spec_directory|
+          Dir["#{spec_directory}/**/*.gemspec"].each do |gemspec_file_name|
+            add_nodes_from_gemspec(nodes, gemspec_file_name)
+          end
+        end
+
+        return nodes.values.sort
+      end
+
+      private
+      def add_nodes_from_gemspec(nodes, gemspec_file_name)
+        gem_dependencies = get_gemspec_dependencies(gemspec_file_name)
+        gem_name = get_gemspec_name(gemspec_file_name)
+
+        nodes[gem_name] ||= Node.new(gem_name)
+        gem_dependencies.each do |gem_dependency|
+          nodes[gem_dependency] ||= Node.new(gem_dependency)
+          nodes[gem_name].depends_on(nodes[gem_dependency])
+        end
+      end
+
+      def get_gemspec_dependencies(gemspec_file_name)
+        gem_dependencies = []
+        content = File.read(gemspec_file_name)
+        content.scan(/add_dependency\(%q<([^>]+)>/) do |matches|
+          matches.each do |match|
+            gem_dependencies << match
+          end
+        end
+
+        return gem_dependencies
+      end
+
+      def get_gemspec_name(gemspec_file_name)
+        File.basename(gemspec_file_name).match(/(.+)-\d+/)[1].to_s
+      end
+    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

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/destroy.cmd

@@ -0,0 +1 @@
+@ruby script/destroy %*

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/generate.cmd

@@ -0,0 +1 @@
+@ruby script/generate %*

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/DepGraph/version.rb'
+
+version  = DepGraph::VERSION::STRING
+download = 'http://rubyforge.org/projects/DepGraph'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)